מדריך סופי לאלגוריתם היער האקראי עם Python ו-Skikit-Learn

מבוא

אלגוריתם היער האקראי הוא אחד האלגוריתמים הגמישים, החזקים והנפוצים ביותר עבור סיווג ורגרסיה, בנוי כ- אנסמבל של עצי החלטה.

אם אינך מכיר את אלה - אל דאגה, אנו נסקור את כל המושגים הללו.

במדריך מעשי מעמיק זה, נבנה אינטואיציה על האופן שבו פועלים עצי החלטה, כיצד ההרכבה מגבירה מסווגים ורגרסורים בודדים, מהם יערות אקראיים ולבנות מסווג ורגרסור יער אקראי באמצעות Python ו-Skit-Learn, באמצעות מיני-פרויקט מקצה לקצה, ולענות על שאלת מחקר.

קחו בחשבון שאתם כרגע חלק מקבוצת מחקר שמנתחת נתונים על נשים. הקבוצה אספה 100 רשומות נתונים והיא רוצה להיות מסוגלת לארגן את הרישומים הראשוניים על ידי חלוקת הנשים לקטגוריות: בהריון או לא, וחיות באזורים כפריים או עירוניים. החוקרים רוצים להבין כמה נשים יהיו בכל קטגוריה.

יש מבנה חישובי שעושה בדיוק את זה, הוא ה עץ מִבְנֶה. על ידי שימוש במבנה עץ, תוכל לייצג את החטיבות השונות לכל קטגוריה.

עצי החלטה

איך מאכלסים את הצמתים של עץ? זה איפה עצי החלטה להיכנס לפוקוס.

ראשית, נוכל לחלק את הרישומים לפי הריון, לאחר מכן נוכל לחלק אותם על ידי מגורים באזורים עירוניים או כפריים. שימו לב, שאנחנו יכולים לעשות זאת בסדר אחר, לחלק תחילה באיזה אזור חיות הנשים ולאחריו לפי מצב ההריון שלהן. מכאן, אנו יכולים לראות שלעץ יש היררכיה אינהרנטית. מלבד ארגון המידע, עץ מארגן מידע בצורה היררכית - סדר הופעת המידע חשוב ומוביל לעצים שונים כתוצאה מכך.

להלן דוגמה לעץ שתואר:

בתמונת העץ יש 7 ריבועים, זה למעלה המהווה סך של 100 נשים, הריבוע העליון הזה מחובר לשני ריבועים למטה, המחלקים את הנשים לפי מספרן של 78 לא בהריון ו-22 בהריון, וכן משני המשבצות הקודמות יש ארבעה ריבועים; שניים מחוברים לכל ריבוע מעל המחלקים את הנשים לפי שטחן, עבור הלא בהריון 45 מתגוררות באזור עירוני, 33 באזור כפרי ואצל ההריוניות 14 מתגוררות באזור כפרי ו-8 באזור עירוני. רק על ידי הסתכלות על העץ, קל להבין את החלוקים הללו ולראות כיצד כל "שכבה" נגזרת מהשכבות הקודמות, השכבות הללו הן העץ רמות, הרמות מתארות את עומק של העץ:

שימו לב בתמונה למעלה שרמת העץ הראשונה היא רמת 0 שבו יש רק ריבוע אחד, ואחריו רמת 1 שבו יש שני ריבועים, ו רמת 2 שבו יש ארבעה ריבועים. זה עומק 2 עֵץ.

ברמה 0 נקרא הריבוע שמקורו בעץ, הראשון צומת שורש, לשורש הזה יש שניים צמתים של ילדים ברמה 1, כלומר צמתי הורה לארבעת הצמתים ברמה 2. ראה שה"ריבועים" שהזכרנו עד כה, נקראים למעשה צמתים; ושכל צומת קודם הוא הורה לצמתים הבאים, שהם הילדים שלו. צמתי הצאצא של כל רמה שיש להם אותו הורה נקראים אחים, כפי שניתן לראות בתמונה הבאה:

בתמונה הקודמת, אנו מציגים גם את רמה 1 בתור צמתים פנימיים, ברגע שהם נמצאים בין השורש לצמתים האחרונים, שהם ה- צמתים עלים. בלוטות העלים הן החלק האחרון של עץ, אם היינו אומרים מתוך 100 הנשים הראשוניות, כמה הן בהריון וחיות באזורים כפריים, נוכל לעשות זאת על ידי הסתכלות על העלים. אז המספר על הדפים יענה על שאלת המחקר הראשונה.

אם היו רישומים חדשים של נשים, והעץ ששימש בעבר לקטגוריהן, שימש כעת כדי להחליט אם אישה יכולה או לא יכולה להיות חלק מהמחקר, האם הוא עדיין מתפקד? העץ ישתמש באותם קריטריונים, ואישה תהיה כשירה להשתתף אם בהיריון ומתגוררת באזור כפרי.

על ידי התבוננות בתמונה למעלה, נוכל לראות שהתשובות לשאלות של כל צומת עץ - "האם היא משתתפת?", "האם היא בהריון?", "האם היא גרה באזור כפרי?" - הן כן, כן, וכן, אז נראה שהעץ יכול להוביל להחלטה, במקרה זה, שהאישה תוכל לקחת חלק במחקר.

