Support Vector Machine או SVM הוא אחד מאלגוריתמים הפופולריים ביותר של למידה מפוקחת, המשמש לבעיות סיווג כמו גם רגרסיה. עם זאת, בעיקר, הוא משמש לבעיות סיווג בלמידת מכונה.

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

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

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

ניתן להשתמש באלגוריתם SVM עבור זיהוי פנים, סיווג תמונות, סיווג טקסט, וכו '

מטריצת לטקס

סוגי SVM

SVM יכול להיות משני סוגים:

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

וקטורי היפר-מישור ותמיכה באלגוריתם SVM:

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

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

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

תמיכה בוקטורים:

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

איך עובד SVM?

SVM ליניארי:

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

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

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

SVM לא ליניארי:

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

אם עוד ב-bash shell

אז כדי להפריד את נקודות הנתונים הללו, עלינו להוסיף עוד ממד אחד. עבור נתונים ליניאריים, השתמשנו בשני ממדים x ו-y, ולכן עבור נתונים לא ליניאריים, נוסיף ממד שלישי z. ניתן לחשב זאת כך:

 z=x<sup>2</sup> +y<sup>2</sup> 

על ידי הוספת הממד השלישי, החלל לדוגמה יהפוך לתמונה למטה:

אז כעת, SVM יחלק את מערכי הנתונים למחלקות באופן הבא. שקול את התמונה הבאה:

מכיוון שאנו נמצאים במרחב התלת-ממדי, מכאן שהוא נראה כמו מישור מקביל לציר ה-x. אם נמיר אותו במרחב דו מימדי עם z=1, אז הוא יהפוך ל:

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

יישום Python של Support Vector Machine

כעת ניישם את אלגוריתם SVM באמצעות Python. כאן נשתמש באותו מערך נתונים מידע משתמש , שבו השתמשנו ברגרסיה לוגיסטית ובסיווג KNN.

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

עד לשלב עיבוד הנתונים המקדים, הקוד יישאר זהה. להלן הקוד:

 #Data Pre-processing Step # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

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

הפלט בקנה מידה עבור ערכת הבדיקה תהיה:

התאמת מסווג SVM לסט האימונים:

כעת ערכת האימונים תותאם למסווג SVM. כדי ליצור את מסווג SVM, אנו נייבא SVC כיתה מ Sklearn.svm סִפְרִיָה. להלן הקוד עבורו:

 from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train) 

בקוד לעיל, השתמשנו kernel='ליניארי' , שכן כאן אנו יוצרים SVM עבור נתונים הניתנים להפרדה ליניארית. עם זאת, אנו יכולים לשנות זאת עבור נתונים לא ליניאריים. ואז התאמנו את המסווג למערך הנתונים של ההדרכה (x_train, y_train)

תְפוּקָה:

 Out[8]: SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto_deprecated', kernel='linear', max_iter=-1, probability=False, random_state=0, shrinking=True, tol=0.001, verbose=False) 

ניתן לשנות את ביצועי המודל על ידי שינוי הערך של C (גורם רגוליזציה), גמא וקרנל .

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

 #Predicting the test set result y_pred= classifier.predict(x_test) 

לאחר קבלת הווקטור y_pred, נוכל להשוות את התוצאה של y_pred ו y_test כדי לבדוק את ההבדל בין הערך בפועל לערך החזוי.

תְפוּקָה: להלן הפלט לחיזוי מערך הבדיקה:

יצירת מטריצת הבלבול:
כעת נראה את הביצועים של מסווג SVM כמה תחזיות שגויות יש בהשוואה למסווג הרגרסיה הלוגיסטית. כדי ליצור את מטריצת הבלבול, עלינו לייבא את מטריצת_בלבול הפונקציה של ספריית sklearn. לאחר ייבוא ​​הפונקציה, נקרא לה באמצעות משתנה חדש ס'מ . הפונקציה לוקחת שני פרמטרים, בעיקר y_true (הערכים בפועל) ו y_pred (החזרת הערך הממוקדת על ידי המסווג). להלן הקוד עבורו:

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

תְפוּקָה:

כפי שאנו יכולים לראות בתמונת הפלט לעיל, יש 66+24= 90 תחזיות נכונות ו-8+2= 10 תחזיות נכונות. לכן אנו יכולים לומר שמודל ה-SVM שלנו השתפר בהשוואה למודל הרגרסיה הלוגיסטית.

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

 from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red', 'green'))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

תְפוּקָה:

על ידי ביצוע הקוד לעיל, נקבל את הפלט כ:

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

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

 #Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

תְפוּקָה:

מחרוזת מרובת שורות של javascript

על ידי ביצוע הקוד לעיל, נקבל את הפלט כ:

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