מדריך סופי לאשכולות היררכית עם Python ו-Skit-Learn

מבוא

במדריך זה, נתמקד ביישום ה אלגוריתם אשכול היררכי עם Sikit-Learn לפתור בעיה שיווקית.

לאחר קריאת המדריך תבינו:

• מתי להחיל אשכול היררכי
• כיצד להמחיש את מערך הנתונים כדי להבין אם הוא מתאים לאשכול
• כיצד לעבד מראש תכונות ולהנדס תכונות חדשות על סמך מערך הנתונים
• כיצד להפחית את הממדיות של מערך הנתונים באמצעות PCA
• כיצד להשתמש ולקרוא דנדרוגרמה כדי להפריד בין קבוצות
• מהן שיטות הקישור השונות ומדדי המרחק המיושמים על דנדרוגרמות ואלגוריתמי אשכולות
• מהן אסטרטגיות האשכול האגלומרטיביות והמפלגות וכיצד הן פועלות
• כיצד ליישם את האשכול ההיררכי האגלומרטיבי עם Scikit-Learn
• מהן הבעיות השכיחות ביותר בעת התמודדות עם אלגוריתמי אשכול וכיצד לפתור אותן

מוטיבציה

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

האם יש דרך לעזור לקבוע אילו לקוחות דומים? כמה מהם שייכים לאותה קבוצה? וכמה קבוצות שונות יש?

אחת הדרכים לענות על שאלות אלו היא באמצעות א קיבוץ אלגוריתם, כגון K-Means, DBSCAN, Hirarchical Clustering וכו'. במונחים כלליים, אלגוריתמי אשכול מוצאים קווי דמיון בין נקודות נתונים ומקבצים אותם.

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

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

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