זה מהות של עצי החלטה ב, נעשה בצורה ידנית. באמצעות Machine Learning, אנו יכולים לבנות מודל הבונה עבורנו את העץ הזה באופן אוטומטי, באופן כזה כדי למקסם את הדיוק של ההחלטות הסופיות.

בדוגמאות הקודמות, ראה כיצד העץ יכול גם כן לסווג נתונים חדשים בתור משתתף או לא משתתף, או שניתן לשנות את השאלות ל- "כמה הם משתתפים?", "כמה הם בהריון?", "כמה גרים באזור כפרי?"- מה שמוביל אותנו למצוא את כמות של משתתפות בהריון המתגוררות באזור כפרי.

כאשר הנתונים מסווגים, זה אומר שהעץ מבצע א מיון משימה, וכאשר נמצאה כמות הנתונים, העץ מבצע א נסיגה מְשִׁימָה. המשמעות היא שעץ ההחלטות יכול לשמש עבור שתי המשימות - סיווג ורגרסיה.

כעת, לאחר שהבנו מהו עץ החלטות, כיצד ניתן להשתמש בו ואיזו מינוח משמש לתיאורו, אנו יכולים לתהות לגבי מגבלותיו.

הבנת יערות אקראיים

מה קורה להחלטה אם משתתף כלשהו חי על החלוקה בין אזורים עירוניים לכפריים? האם העץ יוסיף את השיא הזה לכפר או עירוני? נראה שקשה להתאים את הנתונים האלה למבנה שיש לנו כרגע, מכיוון שהם די ברורים.

כמו כן, מה אם אישה שחיה על סירה משתתפת במחקר, האם זה ייחשב כפרי או עירוני? באותו אופן כמו המקרה הקודם, זוהי נקודת נתונים מאתגרת לסיווג בהתחשב באפשרויות הזמינות בעץ.

על ידי חשיבה קצת יותר על דוגמה של עץ ההחלטות, אנו יכולים לראות שהיא יכולה לסווג נכון נתונים חדשים בהתחשב בכך שהם כבר עוקבים אחר דפוס שכבר יש לעץ - אך כאשר יש רשומות השונות מהנתונים הראשוניים שהגדירו את העץ, מבנה העץ נוקשה מדי, מה שהופך את הרשומות לא ניתנות לסיווג.

המשמעות היא שעץ ההחלטות יכול להיות קפדני ומוגבל באפשרויותיו. עץ החלטות אידיאלי יהיה גמיש יותר ומסוגל להכיל נתונים בלתי נראים ניואנסים יותר.

לגבי התשובה לשאלה הראשונית, אנחנו כבר יודעים שהיא תוצפן בעלי העץ – אבל מה משתנה כשיש לנו הרבה עצים במקום אחד?

אם העצים משולבים לסיווג, התוצאה תוגדר על ידי רוב התשובות, זה נקרא הצבעת רוב; ובמקרה של רגרסיה, המספר שניתן על ידי כל עץ ביער יהיה בממוצע.

אנסמבל למידה והרכבי מודל

שיטה זו ידועה בשם לימוד הרכבים. בעת שימוש בלימוד אנסמבל, אתה יכול לערבב כל אלגוריתם יחד, כל עוד אתה יכול להבטיח שניתן לנתח את הפלט ולשלב אותו עם פלטים אחרים (באופן ידני או באמצעות ספריות קיימות). בדרך כלל, אתה מרכיב דגמים מרובים מאותו סוג יחד, כגון עצי החלטה מרובים, אבל אתה לא מוגבל רק להצטרף להרכבים מאותו דגם.

Ensembling היא דרך מובטחת כמעט להכליל טוב יותר לבעיה, ולסחוט שיפור קל בביצועים. במקרים מסוימים, שילוב מודלים מניב א משמעותי עלייה בכוח הניבוי, ולפעמים, רק קלה. זה תלוי במערך הנתונים שבו אתה מתאמן ומעריך, כמו גם במודלים עצמם.

צירוף עצי החלטה יחד מניב משמעותי שיפורי ביצועים בהשוואה לעצים בודדים. גישה זו זכתה לפופולריות בקהילות המחקר והלמידת מכונה יישומית, והייתה כה נפוצה עד שמכלול עצי ההחלטה נקרא בשפה הרווחת יער, והסוג הנפוץ של היער שנוצר (יער של עצי החלטה על תת-קבוצה אקראית של תכונות) הפך את השם לפופולרי יערות אקראיים.

לאור שימוש בקנה מידה רחב, ספריות כמו Scikit-Learn הטמיעו עטיפות עבור RandomForestRegressorים ו RandomForestClassifiers, שנבנו על גבי יישומי עץ ההחלטות שלהם, כדי לאפשר לחוקרים להימנע מבניית הרכבים משלהם.

בואו נצלול לתוך יערות אקראיים!

כיצד פועל אלגוריתם היער האקראי?

להלן השלבים הבסיסיים המעורבים בעת ביצוע אלגוריתם היער האקראי:

