I den här guiden kommer vi först att se tillvägagångssättet och sedan förutsäga varje persons stroke genom att analysera data steg för steg.
Logistisk tillbakagång
Logistisk regression, även kallad 'Logit Model', används i prediktiv analys för klassificeringsproblem. Detta är en maskininlärningsmodell som endast fungerar på klassificering för att klassificera klasserna (kategorierna). Till exempel finns det två kategorier i vårt scenario (en person som är drabbad av stroke och en person som inte är drabbad av stroke). De bästa tillämpningarna av modellen är förutsägelse av hjärtsjukdom, förutsägelse av kön, förutsägelse av grödor, etc.
Steg:
1. Datainsamling: Uppgifterna är nödvändiga för att utföra alla förutsägelser/analyser. Det kan vara i form av bland annat CSV/XLSX. Vi kan ladda detta till Spark-miljön (DataFrame) med metoden spark.read.csv().
2. Dataanalys : Att analysera attributen/kolumnerna kallas 'dataanalys'. Kolumnerna som hjälper till att förutsäga klassen är kända som 'oberoende attribut'. Kolumnen som resulterar i förutsägelse kallas 'beroende eller målattribut'. I det här scenariot kan vi använda egenskapen columns för att visa alla kolumner. Metoden distinct() används för att se de unika värdena.
3. Dataförbehandling: Att filtrera noll-/saknade värden kallas 'förbearbetning'. Vi tar bort alla saknade värden i detta skede. Maskinen kan bara det binära språket. Så alla strängkategorier bör konverteras till numeriska kategorivärden. I PySpark kan vi använda 'StringIndexer' som är den tillgängliga klassen i modulen pyspark.ml.feature för att konvertera strängkategorierna till numeriska. Den konverterar dem automatiskt internt. Vi behöver inte tillhandahålla värderingarna. Du kan använda följande syntax:
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,outputCol= 'New_Column_name' )
4. Vektormontering: Nu har du data som maskinen kan förstå. I detta skede bör alla oberoende attribut vektoriseras till en enda kolumn. Detta kan göras med klassen VectorAssembler. Det krävs två parametrar: Den första parametern är inputCols som tar en lista med oberoende attribut. Den andra parametern är outputCol som vektoriserar alla inputCols till denna variabel.
assembler=VectorAssembler(inputCols=[kolumner...],outputCol=vektoriserade_data)5. Transformation: Förbered nu dina data genom att transformera de uppdaterade kolumnerna (steg 3) med hjälp av transform()-funktionen.
assembler.transform(inxed_data)
6. Förbereda data för utbildning och testning: I detta skede delar vi upp data i 'träning' och 'testning'. Det blir bättre om vi delar upp 70 % data för att träna modellen och 30 % data för att testa modellen. Detta kan uppnås med metoden randomSplit() . Den tar en lista som innehåller två flytvärden: en för testdelning och en annan för tågdelning.
train_data,test_data=final_data.select([ 'Funktioner' ,target_column]).randomSplit([0.70.0.30])7. Modellanpassning & utvärdering : Det är dags att passa in Logistic Regression-modellen. Logistic Regression-modellen är tillgänglig i modulen pyspark.ml.classification. Det tar klassetiketten/målkolumnen. Detta resulterar i rawPrediction-, sannolikhets- och prediktionskolumner. Våra resultat lagras i prediktionskolumnen.
# Modellmonteringlogistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# Modellutvärdering
train_results=logistic_regression_model.evaluate(train_data).predictions
8. Noggrannhet och resultat: Detta är det sista steget där vi testar modellens noggrannhet med hjälp av någon testteknik.
Låt oss titta på följande projekt där vi förutsäger om en person är drabbad av stroke eller inte med hjälp av Logistic Regression-modellen.
Förutsägelse av stroke
9. Installera PySpark-modulen i din miljö. Följande är kommandot att installera:
pip installera pyspark 
10. Låt oss skapa en PySpark DataFrame med 10 poster som är relaterade till strokedetaljer för 10 personer. För demonstration skapar vi en DataFrame utan CSV. Det finns 7 kolumner i denna DataFrame. 'Kön', 'Glukosnivå', 'gift', 'ålder', 'hjärtsjukdom', 'högspänning' är oberoende attribut och 'Stroke' är klassetiketten eller beroende attribut. Det betyder att en persons stroke är beroende av dessa oberoende attribut.
importera pysparkfrån pyspark.sql importera SparkSession
linuxhint_spark_app = SparkSession.builder.appName( 'Linux tips' ).getOrCreate()
stoke_data =[
{ 'Kön' : 'Kvinna' , 'ålder' : femtio , 'hjärtsjukdom' : 'Ja' ,
'hyper_tension' : 'Ja' , 'gift' : 'Ja' , 'Glucose_level' : 130 , 'Stroke' : 1 },
{ 'Kön' : 'Manlig' , 'ålder' : tjugo , 'hjärtsjukdom' : 'Nej' ,
'hyper_tension' : 'Ja' , 'gift' : 'Nej' , 'Glucose_level' : 97 , 'Stroke' : 0 },
{ 'Kön' : 'Manlig' , 'ålder' : 12 , 'hjärtsjukdom' : 'Nej' ,
'hyper_tension' : 'Nej' , 'gift' : 'Nej' , 'Glucose_level' : 98 , 'Stroke' : 0 },
{ 'Kön' : 'Kvinna' , 'ålder' : 90 , 'hjärtsjukdom' : 'Nej' ,
'hyper_tension' : 'Nej' , 'gift' : 'Ja' , 'Glucose_level' : 170 , 'Stroke' : 1 },
{ 'Kön' : 'Manlig' , 'ålder' : 43 , 'hjärtsjukdom' : 'Ja' ,
'hyper_tension' : 'Ja' , 'gift' : 'Ja' , 'Glucose_level' : 150 , 'Stroke' : 1 },
{ 'Kön' : 'Kvinna' , 'ålder' : tjugoett , 'hjärtsjukdom' : 'Nej' ,
'hyper_tension' : 'Nej' , 'gift' : 'Ja' , 'Glucose_level' : 110 , 'Stroke' : 0 },
{ 'Kön' : 'Kvinna' , 'ålder' : femtio , 'hjärtsjukdom' : 'Ja' ,
'hyper_tension' : 'Nej' , 'gift' : 'Ja' , 'Glucose_level' : 100 , 'Stroke' : 0 },
{ 'Kön' : 'Manlig' , 'ålder' : 3. 4 , 'hjärtsjukdom' : 'Nej' ,
'hyper_tension' : 'Ja' , 'gift' : 'Ja' , 'Glucose_level' : 190 , 'Stroke' : 1 },
{ 'Kön' : 'Manlig' , 'ålder' : 10 , 'hjärtsjukdom' : 'Nej' ,
'hyper_tension' : 'Nej' , 'gift' : 'Nej' , 'Glucose_level' : 90 , 'Stroke' : 0 },
{ 'Kön' : 'Kvinna' , 'ålder' : 56 , 'hjärtsjukdom' : 'Ja' ,
'hyper_tension' : 'Ja' , 'gift' : 'Ja' , 'Glucose_level' : 145 , 'Stroke' : 1 }
]
# skapa dataramen från ovanstående data
stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)
# Faktisk stoke_df
stroke_df.show()
Produktion:
11. Visa de oberoende kolumnerna med metoden select().
# Visa oberoende attributstroke_df.select(stroke_df[ 'Kön' ],stroke_df[ 'Glukosnivå' ],stroke_df[ 'gift' ],stroke_df[ 'ålder' ],stroke_df[ 'hjärtsjukdom' ],stroke_df[ 'hyper_tension' ]).show()
Produktion:
12. Visa de unika värdena som finns i målattributet (Stroke).
# unika värden för målattributstroke_df.select(stroke_df[ 'Stroke' ]).distinct().show()
Produktion:
13. Returnera datatypen för alla kolumner med funktionen printSchema() .
# Returnera datatyp för alla kolumner.stroke_df.printSchema()
Produktion:
Vi kan se att 4 kolumner är av strängtyp. Låt oss konvertera dem till kategoriska numeriska värden.
14. Låt oss konvertera de kategoriska strängvärdena till numeriska kategorivärden med hjälp av StringIndexer i kolumnerna 'Gender', 'heart_disease', 'hyper_tension' och 'married' och skriv dessa till Categotical_Gender, Categotical_heart_disease, Categotical_mary_gotension. och Categotical_married_gotension. Lagra kolumnerna i indexed_data DataFrame med metoden fit().
från pyspark.ml.feature importera StringIndexer# Konvertera kategoriska strängvärden till numeriska kategorivärden i kolumnen 'Kön'.
indexer_data=StringIndexer(inputCol= 'Kön' ,outputCol= 'Categotical_Gender' )
indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)
# Konvertera kategoriska strängvärden till numeriska kategorivärden i kolumnen 'hjärtsjukdom'.
indexer_data=StringIndexer(inputCol= 'hjärtsjukdom' ,outputCol= 'Kategotisk_hjärtsjukdom' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Konvertera kategoriska strängvärden till numeriska kategorivärden i kolumnen 'hyper_tension'.
indexer_data=StringIndexer(inputCol= 'hyper_tension' ,outputCol= 'Categotical_hyper_tension' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Konvertera kategoriska strängvärden till numeriska kategorivärden i kolumnen 'gift'.
indexer_data=StringIndexer(inputCol= 'gift' ,outputCol= 'Categotical_married' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Visa den uppdaterade
indexed_data.show()
Produktion:
15. Konvertera de oberoende kolumnerna till en vektor med hjälp av vektorsammanställaren. Vektornamnet är 'funktioner'.
från pyspark.ml.feature importera VectorAssemblerassembler= VectorAssembler(inputCols=[ 'Categotical_Gender' , 'Kategotisk_hjärtsjukdom' , 'Categotical_hyper_tension' , 'Categotical_married' , 'ålder' ,
'Glucose_level' ],outputCol= 'Funktioner' )
16. Omvandla tidigare data till en slutlig DataFrame med hjälp av transform()-funktionen och visa den med hjälp av show()-funktionen.
Produktion:
17. Förbered data för träning och testning genom att dela upp dem i 70-30. 'Funktioner' lagras i train_data och 'Stroke' lagras i test_data.
# Förbered data för träning och testningtrain_data,test_data=final.select([ 'Funktioner' , 'Stroke' ]).randomSplit([ 0,70 , 0,30 ])
18. Passa in Logistic Regression-modellen och utvärdera den.
från pyspark.ml.classification import LogisticRegression# Modellmontering
logistic_regression_model=LogisticRegression(labelCol= 'Stroke' ).fit(tågdata)
# Modellutvärdering
train_results=logistic_regression_model.evaluate(train_data).predictions
train_results.show()
Produktion:
19. Använd BinaryClassificationEvaluator för att kontrollera modellens noggrannhet. Vi kan se att vår modell är 100 % korrekt.
från pyspark.ml.evaluation import BinaryClassificationEvaluator# anropa BinaryClassificationEvaluator
resultat = BinaryClassificationEvaluator(rawPredictionCol= 'förutsägelse' ,labelCol= 'Stroke' )
ROC_AUC = results.evaluate(train_results)
print(ROC_AUC * 100 , '% noggrannhet' )
Slutsats
Du kan förutsäga klassificeringsproblemet med verkliga kakel med hjälp av Logistic Regression-modellen i PySpark. Det är viktigt att ta bort noll-/saknade värden eftersom de minskar modellutvärderingen och noggrannheten. Förbearbetning är ett nödvändigt steg innan någon maskininlärningsmodell anpassas. Se till att du gör detta steg korrekt och korrekt.