דבר נוסף שיש לקחת בחשבון בתרחיש זה הוא ש-HCA הוא לא מפוקח אַלגוֹרִיתְם. בעת קיבוץ נתונים, לא תהיה לנו דרך לוודא שאנו מזהים נכון שמשתמש שייך לקבוצה מסוימת (איננו מכירים את הקבוצות). אין תוויות להשוואה לתוצאות שלנו. אם זיהינו נכון את הקבוצות, זה יאושר בהמשך על ידי מחלקת השיווק על בסיס יומיומי (כפי שנמדד במדדים כמו ROI, שיעורי המרה וכו').

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

ניתוח נתונים חקרני קצר

לאחר הורדת מערך הנתונים, שימו לב שהוא א CSV (ערכים מופרדים בפסיק) קובץ שנקרא shopping-data.csv. כדי להקל על חקירת הנתונים ולתפעל אותם, נטען אותם ל-a DataFrame באמצעות פנדות:

import pandas as pd


path_to_file = 'home/projects/datasets/shopping-data.csv'
customer_data = pd.read_csv(path_to_file)

שיווק אמר שהוא אסף 200 רישומי לקוחות. אנו יכולים לבדוק אם הנתונים שהורדתם מלאים עם 200 שורות באמצעות ה shape תְכוּנָה. זה יגיד לנו כמה שורות ועמודות יש לנו, בהתאמה:

customer_data.shape

זו התוצאה:

(200, 5)

גדול! הנתונים שלנו מלאים עם 200 שורות (רישומי לקוח) ויש לנו גם 5 עמודות (תכונות). כדי לראות אילו מאפיינים אספה מחלקת השיווק מלקוחות, נוכל לראות שמות עמודות עם ה columns תְכוּנָה. כדי לעשות זאת, בצע:

customer_data.columns

התסריט למעלה מחזיר:

Index(['CustomerID', 'Genre', 'Age', 'Annual Income (k$)',
       'Spending Score (1-100)'],
      dtype='object')

כאן, אנו רואים ששיווק יצר א CustomerID, אסף את Genre, Age, Annual Income (באלפי דולרים), וא Spending Score עובר מ-1 ל-100 עבור כל אחד מ-200 הלקוחות. כאשר התבקשו להבהיר, הם אמרו כי הערכים ב Spending Score עמודה מציינת באיזו תדירות אדם מוציא כסף בקניון בסולם של 1 עד 100. במילים אחרות, אם ללקוח יש ציון של 0, אדם זה לעולם לא מוציא כסף, ואם הציון הוא 100, זה עתה זיהינו את המוציא הגבוה ביותר.

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

customer_data['Spending Score (1-100)'].hist()

על ידי התבוננות בהיסטוגרמה אנו רואים שלמעלה מ-35 לקוחות יש ציונים ביניהם 40 ו 60, אז פחות מ-25 יש ציונים ביניהם 70 ו 80. אז רוב הלקוחות שלנו הם הוצאות מאוזנות, ואחריו הוצאה בינונית עד גבוהה. אנחנו יכולים גם לראות שיש קו אחרי 0, משמאל להתפלגות, ועוד שורה לפני 100, מימין להתפלגות. רווחים ריקים אלה כנראה פירושם שההפצה אינה מכילה גורמים שאינם מוציאים, אשר יהיה להם ציון של 0, ושגם אין מוציאים גבוהים עם ציון של 100.

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

customer_data.describe().transpose()

זה ייתן לנו טבלה שממנה נוכל לקרוא התפלגות של ערכים אחרים של מערך הנתונים שלנו:

 						count 	mean 	std 		min 	25% 	50% 	75% 	max
CustomerID 				200.0 	100.50 	57.879185 	1.0 	50.75 	100.5 	150.25 	200.0
Age 					200.0 	38.85 	13.969007 	18.0 	28.75 	36.0 	49.00 	70.0
Annual Income (k$) 		200.0 	60.56 	26.264721 	15.0 	41.50 	61.5 	78.00 	137.0
Spending Score (1-100) 	200.0 	50.20 	25.823522 	1.0 	34.75 	50.0 	73.00 	99.0

ההשערה שלנו מאוששת. ה min ערך ה- Spending Score is 1 והמקסימום הוא 99. אז אין לנו 0 or 100 מבזבזים ציונים. אז בואו נסתכל על העמודות האחרות של הטרנספוזיציה describe שולחן. כאשר מסתכלים על mean ו std עמודות, אנחנו יכולים לראות את זה עבור Age מה היא mean is 38.85 ו std הוא כ 13.97. אותו דבר קורה עבור Annual Income, עם mean of 60.56 ו std 26.26, ועבור Spending Score עם mean of 50 ו std of 25.82. עבור כל התכונות, ה mean רחוקה מסטיית התקן, מה שמעיד לנתונים שלנו יש שונות גבוהה.

כדי להבין טוב יותר כיצד הנתונים שלנו משתנים, בואו נשרטט את Annual Income הפצה:

customer_data['Annual Income (k$)'].hist()

מה שייתן לנו:

שימו לב בהיסטוגרמה שרוב הנתונים שלנו, יותר מ-35 לקוחות, מרוכזים ליד המספר 60, על שלנו mean, בציר האופקי. אבל מה קורה כשאנחנו מתקדמים לקראת קצוות ההפצה? כאשר הולכים לכיוון שמאל, מהממוצע של $60.560, הערך הבא שנתקל בו הוא $34.300 - הממוצע ($60.560) פחות הווריאציה הסטנדרטית ($26.260). אם נרחיק יותר משמאל להתפלגות הנתונים שלנו, חל כלל דומה, נפחית את הווריאציה הסטנדרטית ($26.260) מהערך הנוכחי ($34.300). לכן, ניתקל בערך של $8.040. שימו לב איך הנתונים שלנו עברו מ-$60 ל-$8 במהירות. זה "קופץ" $26.260 בכל פעם - משתנה מאוד, וזו הסיבה שיש לנו שונות כל כך גבוהה.

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

עד כה ראינו את צורת הנתונים שלנו, חלק מההפצות שלהם וסטטיסטיקה תיאורית. עם Pandas, אנחנו יכולים גם לרשום את סוגי הנתונים שלנו ולראות אם כל 200 השורות שלנו מלאות או שיש כמה null ערכים:

customer_data.info()

זו התוצאה:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 5 columns):
 #   Column                  Non-Null Count  Dtype 
---  ------                  --------------  ----- 
 0   CustomerID              200 non-null    int64 
 1   Genre                   200 non-null    object
 2   Age                     200 non-null    int64 
 3   Annual Income (k$)      200 non-null    int64 
 4   Spending Score (1-100)  200 non-null    int64 
