I denne guide vil vi først se tilgangen og derefter forudsige hver persons slagtilfælde ved at analysere dataene trin for trin.
Logistisk regression
Logistisk regression, også kaldet 'Logit-modellen', bruges i prædiktiv analyse til klassificeringsproblemer. Dette er en Machine Learning-model, som kun virker på klassificering for at klassificere klasserne (kategorierne). For eksempel er der to kategorier i vores scenarie (en person, der er ramt af slagtilfælde og en person, der ikke er ramt af slagtilfælde). De bedste anvendelser af modellen er forudsigelse af hjertesygdomme, forudsigelse af køn, forudsigelse af afgrødeliv osv.
Trin:
1. Dataindsamling: Dataene er nødvendige for at udføre enhver forudsigelse/analyse. Det kan blandt andet være i form af CSV/XLSX. Vi kan indlæse dette i Spark-miljøet (DataFrame) ved hjælp af spark.read.csv()-metoden.
2. Dataanalyse : At analysere attributterne/kolonnerne er kendt som 'dataanalyse'. De kolonner, der hjælper med at forudsige klassen, er kendt som 'uafhængige attributter'. Kolonnen, der resulterer i forudsigelse, er kendt som 'afhængig eller målattribut'. I dette scenarie kan vi bruge egenskaben kolonner til at vise alle kolonnerne. Metoden distinct() bruges til at se de unikke værdier.
3. Dataforbehandling: Filtrering af nul/manglende værdier er kendt som 'forbehandling'. Vi fjerner alle de manglende værdier i denne fase. Maskinen kender kun det binære sprog. Så alle strengkategorier skal konverteres til numeriske kategoriske værdier. I PySpark kan vi bruge 'StringIndexer', som er den tilgængelige klasse i modulet pyspark.ml.feature til at konvertere strengkategorierne til numeriske. Det konverterer dem automatisk internt. Vi behøver ikke at give værdierne. Du kan bruge følgende syntaks:
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,outputCol= 'Nyt_kolonne_navn' )
4. Vektorsamling: Nu har du de data, som maskinen kan forstå. I dette trin skal alle uafhængige attributter vektoriseres i en enkelt kolonne. Dette kan gøres ved hjælp af VectorAssembler-klassen. Det kræver to parametre: Den første parameter er inputCols, som tager en liste over uafhængige attributter. Den anden parameter er outputCol, som vektoriserer alle inputCols til denne variabel.
assembler=VectorAssembler(inputCols=[kolonner…],outputCol=vektoriserede_data)5. Transformation: Forbered nu dine data ved at transformere de opdaterede kolonner (trin 3) ved hjælp af transform()-funktionen.
assembler.transform(inxed_data)
6. Forberedelse af data til træning og test: I denne fase opdeler vi dataene i 'træning' og 'test'. Det vil være bedre, hvis vi deler de 70 % data for at træne modellen og 30 % data for at teste modellen. Dette kan opnås ved hjælp af randomSplit() metoden. Det kræver en liste, som indeholder to flydende værdier: en for test split og en anden for tog split.
train_data,test_data=final_data.select([ 'funktioner' ,target_column]).randomSplit([0.70.0.30])7. Modeltilpasning og evaluering : Det er tid til at passe til Logistic Regression-modellen. Logistic Regression-modellen er tilgængelig i pyspark.ml.classification-modulet. Det tager klasseetiketten/målkolonnen. Dette resulterer i råForudsigelse, sandsynlighed og forudsigelseskolonner. Vores resultater er gemt i forudsigelseskolonnen.
# Modeltilpasninglogistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# Modelevaluering
train_results=logistic_regression_model.evaluate(train_data).forudsigelser
8. Nøjagtighed og resultater: Dette er den sidste fase, hvor vi tester modellens nøjagtighed ved hjælp af alle testteknikker.
Lad os se på følgende projekt, hvor vi forudsiger, om en person er ramt af slagtilfælde eller ej ved hjælp af den logistiske regressionsmodel.
Forudsigelse af slagtilfælde
9. Installer PySpark-modulet i dit miljø. Følgende er kommandoen til at installere:
pip installer pyspark 
10. Lad os oprette en PySpark DataFrame med 10 poster, som er relateret til stregdetaljer for 10 personer. Til demonstration opretter vi en DataFrame uden CSV. Der er 7 kolonner i denne DataFrame. 'Køn', 'Glukoseniveau', 'gift', 'alder', 'hjertesygdom', 'hyper_tension' er uafhængige attributter, og 'slagtilfælde' er klassemærket eller afhængig attribut. Det betyder, at en persons slagtilfælde er afhængig af disse uafhængige egenskaber.
importere pysparkfra pyspark.sql importer SparkSession
linuxhint_spark_app = SparkSession.builder.appName( 'Linux-tip' ).getOrCreate()
stoke_data =[
{ 'Køn' : 'Kvinde' , 'alder' : halvtreds , 'hjerte sygdom' : 'Ja' ,
'forhøjet blodtryk' : 'Ja' , 'gift' : 'Ja' , 'Glucoseniveau' : 130 , 'Slag' : 1 },
{ 'Køn' : 'Han' , 'alder' : tyve , 'hjerte sygdom' : 'Ingen' ,
'forhøjet blodtryk' : 'Ja' , 'gift' : 'Ingen' , 'Glucoseniveau' : 97 , 'Slag' : 0 },
{ 'Køn' : 'Han' , 'alder' : 12 , 'hjerte sygdom' : 'Ingen' ,
'forhøjet blodtryk' : 'Ingen' , 'gift' : 'Ingen' , 'Glucoseniveau' : 98 , 'Slag' : 0 },
{ 'Køn' : 'Kvinde' , 'alder' : 90 , 'hjerte sygdom' : 'Ingen' ,
'forhøjet blodtryk' : 'Ingen' , 'gift' : 'Ja' , 'Glucoseniveau' : 170 , 'Slag' : 1 },
{ 'Køn' : 'Han' , 'alder' : 43 , 'hjerte sygdom' : 'Ja' ,
'forhøjet blodtryk' : 'Ja' , 'gift' : 'Ja' , 'Glucoseniveau' : 150 , 'Slag' : 1 },
{ 'Køn' : 'Kvinde' , 'alder' : enogtyve , 'hjerte sygdom' : 'Ingen' ,
'forhøjet blodtryk' : 'Ingen' , 'gift' : 'Ja' , 'Glucoseniveau' : 110 , 'Slag' : 0 },
{ 'Køn' : 'Kvinde' , 'alder' : halvtreds , 'hjerte sygdom' : 'Ja' ,
'forhøjet blodtryk' : 'Ingen' , 'gift' : 'Ja' , 'Glucoseniveau' : 100 , 'Slag' : 0 },
{ 'Køn' : 'Han' , 'alder' : 3. 4 , 'hjerte sygdom' : 'Ingen' ,
'forhøjet blodtryk' : 'Ja' , 'gift' : 'Ja' , 'Glucoseniveau' : 190 , 'Slag' : 1 },
{ 'Køn' : 'Han' , 'alder' : 10 , 'hjerte sygdom' : 'Ingen' ,
'forhøjet blodtryk' : 'Ingen' , 'gift' : 'Ingen' , 'Glucoseniveau' : 90 , 'Slag' : 0 },
{ 'Køn' : 'Kvinde' , 'alder' : 56 , 'hjerte sygdom' : 'Ja' ,
'forhøjet blodtryk' : 'Ja' , 'gift' : 'Ja' , 'Glucoseniveau' : 145 , 'Slag' : 1 }
]
# opret datarammen ud fra ovenstående data
stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)
# Faktisk stoke_df
stroke_df.show()
Produktion:
11. Vis de uafhængige kolonner ved hjælp af select() metoden.
# Vis uafhængige attributterslag_df.select(slag_df[ 'Køn' ],slag_df[ 'Glukoseniveau' ],slag_df[ 'gift' ],slag_df[ 'alder' ],slag_df[ 'hjerte sygdom' ],slag_df[ 'forhøjet blodtryk' ]).at vise()
Produktion:
12. Vis de unikke værdier, der er til stede i målattributten (Stroke).
# unikke værdier for målattributslag_df.select(slag_df[ 'Slag' ]).distinct().show()
Produktion:
13. Returner datatypen for alle kolonnerne ved hjælp af printSchema()-funktionen.
# Returner datatype for alle kolonnerne.stroke_df.printSchema()
Produktion:
Vi kan se, at 4 kolonner er af strengtype. Lad os konvertere dem til kategoriske numeriske værdier.
14. Lad os konvertere strengens kategoriske værdier til numeriske kategoriske værdier ved hjælp af StringIndexer i kolonnerne 'Køn', 'hjertesygdom', 'hyper_tension' og 'gift' og skrive disse ind i kategorierne Kategotisk_Køn, Kategotisk_hjertesygdom, Kategotisk_marig og Kategotisk_gotension. Gem kolonnerne i indexed_data DataFrame ved hjælp af fit()-metoden.
fra pyspark.ml.feature importer StringIndexer# Konverter strenge kategoriske værdier til numeriske kategoriske værdier i kolonnen 'Køn'.
indexer_data=StringIndexer(inputCol= 'Køn' ,outputCol= 'Kategotisk_køn' )
indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)
# Konverter strenge kategoriske værdier til numeriske kategoriske værdier i kolonnen 'hjertesygdom'.
indexer_data=StringIndexer(inputCol= 'hjerte sygdom' ,outputCol= 'Kategotisk_hjertesygdom' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Konverter strenge kategoriske værdier til numeriske kategoriske værdier i kolonnen 'hyper_tension'.
indexer_data=StringIndexer(inputCol= 'forhøjet blodtryk' ,outputCol= 'Categotical_hyper_tension' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Konverter strenge kategoriske værdier til numeriske kategoriske værdier i kolonnen 'gift'.
indexer_data=StringIndexer(inputCol= 'gift' ,outputCol= 'Kategotisk_gift' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Vis den opdaterede
indexed_data.show()
Produktion:
15. Konverter de uafhængige kolonner til en vektor ved hjælp af vektorsamleren. Vektornavnet er 'funktioner'.
fra pyspark.ml.feature importerer VectorAssemblerassembler= VectorAssembler(inputCols=[ 'Kategotisk_køn' , 'Kategotisk_hjertesygdom' , 'Categotical_hyper_tension' , 'Kategotisk_gift' , 'alder' ,
'Glucoseniveau' ],outputCol= 'funktioner' )
16. Transform de tidligere data til en endelig DataFrame ved hjælp af transform()-funktionen og vis dem ved hjælp af show()-funktionen.
Produktion:
17. Forbered dataene til træning og test ved at opdele dem i 70-30. 'Features' er gemt i train_data og 'Stroke' er gemt i test_data.
# Forbered data til træning og testtrain_data,test_data=final.select([ 'funktioner' , 'Slag' ]).randomSplit([ 0,70 , 0,30 ])
18. Tilpas den logistiske regressionsmodel og evaluer den.
fra pyspark.ml.classification import LogisticRegression# Modeltilpasning
logistic_regression_model=Logistisk regression(labelCol= 'Slag' ).fit(tog_data)
# Modelevaluering
train_results=logistic_regression_model.evaluate(train_data).forudsigelser
train_results.show()
Produktion:
19. Brug BinaryClassificationEvaluator til at kontrollere modellens nøjagtighed. Vi kan se, at vores model er 100 % nøjagtig.
fra pyspark.ml.evaluation import BinaryClassificationEvaluator# kalder BinaryClassificationEvaluator
resultater = BinaryClassificationEvaluator(rawPredictionCol= 'forudsigelse' ,labelCol= 'Slag' )
ROC_AUC = results.evaluate(train_results)
print(ROC_AUC * 100 , '% nøjagtighed' )
Konklusion
Du er i stand til at forudsige klassificeringsproblemet i real-tile ved hjælp af Logistic Regression-modellen i PySpark. Det er vigtigt at fjerne nul/manglende værdier, da de mindsker modelevalueringen og nøjagtigheden. Forbehandling er et nødvendigt trin, før en maskinlæringsmodel tilpasses. Sørg for, at du udfører dette trin korrekt og præcist.