ఈ గైడ్‌లో, మేము మొదట విధానాన్ని చూస్తాము మరియు డేటాను దశలవారీగా విశ్లేషించడం ద్వారా ప్రతి వ్యక్తి యొక్క స్ట్రోక్‌ను అంచనా వేస్తాము.
లాజిస్టిక్ రిగ్రెషన్
లాజిస్టిక్ రిగ్రెషన్, 'లాజిట్ మోడల్' అని కూడా పిలుస్తారు, వర్గీకరణ సమస్యల కోసం ప్రిడిక్టివ్ అనలిటిక్స్‌లో ఉపయోగించబడుతుంది. ఇది మెషిన్ లెర్నింగ్ మోడల్, ఇది తరగతులను (కేటగిరీలు) వర్గీకరించడానికి వర్గీకరణపై మాత్రమే పనిచేస్తుంది. ఉదాహరణకు, మా దృష్టాంతంలో రెండు వర్గాలు ఉన్నాయి (స్ట్రోక్‌తో బాధపడుతున్న వ్యక్తి మరియు స్ట్రోక్‌తో ప్రభావితం కాని వ్యక్తి). మోడల్ యొక్క ఉత్తమ అనువర్తనాలు గుండె జబ్బుల అంచనా, లింగ అంచనా, పంట జీవిత అంచనా మొదలైనవి.
దశలు:
1. డేటా సేకరణ: ఏదైనా అంచనాలు/విశ్లేషణ చేయడానికి డేటా అవసరం. ఇది ఇతరులతో పాటు CSV/XLSX రూపంలో ఉండవచ్చు. మేము దీనిని spark.read.csv() పద్ధతిని ఉపయోగించి స్పార్క్ ఎన్విరాన్మెంట్ (డేటాఫ్రేమ్)లోకి లోడ్ చేయవచ్చు.
2. డేటా విశ్లేషణ : గుణాలు/నిలువు వరుసలను విశ్లేషించడాన్ని “డేటా విశ్లేషణ” అంటారు. తరగతిని అంచనా వేయడానికి సహాయపడే నిలువు వరుసలను 'స్వతంత్ర గుణాలు' అంటారు. అంచనాకు దారితీసే నిలువు వరుసను 'ఆధారిత లేదా లక్ష్య లక్షణం' అంటారు. ఈ దృష్టాంతంలో, మేము అన్ని నిలువు వరుసలను ప్రదర్శించడానికి నిలువు వరుసల ప్రాపర్టీని ఉపయోగించవచ్చు. ప్రత్యేక విలువలను చూడడానికి ప్రత్యేకమైన () పద్ధతి ఉపయోగించబడుతుంది.
3. డేటా ప్రిప్రాసెసింగ్: శూన్య/తప్పిపోయిన విలువలను ఫిల్టర్ చేయడాన్ని “ప్రీప్రాసెసింగ్” అంటారు. మేము ఈ దశలో తప్పిపోయిన అన్ని విలువలను తీసివేస్తాము. యంత్రానికి బైనరీ భాష మాత్రమే తెలుసు. కాబట్టి, అన్ని స్ట్రింగ్ కేటగిరీలు సంఖ్యా వర్గ విలువలకు మార్చబడాలి. PySparkలో, స్ట్రింగ్ వర్గాలను సంఖ్యకు మార్చడానికి pyspark.ml.feature మాడ్యూల్‌లో అందుబాటులో ఉన్న 'StringIndexer'ని ఉపయోగించవచ్చు. ఇది స్వయంచాలకంగా వాటిని అంతర్గతంగా మారుస్తుంది. మేము విలువలను అందించాల్సిన అవసరం లేదు. మీరు క్రింది వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,outputCol= 'కొత్త_నిలువు_పేరు' )
4. వెక్టర్ అసెంబ్లింగ్: ఇప్పుడు, మెషీన్ అర్థం చేసుకోగలిగే డేటా మీ వద్ద ఉంది. ఈ దశలో, అన్ని స్వతంత్ర లక్షణాలను ఒకే నిలువు వరుసలోకి వెక్టరైజ్ చేయాలి. ఇది వెక్టార్ అసెంబ్లర్ తరగతిని ఉపయోగించి చేయవచ్చు. ఇది రెండు పారామితులను తీసుకుంటుంది: మొదటి పరామితి స్వతంత్ర లక్షణాల జాబితాను తీసుకునే ఇన్‌పుట్‌కాల్స్. రెండవ పరామితి outputCol, ఇది అన్ని ఇన్‌పుట్‌కాల్‌లను ఈ వేరియబుల్‌లోకి వెక్టరైజ్ చేస్తుంది.
assembler=VectorAssembler(inputCols=[నిలువు వరుసలు...],outputCol=vectorized_data)5. పరివర్తన: ఇప్పుడు, ట్రాన్స్‌ఫార్మ్() ఫంక్షన్‌ని ఉపయోగించి అప్‌డేట్ చేయబడిన నిలువు వరుసలను (స్టెప్ 3) మార్చడం ద్వారా మీ డేటాను సిద్ధం చేయండి.
assembler.transform(inxed_data)
6. శిక్షణ & పరీక్ష కోసం డేటాను సిద్ధం చేయడం: ఈ దశలో, మేము డేటాను 'శిక్షణ' మరియు 'పరీక్ష'గా విభజించాము. మోడల్‌కు శిక్షణ ఇవ్వడానికి 70% డేటాను మరియు మోడల్‌ను పరీక్షించడానికి 30% డేటాను విభజించడం మంచిది. ఇది randomSplit() పద్ధతిని ఉపయోగించి సాధించవచ్చు. ఇది రెండు ఫ్లోట్ విలువలను కలిగి ఉన్న జాబితాను తీసుకుంటుంది: ఒకటి టెస్ట్ స్ప్లిట్ మరియు మరొకటి రైలు విభజన కోసం.
train_data,test_data=final_data.select([ 'లక్షణాలు' ,target_column]).randomSplit([0.70.0.30])7. మోడల్ ఫిట్టింగ్ & మూల్యాంకనం : ఇది లాజిస్టిక్ రిగ్రెషన్ మోడల్‌కు సరిపోయే సమయం. లాజిస్టిక్ రిగ్రెషన్ మోడల్ pyspark.ml.classification మాడ్యూల్‌లో అందుబాటులో ఉంది. ఇది క్లాస్ లేబుల్/టార్గెట్ కాలమ్‌ను తీసుకుంటుంది. ఇది ముడి అంచనా, సంభావ్యత మరియు అంచనా నిలువు వరుసలకు దారి తీస్తుంది. మా ఫలితాలు అంచనా కాలమ్‌లో నిల్వ చేయబడ్డాయి.
# మోడల్ ఫిట్టింగ్logistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# మోడల్ మూల్యాంకనం
train_results=logistic_regression_model.evaluate(train_data).predictions
8. ఖచ్చితత్వం & ఫలితాలు: ఏదైనా టెస్టింగ్ టెక్నిక్‌లను ఉపయోగించి మేము మోడల్ ఖచ్చితత్వాన్ని పరీక్షించే చివరి దశ ఇది.
లాజిస్టిక్ రిగ్రెషన్ మోడల్‌ని ఉపయోగించకుండా ఒక వ్యక్తి స్ట్రోక్‌తో ప్రభావితమయ్యాడో లేదో మనం అంచనా వేసే క్రింది ప్రాజెక్ట్‌ను చూద్దాం.
స్ట్రోక్ ప్రిడిక్షన్
9. మీ వాతావరణంలో PySpark మాడ్యూల్‌ను ఇన్‌స్టాల్ చేయండి. ఇన్‌స్టాల్ చేయడానికి కింది ఆదేశం ఉంది:
పిప్ ఇన్‌స్టాల్ పిస్పార్క్ 
10. 10 మంది వ్యక్తుల స్ట్రోక్ వివరాలకు సంబంధించిన 10 రికార్డులతో PySpark DataFrameని క్రియేట్ చేద్దాం. ప్రదర్శన కోసం, మేము CSV లేకుండా డేటాఫ్రేమ్‌ని సృష్టిస్తాము. ఈ డేటాఫ్రేమ్‌లో 7 నిలువు వరుసలు ఉన్నాయి. “లింగం”, “గ్లూకోజ్_లెవెల్”, “వివాహం”, “వయస్సు”, “హృదయ_వ్యాధి”, “హైపర్_టెన్షన్” అనేది స్వతంత్ర లక్షణాలు మరియు “స్ట్రోక్” అనేది క్లాస్ లేబుల్ లేదా డిపెండెంట్ లక్షణం. అంటే ఒక వ్యక్తి యొక్క స్ట్రోక్ ఈ స్వతంత్ర లక్షణాలపై ఆధారపడి ఉంటుంది.
పైస్పార్క్ దిగుమతిpyspark.sql దిగుమతి SparkSession నుండి
linuxhint_spark_app = SparkSession.builder.appName( 'Linux సూచన' ).getOrCreate()
స్టోక్_డేటా =[
{ 'లింగం' : 'స్త్రీ' , 'వయస్సు' : యాభై , 'గుండె వ్యాధి' : 'అవును' ,
'హైపర్_టెన్షన్' : 'అవును' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 130 , 'స్ట్రోక్' : 1 },
{ 'లింగం' : 'పురుషుడు' , 'వయస్సు' : ఇరవై , 'గుండె వ్యాధి' : 'లేదు' ,
'హైపర్_టెన్షన్' : 'అవును' , 'వివాహం' : 'లేదు' , 'గ్లూకోజ్_స్థాయి' : 97 , 'స్ట్రోక్' : 0 },
{ 'లింగం' : 'పురుషుడు' , 'వయస్సు' : 12 , 'గుండె వ్యాధి' : 'లేదు' ,
'హైపర్_టెన్షన్' : 'లేదు' , 'వివాహం' : 'లేదు' , 'గ్లూకోజ్_స్థాయి' : 98 , 'స్ట్రోక్' : 0 },
{ 'లింగం' : 'స్త్రీ' , 'వయస్సు' : 90 , 'గుండె వ్యాధి' : 'లేదు' ,
'హైపర్_టెన్షన్' : 'లేదు' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 170 , 'స్ట్రోక్' : 1 },
{ 'లింగం' : 'పురుషుడు' , 'వయస్సు' : 43 , 'గుండె వ్యాధి' : 'అవును' ,
'హైపర్_టెన్షన్' : 'అవును' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 150 , 'స్ట్రోక్' : 1 },
{ 'లింగం' : 'స్త్రీ' , 'వయస్సు' : ఇరవై ఒకటి , 'గుండె వ్యాధి' : 'లేదు' ,
'హైపర్_టెన్షన్' : 'లేదు' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 110 , 'స్ట్రోక్' : 0 },
{ 'లింగం' : 'స్త్రీ' , 'వయస్సు' : యాభై , 'గుండె వ్యాధి' : 'అవును' ,
'హైపర్_టెన్షన్' : 'లేదు' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 100 , 'స్ట్రోక్' : 0 },
{ 'లింగం' : 'పురుషుడు' , 'వయస్సు' : 3. 4 , 'గుండె వ్యాధి' : 'లేదు' ,
'హైపర్_టెన్షన్' : 'అవును' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 190 , 'స్ట్రోక్' : 1 },
{ 'లింగం' : 'పురుషుడు' , 'వయస్సు' : 10 , 'గుండె వ్యాధి' : 'లేదు' ,
'హైపర్_టెన్షన్' : 'లేదు' , 'వివాహం' : 'లేదు' , 'గ్లూకోజ్_స్థాయి' : 90 , 'స్ట్రోక్' : 0 },
{ 'లింగం' : 'స్త్రీ' , 'వయస్సు' : 56 , 'గుండె వ్యాధి' : 'అవును' ,
'హైపర్_టెన్షన్' : 'అవును' , 'వివాహం' : 'అవును' , 'గ్లూకోజ్_స్థాయి' : 145 , 'స్ట్రోక్' : 1 }
]
# పై డేటా నుండి డేటాఫ్రేమ్‌ను సృష్టించండి
stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)
# వాస్తవ స్టోక్_df
stroke_df.show()
అవుట్‌పుట్:
11. సెలెక్ట్() పద్ధతిని ఉపయోగించి స్వతంత్ర నిలువు వరుసలను ప్రదర్శించండి.
# స్వతంత్ర లక్షణాలను ప్రదర్శించండిstroke_df.select(stroke_df[ 'లింగం' ],స్ట్రోక్_డిఎఫ్[ 'గ్లూకోజ్_స్థాయి' ],స్ట్రోక్_డిఎఫ్[ 'వివాహం' ],స్ట్రోక్_డిఎఫ్[ 'వయస్సు' ],స్ట్రోక్_డిఎఫ్[ 'గుండె వ్యాధి' ],స్ట్రోక్_డిఎఫ్[ 'హైపర్_టెన్షన్' ]).షో()
అవుట్‌పుట్:
12. లక్ష్య లక్షణం (స్ట్రోక్)లో ఉన్న ప్రత్యేక విలువలను ప్రదర్శించండి.
# లక్ష్య లక్షణం ప్రత్యేక విలువలుstroke_df.select(stroke_df[ 'స్ట్రోక్' ]).విశిష్ట().షో()
అవుట్‌పుట్:
13. printSchema() ఫంక్షన్‌ని ఉపయోగించి అన్ని నిలువు వరుసల డేటా రకాన్ని తిరిగి ఇవ్వండి.
# అన్ని నిలువు వరుసల డేటా రకాన్ని తిరిగి ఇవ్వండి.stroke_df.printSchema()
అవుట్‌పుట్:
4 నిలువు వరుసలు స్ట్రింగ్ రకంగా ఉన్నాయని మనం చూడవచ్చు. వాటిని వర్గీకరణ సంఖ్యా విలువలుగా మారుద్దాం.
14. 'లింగం', 'హార్ట్_డిసీజ్', 'హైపర్_టెన్షన్' మరియు 'వివాహితులు' కాలమ్‌లలోని స్ట్రింగ్ ఇండెక్సర్‌ని ఉపయోగించి స్ట్రింగ్ వర్గీకరణ విలువలను సంఖ్యా వర్గ విలువలుగా మారుద్దాం మరియు వీటిని Categotical_Gender, Categotical_heart_disease. ఫిట్() పద్ధతిని ఉపయోగించి ఇండెక్స్డ్_డేటా డేటాఫ్రేమ్‌లో నిలువు వరుసలను నిల్వ చేయండి.
pyspark.ml.feature దిగుమతి StringIndexer నుండి# 'లింగం' నిలువు వరుసలో స్ట్రింగ్ వర్గీకరణ విలువలను సంఖ్యా వర్గ విలువలుగా మార్చండి.
indexer_data=StringIndexer(inputCol= 'లింగం' ,outputCol= 'వర్గీకరణ_లింగం' )
indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)
# 'గుండె_వ్యాధి' నిలువు వరుసలో స్ట్రింగ్ వర్గీకరణ విలువలను సంఖ్యా వర్గ విలువలుగా మార్చండి.
indexer_data=StringIndexer(inputCol= 'గుండె వ్యాధి' ,outputCol= 'వర్గసంబంధమైన_గుండె_వ్యాధి' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# 'హైపర్_టెన్షన్' నిలువు వరుసలో స్ట్రింగ్ వర్గీకరణ విలువలను సంఖ్యా వర్గ విలువలుగా మార్చండి.
indexer_data=StringIndexer(inputCol= 'హైపర్_టెన్షన్' ,outputCol= 'Categotical_hyper_tension' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# 'వివాహం' కాలమ్‌లో స్ట్రింగ్ వర్గీకరణ విలువలను సంఖ్యా వర్గ విలువలుగా మార్చండి.
indexer_data=StringIndexer(inputCol= 'వివాహం' ,outputCol= 'Categotical_married' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# నవీకరించబడిన వాటిని ప్రదర్శించు
indexed_data.show()
అవుట్‌పుట్:
15. వెక్టర్ అసెంబ్లర్ ఉపయోగించి స్వతంత్ర నిలువు వరుసలను వెక్టర్‌గా మార్చండి. వెక్టర్ పేరు 'లక్షణాలు'.
pyspark.ml.feature దిగుమతి VectorAssembler నుండిఅసెంబ్లర్= వెక్టార్ అసెంబ్లర్(ఇన్‌పుట్‌కాల్స్=[ 'వర్గీకరణ_లింగం' , 'వర్గసంబంధమైన_గుండె_వ్యాధి' , 'Categotical_hyper_tension' , 'Categotical_married' , 'వయస్సు' ,
'గ్లూకోజ్_స్థాయి' ],outputCol= 'లక్షణాలు' )
16. ట్రాన్స్‌ఫార్మ్() ఫంక్షన్‌ని ఉపయోగించి మునుపటి డేటాను తుది డేటాఫ్రేమ్‌గా మార్చండి మరియు షో() ఫంక్షన్‌ని ఉపయోగించి దాన్ని ప్రదర్శించండి.
అవుట్‌పుట్:
17. శిక్షణ మరియు పరీక్ష కోసం డేటాను 70-30గా విభజించడం ద్వారా సిద్ధం చేయండి. “ఫీచర్‌లు” రైలు_డేటాలో నిల్వ చేయబడతాయి మరియు “స్ట్రోక్” టెస్ట్_డేటాలో నిల్వ చేయబడతాయి.
# శిక్షణ మరియు పరీక్ష కోసం డేటాను సిద్ధం చేయండిtrain_data, test_data=final.select([ 'లక్షణాలు' , 'స్ట్రోక్' ]).రాండమ్‌స్ప్లిట్([ 0.70 , 0.30 ])
18. లాజిస్టిక్ రిగ్రెషన్ మోడల్‌ను అమర్చండి మరియు దానిని మూల్యాంకనం చేయండి.
pyspark.ml.classification దిగుమతి లాజిస్టిక్ రిగ్రెషన్ నుండి# మోడల్ ఫిట్టింగ్
logistic_regression_model=లాజిస్టిక్ రిగ్రెషన్(labelCol= 'స్ట్రోక్' ).fit(రైలు_డేటా)
# మోడల్ మూల్యాంకనం
train_results=logistic_regression_model.evaluate(train_data).predictions
train_results.show()
అవుట్‌పుట్:
19. మోడల్ ఖచ్చితత్వాన్ని తనిఖీ చేయడానికి బైనరీ క్లాసిఫికేషన్ ఎవాల్యుయేటర్‌ని ఉపయోగించండి. మా మోడల్ 100% ఖచ్చితమైనదని మనం చూడవచ్చు.
pyspark.ml.evaluation దిగుమతి బైనరీ క్లాసిఫికేషన్ ఎవాల్యుయేటర్ నుండి# బైనరీ క్లాసిఫికేషన్ ఎవాల్యుయేటర్‌కు కాల్ చేయండి
ఫలితాలు = BinaryClassificationEvaluator(rawPredictionCol= 'భవిష్య వాణి' ,labelCol= 'స్ట్రోక్' )
ROC_AUC = ఫలితాలు.మూల్యాంకనం(రైలు_ఫలితాలు)
ప్రింట్ (ROC_AUC * 100 , '% ఖచ్చితత్వం' )
ముగింపు
మీరు PySparkలోని లాజిస్టిక్ రిగ్రెషన్ మోడల్‌ని ఉపయోగించి రియల్-టైల్ వర్గీకరణ సమస్యను అంచనా వేయగలరు. మోడల్ మూల్యాంకనం మరియు ఖచ్చితత్వాన్ని తగ్గించడం వలన శూన్య/తప్పిపోయిన విలువలను తీసివేయడం ముఖ్యం. ఏదైనా మెషిన్ లెర్నింగ్ మోడల్‌ను అమర్చడానికి ముందు ప్రీప్రాసెసింగ్ అనేది ఒక అవసరమైన దశ. మీరు ఈ దశను సరిగ్గా మరియు ఖచ్చితంగా చేశారని నిర్ధారించుకోండి.