dtypes: int64(4), object(1)
memory usage: 7.9+ KB

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

בוא נראה איך Genre מתמלא על ידי הצצה מהירה ב-5 הערכים הראשונים של הנתונים שלנו:

customer_data.head() 

זו התוצאה:

    CustomerID 	Genre 	Age 	Annual Income (k$) 	Spending Score (1-100)
0 	1 			Male 	19 		15 					39
1 	2 			Male 	21 		15 					81
2 	3 			Female 	20 		16 					6
3 	4 			Female 	23 		16 					77
4 	5 			Female 	31 		17 					40

נראה שיש לו רק Female ו Male קטגוריות. אנו יכולים להיות בטוחים בכך על ידי התבוננות בערכים הייחודיים שלו unique:

customer_data['Genre'].unique()

זה מאשש את ההנחה שלנו:

array(['Male', 'Female'], dtype=object)

עד כה, אנחנו יודעים שיש לנו רק שני ז'אנרים, אם אנחנו מתכננים להשתמש בתכונה הזו בדגם שלנו, Male ניתן להפוך ל 0 ו Female ל 1. חשוב גם לבדוק את הפרופורציה בין הז'אנרים, כדי לראות אם הם מאוזנים. אנחנו יכולים לעשות את זה עם value_counts() השיטה והטיעון שלה normalize=True כדי להציג את האחוז ביניהם Male ו Female:

customer_data['Genre'].value_counts(normalize=True)

תפוקות אלה:

Female    0.56
Male      0.44
Name: Genre, dtype: float64

יש לנו 56% מהנשים במערך הנתונים ו-44% מהגברים. ההבדל ביניהם הוא רק 16%, והנתונים שלנו הם לא 50/50 אלא כן מאוזן מספיק לא לגרום לצרות. אם התוצאות היו 70/30, 60/40, אז אולי היה צורך לאסוף יותר נתונים או להשתמש בסוג של טכניקת הגדלת נתונים כדי להפוך את היחס הזה למאוזן יותר.

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

לאחר השערות לגבי מה ניתן לעשות עם קטגוריות - או קטגוריות להיות - Genre ו Age עמודות, בואו ליישם את מה שנדון.

קידוד משתנים והנדסת תכונות

נתחיל בחלוקת ה Age לקבוצות שמשתנות ב-10, כך שיש לנו 20-30, 30-40, 40-50 וכן הלאה. מכיוון שהלקוח הצעיר ביותר שלנו הוא בן 15, נוכל להתחיל ב-15 ולסיים ב-70, שזה הגיל של הלקוח המבוגר ביותר בנתונים. החל מ-15, ומסתיים ב-70, יהיו לנו מרווחים של 15-20, 20-30, 30-40, 40-50, 50-60 ו-60-70.

לקבוצה או בן Age ערכים לתוך המרווחים האלה, נוכל להשתמש בפנדות cut() שיטה לחתוך אותם לפחים ולאחר מכן להקצות את הפחים לפחים חדשים Age Groups טור:

intervals = [15, 20, 30, 40, 50, 60, 70]
col = customer_data['Age']
customer_data['Age Groups'] = pd.cut(x=col, bins=intervals)


customer_data['Age Groups'] 

זו התוצאה:

0      (15, 20]
1      (20, 30]
2      (15, 20]
3      (20, 30]
4      (30, 40]
         ...   
195    (30, 40]
196    (40, 50]
197    (30, 40]
198    (30, 40]
199    (20, 30]
Name: Age Groups, Length: 200, dtype: category
Categories (6, interval[int64, right]): [(15, 20] < (20, 30] < (30, 40] < (40, 50] < (50, 60] < (60, 70]]

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

וכמה לקוחות יש לנו בכל קטגוריה? אנחנו יכולים לדעת את זה במהירות על ידי קיבוץ העמודה וספירת הערכים עם groupby() ו count():

customer_data.groupby('Age Groups')['Age Groups'].count()

זו התוצאה:

Age Groups
(15, 20]    17
(20, 30]    45
(30, 40]    60
(40, 50]    38
(50, 60]    23
(60, 70]    17
Name: Age Groups, dtype: int64

