במדריך זה נראה תחילה את הגישה ולאחר מכן נחזה את השבץ של כל אדם על ידי ניתוח הנתונים צעד אחר צעד.
רגרסיה לוגיסטית
רגרסיה לוגיסטית, המכונה גם 'מודל לוגיט', משמשת בניתוח חזוי לבעיות סיווג. זהו מודל למידת מכונה שעובד רק על סיווג כדי לסווג את השיעורים (קטגוריות). לדוגמה, ישנן שתי קטגוריות בתרחיש שלנו (אדם שנפגע משבץ מוחי ואדם שלא סובל משבץ). היישומים הטובים ביותר של המודל הם חיזוי מחלות לב, חיזוי מגדר, חיזוי חיי יבול וכו'.
שלבים:
1. איסוף נתונים: הנתונים נחוצים לביצוע כל ניבוי/ניתוח. זה יכול להיות בצורת CSV/XLSX, בין היתר. אנחנו יכולים לטעון את זה לתוך סביבת Spark (DataFrame) באמצעות השיטה spark.read.csv() .
2. ניתוח נתונים : ניתוח התכונות/עמודות מכונה 'ניתוח נתונים'. העמודות המסייעות לחזות את המחלקה ידועות כ'תכונות עצמאיות'. העמודה שמביאה לחיזוי ידועה בשם 'תכונת תלות או יעד'. בתרחיש זה, נוכל להשתמש במאפיין עמודות כדי להציג את כל העמודות. השיטה distinct() משמשת כדי לראות את הערכים הייחודיים.
3. עיבוד נתונים מראש: סינון הערכים האפסים/החסרים מכונה 'עיבוד מקדים'. אנו מסירים את כל הערכים החסרים בשלב זה. המכונה יודעת רק את השפה הבינארית. לכן, יש להמיר את כל קטגוריות המחרוזות לערכים קטגוריים מספריים. ב-PySpark, נוכל להשתמש ב-'StringIndexer' שהוא המחלקה הזמינה במודול pyspark.ml.feature כדי להמיר את קטגוריות המחרוזות למספריות. זה ממיר אותם באופן אוטומטי. אנחנו לא צריכים לספק את הערכים. אתה יכול להשתמש בתחביר הבא:
indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,outputCol= 'שם_עמודה_חדש' )
4. הרכבת וקטור: כעת, יש לך את הנתונים שהמכונה יכולה להבין. בשלב זה, כל התכונות העצמאיות צריכות להיות וקטוריות לעמודה אחת. ניתן לעשות זאת באמצעות המחלקה VectorAssembler. זה דורש שני פרמטרים: הפרמטר הראשון הוא inputCols שלוקח רשימה של תכונות עצמאיות. הפרמטר השני הוא outputCol אשר מעביר את כל ה-inputCols למשתנה זה.
assembler=VectorAssembler(inputCols=[עמודות...],outputCol=vectorized_data)5. טרנספורמציה: כעת, הכן את הנתונים שלך על ידי שינוי העמודות המעודכנות (שלב 3) באמצעות הפונקציה transform() .
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. זה לוקח את תווית הכיתה/עמודת היעד. כתוצאה מכך נוצרות עמודות חיזוי raw, הסתברות וחיזוי. התוצאות שלנו מאוחסנות בעמודת החיזוי.
# התאמת דגםlogistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)
# הערכת מודל
train_results=logistic_regression_model.evaluate(train_data).predictions
8. דיוק ותוצאות: זהו השלב האחרון בו אנו בודקים את דיוק המודל באמצעות כל טכניקת בדיקה.
בואו נסתכל על הפרויקט הבא שבו אנו חוזים אם אדם מושפע משבץ או לא באמצעות מודל הרגרסיה הלוגיסטית.
חיזוי שבץ
9. התקן את מודול PySpark בסביבה שלך. להלן הפקודה להתקנה:
pip להתקין pyspark 
10. בואו ניצור PySpark DataFrame עם 10 רשומות הקשורות לפרטי שבץ של 10 אנשים. לצורך הדגמה, אנו יוצרים DataFrame ללא CSV. יש 7 עמודות ב-DataFrame זה. 'מין', 'רמת_גלוקוז', 'נשוי', 'גיל', 'מחלת לב', 'יתר_מתח' הן תכונות עצמאיות ו'שבץ מוחי' הוא תווית הכיתה או התכונה התלויה. זה אומר שהשבץ של אדם תלוי בתכונות העצמאיות הללו.
ייבוא pysparkמ-pyspark.sql ייבוא SparkSession
linuxhint_spark_app = SparkSession.builder.appName( 'רמז לינוקס' ).getOrCreate()
stoke_data =[
{ 'מִין' : 'נְקֵבָה' , 'גיל' : חמישים , 'מחלת לב' : 'כן' ,
'לַחַץ יֶתֶר' : 'כן' , 'נָשׂוּי' : 'כן' , 'רמת_גלוקוז' : 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. הצג את העמודות העצמאיות באמצעות שיטת select() .
# הצג תכונות עצמאיותstroke_df.select(stroke_df[ 'מִין' ],stroke_df[ 'רמת_גלוקוז' ],stroke_df[ 'נָשׂוּי' ],stroke_df[ 'גיל' ],stroke_df[ 'מחלת לב' ],stroke_df[ 'לַחַץ יֶתֶר' ]).הופעה()
תְפוּקָה:
12. הצג את הערכים הייחודיים הקיימים בתכונת המטרה (Stroke).
# ערכים ייחודיים של תכונת יעדstroke_df.select(stroke_df[ 'שבץ' ]).distinct().show()
תְפוּקָה:
13. החזר את סוג הנתונים של כל העמודות באמצעות הפונקציה printSchema() .
# החזרת סוג נתונים של כל העמודות.stroke_df.printSchema()
תְפוּקָה:
אנו יכולים לראות ש-4 עמודות הן מסוג מחרוזת. בואו נמיר אותם לערכים מספריים קטגוריים.
14. הבה נמיר את הערכים הקטגוריים של המחרוזת לערכים קטגוריים מספריים באמצעות ה-StringIndexer בעמודות 'מגדר', 'מחלת_לב', 'מתח_מתח' ו'נשואים' ונכתוב אותם לקטגוריות_מגדר, מחלת_לב_קטגוטיות, קטגוטיות_מרודות, וקטגוטיות. אחסן את העמודות ב-indexed_data DataFrame באמצעות שיטת fit() .
מ-pyspark.ml.feature ייבוא StringIndexer# המרת ערכים קטגוריים של מחרוזת לערכים קטגוריים מספריים בעמודה 'מגדר'.
indexer_data=StringIndexer(inputCol= 'מִין' ,outputCol= 'Categotical_Gender' )
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= 'מתח_קטגוטי' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# המרת ערכים קטגוריים של מחרוזת לערכים קטגוריים מספריים בעמודה 'נשואים'.
indexer_data=StringIndexer(inputCol= 'נָשׂוּי' ,outputCol= 'נשוי_קטגוטי' )
indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)
# הצג את המעודכן
indexed_data.show()
תְפוּקָה:
15. המר את העמודות הבלתי תלויות לווקטור באמצעות מרכיב הווקטור. שם הווקטור הוא 'תכונות'.
מ-pyspark.ml.feature ייבוא VectorAssemblerassembler= VectorAssembler(inputCols=[ 'Categotical_Gender' , 'מחלת לב_קטגוטית' , 'מתח_קטגוטי' , 'נשוי_קטגוטי' , 'גיל' ,
'רמת_גלוקוז' ],outputCol= 'מאפיינים' )
16. הפוך את הנתונים הקודמים ל-DataFrame סופי באמצעות הפונקציה transform() והצג אותם באמצעות הפונקציה show() .
תְפוּקָה:
17. הכינו את הנתונים לאימון ובדיקה על ידי פיצולם ל-70-30. ה'תכונות' מאוחסנות ב-train_data ו-'Stroke' מאוחסן ב-test_data.
# הכן נתונים להדרכה ובדיקהtrain_data,test_data=final.select([ 'מאפיינים' , 'שבץ' ]).randomSplit([ 0.70 , 0.30 ])
18. התאימו למודל הרגרסיה הלוגיסטית והעריכו אותו.
מ-pyspark.ml.classification ייבוא LogisticRegression# התאמת דגם
logistic_regression_model=LogisticRegression(labelCol= 'שבץ' ).fit(train_data)
# הערכת מודל
train_results=logistic_regression_model.evaluate(train_data).predictions
train_results.show()
תְפוּקָה:
19. השתמש ב-BinaryClassificationEvaluator כדי לבדוק את דיוק המודל. אנו יכולים לראות שהמודל שלנו מדויק ב-100%.
מ-pyspark.ml.evaluation ייבוא BinaryClassificationEvaluator# קרא ל-BinaryClassificationEvaluator
results = BinaryClassificationEvaluator(rawPredictionCol= 'נְבוּאָה' ,labelCol= 'שבץ' )
ROC_AUC = results.evaluate(train_results)
print(ROC_AUC * 100 , '% דיוק' )
סיכום
אתה יכול לחזות את בעיית סיווג האריחים האמיתיים באמצעות מודל הרגרסיה הלוגיסטית ב- PySpark. הסרת הערכים האפסים/החסרים חשובה מכיוון שהם מפחיתים את הערכת המודל והדיוק. עיבוד מקדים הוא שלב הכרחי לפני התאמת כל מודל למידת מכונה. ודא שאתה עושה את השלב הזה בצורה נכונה ומדויקת.