1. בחר מספר רשומות אקראיות, זה יכול להיות כל מספר, כגון 4, 20, 76, 150, או אפילו 2.000 מתוך מערך הנתונים (נקרא N רשומות). המספר יהיה תלוי ברוחב של מערך הנתונים, ככל שיותר רחב, כך גדול יותר N יכול להיות. זה המקום שבו ה אקראי חלק בשמו של האלגוריתם מגיע ממנו!
2. בנה עץ החלטות על סמך אלה N רשומות אקראיות;
3. לפי מספר העצים שהוגדרו עבור האלגוריתם, או מספר העצים ביער, חזור על שלבים 1 ו-2. זה יוצר יותר עצים מקבוצות של רשומות נתונים אקראיות;
4. לאחר שלב 3, מגיע השלב האחרון, שהוא חיזוי התוצאות:
   • במקרה של סיווג: כל עץ ביער ינבא את הקטגוריה אליה שייך השיא החדש. לאחר מכן, השיא החדש מוקצה לקטגוריה הזוכה בהצבעות הרוב.
   • במקרה של רגרסיה: כל עץ ביער מנבא ערך עבור הרשומה החדשה, וערך החיזוי הסופי יחושב על ידי לקיחת ממוצע של כל הערכים שנחזו על ידי כל העצים ביער.

לכל עץ מתאים תת-קבוצה אקראית של תכונות לא יהיה בהכרח ידע על כמה תכונות אחרות, מה שמתוקן על ידי הרכבה, תוך שמירה על עלות החישוב נמוכה יותר.

עם אינטואיציה לגבי איך עצים עובדים, והבנה של יערות אקראיים - הדבר היחיד שנותר הוא לתרגל בנייה, אימון וכוונון שלהם על נתונים!

בנייה והדרכה של מודלים אקראיים של יער עם Scikit-Learn

הייתה סיבה לכך שהדוגמאות ששימשו עד כה כוללות הריון, אזור מגורים ונשים.

בשנת 2020, חוקרים מבנגלדש שמו לב שהתמותה בקרב נשים הרות עדיין גבוהה מאוד, במיוחד בהתחשב באלה שחיות באזורים כפריים. בגלל זה, הם השתמשו במערכת ניטור IOT כדי לנתח את הסיכון לבריאות האם. מערכת ה-IOT אספה נתונים מבתי חולים שונים, מרפאות קהילתיות וטיפולי בריאות אימהות מהאזורים הכפריים של בנגלדש.

הנתונים שנאספו אורגנו לאחר מכן בקובץ ערכים מופרדים בפסיקים (csv) והועלו אל מאגר למידת מכונה של UCI.

אלו הנתונים שבהם נשתמש כדי לתרגל ולנסות להבין אם לאישה בהריון יש א נמוך, בינוני or גָבוֹהַ סיכון לתמותה.

שימוש ביער אקראי לסיווג

מכיוון שאנו רוצים לדעת אם לאישה יש א נמוך, בינוני or גָבוֹהַ סיכון לתמותה, זה אומר שנבצע סיווג עם שלושה מחלקות. כאשר לבעיה יש יותר משתי מחלקות, היא נקראת a מולטי קלאס בעיה, בניגוד לא בינרי בעיה (כאשר אתה בוחר בין שתי מחלקות, בדרך כלל 0 ו 1).

בדוגמה הראשונה הזו, ניישם מודל סיווג רב-מחלקות עם מסווג יער אקראי ו-Scikit-Learn של Python.

אנו נעקוב אחר השלבים הרגילים של למידת מכונה כדי לפתור בעיה זו, שהם טעינת ספריות, קריאת הנתונים, הסתכלות על סטטיסטיקות סיכום ויצירת הדמיות נתונים כדי להבין אותן טוב יותר. לאחר מכן, עיבוד מוקדם ופיצול הנתונים ולאחר מכן יצירה, הדרכה והערכת מודל.

יבוא ספריות

אנו נשתמש ב-Pandas כדי לקרוא את הנתונים, ב-Seaborn וב-Matplotlib כדי להמחיש אותם, וב-NumPy עבור שיטות השירות הנהדרות:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

ייבוא ​​מערך הנתונים

הקוד הבא מייבא את מערך הנתונים וטוען אותו לפייתון DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

כדי להסתכל על חמש השורות הראשונות של הנתונים, אנו מבצעים את head() פקודה:

dataset.head()

תפוקות אלה:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

כאן אנו יכולים לראות את כל התכונות שנאספו במהלך המחקר.

• גיל: גילאים בשנים.
• SystolicBP: ערך עליון של לחץ דם ב-mmHg, תכונה משמעותית במהלך ההריון.
• DiastolicBP: ערך נמוך יותר של לחץ דם ב-mmHg, תכונה משמעותית נוספת במהלך ההריון.
• BS: רמות הגלוקוז בדם במונחים של ריכוז מולארי, mmol/L.
• קצב לב: דופק במנוחה בפעימות לדקה.
• רמת סיכון: רמת הסיכון במהלך ההריון.
• BodyTemp: טמפרטורת הגוף.

עכשיו, כשאנחנו מבינים יותר על מה נמדד, אנחנו יכולים להסתכל על סוגי הנתונים איתם info():

dataset.info()

זו התוצאה:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

מתוך התבוננות ב RangeIndex בשורה, אנו יכולים לראות שיש 1014 רשומות, והעמודה Non-Null Count מודיע שלנתונים אין ערכים חסרים. משמעות הדבר היא, שלא נצטרך לבצע שום טיפול עבור נתונים חסרים!