קל לזהות שרוב הלקוחות הם בין גילאי 30 ל-40, אחריהם לקוחות בין 20 ל-30 ואחר כך לקוחות בין 40 ל-50. זה גם מידע טוב למחלקת השיווק.

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

customer_data_oh = pd.get_dummies(customer_data)

customer_data_oh 

זה ייתן לנו תצוגה מקדימה של הטבלה המתקבלת:

עם הפלט, קל לראות שהעמודה Genre פוצל לעמודות - Genre_Female ו Genre_Male. כשהלקוחה היא נקבה, Genre_Female שווה ל 1, וכשהלקוח הוא זכר, זה שווה 0.

כמו כן, Age Groups העמודה חולקה ל-6 עמודות, אחת לכל מרווח, כגון Age Groups_(15, 20], Age Groups_(20, 30], וכן הלאה. באותה דרך כמו Genre, כאשר הלקוח הוא בן 18, ה Age Groups_(15, 20] הערך הוא 1 והערך של כל שאר העמודות הוא 0.

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

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

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

תכנון בסיסי והפחתת ממדיות

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

תכנון כל זוג נתונים

מכיוון שציור של 10 ממדים הוא קצת בלתי אפשרי, אנו בוחרים ללכת עם הגישה השנייה - נשרטט את התכונות הראשוניות שלנו. אנחנו יכולים לבחור שניים מהם לניתוח האשכולות שלנו. דרך אחת שבה נוכל לראות את כל צמדי הנתונים שלנו משולבים היא עם Seaborn pairplot():

import seaborn as sns


customer_data = customer_data.drop('CustomerID', axis=1)

sns.pairplot(customer_data)

המציג:

במבט חטוף, אנו יכולים לזהות את מסלולי הפיזור שנראה שיש להם קבוצות של נתונים. אחד שנראה מעניין הוא עלילת הפיזור המשלבת Annual Income ו Spending Score. שימו לב שאין הפרדה ברורה בין תרשימי פיזור משתנים אחרים. לכל היותר, אנו יכולים אולי לדעת שיש שני ריכוזים ברורים של נקודות ב- Spending Score vs Age גרף פיזור.

שתי עלילות הפיזור המורכבות מ Annual Income ו Spending Score הם בעצם זהים. אנחנו יכולים לראות את זה פעמיים כי ציר ה-x וה-y הוחלפו. על ידי התבוננות בכל אחת מהן, נוכל לראות מה שנראה כחמש קבוצות שונות. בואו נתווה רק את שתי התכונות האלה עם Seaborn scatterplot() כדי להסתכל מקרוב:

sns.scatterplot(x=customer_data['Annual Income (k$)'],
                y=customer_data['Spending Score (1-100)'])

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

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

שרטוט נתונים לאחר שימוש ב-PCA

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

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

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

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

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

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

לפני החלת PCA, עלינו לבחור בין ה Age עמודה או ה Age Groups עמודות בנתונים המקודדים החמים שלנו בעבר. מכיוון ששתי העמודות מייצגות את אותו מידע, הצגתו פעמיים משפיעה על שונות הנתונים שלנו. אם ה Age Groups נבחרת, פשוט הסר את Age עמודה באמצעות הפנדות drop() השיטה ולהקצות אותה מחדש ל- customer_data_oh מִשְׁתַנֶה:

customer_data_oh = customer_data_oh.drop(['Age'], axis=1)
customer_data_oh.shape 

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

בואו נעשה את זה עם Scikit-Learn PCA. אנו נחשב את השונות המוסברת של כל מימד, הניתנת על ידי explained_variance_ratio_ , ולאחר מכן להסתכל על הסכום המצטבר שלהם עם cumsum() :

from sklearn.decomposition import PCA

pca = PCA(n_components=10)
pca.fit_transform(customer_data_oh)
pca.explained_variance_ratio_.cumsum()

השונות המוסברות המצטברות שלנו הן:

array([0.509337  , 0.99909504, 0.99946364, 0.99965506, 0.99977937,
       0.99986848, 0.99993716, 1.        , 1.        , 1.        ])

