Sa gabay na ito, makikita muna natin ang diskarte at pagkatapos ay mahulaan ang stroke ng bawat tao sa pamamagitan ng pagsusuri sa data nang hakbang-hakbang.
Logistic Regression
Ang logistic regression, na tinatawag ding 'Logit Model', ay ginagamit sa predictive analytics para sa mga problema sa pag-uuri. Ito ay isang modelo ng Machine Learning na gumagana lamang sa pag-uuri upang pag-uri-uriin ang mga klase (mga kategorya). Halimbawa, may dalawang kategorya sa aming senaryo (isang taong apektado ng stroke at isang taong hindi apektado ng stroke). Ang pinakamahusay na mga aplikasyon ng modelo ay ang hula sa sakit sa puso, hula sa kasarian, hula sa buhay ng pananim, atbp.
Mga hakbang:
1. Pangongolekta ng Data: Ang data ay kinakailangan upang maisagawa ang anumang mga hula/pagsusuri. Maaari itong nasa anyo ng CSV/XLSX, bukod sa iba pa. Maaari naming i-load ito sa Spark environment (DataFrame) gamit ang spark.read.csv() na paraan.
2. Pagsusuri ng Datos : Ang pagsusuri sa mga katangian/kolum ay kilala bilang “data analysis”. Ang mga column na nakakatulong upang mahulaan ang klase ay kilala bilang 'mga independiyenteng katangian'. Ang column na nagreresulta sa hula ay kilala bilang 'depende o target na katangian'. Sa sitwasyong ito, magagamit natin ang property ng columns para ipakita ang lahat ng column. Ang distinct() na paraan ay ginagamit upang makita ang mga natatanging halaga.
3. Preprocessing ng Data: Ang pag-filter sa mga null/nawawalang value ay kilala bilang “preprocessing”. Inalis namin ang lahat ng nawawalang value sa yugtong ito. Binary language lang ang alam ng makina. Kaya, ang lahat ng mga kategorya ng string ay dapat na ma-convert sa mga numerong pangkategoryang halaga. Sa PySpark, maaari naming gamitin ang 'StringIndexer' na magagamit na klase sa pyspark.ml.feature module upang i-convert ang mga kategorya ng string sa numeric. Awtomatiko nitong kino-convert ang mga ito sa loob. Hindi natin kailangang ibigay ang mga halaga. Maaari mong gamitin ang sumusunod na syntax:
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,outputCol= 'New_Column_name' )
4. Vector Assembling: Ngayon, mayroon kang data na mauunawaan ng makina. Sa yugtong ito, ang lahat ng mga independiyenteng katangian ay dapat i-vector sa iisang column. Magagawa ito gamit ang klase ng VectorAssembler. Kailangan ng dalawang parameter: Ang unang parameter ay ang inputCols na kumukuha ng listahan ng mga independiyenteng katangian. Ang pangalawang parameter ay ang outputCol na nagve-vector sa lahat ng inputCols sa variable na ito.
assembler=VectorAssembler(inputCols=[column…],outputCol=vectorized_data)5. Pagbabago: Ngayon, ihanda ang iyong data sa pamamagitan ng pagbabago ng mga na-update na column (Hakbang 3) gamit ang transform() function.
assembler.transform(inxed_data)
6. Paghahanda ng Data para sa Pagsasanay at Pagsubok: Sa yugtong ito, hinati namin ang data sa 'pagsasanay' at 'pagsubok'. Mas maganda kung hatiin natin ang 70% data para sanayin ang modelo at 30% data para subukan ang modelo. Ito ay maaaring makamit gamit ang randomSplit() na pamamaraan. Kailangan ng isang listahan na naglalaman ng dalawang float value: isa para sa test split at isa pa para sa train split.
train_data,test_data=final_data.select([ 'mga tampok' ,target_column]).randomSplit([0.70.0.30])7. Pag-aayos ng Modelo at Pagsusuri : Oras na para magkasya sa modelo ng Logistic Regression. Available ang modelong Logistic Regression sa pyspark.ml.classification module. Kinukuha nito ang label ng klase/target na column. Nagreresulta ito sa rawPrediction, probability, at prediction columns. Ang aming mga resulta ay nakaimbak sa hanay ng hula.
# Angkop ng modelologistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# Pagsusuri ng modelo
train_results=logistic_regression_model.evaluate(train_data).predictions
8. Katumpakan at Mga Resulta: Ito ang huling yugto kung saan sinusuri namin ang katumpakan ng modelo gamit ang anumang mga diskarte sa pagsubok.
Tingnan natin ang sumusunod na proyekto kung saan hinuhulaan natin kung ang isang tao ay apektado ng stroke o hindi gamit ang Logistic Regression model.
Hula ng Stroke
9. I-install ang PySpark module sa iyong kapaligiran. Ang sumusunod ay ang utos para i-install:
pip install pyspark 
10. Gumawa tayo ng PySpark DataFrame na may 10 record na nauugnay sa mga detalye ng stroke ng 10 tao. Para sa pagpapakita, gumawa kami ng DataFrame na walang CSV. Mayroong 7 column sa DataFrame na ito. Ang “Gender”, “Glucose_level”, “married”, “age”, “heart_disease”, “hyper_tension” ay mga independent attribute at ang “Stroke” ay ang class label o dependent attribute. Nangangahulugan iyon na ang stroke ng isang tao ay nakasalalay sa mga independiyenteng katangiang ito.
import pysparkmula sa pyspark.sql import SparkSession
linuxhint_spark_app = SparkSession.builder.appName( 'Linux Hint' ).getOrCreate()
stoke_data =[
{ 'Kasarian' : 'Babae' , 'edad' : limampu , 'sakit sa puso' : 'Oo' ,
'hyper_tension' : 'Oo' , 'may asawa' : 'Oo' , 'Glucose_level' : 130 , 'Stroke' : 1 },
{ 'Kasarian' : 'Lalaki' , 'edad' : dalawampu , 'sakit sa puso' : 'Hindi' ,
'hyper_tension' : 'Oo' , 'may asawa' : 'Hindi' , 'Glucose_level' : 97 , 'Stroke' : 0 },
{ 'Kasarian' : 'Lalaki' , 'edad' : 12 , 'sakit sa puso' : 'Hindi' ,
'hyper_tension' : 'Hindi' , 'may asawa' : 'Hindi' , 'Glucose_level' : 98 , 'Stroke' : 0 },
{ 'Kasarian' : 'Babae' , 'edad' : 90 , 'sakit sa puso' : 'Hindi' ,
'hyper_tension' : 'Hindi' , 'may asawa' : 'Oo' , 'Glucose_level' : 170 , 'Stroke' : 1 },
{ 'Kasarian' : 'Lalaki' , 'edad' : 43 , 'sakit sa puso' : 'Oo' ,
'hyper_tension' : 'Oo' , 'may asawa' : 'Oo' , 'Glucose_level' : 150 , 'Stroke' : 1 },
{ 'Kasarian' : 'Babae' , 'edad' : dalawampu't isa , 'sakit sa puso' : 'Hindi' ,
'hyper_tension' : 'Hindi' , 'may asawa' : 'Oo' , 'Glucose_level' : 110 , 'Stroke' : 0 },
{ 'Kasarian' : 'Babae' , 'edad' : limampu , 'sakit sa puso' : 'Oo' ,
'hyper_tension' : 'Hindi' , 'may asawa' : 'Oo' , 'Glucose_level' : 100 , 'Stroke' : 0 },
{ 'Kasarian' : 'Lalaki' , 'edad' : 3. 4 , 'sakit sa puso' : 'Hindi' ,
'hyper_tension' : 'Oo' , 'may asawa' : 'Oo' , 'Glucose_level' : 190 , 'Stroke' : 1 },
{ 'Kasarian' : 'Lalaki' , 'edad' : 10 , 'sakit sa puso' : 'Hindi' ,
'hyper_tension' : 'Hindi' , 'may asawa' : 'Hindi' , 'Glucose_level' : 90 , 'Stroke' : 0 },
{ 'Kasarian' : 'Babae' , 'edad' : 56 , 'sakit sa puso' : 'Oo' ,
'hyper_tension' : 'Oo' , 'may asawa' : 'Oo' , 'Glucose_level' : 145 , 'Stroke' : 1 }
]
# lumikha ng dataframe mula sa data sa itaas
stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)
# Aktwal na stoke_df
stroke_df.show()
Output:
11. Ipakita ang mga independiyenteng column gamit ang select() method.
# Ipakita ang mga independiyenteng katangianstroke_df.select(stroke_df[ 'Kasarian' ],stroke_df[ 'Glucose_level' ],stroke_df[ 'may asawa' ],stroke_df[ 'edad' ],stroke_df[ 'sakit sa puso' ],stroke_df[ 'hyper_tension' ]).show()
Output:
12. Ipakita ang mga natatanging halaga na naroroon sa target na katangian (Stroke).
# target na attribute na mga natatanging valuestroke_df.select(stroke_df[ 'Stroke' ]).distinct().show()
Output:
13. Ibalik ang uri ng data ng lahat ng column gamit ang printSchema() function.
# Ibalik ang datatype ng lahat ng column.stroke_df.printSchema()
Output:
Makikita natin na ang 4 na column ay may uri ng string. I-convert natin ang mga ito sa mga kategoryang numeric na halaga.
14. I-convert natin ang string categorical values sa numeric categorical value gamit ang StringIndexer sa mga column na “Gender”, “heart_disease”, “hyper_tension”, at “married” at isulat ang mga ito sa Categotical_Gender, Categotical_heart_disease, Categotical_hyper_tensiontical, at Categotical_hyper_tension. I-store ang mga column sa indexed_data DataFrame gamit ang fit() method.
mula sa pyspark.ml.feature import StringIndexer# I-convert ang string categorical values sa numeric categorical value sa column na 'Kasarian.'
indexer_data=StringIndexer(inputCol= 'Kasarian' ,outputCol= 'Categotical_Gender' )
indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)
# I-convert ang string categorical values sa numeric categorical value sa column na 'heart_disease.'
indexer_data=StringIndexer(inputCol= 'sakit sa puso' ,outputCol= 'Categotical_heart_disease' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# I-convert ang string categorical values sa numeric categorical value sa column na 'hyper_tension.'
indexer_data=StringIndexer(inputCol= 'hyper_tension' ,outputCol= 'Categotical_hyper_tension' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# I-convert ang string categorical values sa numeric categorical values sa column na 'may asawa'.
indexer_data=StringIndexer(inputCol= 'may asawa' ,outputCol= 'Categotical_married' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# Ipakita ang na-update
indexed_data.show()
Output:
15. I-convert ang mga independent column sa isang vector gamit ang vector assembler. Ang pangalan ng vector ay 'mga tampok'.
mula sa pyspark.ml.feature import VectorAssemblerassembler= VectorAssembler(inputCols=[ 'Categotical_Gender' , 'Categotical_heart_disease' , 'Categotical_hyper_tension' , 'Categotical_married' , 'edad' ,
'Glucose_level' ],outputCol= 'mga tampok' )
16. Ibahin ang dating data sa isang panghuling DataFrame gamit ang transform() function at ipakita ito gamit ang show() function.
Output:
17. Ihanda ang data para sa pagsasanay at pagsubok sa pamamagitan ng paghahati nito sa 70-30. Ang 'mga tampok' ay nakaimbak sa train_data at ang 'Stroke' ay nakaimbak sa test_data.
# Maghanda ng data para sa pagsasanay at pagsuboktrain_data,test_data=final.select([ 'mga tampok' , 'Stroke' ]).randomSplit([ 0.70 , 0.30 ])
18. Pagkasyahin ang modelo ng Logistic Regression at suriin ito.
mula sa pyspark.ml.classification import LogisticRegression# Angkop ng modelo
logistic_regression_model=LogisticRegression(labelCol= 'Stroke' ).fit(train_data)
# Pagsusuri ng modelo
train_results=logistic_regression_model.evaluate(train_data).predictions
train_results.show()
Output:
19. Gamitin ang BinaryClassificationEvaluator upang suriin ang katumpakan ng modelo. Makikita natin na 100% tumpak ang ating modelo.
mula sa pyspark.ml.evaluation import BinaryClassificationEvaluator# tawagan ang BinaryClassificationEvaluator
resulta = BinaryClassificationEvaluator(rawPredictionCol= 'hula' ,labelCol= 'Stroke' )
ROC_AUC = results.evaluate(train_results)
print(ROC_AUC * 100 , '% Katumpakan' )
Konklusyon
Mahuhulaan mo ang problema sa real-tile classification gamit ang Logistic Regression model sa PySpark. Ang pag-alis ng mga null/nawawalang halaga ay mahalaga habang binabawasan ng mga ito ang pagsusuri at katumpakan ng modelo. Ang preprocessing ay isang kinakailangang hakbang bago ilapat ang anumang modelo ng machine learning. Tiyaking ginagawa mo ang hakbang na ito nang maayos at tumpak.