ב Dtype בעמודה, נוכל לראות את הסוג של כל משתנה. כַּיוֹם, float64 עמודות כאלה BS ו BodyTemp בעלי ערכים מספריים שעשויים להשתנות בכל טווח, כגון 15.0, 15.51, 15.76, 17.28, מה שהופך אותם רציף מספרית (אתה תמיד יכול להוסיף 0 למספר נקודה צפה, אינסופי). מצד שני משתנים כגון Age, SystolicBP, DiastolicBP, ו HeartRate הם מהסוג int64, זה אומר שהמספרים משתנים רק לפי היחידה, כמו 11, 12, 13, 14 - לא יהיה לנו דופק של 77.78, זה או 77 או 78 - אלה הם דיסקרטי מספרית ערכים. וגם לנו יש RiskLevel עם object סוג, זה בדרך כלל מציין שהמשתנה הוא טקסט, וכנראה שנצטרך להפוך אותו למספר. מכיוון שרמת הסיכון גדלה מנמוכה לגבוהה, יש סדר מרומז בקטגוריות, זה מצביע על סידור קטגורי משתנה

לאחר הסתכלות על סוגי נתונים, נוכל להשתמש describe() כדי לקחת שיא בכמה סטטיסטיקות תיאוריות, כגון הערכים הממוצעים של כל עמודה, סטיית התקן, קוונטילים, ערכי נתונים מינימליים ומקסימליים:

dataset.describe().T 

הקוד לעיל מציג:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

שימו לב שברוב העמודות, ה אומר הערכים רחוקים מה- סטיית תקן (סטד) - זה מצביע על כך שהנתונים לא בהכרח עוקבים אחר התפלגות סטטיסטית מתנהגת היטב. אם כן, זה היה עוזר למודל בעת חיזוי הסיכון. מה שאפשר לעשות כאן הוא לעבד מראש את הנתונים כדי שיהיו ייצוגיים יותר כאילו היו נתונים מכל אוכלוסיית העולם, או יותר מנורמל. אבל, יתרון בעת ​​שימוש בדגמי יער אקראי עבור מיון, הוא שמבנה העץ המובנה יכול להתמודד היטב עם נתונים שלא נורמלו, ברגע שהוא מחלק אותם בערך בכל רמת עץ עבור כל משתנה.

כמו כן, מכיוון שאנו משתמשים בעצים ושהמחלקה המתקבלת תתקבל על ידי הצבעה, איננו משווים מטבענו בין ערכים שונים, רק בין אותם סוגי ערכים, ולכן התאמת התכונות לאותו קנה מידה אינה הכרחית במקרה זה . זה אומר שמודל הסיווג של יער אקראי הוא קנה מידה בלתי משתנה, ואתה לא צריך לבצע קנה מידה של תכונות.

במקרה זה, השלב בעיבוד המקדים של הנתונים שאנו יכולים לעשות הוא להפוך את הקטגוריה RiskLevel עמודה למספרית.

הדמיה של הנתונים

לפני שינוי RiskLevel, בואו גם נדמיין במהירות את הנתונים על ידי התבוננות בשילובי הנקודות עבור כל זוג תכונות עם תרשים פיזור וכיצד הנקודות מתפלגות על ידי הדמיית עקומת ההיסטוגרמה. לשם כך, נשתמש ב-Seaborn's pairplot() המשלב את שתי העלילות. זה מייצר את שתי המגרשים עבור כל שילוב של תכונה ומציג את הצבעים המקודדים לפי רמת הסיכון שלהם עם hue נכס:

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

הקוד לעיל יוצר:

כאשר מסתכלים על העלילה, המצב האידיאלי יהיה הפרדה ברורה בין עקומות לנקודות. כפי שאנו יכולים לראות, שלושת סוגי מחלקות הסיכון מתערבבים בעיקר, מכיוון שהעצים מציירים קווים באופן פנימי בעת תוחמות הרווחים בין נקודות, אנו יכולים לשער שיותר עצים ביער יוכלו להגביל יותר רווחים ולסווג טוב יותר את הנקודות.

עם ניתוח הנתונים החקרניים הבסיסיים שנעשה, נוכל לעבד מראש את RiskLevel עמודה.

עיבוד מוקדם של נתונים לסיווג

כדי להיות בטוח יש רק שלושה מחלקות של RiskLevel בנתונים שלנו, ושלא נוספו ערכים אחרים בטעות, אנחנו יכולים להשתמש unique() כדי להציג את הערכים הייחודיים של העמודה:

dataset['RiskLevel'].unique()

תפוקות אלה:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

השיעורים נבדקים, כעת השלב הבא הוא להפוך כל ערך למספר. מכיוון שיש סדר בין סיווגים, נוכל להשתמש בערכים 0, 1 ו-2 כדי לסמן נמוך, בינוני ו גָבוֹהַ סיכונים. ישנן דרכים רבות לשנות את ערכי העמודות, בעקבות זה של Python פשוט עדיף על מורכב המוטו, נשתמש ב- .replace() שיטה, ופשוט החליפו אותם בייצוגי המספרים השלמים שלהם:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