אנו יכולים לראות שהמימד הראשון מסביר 50% מהנתונים, ובשילוב עם הממד השני, הם מסבירים 99% אחוז. המשמעות היא ש-2 המימדים הראשונים כבר מסבירים 99% מהנתונים שלנו. אז אנחנו יכולים ליישם PCA עם 2 רכיבים, להשיג את הרכיבים העיקריים שלנו ולתכנן אותם:

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
pcs = pca.fit_transform(customer_data_oh)

pc1_values = pcs[:,0]
pc2_values = pcs[:,1]
sns.scatterplot(x=pc1_values, y=pc2_values)

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

הדמיית מבנה היררכי באמצעות דנדרוגרמות

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

אל האני דנדרוגרמה הוא תוצאה של קישור של נקודות במערך נתונים. זהו ייצוג חזותי של תהליך האשכול ההיררכי. ואיך עובד תהליך האשכול ההיררכי? ובכן... זה תלוי - כנראה תשובה שכבר שמעתם הרבה ב-Data Science.

הבנת אשכול היררכי

כאשר אלגוריתם אשכול היררכי (HCA) מתחיל לקשר את הנקודות ולמצוא אשכולות, הוא יכול תחילה לפצל נקודות ל-2 קבוצות גדולות, ולאחר מכן לפצל כל אחת משתי הקבוצות הללו ל-2 קבוצות קטנות יותר, עם 4 קבוצות בסך הכל, כלומר מחלק ו מלמעלה למטה גִישָׁה.

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

שלבים לביצוע אשכול היררכי אגלומרטיבי

כדי להבהיר אפילו את הגישה האגלומרטיבית, ישנם שלבים של אשכול היררכי אגלומרטיבי (AHC) אַלגוֹרִיתְם:

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

אם תהפוך את השלבים של אלגוריתם ACH, מעבר מ-4 ל-1 - אלה יהיו השלבים ל-*אשכול היררכי מחלק (DHC)*.

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

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

import scipy.cluster.hierarchy as shc
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 7))
plt.title("Customers Dendrogram")


selected_data = customer_data_oh.iloc[:, 1:3]
clusters = shc.linkage(selected_data, 
            method='ward', 
            metric="euclidean")
shc.dendrogram(Z=clusters)
plt.show()

הפלט של הסקריפט נראה כך:

בסקריפט שלמעלה, יצרנו את האשכולות והתת אשכולות עם הנקודות שלנו, הגדרנו כיצד הנקודות שלנו יתחברו (על ידי יישום ward שיטה), וכיצד למדוד את המרחק בין נקודות (על ידי שימוש ב- euclidean מֶטרִי).

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

שיטות קישור

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

חלק משיטות ההצמדה הן:

• הצמדה בודדת: מכונה גם השכן הקרוב ביותר (NN). המרחק בין אשכולות מוגדר על ידי המרחק בין האיברים הקרובים ביותר שלהם.

• קישור שלם: מכונה גם הכי רחוק (FN), אלגוריתם הנקודה הרחוקה ביותר, או אלגוריתם Voor Hees. המרחק בין אשכולות מוגדר על ידי המרחק בין האיברים הרחוקים ביותר שלהם. שיטה זו יקרה מבחינה חישובית.

• הצמדה ממוצעת: מוכר גם בשם UPGMA (שיטת קבוצת צמד ללא משקל עם ממוצע אריתמטי). האחוז ממספר הנקודות של כל אשכול מחושב ביחס למספר הנקודות של שני האשכולות אם היו ממוזגים.

• הצמדה משוקללת: מוכר גם בשם WPGMA (שיטת קבוצת זוג משוקלל עם ממוצע אריתמטי). הנקודות הבודדות של שני האשכולות תורמות למרחק המצטבר בין אשכול קטן יותר לגדול יותר.
• קישור מרכז: מכונה גם UPGMC (שיטת קבוצת זוג לא משוקללת באמצעות סנטרואידים). נקודה המוגדרת על ידי הממוצע של כל הנקודות (מרכז) מחושבת עבור כל אשכול והמרחק בין אשכולות הוא המרחק בין המוקדים שלהם.

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

מדדי מרחק

