Matrices ב-R: matrix(), cbind, rbind וחישובי מטריצות

מטריצה היא וקטור עם ממדים

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

בונים אחת על ידי עיצוב מחדש של וקטור עם matrix():

m <- matrix(1:6, nrow = 2)
print(m)
print(dim(m))
print(nrow(m))
print(ncol(m))

שישה ערכים, שתי שורות: R מחשב שצריך שלוש עמודות. dim() מדווח על שני הממדים בבת אחת כ-2 3; nrow() ו-ncol() נותנים אותם בנפרד.

הסתכלו היטב על המטריצה המודפסת: הערכים רצים 1 2 במורד העמודה הראשונה, ואז 3 4 במורד הבאה. R ממלא מטריצות עמודה אחר עמודה כברירת מחדל. אם הנתונים שלכם נקראים שורה אחר שורה, כמו שבני אדם בדרך כלל כותבים אותם, אמרו זאת עם byrow = TRUE:

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

עכשיו השורה הראשונה היא 1 2 3. שכחה של byrow = TRUE לא גורמת לשגיאה: היא נותנת בשקט סידור שנראה משוחלף של אותם מספרים, אז הפכו לבדיקת הפריסה המודפסת להרגל בכל פעם שאתם בונים מטריצה מערכים גולמיים.

גישה: m[row, column]

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

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

print(m[1, 2])
print(m[1, ])
print(m[, 2])

השארת מיקום ריק פירושה "את כולם": m[1, ] היא כל השורה הראשונה, m[, 2] כל העמודה השנייה. שימו לב ששתיהן חוזרות כווקטורים רגילים: R משמיט את הממד שהתכווץ לגודל 1. זה נוח בעבודה אינטראקטיבית ומלכודת בקוד, כי פונקציה שמצפה למטריצה תיחנק מהווקטור. בקשו מ-R לשמור על הצורה עם drop = FALSE:

m <- matrix(1:6, nrow = 2, byrow = TRUE)

row1 <- m[1, , drop = FALSE]
print(row1)
print(dim(row1))

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

גם מסכות לוגיות עובדות כאן: m[m > 3] מחזיר את כל התאים שגדולים מ-3, כווקטור.

בנייה עם cbind() ו-rbind()

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

heights <- c(170, 182, 165)
weights <- c(65, 80, 58)

people <- cbind(heights, weights)
print(people)

people <- rbind(people, c(175, 72))
print(people)

השמות נוסעים יחד עם הווקטורים: cbind() השתמש ב-heights וב-weights כשמות עמודות אוטומטית, וזה שומר על המטריצה המודפסת קריאה. שתי הפונקציות מתעקשות שהאורכים יתאימו (עם מחזור עבור ערכים באורך 1); חיבור וקטור באורך 3 למטריצה של 4 שורות יפיק אזהרה.

אפשר גם להגדיר שמות עמודות ושורות ישירות עם colnames(m) <- ... ו-rownames(m) <- ..., ואחרי זה לגשת לפי שם: people[, "weights"].

* איבר אחר איבר מול כפל מטריצות אמיתי %*%

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

a <- matrix(1:4, nrow = 2)
print(a)

print(a * a)
print(a %*% a)

• a * a הוא איבר אחר איבר: כל תא כפול התא המתאים. 1 2 3 4 הופכים ל-1 4 9 16, מסודרים באותה צורה. זה פשוט חשבון וקטורי, אותו * שמשתמשים בו על וקטורים.
• a %*% a הוא כפל מטריצות מאלגברה לינארית: כל תא בתוצאה הוא שורה של המטריצה הראשונה כפול עמודה של השנייה, מסוכם. אותו קלט נותן 7 10 15 22: מספרים שונים לגמרי.

הריצו את הקטע והשוו את שני הפלטים זה לצד זה; לראות אותם שונים על קלטים זהים זה מה שגורם להבחנה להיקלט. אם כותבים * כשהמתמטיקה דורשת %*%, R לא יזהיר אתכם, כי הצורות תואמות בכל מקרה למטריצות ריבועיות. פשוט מקבלים מספרים שגויים. בקוד סטטיסטי (מטריצות שונות משותפת, אלגברה של מודלים לינאריים) זה אחד הבאגים השקטים הקלאסיים.

t() משחלף, כלומר הופך שורות ועמודות, ומופיע כל הזמן ליד %*% כי כפל מטריצות דורש שהממדים הפנימיים יתאימו:

a <- matrix(1:4, nrow = 2)
print(t(a))
print(t(a) %*% a)

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

סיכומי שורות ועמודות

סכימה או מיצוע לאורך שורות ועמודות נפוצים כל כך ש-R מגיע עם פונקציות ייעודיות ומהירות לכך:

m <- matrix(1:6, nrow = 2, byrow = TRUE)
print(m)

print(rowSums(m))
print(colSums(m))
print(rowMeans(m))
print(colMeans(m))

rowSums() מכווץ כל שורה למספר אחד (6 15 כאן), colSums() כל עמודה (5 7 9), וגרסאות ה-Means מחשבות ממוצע במקום. העדיפו אותן על פני לולאות שנכתבו ידנית או אפילו apply(m, 1, sum): הן ברורות ומהירות יותר. לסיכומים שארבע אלה לא מכסות (למשל, מקסימום לכל עמודה), משפחת apply היא הכלי הכללי: apply(m, 2, max).

מטריצה או data frame?

שניהם מלבניים, אז במה לבחור?

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

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

מה לקחת מכאן

• מטריצה היא וקטור עם ממדים: טיפוס אחד לכל אורכה, נבנית עם matrix(data, nrow, ncol), ומתמלאת עמודה אחר עמודה אלא אם מעבירים byrow = TRUE.
• גשו כ-m[row, col]; מיקום ריק פירושו "הכול"; הוסיפו drop = FALSE כשחותכים שורות או עמודות בודדות בתוך קוד.
• cbind() ו-rbind() מרכיבים מטריצות מווקטורים או מרחיבים מטריצות קיימות.
• * פועל איבר אחר איבר, %*% הוא כפל מטריצות אמיתי: אותם קלטים, תשובות שונות, בלי אזהרה.
• rowSums() / colSums() / rowMeans() / colMeans() מטפלים בסיכומים היומיומיים.

בהמשך: factors, איך R מייצג נתונים קטגוריאליים, והמלכודות שמגיעות איתם.