לאחר החלפת הערכים, נוכל לחלק את הנתונים למה שישמש לאימון המודל, ה מאפיינים or X, ומה שאנחנו רוצים לחזות, ה תוויות or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

פעם אחת X ו y סטים מוכנים, אנחנו יכולים להשתמש ב-Scikit-Learn train_test_split() שיטה לחלק אותם עוד יותר למערכות הרכבת והבדיקה:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

כאן אנו משתמשים ב-20% מהנתונים לבדיקות ו-80% לאימון.

הכשרת RandomForestClassifier

אסמבלים מיושמים של Scikit-Learn תחת ה sklearn.ensemble מודול. אנסמבל של עצי החלטה המשמשים לסיווג, שבו מתקבלת הצבעת רוב, מיושם כ- RandomForestClassifier.

עם הרכבת וערכות הבדיקה, נוכל לייבא את RandomForestClassifier בכיתה וליצור את המודל. כדי להתחיל, בואו ניצור יער עם שלושה עצים, על ידי הגדרה n_estimators פרמטר כ-3, ולכל עץ יש שלוש רמות, לפי הגדרה max_depthל- 2:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

כדי להתאים את המודל סביב הנתונים - אנו קוראים את fit() שיטה, תוך העברת תכונות האימון והתוויות:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

כעת אנו יכולים להשוות את התוויות החזויות מול התוויות האמיתיות כדי להעריך עד כמה המודל הצליח! לפני הערכת המודל, בואו נסתכל לתוך האנסמבל.

כדי להסתכל קצת יותר לעומק במודל, נוכל לדמיין כל אחד מהעצים וכיצד הם מחלקים את הנתונים. ניתן לעשות זאת על ידי שימוש ב- tree מודול מובנה ב-Skikit-Learn, ולאחר מכן עובר בלולאה דרך כל אחד מהאומדנים באנסמבל:

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

הקוד לעיל מציג את חלקות העצים:

שימו לב איך שלושת העצים שונים. הראשון מתחיל ב- BS תכונה, השנייה עם DiastolicBP, והשלישי עם BS שוב. למרות שהשלישי מסתכל על מספר שונה של דוגמאות. על הענף הימני, שני העצים הראשונים מחליטים גם להשתמש Age בגובה העלים, בעוד העץ השלישי מסתיים ב BS תכונה. עם שלושה אומדנים בלבד, ברור כיצד הגדלה נותנת ייצוג עשיר ומגוון של הידע שניתן להרכיב בהצלחה למודל מדויק ביותר.

ככל שיותר עצים ביער, כך הדגם יכול להיות מגוון יותר. עם זאת, יש נקודה להפחתת התשואות, שכן עם עצים רבים מתאימים לקבוצת משנה אקראית של תכונות, יהיו מעט עצים דומים שלא מציעים גיוון רב בהרכב, ואשר יתחילו להיות להם. יותר מדי כוח הצבעה ולהטות את האנסמבל כדי להתאים יתר על המידה על מערך ההדרכה, ולפגוע בהכללה למערך האימות.

הייתה השערה שהועלתה קודם לכן לגבי יותר עצים, וכיצד זה יכול לשפר את תוצאות המודל. בואו נסתכל על התוצאות, ניצור מודל חדש ונראה אם ​​ההיפוטזה מתקיימת!

הערכת ה-RandomForestClassifier

Scikit-Learn מקל על יצירת קווי בסיס על ידי מתן א DummyClassifier, שמוציא תחזיות מבלי להשתמש בתכונות הקלט (פלטים אקראיים לחלוטין). אם הדגם שלך טוב יותר מה DummyClassifier, כמה הלמידה מתרחשת! כדי למקסם את הלמידה - אתה יכול לבדוק היפרפרמטרים שונים באופן אוטומטי באמצעות א RandomizedSearchCV or GridSearchCV. מלבד קו בסיס, אתה יכול להעריך את ביצועי הדגם שלך מהעדשה של מספר מדדים.

כמה מדדי סיווג מסורתיים שניתן להשתמש בהם כדי להעריך את האלגוריתם הם דיוק, זכירה, ציון f1, דיוק ומטריצת בלבול. להלן הסבר קצר על כל אחד מהם:

1. דיוק: כאשר המטרה שלנו היא להבין אילו ערכי חיזוי נכונים נחשבו נכונים על ידי המסווג שלנו. הדיוק יחלק את אותם ערכים חיוביים אמיתיים בדגימות שנחזו כחיוביות;

$$
דיוק = frac{text{true positives}}{text{true positives} + text{false positives}}
$$

2. להיזכר: בדרך כלל מחושב יחד עם דיוק כדי להבין כמה מהנקודות החיוביות האמיתיות זוהו על ידי המסווג שלנו. ההחזרה מחושבת על ידי חלוקת התוצאות החיוביות האמיתיות בכל מה שהיה צריך לחזות כחיובי.

$$
recall = frac{text{true positives}}{text{true positives} + text{false negatives}}
$$

3. ציון F1: האם המאוזן או ממוצע הרמוני של דיוק וזכירה. הערך הנמוך ביותר הוא 0 והגבוה ביותר הוא 1. מתי f1-score שווה ל-1, זה אומר שכל המחלקות חזו נכון - זה ציון שקשה מאוד להשיג עם נתונים אמיתיים (קיימים כמעט תמיד חריגים).