מלבד ההצמדה, אנו יכולים גם לציין כמה מדדי המרחק הנפוצים ביותר:

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

$$
c^2 = a^2 + b^2
$$

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

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

$$
Dleft(X,Yright) = left(sum_{i=1}^n |x_i-y_i|^pright)^{frac{1}{p}}
$$

• צ'בישב: מוכר גם בשם לוח שחמט מֶרְחָק. זה המקרה הקיצוני של מרחק מינקובסקי. כאשר אנו משתמשים באינסוף כערך של הפרמטר p (p = ∞), בסופו של דבר נקבל מדד המגדיר את המרחק כהפרש המוחלט המקסימלי בין הקואורדינטות.
• קוסיין: זהו מרחק הקוסינוס הזוויתי בין שני רצפים של נקודות, או וקטורים. הדמיון הקוסינוס הוא מכפלת הנקודות של הוקטורים חלקי מכפלת אורכם.
• ג'קארד: מודד את הדמיון בין קבוצות סופיות של נקודות. הוא מוגדר כמספר הנקודות הכולל (קרדינליות) בנקודות המשותפות בכל קבוצה (צומת), חלקי סך הנקודות (קרדינליות) של סך הנקודות של שתי הקבוצות (איחוד).
• ג'נסן-שאנון: מבוסס על הפער בין קולבק-לייבלר. הוא בוחן את התפלגויות ההסתברות של הנקודות ומודד את הדמיון בין התפלגויות אלו. זוהי שיטה פופולרית של תורת הסתברות וסטטיסטיקה.

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

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

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

אם היינו כוללים יותר תכונות, אז יש לנו יותר מ-200 תכונות, המרחק האוקלידי עלול לא לעבוד טוב במיוחד, מכיוון שהוא היה מתקשה למדוד את כל המרחקים הקטנים בחלל גדול מאוד שרק הולך וגדל. במילים אחרות, לגישת המרחק האוקלידי יש קשיים בעבודה עם הנתונים דְלִילוּת. זה נושא שנקרא קללת המימדיות. ערכי המרחק היו קטנים כל כך, כאילו הם נהיו "מדוללים" במרחב הגדול יותר, מעוותים עד שהם הופכים ל-0.

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

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

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

plt.figure(figsize=(10, 7))
plt.title("Customers Dendogram with line")
clusters = shc.linkage(selected_data, 
            method='ward', 
            metric="euclidean")
shc.dendrogram(clusters)
plt.axhline(y = 125, color = 'r', linestyle = '-')

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

יישום מקבץ היררכי אגלומרטיבי

שימוש בנתונים מקוריים

עד כה חישבנו את המספר המוצע של אשכולות עבור מערך הנתונים שלנו שמאשרים את הניתוח הראשוני שלנו וניתוח ה-PCA שלנו. כעת אנו יכולים ליצור את מודל האשכולות ההיררכי האגלומרטיבי שלנו באמצעות Scikit-Learn AgglomerativeClustering ולגלות את התוויות של נקודות שיווק עם labels_:

from sklearn.cluster import AgglomerativeClustering

clustering_model = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
clustering_model.fit(selected_data)
clustering_model.labels_

זו התוצאה:

array([4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3,
       4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 1,
       4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 0, 2, 0, 2,
       1, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 2, 1, 2, 0, 2, 0, 2, 0, 2,
       0, 2, 0, 2, 0, 2, 1, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2,
       0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2,
       0, 2])

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

data_labels = clustering_model.labels_
sns.scatterplot(x='Annual Income (k$)', 
                y='Spending Score (1-100)', 
                data=selected_data, 
                hue=data_labels,
                pallete="rainbow").set_title('Labeled Customer Data')

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

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

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

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

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

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

שימוש בתוצאה מ-PCA

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

clustering_model_pca = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
clustering_model_pca.fit(pcs)

data_labels_pca = clustering_model_pca.labels_

sns.scatterplot(x=pc1_values, 
                y=pc2_values,
                hue=data_labels_pca,
                palette="rainbow").set_title('Labeled Customer Data Reduced with PCA')

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

כמה שפחות צריך לשנות את הנתונים שלנו, כך ייטב.

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

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

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

סיכום

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

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

מקבץ שמח!