>> [השמעת מוסיקה]
דסטין TRAN: היי.
קוראים לי דסטין.
אז אני יהיה הצגה ניתוח נתונים בר '
רק קצת על עצמי.
אני כרגע סטודנט לתואר שני ב מדעי ההנדסה יישומית.
אני לומד צומת למידת מכונה וסטטיסטיקה
כך ניתוח נתונים במחקר הוא באמת בסיסי למה ש
אני עושה על בסיס יומי.
>> וR הוא במיוחד טוב לניתוח נתונים
כי זה טוב מאוד עבור אב טיפוס.
ובדרך כלל, כשאתה עושה סוג כלשהו ניתוח נתונים, הרבה בעיות
הולכים קוגניטיבית.
ואז אתה פשוט רוצה שתהיה לי כמה שפה ממש טובה ש
רק טוב לעושה פונקציות מובנות, בניגוד
לצורך להתמודד עם דברים ברמה נמוכים.
אז בהתחלה, אני פשוט הולך כדי להציג את מה שהוא R, למה ש
אתה רוצה להשתמש בו, ו אז ללכת על לכמה הדגמה,
ופשוט ללכת משם.
>> אז מה הוא R?
R הוא רק שפה שפותחה עבור מחשוב סטטיסטי
והדמיה.
אז מה שזה אומר זה ש זה שפה מאוד מעולה
לכל סוג של דבר שעוסק ב חוסר ודאות או נתונים להדמיה.
אז יש לך את כל אלה הסתברויות.
יש הולכים להיות פונקציות מובנות.
תהיה לך גם מצוין זומם חבילות.
>> Python הוא עוד מתחרה שפה לנתונים.
ועוד דבר אחד שאני מוצא את R ש הוא הרבה יותר טוב בהיא הדמיה.
אז מה שתראה בהדגמה כ גם היא רק שפה מאוד אינטואיטיבי
שפשוט עובד טוב מאוד.
זה גם בחינם וקוד פתוח, כ הוא כל שפה טובה אחרת אני מניח.
>> וכאן, חבורה של רק מילות מפתח שזרקו אותך.
זה דינמי, כלומר אם יש לך סוג מסוים שהוקצה לאובייקט
ממה שזה פשוט לשנות את זה במהירות ההבזק.
זה עצלן אז זה חכם על איך היא עושה את החישובים.
פונקציונלי משמעות זה באמת יכול לפעול מבוסס על הנחה של פונקציות כך anything--
כל סוג של מניפולציה שאתה עושה, זה יהיה מבוסס על הנחה פונקציות.
>> מפעילים אז בינארי, לדוגמא, הן פונקציות פשוט מיסודו.
וכל מה ש אתה הולך לעשות הוא
הולך להיות לברוח פונקציות עצמו.
ולאחר מכן מונחה עצמים, כמו גם.
>> אז הנה עלילת XKCD.
לא רק בגלל שאני מרגיש כמו XKCD הוא יסוד לכל סוג
הצגה, אלא משום ש אני מרגיש כאילו זה באמת
פטישי הנקודה שהרבה זמן שבו אתה עושה איזה נתונים
ניתוח, הבעיה היא לא כל כך הרבה כמה מהר הוא פועל,
אבל כמה זמן זה הולך לקחת לך לתכנת את המשימה.
אז הנה הוא רק ניתוח אם אסטרטגיה או b הוא יעיל יותר.
זה הולך להיות משהו שאתה
הולך להתמודד עם הרבה ב שפות ברמה נמוכה סוג של
עם תקלות SEG שבו אתה מתעסק, הקצאת זיכרון, אתחולים,
אפילו מה שהופך את הפונקציות המובנות.
והדבר הזה הוא כל מטופלים מאוד, מאוד באלגנטיות בר '
>> אז רק כדי לתקוע את זה נקודה, צוואר הבקבוק הגדול ביותר
הולך להיות קוגניטיבית.
אז ניתוח נתונים הוא בעיה קשה מאוד.
בין אם אתה עושה למידת מכונה או שאתה
עושה בדיוק איזה חקר נתונים בסיסי,
אתה לא רוצה שתהיה לי לקחת מסמך
ואז לקמפל משהו בכל פעם ש
רוצה לראות מה טור נראה כמו, מה מיוחד ערכים במטריצה
נראה.
אז אתה פשוט רוצה שתהיה לי כמה ממשק ממש נחמד
אתה יכול להריץ פונקציה פשוטה כי מדדים לכל מה ש
אתה רוצה ופשוט להפעיל אותו משם.
ואתה צריך תחום שפות ספציפיות לזה.
וR באמת יעזור לך להגדיר את בעיה ולפתור אותה בצורה זו.
>> אז הנה תכנות מראה עלילה פופולריות של R כזה נעלם עם זמן.
אז כפי שאתם יכולים לראות, כמו 2013 או אז זה פשוט פוצץ מאוד.
וזה היה רק ​​בגלל ש מגמה ענק בתעשיית הטכנולוגיה
נתונים גדולים עליו.
כמו כן, לא רק הטכנולוגיה תעשייה, אבל באמת
כל that-- כי תעשייה הרבה תעשיות
הם סוג של יסוד ל מנסה לפתור את הבעיות הללו.
ובדרך כלל, אתה יכול לקבל כמה טוב אפשרות למדוד את הבעיות האלה
או אפילו מגדיר אותם או פתרונן תוך שימוש בנתונים.
אז אני חושב שעכשיו הוא R ה -11 רוב השפה הפופולרית בTIOBE
וזה כבר גדל מאז.
>> אז הנה עוד קצת תכונותיו של ר 'יש לו
מספר עצום של חבילות ו לכל הדברים השונים הללו.
אז כל זמן שיש לך בעיה מסוימת, רוב
R הזמן יהיה לי פונקציה זה בשבילך.
אז אם אתה רוצה לבנות איזה מכונה
אלגוריתם למידה הנקרא אקראי יער או עצי החלטות,
או אפילו מנסה לקחת הממוצע של פונקציה או כל הדברים האלה,
R יהיה ש.
>> ואם אתה עושה שאכפת לך אופטימיזציה, דבר אחד זה נפוץ
הוא שלאחר שתסיים prototyping איזה שפה ברמה גבוהה,
אתה תזרוק שin-- אתה פשוט יציאה שמעל
לכמה שפה ברמה נמוכה.
מה טוב בR הוא שברגע שאתה עשה prototyping את זה, אתה יכול לרוץ C ++,
או Fortran, או כל אחד מאלה אלה ברמה נמוכה יותר באופן ישיר לר '
אז זה באמת תכונה מגניב על R,
אם אתה באמת אכפת לי נקודת אופטימיזציה.
>> וזה גם ממש טוב לפריטים חזותיים אינטרנט.
אז D3.js, למשל, הוא אני מניח שסמינר אחר
שהצגנו היום.
וזה באמת מדהים עבור עושה חזותיים אינטראקטיבי.
וD3.js מניח שיש לך איזה נתונים כדי להתוות
וR הוא דרך של להיות מסוגל לעשות גדולה ניתוח הנתונים לפני שאתה לייצא אותו
מעל לD3.js או אפילו רק לרוץ D3.js פקודות לR עצמו,
כמו גם את כל אלה ספריות אחרות גם כן.
>> אז זה היה רק ​​המבוא ל מה הוא R ומדוע אתה עלול להשתמש בו.
אז אני מקווה, יש לי שכנעתי אותך משהו
על רק מנסה לראות איך זה.
אז אני הולך קדימה ולעבור כמה יסודות על אובייקטי R
ומה שאתה באמת יכול לעשות.
>> אז הנה הוא רק חבורה של פקודות מתמטיקה.
כך אומר you're-- אתה רוצה לבנות את עצמך שפה ואתה רק רוצה
יש חבורה של כלים שונים.
כל סוג של פעולה שאתה חושב שאתה רוצה הולך להיות פחות או יותר בר '
>> אז הנה הוא 2 ועוד 2.
הנה pi 2 פעמים.
יש R חבורה של קבועים מובנים כי אתה משתמש לעתים קרובות כמו פאי, e.
>> ואז, הנה 7 בתוספת runif, כך runif של 1.
זוהי פונקציה שזה יוצרת אחיד אקראית אחד 0-1.
ואז יש 3 לכח של 4.
יש שורשים מרובעים.
>> יש יומן.
אז להיכנס יעשה בסיס מעריכי בכוחות עצמו.
ולאחר מכן, אם תציין בסיס, לאחר מכן אתה יכול לעשות מה שאתה רוצה בסיס.
ואז הנה כמה פקודות אחרות.
אז יש לך 23 mod 2.
אז יש לך את השארית.
אז אתה צריך מדעי סימון גם אם אתה
רוצה לעשות רק יותר ו דברים מסובכים יותר.
>> אז הנה היא משימה.
משימות אופייניות כל כך ב R נעשה עם חץ
כך שזה פחות מ ולאחר מכן המקף.
אז הנה רק אני הקצאה 3 לval משתנה.
>> ואז אני מדפיס את val ואז זה מדפיס את שלוש.
כברירת מחדל במתורגמן R, זה יהיה להדפיס את הדברים בשבילך
אז אתה לא צריך לציין להדפיס val כל פעם שאתה רוצה להדפיס משהו.
אתה פשוט יכול לעשות val ו אז זה יעשה את זה בשבילך.
>> כמו כן, ניתן להשתמש בשווה מבחינה טכנית כמפעיל משימה.
יש דקויות קלות בין באמצעות החץ
מפעיל והשווים מפעיל למשימות.
בעיקר על ידי אמנה, כולם פשוט להשתמש במפעיל החץ.
>> וכאן, אני הקצאה זו סימון אלכסוני נקרא מעי גס 1 6.
זה יוצר וקטור 1-6.
וזה ממש נחמד כי אז אתה פשוט להקצות את הווקטור לval
וזה עובד על ידי עצמו.
>> אז זה כבר הולך מ single-- נתונים מאוד אינטואיטיבי
מבנה פשוט כפול של איזה סוג של סוג לוקטור
ושיאסוף את כל ערכי סקלר בשבילך.
אז אחרי הולכים מסקלר, אתה יש לי אובייקטי R וזה וקטור.
וקטור הוא כל סוג של אוסף מאותו הסוג.
אז הנה חבורה של וקטורים.
>> אז זה מספרי.
המספרי הוא דרכו של R לומר כפול.
וכך כברירת מחדל, כל מספר יהיה כפול.
>> אז אם יש לך ג של 1.1, 3, שלילי של 5.7, ג הוא פונקציה.
זה משרשר את כל שלוש מספרים לתוך וקטור.
וזה יהיה be-- כך שאם אתה שם לב 3 על ידי עצמו,
בדרך כלל היית להניח שזה כמו מספר שלם,
אבל בגלל שכל הווקטורים הם אותו הסוג,
זה הוא וקטור של זוגות או מספרי במקרה זה.
>> rnorm היא פונקציה שיוצרת variables-- הנורמלי סטנדרטי
או ערכים נורמלים סטנדרטיים.
ואני מפרט שניים מהם.
אז אני עושה rnorm 2, הקצאה של devs, ואז אני מדפיס את devs.
אז אלה הם רק שתיים ערכים נורמלים אקראיים.
>> ולאחר מכן INTs אם אתה עושה אכפת לך מספרים שלמים.
אז זה רק על זיכרון הקצאה וגודל זיכרון חיסכון.
אז היית צריך להוסיף המספרים שלך על ידי ההון L.
>> באופן כללי, זה הסימון ההיסטורי של R
למשהו שנקרא שלם ארוכה.
אז רוב הזמן, אתה להיות התמודדות עם זוגות.
ואם אי פעם יהיו מאוחר יותר על למטב את הקוד שלך,
אתה יכול פשוט להוסיף אלה L's לאחר מכן או במהלכה
אם אתה ממש נבואי על מה אתה הולך לעשות המשתנים הללו.
>> אז הנה הוא וקטור אופי.
אז, שוב, אני שרשור שלושה מיתרים הפעם.
שימו לב שמייתרים כפולים ו מחרוזות יחידים הן אותו הדבר בר '
אז יש לי ארתור ומרווין של וכן כשאני מדפיס את זה, כולם
הולכים להראות מיתרים כפולים.
ואם גם אתם רוצים לכלול המחרוזת הכפולה או בודדת
בדמויות שלך, אז אתה יכול או להחליף המיתרים שלך.
>> אז מרווין של ל אלמנט שני, זה הוא
הולך show-- רק צריכים מחרוזות כפולות
ואז מחרוזת אחת כך זה לסירוגין.
אחרת, אם ברצונך להשתמש כפול מפעיל מחרוזת במחרוזת כפולה
כשאתה מכריז את זה, אז אתה פשוט להשתמש במפעיל הבריחה.
אז אתה עושה את המחרוזת הכפולה הקו הנטוי.
>> ולבסוף, אנחנו גם יש וקטורים הגיוניים.
אז logical-- כל כך נכון וFALSE, והם
הולך להיות כל האותיות גדולות.
ואז, שוב, אני שרשור שלהם ולאחר מכן הקצאתם לbools.
אז bools הולך להראות אתה TRUE, FALSE, ואמיתי.
>> אז הנה אינדקס vectorized.
אז בהתחלה, אני אני לוקח function--
זה נקרא sequence-- רצף 2-12.
ואני לוקח את רצף על ידי 2.
אז זה הולך לעשות 2, 4, 6, 8, 10 ו -12.
ואז, אני אינדקס כדי לקבל את האלמנט השלישי.
>> אז דבר אחד שכדאי לזכור הוא שמדדי R על ידי החל מיום 1.
אז Vals 3 הוא הולך לתת לי אתה המרכיב השלישי.
זה סוג אחר של מאחר שפות בו הוא מתחיל מאפס.
אז בC או C ++, למשל, אתה הולך לקבל את האלמנט הרביעי.
>> וכאן הוא Vals 3-5.
אז דבר אחד שהוא ממש מגניב הוא שאתה
יכול ליצור משתנים זמניים בתוך ואז פשוט להשתמש בם במהירות ההבזק.
אז הנה הוא 3 עד 5.
אז אני יצירת וקטור 3, 4, ו -5 ולאחר מכן
אני אינדקס כדי לקבל השלישי, אלמנטים רביעי, וחמישי.
>> אז באופן דומה, אתה יכול מופשט זה פשוט לעשות
כל סוג של וקטור זה נותן לך לאינדקס.
אז הנה הוא Vals ולאחר מכן אלמנטים ראשון, שלישי, והשישי.
ולאחר מכן, אם אתה רוצה לעשות משלים,
אז אתה פשוט עושה מינוס שימצא אחר כך ו
לתת לך את כל מה שלא ראשון, שלישי, או אלמנט שישי.
אז זה יהיה 4, 8, ו -10.
>> ואם אתה רוצה לקבל אפילו יותר מתקדם,
אתה יכול לשרשר וקטורים בוליאנית.
אז מדד זה הולך לתת לך וקטור בוליאני זה באורך 6.
אז פסיק אמיתי נציג 3.
זה יחזור שלוש פעמים TRUE.
אז זה ייתן לך וקטור TRUE, TRUE, TRUE.
>> נציג FALSE 4-- זה הולך לתת לך וקטור של שקר, שקר, שקר, שקר.
ולאחר מכן ג הולך לשרשר אלה שני Booleans יחד.
אז אתה הולך לקבל את שלוש TRUEs ולאחר מכן ארבע FALSEs.
>> כך שכאשר אתה Vals מדד, אתה הולך לקבל אמיתי TRUE, TRUE,.
אז זה הולך להגיד כן, אני רוצה שלושת מרכיבים אלה.
ואז שקר, שקר, שקר שקר הולך,
להגיד לא, אני לא רוצה אותם אלמנטים כך שזה לא הולך להחזיר אותם.
>> ואני מניח שיש בעצם טעות דפוס כאן כי זה אומר חוזר אמיתי 3
וחזור 4 FALSE, ומבחינה טכנית, אתה רק יש לי שישה אלמנטים כל כך לחזור FALSE,
זה צריך להיות חוזר FALSE 3.
אני חושב שR הוא גם חכם מספיק כאלה כי אם אתה רק לציין 4 כאן, אז
זה אפילו לא שגיאה החוצה.
זה פשוט ייתן לך ערך זה.
אז זה פשוט להתעלם מזה FALSE הרביעי.
>> אז הנה היא משימת vectorized.
אז set.seed-- זה רק מגדיר את זרע למספרי פסוודו.
אז אני הגדרת את הזרע ל 42, מה שאומרים שאם אני יוצר
שלוש אקראי נורמלי ערכים, ולאחר מכן אם אתה
לרוץ set.seed בעצמך מחשב משתמש באותו הערך 42,
אז אתה גם מקבל אותם שלוש נורמלים אקראיים.
>> אז זה ממש טוב לשחזור.
בדרך כלל, כשאתה עושה קצת סוג של ניתוח מדעי,
היית רוצה להגדיר את הזרע.
בדרך זו מדענים אחרים רק יכולים לשחזר בדיוק את אותו קוד שיש לך
עשה את זה כי יהיה להם מדויק אותם משתנים אקראיים that-- או אקראי
ערכים שאתה כבר לקח את גם כן.
>> וכך משימת vectorized כאן הוא מראה Vals 1 עד 2.
אז זה לוקח שני יסודות הראשונים של Vals ולאחר מכן מקצה להם 0.
ואז, אתה יכול גם פשוט לעשות דבר דומה עם Booleans.
>> אז Vals אינו שווה ל0-- רצון זה אתן לך FALSE וקטור, FALSE, TRUE
במקרה זה.
ואז, זה הולך לומר כל מאותם מדדים שהיו נכונים,
אז זה הולך להקצות שעד 5.
אז זה לוקח את האלמנט השלישי כאן ולאחר מכן מקצה אותו ל5.
>> וזה ממש נחמד בהשוואה לשפות ברמה הנמוכה
שבו אתה צריך להשתמש ללולאות לעשות את כל דברים vectorized זה
כי זה פשוט מאוד אינטואיטיבי וזה אחד-אניה אחת.
ומה על גדול סימון vectorized
הוא שבR, אלה הם סוג של מובנה בכך שהם כמעט באותה מהירות
כעושה בשפה ברמה נמוכה כ בניגוד לעשיית ללולאה בR
ואז שיש בו כדי לעשות האינדקס הדינמי עצמו.
וזה יהיה איטי יותר מאשר לעשות דברים מהסוג הזה vectorized
בו הוא יכול לעשות את זה במקביל, בי זה עושה את זה בשחלה בעצם.
>> אז הנה הוא vectorized פעולות.
אז אני יצירת ערך 1 עד 3, הקצאה שלvec1, 3 עד 5, vec2,
מוסיף אותם יחד.
זה מוסיף להם רכיב חכם כל כך זה 1 ועוד 3, 2 ו- 4, וכן הלאה.
>> vec1 vec2 פעמים.
זה מכפיל את שני ערכי רכיב חכם.
אז זה 1 פעמים 3, 2 פעמים 4, ולאחר מכן 3 פעמים 5.
>> ולאחר מכן, באופן דומה אתה יכול גם לעשות comparisons-- השוואות לוגיות.
אז זה שקר שקר אמיתי בזה מקרה כי 1 אינו גדול מ 3,
2 הוא לא יותר מ- 4.
זה, אני מניח, טעות דפוס אחר, 3 בהחלט לא יותר מ -5.
כן.
ואז אתה יכול פשוט לעשות את כל פעולות פשוטות הבאות
בגלל הירושה שלהם מהשיעורים עצמם.
>> אז זה היה רק ​​הווקטור.
וזה סוג של הבסיסי ביותר אובייקט R כי ניתנו וקטור,
אתה יכול לבנות עצמים מתקדמים יותר.
>> אז הנה מטריצה.
זהו למעשה ההפשטה ממה שמטריצה ​​היא עצמו.
אז במקרה הזה, זה שלוש שונים וקטורים, שבו כל אחד הוא טור,
או שאתה יכול לשקול את זה כמו כל אחד היא שורה.
>> אז אני אחסון מטריצה ​​מ -1 עד 9 ואז אני מפרט 3 שורות.
אז 1-9 ייתן לך וקטור 1, 2, 3, 4, 5, 6, וכל הדרך עד 9.
>> דבר אחד גם לזכור הוא ש חנויות R ערכים בפורמט טור-גדול.
אז במילים אחרות, כשאתה רואה 1 ל -9, זה הולך לאחסון them--
זה הולך להיות 1, 2, 3 בטור הראשון,
ואז זה יעשה 4, 5, 6 בטור השני,
ולאחר מכן 7, 8, 9 בעמודה השלישית.
>> והנה כמה אחר פונקציות נפוצות שאתה יכול להשתמש.
אז מחצלת עמומה, זה ייתן לך הממדים של המטריצה.
זה הולך להחזיר אותך וקטור של הממד.
אז במקרה הזה, בגלל ש המטריצה ​​שלנו היא 3 על 3,
זה הולך לתת לך וקטור מספרי זה 3 3.
>> וכאן הוא רק מראה כפל מטריצות.
אז בדרך כלל, אם אתה רק עושה asterisk-- כך מחצלת כוכבית mat--
זה הולך להיות פעולת רכיב חכם
או מה שנקרא מוצר Hadamard.
אז זה הולך לעשות כל רכיב חכם אלמנט.
עם זאת, אם אתה רוצה multiplication-- מטריצה
כך הכפלת הפעמים השורה הראשונה הטור הראשון של המטריצה ​​השנייה
וכך on-- היית להשתמש פעולה זו אחוזים.
>> ולא של שטיח הוא פשוט פעולה ללשרבב.
אז אני אומר לקחת את לשרבב ב מטריקס, להכפיל את זה על ידי מטריקס
עצמו.
ואז זה הולך אחזור אליך עוד 3
על ידי 3 מראה מטריצה המוצר שאתה רוצה.
>> וכך הייתה מטריצה.
הנה מה שנקרא מסגרת נתונים.
מסגרת הנתונים שאתה יכול לחשוב על כ מטריקס, אבל כל עמודה עצמו
הולך להיות מסוג אחר.
>> אז מה באמת מגניב על נתונים מסגרות היא שבניתוח הנתונים עצמו,
אתה הולך לקבל את כל זה נתונים הטרוגניים וכל אלה באמת
דברים מבולגנים שבו כל אחד מהעמודים עצמם יכולים להיות מסוגים שונים.
אז הנה אני אומר ליצור מסגרת נתונים, לעשות ints 1-3,
ואז יש גם וקטור אופי.
אז אני יכול מדד דרך כל אחד מעמודים אלה
ואז אני אקבל את הערכים עצמם.
ואתה גם יכול לעשות כלשהו פעילות במסגרות נתונים.
ורוב הזמן כשאתה עושה ניתוח נתונים או סוג כלשהו
עיבוד מקדים, אתה תהיה עבודה עם מבני נתונים אלה
שבו כל עמודה הולכת להיות מסוג אחר.
>> לבסוף, ולכן אלה הם למעשה רק ארבעה חפצים חיוניים ברשימת ר '
פשוט לאסוף כל חפצים אחרים שאתה רוצה.
אז זה יהיה לאחסן את זה באחד משתנה שאתה יכול בקלות לגשת.
>> אז הנה, אני לוקח את רשימה.
אני אומר דברים שווים 3.
אז אני הולך להיות מרכיב אחד ב הרשימה, וזה נקרא דברים,
וזה הולך להיות הערך 3.
>> אני יכול גם ליצור מטריצה.
אז זה 1 עד 4 ושורת הסוף שווה 2, כך 2 על ידי 2 מטריצה.
גם ברשימה וזה נקרא מזרן.
moreStuff, מחרוזת תווים, ואפילו רשימה אחרת בעצמו.
>> אז זה רשימה זה 5 ודוב.
אז יש לו את הערך 5 ו יש דוב מחרוזת תווים
וזה רשימה בתוך רשימה.
אז אתה יכול לקבל אלה דברים רקורסיבית בי
יש לך another-- הקלד בתוך הסוג.
אז באופן דומה, אתה יכול לקבל מטריצה בתוך מטריצה ​​אחרת וכן הלאה.
ורשימה היא פשוט דרך טובה של איסוף וצבירה
כל האובייקטים השונים הללו.
>> ולבסוף, כאן הוא רק לעזור במקרה זה פשוט נעלם מעל מהר מאוד.
אז כל פעם שאתה מבולבל על איזה פונקציה,
אתה יכול לעשות בעזרת פונקציה ש.
אז אתה יכול לעשות את מטריצת עזרה או מטריצת סימן שאלה.
ועזרה וסימן השאלה הן רק קיצור לאותו הדבר
כך הם כינויים.
>> lm הוא פונקציה ש פשוט עושה את מודל ליניארי.
אבל אם רק יש לך מושג כמה ש עבודות, אתה יכול פשוט לעשות את העזרה של lm
ושאתן לך כמה סוג של תיעוד ש
נראה כמו סוג של דף אדם ביוניקס, שבו
יש לך תיאור קצר של מה ש היא עושה, גם מה הן טענותיו,
מה שהוא חוזר, ורק טיפים על איך כדי להשתמש בו, וכמה דוגמאות, כמו גם.
>> אז תן לי ללכת קדימה ותכנית כמה הדגמה של השימוש בר 'אישור'.
אז ניגשתי מאוד במהירות רק נתונים
מבנים וסוג מסוים של op-- חלק מהפעולות.
הנה כמה פונקציות.
>> אז הנה רק אני הולך להגדיר פונקציה.
אז גם אני משתמש אופרטור השמה כאן,
ואז אני אומר להכריז עליו כפונקציה.
וזה לוקח x הערך.
אז זה כל ערך שאתה רוצה ואני הולך לחזור x עצמו.
אז זה פונקצית הזהות.
>> ומה זה מגניב על זה בהשוואה לשפות אחרות
ורמה נמוכה עוד שפות היא x ש
יכול להיות מכל סוג עצמו וזה יחזור סוג זה.
אז אתה יכול imagine-- אז בוא לי רק לרוץ במהירות זו.
מצטער.
>> אז דבר אחד אני צריך גם להזכיר הוא שעורך זה אני משתמש ב
נקרא rstudio.
זה מה שנקרא IDE.
ועוד דבר אחד זה ממש נחמד על זה
הוא שהיא משלבת הרבה דברים שאתה רוצה לעשות בR על ידי עצמו
פשוט מאוד אינטואיטיבי.
>> אז הנה היא קונסולת מתורגמן.
אז באופן דומה, ניתן גם לקבל את זה גלם קונסולה רק על ידי עשיית ר הון
וזה בדיוק אותו דבר כמו הקונסולה.
אז רק אני יכול לעשות x id פונקציה, x, x.
וthen-- ולאחר מכן ש יהיה בסדר עצמו.
>> אז rstudio הוא גדול כי יש לו הקונסולה.
כמו כן, יש מסמכים אתה רוצה לרוץ על.
ואז יש לו כמה משתנים שאתה יכול לראות בסביבות.
ולאחר מכן, אם יש לך לעשות חלקות, אז אתה
רק יכול לראות את זה כאן, בניגוד ל ניהול כל חלונות שונים אלה
על ידי עצמם.
>> אני דווקא אישית משתמש Vim, אבל אני מרגיש כמו rstudio הוא מצוין רק
להשגת רעיון טוב כיצד להשתמש ר 'בדרך כלל,
כאשר אתה מנסה ללמוד כמה משימה חדשה,
אתה לא רוצה להתמודד יותר מדי דברים בבת אחת.
אז R הוא רק rstudio very-- היא דרך טובה מאוד של R הלמידה
מבלי להתמודד עם כל אלה דברים אחרים.
>> אז הנה אני רץ id שלום.
זה מחזיר שלום.
id 123.
כאן הוא וקטור של מספרים שלמים.
אז באופן דומה, כי אתה יכול לקחת כל סוג מסוים של ערך,
אתה יכול לעשות חוזר id של x, כך שהוא מחזיר 1,234 ו -5.
>> ותן לי רק להראות לך ש זה אכן מספר שלם.
ובאופן דומה, אם אתה עושה בכיתה x id, זה הולך להיות מספר שלם.
ואז, אתה יכול גם להשוות בין השניים וזה נכון.
אז אני בודק אם id של x שווה x השווה והודעה
כי זה נותן לך שתי TRUEs.
אז זה לא אומר הם שני אובייקטים זהים,
אך כל אחד מהערכים בתוך הווקטורים זהים.
>> הנה bounded.compare.
אז זה קצת יותר מסובך שביש לו אם מצב ואחר
ואז זה לוקח שני טיעונים בכל פעם.
אז x הוא מכל סוג.
ואני אומר את זה טיעון שני הוא.
זה יכול להיות כל דבר, כמו גם.
אבל כברירת מחדל, זה הולך לקחת 5 אם לא יציינו דבר.
>> אז הנה אני הולך להגיד אם x גדול מ.
אז אם אני לא לציין, זה אומר שאם x הוא יותר מ -5,
אז אני הולך להחזיר TRUE.
אחר, אני הולך לחזור FALSE.
אז תן לי ללכת קדימה ולהגדיר את זה.
>> ועכשיו אני הולך ל לרוץ bounded.compare 3.
אז זה אומר שפחות 3 than-- הוא 3 גדול מ -5.
לא, זה לא כל כך FALSE.
>> וbounded.compare 3 ואני הולך כדי להשוות אותו באמצעות שווה 2.
אז עכשיו אני אומר כן, עכשיו אני רוצה להיות משהו אחר.
אז אני הולך להגיד, אתה צריך להיות 2.
>> אני יכול גם לעשות את זה סוג של סימון או אני אומר שווה 2.
זה קריא יותר שבכאשר אתה
מסתכל על באמת אלה פונקציות מסובכות ש
לקחת arguments-- מרובה וזה יכול להיות עשרות oftentimes-- רק אומרים
שווה 2 הוא קריאים יותר ל אתה כל כך שמאוחר יותר בעתיד
אתה יודע מה שאתה עושה.
>> אז במקרה הזה, אני האמרה היא 3 גדולה מ -2.
כן, זה הוא.
ובאופן דומה, אני יכול רק להסיר זה ואומר, הוא 3 גדול מ 2
שבו שווה 2.
וזה גם נכון.
כן?
>> קהל: האם אתה ביצוע שורה אחר שורה?
>> דסטין TRAN: כן אני.
אז מה אני עושה כאן הוא לוקח את הטקסט הזה document--
ומה שיפה הוא שrstudio אני רק יכול לרוץ short-- מקש קיצור.
אז אני עושה את הבקרה-הזן.
>> ואז, אני לוקח קו במסמך הטקסט
ולאחר מכן לשים בקונסולה.
אז הנה אני אומר, bounded.compare ואני עושה את הבקרה-X.
אז אני יכול פשוט לרוץ גם כאן.
ואז שתיקח את קו ואז לשים אותו כאן.
ולאחר מכן באופן דומה, אני יכול רץ כאן.
ואז זה יהיה רק ​​לשמור על ההגדרה הקווים לקונסולה כמו ש.
>> ואם אתה גם שם לב המתולתל פלטה נמצאות שם בדיוק כמו בתחביר C.
x-- אם אם המצב הוא גם הולך להשתמש בסוגריים ולאחר מכן
אתה יכול להשתמש אחר.
אחד נוסף הוא אם אחר.
אז זה הולך להיות x שווה שווה, למשל.
ואז אני הולך ל לחזור כאן משהו.
>> שים לב שיש שני שונים פה דברים שקורה.
אחת הוא שכאן אני מפרט להחזיר TRUE הערך.
כאן אני רק אומר x.
אז R בדרך כלל כברירת מחדל לקחת arguments-- האחרון
או לקחת את השורה האחרונה של הקוד, וזה יהיה מה שהוא חזר.
אז הנה זה זהה דבר עושה x תמורה.
>> ורק כדי להראות לך.
ואז, זה יעבוד ככה סתם.
אז תן לי להמשיך עם זה.
>> אז אחר אם.
ובאמת, אני יכול לחזור כל מה שאני רוצה.
אז גם אין לי ל התמורה Booleans כל הזמן,
אני יכול רק לחזור למשהו אחר.
אז אני יכול לעשות את דוב תמורה.
>> אז אם x שווה שווה, זה הולך לחזור דוב.
אחרת, זה הולך להחזיר TRUE.
אני יכול גם לעשות וקטור או בעצם כל דבר.
>> ובדרך כלל באופן סטטי שפות מודפסות,
היית צריך לציין כאן סוג.
ושים לב שזה יכול להיות רק דבר.
וR הוא אינטליגנטי מספיק ש יהיה פשוט לעשות את זה וזה יעבוד בסדר.
>> אז תן לי להגדיר את זה.
Unexpected-- הו מצטער.
זה צריך להיות סד מתולתל כאן.
OK.
מגניב.
בְּסֵדֶר.
אז עכשיו בואו להשוות 3 ושווה 3.
כך זה צריך return-- yeah-- דוב הערך.
>> אז עכשיו דבר כללי יותר הוא כמו מה לגבי מבני נתונים אחרים.
אז יש לך בפונקציה זו.
זה הולך לעבוד על כל סוג של ערך כמו 3 או כל מספרי,
במילים אחרות, כפול.
>> אבל מה עם משהו כמו וקטור.
אז מה קורה אם אתה do-- אז אני הולך להקצות val, נניח, 4 עד 6.
אז אם אני חוזר זה, זה הוא וקטור מ4, 5, 6.
>> עכשיו בואו לראות מה קורה אם אני עושה את bounded.compare val.
אז זה הולך לתת לך 15 1,251.
אז במילים אחרות, זה אומר אם אתה מסתכל על המצב הזה
אז זה אומר x הוא פחות מ או משהו.
אז זה מעט מבלבל כי עכשיו
אתה פשוט לא יודע מה קורה.
אז אני מניח שדבר אחד שבאמת טוב על רק מנסה לאתר באגים
הוא שאתה יכול פשוט לעשות את val גדול מ ולראות מה קורה שם.
>> אז val-- הוא כברירת מחדל 5 כל כך בואו פשוט Val של יותר מ -5.
אז זה שקר שקר וקטור TRUE.
אז עכשיו כשאתה מסתכל על זה, זה הולך לומר אם,
ואז זה הולך לתת לך את זה הוא וקטור של שקר שקר אמיתי.
>> לכן, כאשר אתה עובר את זה בR, R אין לו מושג מה אתה עושה.
כי זה מצפה אחד ערך, שבו הוא בוליאנית, ועכשיו
אתה נותן את זה וקטור של Booleans.
אז כברירת מחדל, R הוא פשוט הולך להגיד מה לעזאזל,
אני הולך להניח שאתה הולך לקחת את האלמנט הראשון כאן.
אז אני הולך לsay-- אני הולך להניח שזה שקר.
אז זה הולך להגיד לא, זה לא בסדר.
>> בדומה לכך, זה הולך להיות val שווה שווה.
לא, מצטער 5.
וזה גם הולך להיות כוזב, כמו גם.
אז זה הולך להגיד לא, זה לא נכון, כמו גם אז זה
עומד לחזור זה אחרון.
>> אז זה גם דבר טוב או רע דבר, תלוי איך אתה מציג את זה.
כי כשאתה יצירת פונקציות אלה,
אתה באמת לא יודע מה קורה.
אז לפעמים היית רוצה שגיאה, או אולי אתה פשוט רוצה אזהרה.
במקרה זה, R לא עושה את זה.
אז זה באמת תלוי בי אתה מבוסס על הנחה של מה ש
אתה חושב שפה צריך לעשות במקרה זה
אם אתה עובר בוקטור של Booleans כאשר אתה עושה אם מצב.
>> אז נניח שהיה לך מקורי אחד עם אם אחר להחזיר TRUE ואתה
הולך להחזיר FALSE.
אז דרך אחת ההפשטה זה אומר ש
אפילו לא צריך דבר המותנה הזה.
עוד דבר שאני יכול לעשות הוא פשוט חוזר את הערכים עצמם.
אז אם אתה שם לב, אם אתה לעשות val הוא יותר מ -5,
זה הולך לחזור וקטור שקר שקר אמיתי.
>> אולי זה מה שאתה רוצה לbounded.compare.
אתה רוצה לחזור וקטור של Booleans שבו הוא משווה כל אחד מהערכים
לעצמם.
אז אתה יכול פשוט bounded.compare x פונקציה, שווה 5.
ואז במקום לעשות מצב זה אם אחר,
אני רק הולך לחזור x גדול מ -5.
אז אם זה נכון, אז זה הולך להחזיר TRUE.
ואז אם זה לא, זה הולך להחזיר FALSE.
>> וזה יעבוד ל כל המבנים הללו.
אז אני יכול bounded.compare ג 1 6 או 9 ואז אני הולך להגיד שווה 6,
לדוגמא.
ואז זה הולך אתן לך בוליאנית תקין
וקטור שאתה מעצב.
>> אז אלה הם רק פונקציות ועכשיו תן לי רק
להראות לך כמה חזותיים אינטראקטיביים.
אני לא חושב שאני באמת צריך Wi-Fi כאן אז תן לי רק קדימה
ולדלג על זה אני מניח.
>> אבל דבר אחד זה מגניב למרות שהוא שאם אתה רק
רוצה לבדוק את חבורה של פקודות נתונים שונות,
יש חבורה של מערכי נתונים שונים כי הם כבר מראש לתוך ר '
אז אחד מהם הוא בשם בסיס נתוני קשתית.
זהו אחד הידוע ביותר אלה בלמידת מכונה.
בדרך כלל אתה פשוט לעשות איזה מקרי מבחן כדי לראות אם הקוד שלך פועל.
אז בואו רק לבדוק מה היא קשתית.
>> אז הדבר הזה הולך להיות מסגרת נתונים.
וזה סוג של ארוך, כי אני רק הדפסתי איריס.
זה מדפיס את כל הדבר.
אז יש לו את כל שמות השונים אלה.
אז איריס היא אוסף פרחים שונים.
במקרה זה, את אומר ל אתה המינים שלו,
כל רוחב שונה אלה ו אורכים של עלה הגביע ועלה הכותרת.
>> ואז בדרך כלל, אם ברצונך להדפיס איריס,
לדוגמא, אתה לא רוצה לעשות את זה לעשות את כל זה בגלל שיכול להשתלט על
הקונסולה כולו שלך.
אז דבר אחד שבאמת נחמד הוא פונקצית הראש.
אז אם אתה פשוט עושה את הראש איריס, זה ייתן לך
חמש השורות הראשונות, או שש אני מניח.
ולאחר מכן גם, אתה רק יכול לציין כאן.
אז 20-- זה ייתן לי שלך 20 השורות הראשונות.
ואני דווקא היה סוג של מופתע שזה
נתנו לי שש אז תן לי ללכת קדימה וסמן את iris-- או הראש, מצטער.
וכאן זה ייתן לי אתה התיעוד
ממה שראש הערך עושה.
אז זה מחזיר את ראשון או אחרון של אובייקט.
ואז אני הולך ל מסתכל על ברירות המחדל.
ואז זה אומר ברירת המחדל x ראש השיטה וn שווה 6L.
אז זה מחזיר את ששת היסודות הראשונים.
ובאופן דומה, אם שמתם לב לכאן, אני לא צריך לציין n שווה 6.
כברירת מחדל הוא משתמש בשש, אני מניח.
ולאחר מכן, אם אני רוצה לציין מסוים ערך, אז אני יכול להציג את זה גם כן.
>> אז זה חלק מפקודות פשוטות ו הנה עוד אחד שהוא פשוט- גם,
אני can-- זה הוא למעשה יותר מורכב מעט,
אבל זה רק ייקח הכיתה כל עמודה של בסיס נתוני הקשתית.
אז זה ייראה לכם מה כל אחד מאלה העמודות במונחים של סוגיהם.
אז אורך עלה גביע הוא מספרי, רוחב עלה גביע הוא מספרי.
כל הערכים הללו הם רק מספריים בגלל שאתה יכול להגיד לי מנתונים אלה
מבנה אלה כל הולך מספרי.
>> וטור המינים הולך להיות גורם.
אז בדרך כלל, היית חושב ש זה כמו מחרוזת תווים.
אבל אם אתה רק עושה irisSpecies, ואז אני הולך לעשות את הראש 5,
וזה הולך להדפיס חמישה הערכים הראשונים.
>> ואז שם לב רמות זה.
אז זה saying-- זו דרכו של R שיש משתני קטגורי.
אז במקום רק יש מחרוזות תווים,
יש לו ולציין רמות שהדברים האלה הם.
>> אז בואו נגיד שirisSpecies 1.
אז מה אתה רוצה לעשות כאן הוא אני subsetting לעמודה מין זה.
אז זה לוקח טור מינים ולאחר מכן
מדדיו כדי לקבל את האלמנט הראשון.
אז זה אמור לתת לך setosa.
וזה גם נותן לך רמות כאן.
>> אז אתה גם יכול להשוות זה לsetosa האופי
וזה לא הולך להיות אמיתי, כי אחד
הוא מסוג שונה מאחר.
או אני מניח שזה נכון, כי R הוא יותר אינטליגנטי מזה.
וזה נראה בשלב זה ולאחר מכן אומר, אולי זה מה שאתה רוצה.
אז זה הולך לומר את האופי setosa מחרוזת זהה לזה.
ולאחר מכן באופן דומה, אתה יכול גם פשוט לתפוס אלה כמו כן הלאה.
>> אז זה פשוט סוג מסוים של פקודות מהירות של בסיס הנתונים.
אז הנה כמה חקר נתונים.
אז זה קצת יותר מעורב עם ניתוח נתונים.
וזה נלקח מכמה טירונות בR בברקלי.
>> אז ספרייה זרה.
אז אני הולך לטעון ב ספרייה שנקראת זר.
אז זה הולך לתת לי read.dta כך מניח שיש לי במערך זה.
זה מאוחסן בזרם עובד בספרייה של הקונסולה שלי.
אז בואו רק לראות מה ספריית העבודה היא.
>> אז הנה ספריית העבודה שלי.
ולקרוא את נתוני נקודה, זה דבר, הוא אומר בקובץ זה
ממוקם בתיקיית נתונים של ספריית עבודה הנוכחית.
וread.dta זה לא פקודת ברירת המחדל.
אני מניח שאני טעון בזה כבר.
IEI להניח אני טעון בזה כבר.
>> אבל כל כך read.dta לא הולך להיות פקודת ברירת המחדל.
וזו הסיבה שאתה הולך יש לי כדי לטעון בספרייה זו package--
חבילה זו נקראת זרה.
ואם אין לך החבילה, אני חושב ש
חוץ הוא אחד מאלה מובנים.
אחרת, אתה גם יכול לעשות install.packages
וזה יהיה להתקין את החבילה.
וזה ייתן לך ר 'אה, לא.
ואז אני פשוט הולך להפסיק זה בגלל שיש לי כבר את זה.
>> אבל מה שבאמת נחמד על R הוא שניהול החבילות
המערכת היא מאוד אלגנטית.
כי זה יהיה לאחסן הכל ממש יפה לך.
אז במקרה הזה, זה הולך לאחסון זה ב, אני מאמין, ספרייה זו כאן.
>> אז כל פעם שאתה רוצה להתקין חבילות חדשות,
זה פשוט פשוט כמו עושה install.packages
וR ינהל את כל החבילות בשבילך.
אז אתה לא צריך לעשות משהו ב Python, שבו יש לך חבילה חיצונית
המנהלים כמו נייר אנקונדה שבו אתה נמצא
doing-- התקנה חבילות מחוץ לפייתון
ואז אתה מנסה להפעיל אותם בעצמך.
אז זה באמת דרך נחמדה.
>> וinstall.packages דורש אינטרנט.
זה לוקח אותו משרת והמאגר ש
אוסף את כל חבילות נקראת קראן.
וניתן לציין איזה סוג של מראה אתה רוצה להוריד את החבילות מ.
>> אז הנה אני לוקח את בסיס הנתונים הזה.
אני קוראת את זה בשימוש בפונקציה זו.
אז תן לי ללכת קדימה ולעשות את זה.
>> אז בואו נניח ש יש לך מערך זה
ויש לך לחלוטין אין לי מושג מה זה.
וזה בעצם עולה לעתים קרובות למדי בתעשייה
שבו אתה רק צריך אלה טונות של דברים מבולגנים
והם ללא תווית להפליא.
אז הנה יש לי את זה ובסיס נתונים אני לא יודע
מה זה כל כך אני רק מראה כדי לבדוק את זה.
>> אז אני הולך ראשון לעשות את הראש.
אז אני בודק את שש הראשונים טורים של מה במערך זה.
אז זה מצב, pres04, ולאחר מכן כל סוג אחר של אלה עמודות.
ומה שמעניין כאן, אני מניח, הוא שאתה
היה מניח שזה נראה כמו איזה בחירות.
ואני מניח שרק מ מסתכל על הקובץ
שם זה סוג של אוסף נתונים על מועמדים או בוחרים
מי הצביע לנשיאים ספציפיים או מועמדי נשיא
לבחירות 2004.
>> אז הנה הוא ערכי 1, 2 כך בדרך זו של אחסון
מועמדי הנשיא שמותיהם.
במקרה זה, זה נראה כמו הם ערכים רק מספר שלם.
אז שנת 2004, זה היה בוש לעומת קרי אני מאמין.
ועכשיו, נניח שאתה פשוט לא יודע אם 1, מקבילה בוש או 2
מתאים לקרי או ו כך הלאה וכך הלאה, נכון?
>> וזה, רק לי, בעיה נפוצה למדי.
אז מה אפשר לעשות במקרה זה?
אז בואו לבדוק את כל אלה דברים אחרים.
>> מדינה, אני מניח שזה מגיע ממדינות שונות.
partyid, הכנסה.
בואו נסתכל על partyid.
אז אולי דבר יחיד שאתה יכול לעשות הוא מסתכל על כל אחת מהתצפיות
שיש לי partyid של רפובליקאים או דמוקרט או משהו.
אז בואו רק להסתכל על מה partyid הוא.
>> אז אני הולך לקחת dat ולאחר מכן אני הולך
לעשות סימן דולר זה מפעיל שעשיתי בעבר
וזה הולך משנה לטור זה.
ואז אני הולך לעמוד בראש זה ב 20, רק כדי לראות איך זה נראה.
>> אז זה פשוט חבורה של NAS.
אז במילים אחרות, יש לך נתונים חסרים על החבר'ה האלה.
אבל אתה גם שם לב זה dat partyid הוא גורם
אז זה נותן לך קטגוריות שונות.
אז במילים אחרות, partyid יכול לקחת דמוקרט, רפובליקני, עצמאי,
או משהו אחר.
>> אז בואו נלך קדימה ובואו לראות אילו של is-- אלה הו, בסדר.
אז אני הולך לקבוצת משנה לpartyid ולאחר מכן
מסתכל אילו הם דמוקרט, למשל.
זה הולך לתת לך בוליאנית, בוליאנית של TRUEs וFALSEs ענק.
>> ועכשיו, בואו נגיד שאני רוצה לקבוצת משנה לבחורים האלה.
אז זה הולך לקחת dat שלי ו משנה ללפי תצפיות
יש שווים partyid שווה דמוקרט.
וזה די ארוך, כי יש כל כך הרבה מהם.
אז עכשיו, אני הולך לעמוד בראש זה ב -20.
>> וכמו שאתה שם לב, שווה שווה מעניין שבאתה
already-- אתה גם כולל NAS.
אז במקרה הזה, אתה עדיין לא יכול לקבל כל מידע כי עכשיו יש לך NAS
ואתה רק רוצה לראות מי מ תצפית מתאימות לדמוקרט
ולא אלה חסרים ערכים עצמם.
אז איך היית להיפטר מNAS אלה?
>> אז הנה רק אני משתמש במפתח עליי סמן ואז אומר מסתובב.
ואז כאן אני פשוט הולך לומר is.na datpartyid.
אז וזה וייקח שני וקטורים בוליאנית שונים
ואומר שזה הולך להיות אמת ושקר לדוגמא.
אז זה הולך לעשות רכיב חכם זה.
אז הנה אני אומר לקחת מסגרת הנתונים, משנה
לאלה שמתאימים לדמוקרט, ולהסיר כל אחד מהם, כי הם לא NA.
>> אז will-- זה צריך לתת לך משהו.
בואו לראות is.na.
בואו ננסה datpartyid is.na.
וזה אמור לתת לי you-- sorry-- רק וקטור בוליאנית.
ואז, בגלל שזה כל כך הרבה זמן, אני הולך לקבוצת משנה עד 20.
OK.
אז זה אמור לעבוד.
>> וזה אחד יהיה גם TRUEs.
אה, אז הטעות שלי כאן היא שאני I'm-- להשתמש C ++ ו- R לסירוגין כך אני עושה
את הטעות הזאת כל הזמן.
והמפעיל הוא למעשה אחד שאתה רוצה.
אתה לא רוצה להשתמש בשתי סימן חיבור, רק אחד.
OK.
>> אז בואו נראה.
אז אנחנו subsetted ל partyid שבו הם דמוקרט
והם לא חסרים ערכים.
ועכשיו בואו נסתכל על אילו הם הצביעו בעד.
אז זה נראה כמו רוב מהם הצביע בעד 1.
אז אני הולך קדימה ולומר שהוא קרי.
>> ובאופן דומה, אתה יכול גם ללכת רפובליקני
ואנו מקווים, זה אמור לתת לך 2.
זה פשוט חבורה של עמודות שונות.
ואכן, זה 2.
אז partyid כל הרפובליקני, רובם מצביעים עבור 2.
>> אז זה נראה כאילו, רק על ידי התבוננות בזה,
הרפובליקני הולך להיות very-- או partyid
הולך להיות מאוד גורם חשוב בקביעה
שמועמד שהם הולך להצביע.
וזה כמובן נכון באופן כללי.
וזו תואמת שלך אינטואיציה, כמובן.
כך זה נראה כאילו אני אוזל זמן כל כך
תן לי רק צריך ללכת קדימה ולהראות כמה תמונות מהירות.
אז הנה משהו שמעט יותר מסובך עם הדמיה.
אז במקרה הזה, זה מאוד ניתוח פשוט של רק בודק מה
נשיא '04 הוא.
>> אז במקרה הזה, נניח שאתה רציתי לענות על שאלה זו.
אז נניח שאנחנו רוצים לדעת את ההצבעה התנהגות בבחירות 2,004 הנשיא
ואיך זה משתנה על פי גזע.
אז לא רק שאתה רוצה לראות את ההצבעה ההתנהגות,
אבל אתה רוצה קבוצת משנה של כל אחד גזע ומין לסכם ש.
ואתה רק יכול לומר לי על ידי סימון מורכב זו
שזה סוג של מקבל מעורפל.
>> אז אחת מR המתקדם יותר חבילות שגם סוג של אחרונים
נקרא dplyr.
אז זה זה ממש כאן.
וggplot2 ggg-- הוא רק נחמד דרך לעשות חזותיים טוב יותר
יותר מזה המובנה.
>> אז אני הולך לטעינה שתי ספריות אלה.
ולאחר מכן, אני מתכוון ללכת קדימה ולהריץ את הפקודה.
אתה פשוט יכול להתייחס לזה כמו קופסא שחורה.
>> מה שקורה הוא שצינור זה המפעיל עובר בטענה זו
לכאן.
אז אני אומר קבוצה על ידי dat גזע ולאחר מכן נשיא 04.
ולאחר מכן, כל פקודות אחרות אלה מסננים ולאחר מכן סיכום
שבו אני עושה ספירה ו אז אני זומם אותו כאן.
אישור מגניב.
אז בואו נלך קדימה ו לראות מה זה נראה כמו.
>> אז מה שקורה פה זה אני ש רק זממתי כל אחד מהגזעים ולאחר מכן
אילו הם הצביעו בעד.
ושני אלה שונים ערכים מתאים ל- 2 ו -1.
אם אתה רוצה להיות יותר אלגנטי, אתה יכול גם
רק לציין כי 2 הוא Kerry-- או 2 הוא בוש, ולאחר מכן 1 הוא קרי.
ואתה גם יכול להיות כי באגדה שלך.
>> ואתה גם יכול לפצל גרפים בר אלה.
כי דבר אחד הוא כי, אם תשימו לב,
זה לא קל מאוד לזהות איזו משני ערכים אלה הם גדולים יותר.
אז דבר אחד שהיית רוצה לעשות הוא לקחת את אזור כחול זה
ורק להעביר אותו לכאן כדי ש יכול להשוות בין שתי תופעות אלה על ידי צד.
ואני מניח שזה משהו ש אין לי זמן לעשות עכשיו,
אבל זה גם מאוד קל לעשות.
אתה פשוט יכול להסתכל ל דפי הגבר של ggplot.
אז אתה יכול פשוט ggplot כמו ושלקרוא לדף האיש הזה.
>> אז תן לי רק במהירות להראות לך כמה דברים מגניבים.
בואו נלך קדימה וללכת to-- רק יישום של למידת מכונה.
אז בואו נגיד שיש לנו שלושה אלה חבילות אז אני הולך לטעון אלה ב.
אז זה פשוט מדפיס את חלק מידע אחרי שנטענתי בעניין.
אז אני אומר read.csv זה, מערך זה, ועכשיו
אני הולך קדימה, אסתכל ו לראות מה יש בפנים במערך זה.
>> אז 20 התצפיות הראשונות.
אז יש לי רק X1, X2, וי 'אז זה נראה כמו חבורה של ערכים אלה
הם נעים בין אולי 20 עד 80 או משהו כזה.
ולאחר מכן באופן דומה לX2 ולאחר מכן נראה Y זה להיות תוויות 0 ו -1.
>> כדי לאמת את זה, אני יכול פשוט לעשות את X1 נתוני סיכום.
ולאחר מכן באופן דומה ל כל אלה עמודות אחרות.
אז סיכום היא דרך מהירה של רק מראה לך ערכים מהירים.
אה, סליחה.
אחד זה צריך להיות י '
>> אז במקרה הזה, נותן לי quantiles, חציונים, maxes גם כן.
במקרה זה, dataY, אתה יכול לראות שזה פשוט הולך להיות 0 ו -1.
גם הממוצע אומר 0.6, רק אומר שזה
נראה כאילו יש לי יותר מ 1s 0s.
>> אז תן לי ללכת קדימה ותכנית לך מה זה נראה.
אז אני פשוט הולך לחלקה זו.
בואו לראות איך לנקות את זה.
אה OK.
OK.
>> אז זה מה שזה נראה.
אז זה נראה כמו צהוב אני צוינו כ0, ולאחר מכן אדומים אני צוין כ1s.
אז הנה זה נראה כמו נקודות תווית ו
נראה כאילו אתה רק רוצה קצת סוג של אשכולות על זה.
>> ותן לי רק קדימה ותכנית אתה חלק מפונקציות המובנות באלה.
אז הנה הוא lm.
אז זה הוא רק מנסה כדי שיתאים לקו זה.
אז מה היא הדרך הטובה ביותר שאני יכול להתאים קו כזה
שזה יהיה הטוב ביותר להפריד סוג זה של קיבוץ באשכולות.
ובאופן אידיאלי, אתה יכול פשוט לראות כי אני פשוט להפעיל את כל הפקודות האלה
ולאחר מכן, אני הולך קדימה ולהוסיף את השורה.
>> אז זה נראה כמו הניחוש הטוב ביותר.
זה לוקח את הטוב ביותר שממזער השגיאה בניסיון להתאים את הקו הזה.
ברור, זה נראה סוג של טוב, אבל זה לא הכי טוב.
ומודלים ליניאריים, ב כללי, הולכים להיות
באמת נהדר לתאוריה ורק סוג של יסודות בניין של מכונה
למידה.
אבל בפועל, אתה הולך רוצה לעשות משהו יותר כללי.
>> אז אתה יכול פשוט לנסות פועל משהו שנקרא רשת עצבית.
דברים אלה הם יותר ויותר נפוץ.
והם פשוט עובדים בצורה פנטסטית למערכי נתונים גדולים.
אז במקרה הזה, אנחנו have-- רק בואו see-- יש לנו nrow.
אז nrow הוא רק אומר מספר השורות.
אז במקרה הזה, אני יש לי 100 תצפיות.
>> אז תן לי ללכת קדימה ו להפוך את רשת עצבית.
אז זה ממש נחמד כי אני יכול רק לומר nnet
ואז אני רגרסיה י ' אז Y הוא טור ש.
ולאחר מכן נסוג אותו על שני משתנים האחרים.
אז זה קצר יותר סימון לX1 וX2.
>> אז בואו נלך קדימה ולהפעיל את זה.
אה, סליחה.
אני צריך להפעיל את כל הדבר הזה.
וזו רק הדפסת סימון לאיזו מהירות או לא במהירות זה
התכנס.
כך זה נראה כאילו זה לא להתכנס.
אז תן לי ללכת קדימה והדפסה מה זה נראה כמו.
>> ראה הנה התמונה והנה היא קווי המתאר מראה כמה טוב זה מתאים.
וזה פשוט- אתה יכול לראות זה שזה מאוד, מאוד נחמד.
זה אפילו יכול להיות overfitting, אבל אתה יכול גם
דין וחשבון על זה עם אחרים טכניקות כמו אימות צולבת.
ואלה גם בנויים לתוך ר '
>> ותן לי רק להראות לך לתמוך במכונת וקטור.
זהו עוד ממש נפוץ טכניקה בלמידת מכונה.
זה מאוד דומה למודלים ליניאריים, אבל הוא משתמש במה שנקרא שיטת ליבה.
ובואו נראה כמה טוב שעושה.
אז זה אחד הוא דומה מאוד לאופן שבי גם רשת עצבית מבצעת,
אבל זה הרבה יותר חלק.
וזה מבוסס על הנחה של what-- איך עבודת SVMs.
>> אז זה פשוט מאוד סקירה מהירה של כמה
של הפונקציות המובנות שאתה יכול לעשות וגם חלק מחקר נתונים.
אז תן לי רק קדימה ונחזור לשקופיות.
>> אז ברור, זה הוא לא מאוד מקיף.
וזה באמת רק טיזר מראה לך את מה שאתה באמת יכול לעשות בר '
אז אם אתה הייתי בדיוק כמו כדי ללמוד עוד, כאן
חבורה של משאבים שונים.
>> אז אם אתה אוהב ספרי לימוד או שאתה פשוט אוהב לקרוא דברים באינטרנט,
אז זה פנטסטי אחד על ידי האדלי Wickham,
כל אלה שגם יצרו חבילות ממש מגניבים.
אם אתה אוהב את קטעי וידאו, ולאחר מכן יש ברקלי טירונות מדהימה
זה several-- זה סוג של ארוך.
והוא ילמד אותך כמעט כל מה שאתה רוצה לדעת על ר '
>> ובאופן דומה, יש Codeacademy וכל סוג אחר אלה
אתרים של אינטראקטיביים.
הם גם מקבלים common-- יותר ויותר נפוץ.
אז זה מאוד דומה לCodeacademy.
ולבסוף, אם אתה רק רוצה קהילה ולעזור,
אלה הם חבורה של דברים שאתה יכול ללכת ל.
כמובן, אנחנו עדיין להשתמש ברשימות דיוור, רק
כמו כמעט בכל אחר קהילת שפת תכנות.
ו#rstats, זה הוא הקהילה שלנו בטוויטר.
זה למעשה די נפוץ.
ולאחר מכן משתמש!
האם רק הכנס שלנו.
>> ואז, כמובן, שאתה יכול להשתמש בכל אלה הדברים Q & A אחרים,
כמו הצפת מחסנית, Google, ולאחר מכן GitHub.
כיוון שרוב החבילות אלה והרבה הקהילה
יהיה מרוכז סביב פיתוח קוד כי זה קוד פתוח.
וזה פשוט ממש נחמד על GitHub.
ולבסוף, אתה יכול לפנות אליי אם רק יש לך שאלות מהירות.
אז אתה יכול למצוא אותי בטוויטר כאן, אתר האינטרנט שלי, ורק הדוא"ל שלי.
אז אני מקווה, שהיה something-- רק טיזר קצר
ממה שR הוא ממש מסוגל לעשות.
ואני מקווה, שאתה פשוט לבדוק את שלושת הקישורים הללו
ותראה מה אתה יכול לעשות יותר.
ואני מניח שזה רק על זה.
תודה.
>> [מחיאות כפות]