$$
text{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

4. מטריקס בלבול: כשאנחנו צריכים לדעת כמה דגימות צדקנו או טעינו כל כיתה. הערכים שהיו נכונים וחזויים כהלכה נקראים חיובי אמיתי, אלה שנחזו כחיוביים אך לא היו חיוביים נקראים תוצאות חיוביות שגויות. אותה המינוח של שליליים אמיתיים ו שלילי שווא משמש לערכים שליליים;

5. דיוק: מתאר כמה תחזיות המסווג שלנו צדק. ערך הדיוק הנמוך ביותר הוא 0 והגבוה ביותר הוא 1. ערך זה מוכפל בדרך כלל ב-100 כדי לקבל אחוז:

$$
דיוק = frac{טקסט{מספר תחזיות נכונות}}{טקסט{מספר כולל של התחזיות}}
$$

אתה יכול להפעיל את הסקריפט הבא כדי לייבא את הספריות הדרושות ולהסתכל על התוצאות:

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

הפלט ייראה בערך כך:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

בדוח הסיווג, שימו לב שהריקול הוא גבוה, 0.89 עבור מחלקה 0, גם הדיוק וגם הריקול גבוהים עבור מחלקה 2, 0.74, 0.72 - ובמחלקה 1, הם נמוכים, במיוחד הריקול של 0.17 ודיוק של 0.57 . הקשר בין ההיזכרות והדיוק עבור כל שלושת השיעורים בנפרד נתפס ב- F1 ניקוד, שהוא הממוצע ההרמוני בין זכירה ודיוק - המודל עושה בסדר עבור מחלקה 0, גרוע למדי עבור מחלקה 1 והגון עבור מחלקה 2.

המודל מתקשה מאוד בזיהוי מקרים בסיכון בינוני.

הדיוק שהושג על ידי מסווג היער האקראי שלנו עם 3 עצים בלבד הוא של 0.58 (58%) - זה אומר שהוא מקבל את קצת יותר ממחצית התוצאות כמו שצריך. זהו דיוק נמוך, ואולי ניתן לשפר אותו על ידי הוספת עצים נוספים.

על ידי התבוננות במטריצת הבלבול, אנו יכולים לראות שרוב הטעויות הן כאשר מסווגים 52 רשומות של סיכון בינוני כסיכון נמוך, מה שנותן תובנה נוספת לזכירה הנמוכה של מחלקה 1. זה מוטה לסיווג חולים בסיכון בינוני כנמוך- חולי סיכון.

דבר נוסף שניתן לבדוק כדי לייצר עוד יותר תובנה הוא אילו תכונות נלקחות בחשבון ביותר על ידי המסווג בעת חיזוי. זה צעד חשוב שצריך לעשות בשבילו מערכות למידת מכונה הניתנות להסבר, ועוזר לזהות ולהפחית הטיה במודלים.

כדי לראות זאת, נוכל לגשת ל- feature_importances_ תכונה של המסווג. זה ייתן לנו רשימה של אחוזים, כך שנוכל גם לגשת ל feature_names_in_ מאפיין כדי לקבל את השם של כל תכונה, לארגן אותם ב-dataframe, למיין אותם מהגבוה לנמוך, ולתכנן את התוצאה:

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

שימו לב איך המסווג שוקל בעיקר את ה סוכר בדם, ואז קצת מהלחץ הדיאסטולי, טמפרטורת הגוף ורק קצת מהגיל כדי לקבל החלטה, זה אולי קשור גם לריקול הנמוך בכיתה 1, אולי נתוני הסיכון הבינוני קשורים לתכונות שאינן נלקח בחשבון הרבה על ידי המודל. אתה יכול לנסות לשחק יותר עם חשיבות התכונות כדי לחקור את זה, ולראות אם שינויים במודל משפיעים על התכונות שבהן נעשה שימוש, גם אם יש קשר משמעותי בין חלק מהתכונות לבין המחלקות החזויות.

סוף סוף הגיע הזמן ליצור מודל חדש עם עצים נוספים כדי לראות כיצד הוא משפיע על התוצאות. בואו ניצור את rfc_ יער עם 900 עצים, 8 מפלסים ואותו זרע. האם התוצאות ישתפרו?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

חישוב והצגת המדדים:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

תפוקות אלה:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

זה מראה כיצד הוספת עוד עצים, ועוד עצים מיוחדים (רמות גבוהות יותר), שיפרה את המדדים שלנו. עדיין יש לנו ריקול נמוך עבור מחלקה 1, אבל הדיוק כעת הוא 74%. ציון F1 בעת מיון מקרים בסיכון גבוה הוא 0.85, מה שאומר שמקרים בסיכון גבוה מזוהים כעת ביתר קלות בהשוואה ל-0.73 במודל הקודם!

בפרויקט יום-יומי, אולי חשוב יותר לזהות מקרים בסיכון גבוה, למשל עם מדד הדומה לדיוק, הידוע גם בשם רגישות בסטטיסטיקה. נסה לכוונן כמה מפרמטרי המודל ולצפות בתוצאות.

עד כה, השגנו הבנה כללית כיצד ניתן להשתמש ב-Random Forest לסיווג נתונים - בסעיף הבא, אנו יכולים להשתמש באותו מערך נתונים בצורה שונה כדי לראות כיצד אותו מודל מנבא ערכים עם רגרסיה.

שימוש ביערות אקראיים לרגרסיה

בחלק זה נלמד כיצד ניתן להשתמש באלגוריתם Random Forest כדי לפתור בעיות רגרסיה באמצעות Scikit-Learn. השלבים שבוצעו כדי ליישם אלגוריתם זה כמעט זהים לשלבים שבוצעו לסיווג, מלבד סוג המודל וסוג הנתונים החזויים - שכעת יהיו ערכים רציפים - יש רק הבדל אחד בהכנת הנתונים.

מאז נעשה רגרסיה עבור ערכים מספריים – בואו נבחר ערך מספרי מתוך מערך הנתונים. ראינו שסוכר בדם היה חשוב בסיווג, אז זה צריך להיות צפוי על סמך מאפיינים אחרים (שכן אם הוא מתאם עם תכונה כלשהי, תכונה זו גם מתאם איתה).

בעקבות מה שעשינו לסיווג, בואו נייבא תחילה את הספריות ואת אותו מערך נתונים. אם כבר עשית זאת עבור מודל הסיווג, תוכל לדלג על חלק זה ולעבור ישירות להכנת נתונים לאימון.

ייבוא ​​ספריות ונתונים

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

עיבוד מקדים של נתונים לרגרסיה

זוהי משימת רגרסיה, כך שבמקום לחזות מחלקות, אנו יכולים לחזות את אחת העמודות המספריות של מערך הנתונים. בדוגמה זו, ה BS העמודה תהיה חזויה. זה אומר את y הנתונים יכילו נתוני הסוכר בדם, ו X הנתונים יכילו את כל התכונות מלבד רמת הסוכר בדם. לאחר הפרדת ה X ו y נתונים, נוכל לפצל את הרכבת וערכות הבדיקה:

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

הכשרת RandomForestRegressor

כעת, לאחר שהגדלנו את מערך הנתונים שלנו, הגיע הזמן לאמן את האלגוריתם שלנו לפתור את בעיית הרגרסיה הזו, לשנות אותה מעט - ניצור מודל עם 20 עצים ביער וכל אחד עם 4 רמות. כדי לעשות זאת, אתה יכול להפעיל את הקוד הבא:

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

אתה יכול למצוא פרטים עבור כל הפרמטרים של RandomForestRegressor בתיעוד הרשמי.

מכיוון שזימה והסתכלות על 20 עצים ידרשו זמן והקדשה, נוכל לתכנן רק את הראשון שיבדוק איך הוא שונה מעץ הסיווג:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

שימו לב שלעץ הרגרסיה כבר יש ערך שהוקצה לנתונים הנופלים על כל צומת. אלה הערכים שיהיו ממוצעים בעת שילוב 20 העצים. בעקבות מה שעשינו עם הסיווג, תוכל גם לשרטט חשיבות תכונות כדי לראות אילו משתנים מודל הרגרסיה לוקח יותר בחשבון בעת ​​חישוב ערכים.

זה הזמן להמשיך לשלב האחרון והאחרון בפתרון בעיית למידת מכונה ולהעריך את ביצועי האלגוריתם!

הערכת RandomForestRegressor

עבור בעיות רגרסיה, המדדים המשמשים להערכת אלגוריתם הם שגיאה אבסולוטית ממוצעת (MAE), שגיאה ממוצעת בריבוע (MSE) ושגיאה ממוצעת בריבוע (RMSE).

1. שגיאה מוחלטת ממוצעת (MAE): כאשר אנו מפחיתים את הערכים החזויים מהערכים בפועל, משיגים את השגיאות, מסכמים את הערכים האבסולוטיים של אותן שגיאות ומקבלים את הממוצע שלהם. מדד זה נותן מושג לגבי השגיאה הכוללת עבור כל חיזוי של המודל, ככל שהוא קטן יותר (קרוב ל-0) כך טוב יותר.

$$
mae = (frac{1}{n})sum_{i=1}^{n}שמאל | בפועל – חזוי נכון |
$$

2. שגיאה ממוצעת בריבוע (MSE): הוא דומה למדד MAE, אבל הוא מציב בריבוע את הערכים האבסולוטיים של השגיאות. כמו כן, כמו ב-MAE, כמה שיותר קטן, או קרוב יותר ל-0, כך ייטב. ערך ה-MSE מרובע כך שיגרום לשגיאות גדולות אפילו יותר. דבר אחד שצריך לשים לב אליו היטב, זה שבדרך כלל קשה לפרש את זה בגלל גודל הערכים שלו ומהעובדה שהם לא נמצאים באותו סקאלה של הנתונים.

$$
mse = sum_{i=1}^{D}(בפועל - חזוי)^2
$$

3. שגיאת בסיס ממוצע בריבוע (RMSE): מנסה לפתור את בעיית הפרשנות שהועלתה עם ה-MSE על ידי קבלת השורש הריבועי של הערך הסופי שלו, כדי להקטין אותו בחזרה לאותן יחידות הנתונים. קל יותר לפרש וטוב כשאנחנו צריכים להציג או להציג את הערך האמיתי של הנתונים עם השגיאה. זה מראה עד כמה הנתונים עשויים להשתנות, לכן, אם יש לנו RMSE של 4.35, המודל שלנו יכול לעשות שגיאה או בגלל שהוא הוסיף 4.35 לערך האמיתי, או שהיה צריך 4.35 כדי להגיע לערך האמיתי. ככל שיותר קרוב ל-0, כך גם טוב יותר.

$$
rmse = sqrt{ sum_{i=1}^{D}(Actual – Predicted)^2}
$$

אנחנו יכולים להשתמש בכל אחד משלושת המדדים האלה כדי לְהַשְׁווֹת דגמים (אם אנחנו צריכים לבחור אחד). אנו יכולים גם להשוות את אותו מודל רגרסיה עם ערכי ארגומנט שונים או עם נתונים שונים ולאחר מכן לשקול את מדדי ההערכה. זה ידוע בשם כוונון hyperparameter - כוונון ההיפרפרמטרים המשפיעים על אלגוריתם למידה והתבוננות בתוצאות.

כאשר בוחרים בין דגמים, אלו עם השגיאות הקטנות ביותר, בדרך כלל מתפקדים טוב יותר. בעת ניטור מודלים, אם המדדים הלכו והחמירו, אז גרסה קודמת של המודל הייתה טובה יותר, או שהיה שינוי משמעותי בנתונים כדי שהמודל יתפקד גרוע יותר מאשר הביצועים שלו.

אתה יכול את הקוד הבא כדי למצוא את הערכים האלה:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

הפלט צריך להיות:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

עם 20 עצים, השגיאה הממוצעת בריבוע השורש היא 1.75 וזה נמוך, אבל למרות זאת - על ידי העלאת מספר העצים וניסויים עם הפרמטרים האחרים, השגיאה הזו כנראה יכולה להצטמצם עוד יותר.

יתרונות השימוש ב-Random Forest

כמו בכל אלגוריתם, יש יתרונות וחסרונות לשימוש בו. בשני הסעיפים הבאים נסקור את היתרונות והחסרונות של שימוש ביער אקראי לסיווג ורגרסיה.

1. אלגוריתם היער האקראי אינו מוטה, שכן ישנם עצים מרובים וכל עץ מאומן על תת-קבוצה אקראית של נתונים. בעצם, אלגוריתם היער האקראי מסתמך על כוחו של "ההמון"; לכן מידת ההטיה הכוללת של האלגוריתם מופחתת.
2. האלגוריתם הזה מאוד יציב. גם אם נקודת נתונים חדשה מוצגת במערך הנתונים, האלגוריתם הכולל לא מושפע הרבה מכיוון שנתונים חדשים עשויים להשפיע על עץ אחד, אבל קשה לו מאוד להשפיע על כל העצים.
3. אלגוריתם היער האקראי עובד היטב כאשר יש לך גם תכונות קטגוריות וגם מספריות.
4. אלגוריתם היער האקראי עובד היטב גם כאשר לנתונים יש ערכים חסרים או שהם לא הותאמו.

חסרונות השימוש ב-Random Forest

1. החיסרון העיקרי של יערות אקראיים טמון במורכבותם. הם דורשים הרבה יותר משאבים חישוביים, בגלל המספר הגדול של עצי החלטה המחוברים יחדיו, בעת אימון הרכבים גדולים. עם זאת - עם חומרה מודרנית, אימון אפילו יער אקראי גדול לא לוקח הרבה זמן.

הולך רחוק יותר - פרויקט יד מקצה לקצה

האופי הסקרן שלך גורם לך לרצות ללכת רחוק יותר? אנו ממליצים לבדוק את שלנו פרויקט מודרך: "תחזית מחיר ביתית מעשית - למידת מכונה בפייתון".

בפרויקט מודרך זה - תלמדו כיצד לבנות מודלים מסורתיים רבי עוצמה של למידת מכונה, כמו גם מודלים של למידה עמוקה, להשתמש ב-Ensemble Learning ואימון מטא-לומדי לחזות מחירי בתים מתוך שקית של מודלים של Scikit-Learn ו-Keras.

באמצעות Keras, API ללמידה עמוקה שנבנה על גבי Tensorflow, נתנסה בארכיטקטורות, נבנה אנסמבל של מודלים מוערמים ונאמן מטא-לומד רשת עצבית (מודל רמה 1) כדי להבין את התמחור של בית.

למידה עמוקה היא מדהימה - אבל לפני שניגשים אליה, מומלץ לנסות לפתור את הבעיה גם בטכניקות פשוטות יותר, כמו עם למידה רדודה אלגוריתמים. ביצועי הבסיס שלנו יתבססו על א רגרסיה אקראית של יער אַלגוֹרִיתְם. בנוסף - נחקור יצירת אנסמבלים של מודלים באמצעות Scikit-Learn באמצעות טכניקות כגון שקית ו הצבעה.

זהו פרויקט מקצה לקצה, וכמו כל פרויקטי Machine Learning, נתחיל עם - עם ניתוח נתונים חקרני, ואחריו עיבוד נתונים מראש ולבסוף בניין רדוד ו מודלים של למידה עמוקה כדי להתאים לנתונים שחקרנו וניקינו בעבר.