ספריית NumPy מאפשרת לנו לבצע פעולות שונות שצריכות להתבצע על מבני נתונים המשמשים לעתים קרובות ללמידת מכונות ומדעי נתונים כמו וקטורים, מטריצות ומערכים. נציג רק את הפעולות הנפוצות ביותר עם NumPy המשמשות בהרבה צינורות למידת מכונה. לבסוף, שים לב כי NumPy היא רק דרך לבצע את הפעולות, ולכן הפעולות המתמטיות שאנו מציגים הן המוקד העיקרי של שיעור זה ולא חבילת NumPy עצמה. בואו נתחיל.
מהו וקטור?
על פי גוגל, וקטור הוא כמות שיש לה כיוון וגם גודל, במיוחד כקביעת המיקום של נקודה אחת בחלל ביחס לאחרת.
הווקטורים חשובים מאוד בלמידת מכונות מכיוון שהם לא רק מתארים את גודל, אלא גם את כיוון התכונות. אנו יכולים ליצור וקטור ב- NumPy עם קטע הקוד הבא:
יבוא מסוחררכפי שלְמָשָׁל
row_vector = np.array([1,2,3])
הדפס(row_vector)
בקטע הקוד שלעיל יצרנו וקטור שורה. אנו יכולים גם ליצור וקטור עמודה כ:
יבוא מסוחררכפי שלְמָשָׁלcol_vector = np.array([[1],[2],[3]])
הדפס(col_vector)
הכנת מטריצה
ניתן להבין מטריצה פשוט כמערך דו ממדי. אנו יכולים ליצור מטריצה עם NumPy על ידי יצירת מערך רב ממדי:
מטריצה = np.array([[1,2,3],[4,5,6],[7,8,9]])
הדפס(מַטרִיצָה)
למרות שהמטריצה דומה בדיוק למערך רב ממדי, מבנה נתוני המטריצה אינו מומלץ בגלל שתי סיבות:
- המערך הוא הסטנדרט בכל הנוגע לחבילת NumPy
- רוב הפעולות עם NumPy מחזירות מערכים ולא מטריצה
שימוש במטריצה דלילה
להזכירכם, מטריצה דלילה היא זו שבה רוב הפריטים אפסיים. כעת, תרחיש נפוץ בעיבוד נתונים ולמידת מכונה הוא עיבוד מטריצות בהן מרבית האלמנטים אפסיים. לדוגמה, שקול מטריצה ששורותיה מתארות כל סרטון ב- YouTube והעמודות מייצגות כל משתמש רשום. כל ערך מייצג אם המשתמש צפה בסרטון או לא. כמובן שרוב הערכים במטריצה זו יהיו אפס. ה יתרון עם מטריצה דלילה הוא שאינו שומר את הערכים שהם אפס. זה מביא ליתרון חישובי עצום וגם לאופטימיזציה של אחסון.
בואו ליצור מטריצת ניצוץ כאן:
מנדיר יבוא דלoriginal_matrix = np.array([[1,0,3],[0,0,6],[7,0,0]])
sparse_matrix = sparse.csr_matrix(מטריקס מקורי)
הדפס(דלילה_מטריצה)
כדי להבין כיצד הקוד פועל, נבחן את הפלט כאן:
בקוד לעיל, השתמשנו בפונקציה של NumPy ליצירת a שורה דלילה דחוסה מטריצה שבה אלמנטים שאינם אפס מיוצגים באמצעות האינדקסים מבוססי האפס. ישנם סוגים שונים של מטריצה דלילה, כגון:
- טור דליל דחוס
- רשימת רשימות
- מילון מפתחות
לא נצלול כאן למטריצות דלילות אחרות אך נדע שכל אחת מהן היא השימוש שלה הוא ספציפי ואי אפשר לכנות אף אחד כ'טוב ביותר '.
החלת פעולות על כל האלמנטים הווקטוריים
זהו תרחיש נפוץ כאשר עלינו ליישם פעולה נפוצה על מרכיבים וקטוריים מרובים. ניתן לעשות זאת על ידי הגדרת למבדה ולאחר מכן וקטור אותו. בואו נראה קטע קוד זהה:
מטריצה = np.array([[1,2,3],
[4,5,6],
[7,8,9]])
mul_5 = lambda x: x* 5
vectorized_mul_5 = np.vectorize(mul_5)
וקטוריז_מול_5(מַטרִיצָה)
כדי להבין כיצד הקוד פועל, נבחן את הפלט כאן:
בקטע הקוד לעיל, השתמשנו בפונקציה וקטוריזציה המהווה חלק מספריית NumPy, כדי להפוך הגדרת למבדה פשוטה לפונקציה שיכולה לעבד כל רכיב וקטור. חשוב לציין כי וקטוריזציה היא רק לולאה על האלמנטים ואין לזה השפעה על ביצועי התוכנית. NumPy מאפשר גם שידור מה שאומר שבמקום הקוד המורכב לעיל יכולנו פשוט לעשות:
מַטרִיצָה* 5והתוצאה הייתה בדיוק אותו הדבר. רציתי להציג את החלק המורכב קודם כל, אחרת היית מדלג על הקטע!
ממוצע, שונות וסטיית תקן
עם NumPy, קל לבצע פעולות הקשורות לסטטיסטיקה תיאורית על וקטורים. ניתן לחשב את ממוצע הווקטור כדלקמן:
np.mean(מַטרִיצָה)ניתן לחשב את השונות של וקטור כך:
np.var(מַטרִיצָה)ניתן לחשב את סטיית התקן של וקטור כך:
למשל std(מַטרִיצָה)הפלט של הפקודות הנ'ל במטריצה הנתונה ניתן כאן:
הפיכת מטריקס
טרנספוזיציה היא פעולה נפוצה מאוד עליה תשמעו בכל פעם שאתם מוקפים במטריצות. טרנספוזיציה היא רק דרך להחליף ערכי עמודות ושורה של מטריצה. שימו לב כי א לא ניתן לשנות את הווקטור כווקטור הוא רק אוסף של ערכים מבלי לערוך אותם ערכים לשורות ועמודות. שים לב שהמרת וקטור שורה לווקטור עמודה אינה מתממשת (בהתבסס על ההגדרות של אלגברה לינארית, שהיא מחוץ להיקפו של שיעור זה).
לעת עתה, נמצא שלום רק על ידי העברת מטריצה. פשוט מאוד לגשת להטמעת מטריצה עם NumPy:
matrix.Tהפלט של הפקודה לעיל במטריצה הנתונה ניתן כאן:
ניתן לבצע אותה פעולה על וקטור שורה כדי להמיר אותו לקטור עמודה.
השטחת מטריצה
נוכל להמיר מטריצה למערך חד ממדי אם נרצה לעבד את יסודותיה בצורה לינארית. ניתן לעשות זאת בעזרת קטע הקוד הבא:
מטריקס.מישור()הפלט של הפקודה לעיל במטריצה הנתונה ניתן כאן:
שים לב שהמטריצה השטוחה היא מערך חד ממדי, פשוט לינארי באופנה.
חישוב ערכי Eigen וקטורים
Eigenvectors נמצאים בשימוש נפוץ מאוד בחבילות למידת מכונה. לכן, כאשר פונקציית טרנספורמציה לינארית מוצגת כמטריצה, אזי X, Eigenvectors הם הווקטורים שמשתנים רק בקנה המידה של הווקטור אך לא בכיוון שלו. אנו יכולים לומר כי:
Xv = γvכאן, X היא המטריצה המרובעת ו- γ מכיל את ערכי Eigen. כמו כן, v מכיל את ויקטורי Eigen. עם NumPy, קל לחשב ערכי Eigen ו- Eigenvectors. להלן קטע הקוד בו אנו מדגימים את אותו הדבר:
evalues, evectors = np.linalg.eig(מַטרִיצָה)הפלט של הפקודה לעיל במטריצה הנתונה ניתן כאן:
מוצרי נקודה של וקטורים
מוצרי Dot של וקטורים היא דרך להכפיל 2 וקטורים. זה מספר לך על כמה מהווקטורים נמצאים באותו כיוון , בניגוד למוצר הצלב שאומר לך את ההפך, כמה מעט הווקטורים נמצאים באותו כיוון (נקרא אורתוגונלי). אנו יכולים לחשב את תוצר הנקודה של שני וקטורים כפי שניתן בקטע הקוד כאן:
a = np.array([3,5,6])b = מערך np.array([2. 3,חֲמֵשׁ עֶשׂרֵה,1])
np.dot(א, ב)
הפלט של הפקודה לעיל במערכים הנתונים ניתן כאן:
הוספה, חיסור והכפלת מטריצות
הוספה והפחתה של מטריצות מרובות היא פעולה פשוטה למדי במטריצות. ישנן שתי דרכים בהן ניתן לבצע זאת. הבה נסתכל על קטע הקוד לביצוע פעולות אלה. לצורך שמירה על זה פשוט, נשתמש באותה מטריצה פעמיים:
np.add(מטריצה, מטריצה)לאחר מכן, ניתן לחסר שתי מטריצות כ:
הפחתת np(מטריצה, מטריצה)הפלט של הפקודה לעיל במטריצה הנתונה ניתן כאן:
כצפוי, כל אחד מהאלמנטים במטריצה מתווסף/מופחת עם האלמנט המתאים. הכפלת מטריצה דומה למציאת המוצר הנקודתי כפי שעשינו קודם לכן:
np.dot(מטריצה, מטריצה)הקוד לעיל ימצא את ערך הכפל האמיתי של שתי מטריצות, הנתון כדלקמן:
הפלט של הפקודה לעיל במטריצה הנתונה ניתן כאן:
סיכום
בשיעור זה עברנו הרבה פעולות מתמטיות הקשורות בווקטורים, מטריצות ומערכים הנמצאים בשימוש נפוץ בעיבוד נתונים, סטטיסטיקות תיאוריות ומדעי הנתונים. זה היה שיעור מהיר המכסה רק את החלקים הנפוצים והחשובים ביותר במגוון המושגים הרחב, אך פעולות אלה אמורות לתת מושג טוב מאוד לגבי כל הפעולות שניתן לבצע תוך התמודדות עם מבני נתונים אלה.
אנא שתף את המשוב שלך באופן חופשי לגבי השיעור בטוויטר @linuxhint ו @sbmaggarwal (זה אני!).