1
00:00:00,000 --> 00:00:00,750

2
00:00:00,750 --> 00:00:09,800
>> [השמעת מוסיקה]

3
00:00:09,800 --> 00:00:13,014

4
00:00:13,014 --> 00:00:13,680
דסטין TRAN: היי.

5
00:00:13,680 --> 00:00:14,980
קוראים לי דסטין.

6
00:00:14,980 --> 00:00:18,419
אז אני יהיה הצגה
ניתוח נתונים בר '

7
00:00:18,419 --> 00:00:19,710
רק קצת על עצמי.

8
00:00:19,710 --> 00:00:24,320
אני כרגע סטודנט לתואר שני ב
מדעי ההנדסה יישומית.

9
00:00:24,320 --> 00:00:28,330
אני לומד צומת
למידת מכונה וסטטיסטיקה

10
00:00:28,330 --> 00:00:31,375
כך ניתוח נתונים במחקר הוא
באמת בסיסי למה ש

11
00:00:31,375 --> 00:00:33,790
אני עושה על בסיס יומי.

12
00:00:33,790 --> 00:00:35,710
>> וR הוא במיוחד
טוב לניתוח נתונים

13
00:00:35,710 --> 00:00:39,310
כי זה טוב מאוד עבור אב טיפוס.

14
00:00:39,310 --> 00:00:43,590
ובדרך כלל, כשאתה עושה סוג כלשהו
ניתוח נתונים, הרבה בעיות

15
00:00:43,590 --> 00:00:44,920
הולכים קוגניטיבית.

16
00:00:44,920 --> 00:00:48,700
ואז אתה פשוט רוצה שתהיה לי
כמה שפה ממש טובה ש

17
00:00:48,700 --> 00:00:53,770
רק טוב לעושה
פונקציות מובנות, בניגוד

18
00:00:53,770 --> 00:00:57,430
לצורך להתמודד עם דברים ברמה נמוכים.

19
00:00:57,430 --> 00:01:01,040
אז בהתחלה, אני פשוט הולך
כדי להציג את מה שהוא R, למה ש

20
00:01:01,040 --> 00:01:04,540
אתה רוצה להשתמש בו, ו
אז ללכת על לכמה הדגמה,

21
00:01:04,540 --> 00:01:07,060
ופשוט ללכת משם.

22
00:01:07,060 --> 00:01:08,150
>> אז מה הוא R?

23
00:01:08,150 --> 00:01:11,180
R הוא רק שפה שפותחה
עבור מחשוב סטטיסטי

24
00:01:11,180 --> 00:01:12,450
והדמיה.

25
00:01:12,450 --> 00:01:16,000
אז מה שזה אומר זה ש
זה שפה מאוד מעולה

26
00:01:16,000 --> 00:01:22,400
לכל סוג של דבר שעוסק ב
חוסר ודאות או נתונים להדמיה.

27
00:01:22,400 --> 00:01:24,850
אז יש לך את כל אלה
הסתברויות.

28
00:01:24,850 --> 00:01:27,140
יש הולכים להיות
פונקציות מובנות.

29
00:01:27,140 --> 00:01:31,650
תהיה לך גם מצוין
זומם חבילות.

30
00:01:31,650 --> 00:01:34,110
>> Python הוא עוד מתחרה
שפה לנתונים.

31
00:01:34,110 --> 00:01:40,020
ועוד דבר אחד שאני מוצא את R ש
הוא הרבה יותר טוב בהיא הדמיה.

32
00:01:40,020 --> 00:01:45,200
אז מה שתראה בהדגמה כ
גם היא רק שפה מאוד אינטואיטיבי

33
00:01:45,200 --> 00:01:48,050
שפשוט עובד טוב מאוד.

34
00:01:48,050 --> 00:01:53,140
זה גם בחינם וקוד פתוח, כ
הוא כל שפה טובה אחרת אני מניח.

35
00:01:53,140 --> 00:01:55,440
>> וכאן, חבורה של רק
מילות מפתח שזרקו אותך.

36
00:01:55,440 --> 00:02:00,450
זה דינמי, כלומר אם יש לך
סוג מסוים שהוקצה לאובייקט

37
00:02:00,450 --> 00:02:02,025
ממה שזה פשוט לשנות את זה במהירות ההבזק.

38
00:02:02,025 --> 00:02:05,670
זה עצלן אז זה חכם על
איך היא עושה את החישובים.

39
00:02:05,670 --> 00:02:12,250
פונקציונלי משמעות זה באמת יכול לפעול
מבוסס על הנחה של פונקציות כך anything--

40
00:02:12,250 --> 00:02:16,910
כל סוג של מניפולציה שאתה
עושה, זה יהיה מבוסס על הנחה פונקציות.

41
00:02:16,910 --> 00:02:20,162
>> מפעילים אז בינארי, לדוגמא,
הן פונקציות פשוט מיסודו.

42
00:02:20,162 --> 00:02:21,870
וכל מה ש
אתה הולך לעשות הוא

43
00:02:21,870 --> 00:02:24,690
הולך להיות לברוח פונקציות עצמו.

44
00:02:24,690 --> 00:02:27,140
ולאחר מכן מונחה עצמים, כמו גם.

45
00:02:27,140 --> 00:02:30,930
>> אז הנה עלילת XKCD.

46
00:02:30,930 --> 00:02:34,350
לא רק בגלל שאני מרגיש כמו
XKCD הוא יסוד לכל סוג

47
00:02:34,350 --> 00:02:37,770
הצגה, אלא משום ש
אני מרגיש כאילו זה באמת

48
00:02:37,770 --> 00:02:42,160
פטישי הנקודה שהרבה
זמן שבו אתה עושה איזה נתונים

49
00:02:42,160 --> 00:02:46,570
ניתוח, הבעיה היא לא
כל כך הרבה כמה מהר הוא פועל,

50
00:02:46,570 --> 00:02:49,850
אבל כמה זמן זה הולך
לקחת לך לתכנת את המשימה.

51
00:02:49,850 --> 00:02:54,112
אז הנה הוא רק ניתוח אם
אסטרטגיה או b הוא יעיל יותר.

52
00:02:54,112 --> 00:02:55,820
זה הולך להיות
משהו שאתה

53
00:02:55,820 --> 00:02:58,290
הולך להתמודד עם הרבה ב
שפות ברמה נמוכה סוג של

54
00:02:58,290 --> 00:03:03,440
עם תקלות SEG שבו אתה מתעסק,
הקצאת זיכרון, אתחולים,

55
00:03:03,440 --> 00:03:05,270
אפילו מה שהופך את הפונקציות המובנות.

56
00:03:05,270 --> 00:03:09,920
והדבר הזה הוא כל מטופלים
מאוד, מאוד באלגנטיות בר '

57
00:03:09,920 --> 00:03:12,839
>> אז רק כדי לתקוע את זה
נקודה, צוואר הבקבוק הגדול ביותר

58
00:03:12,839 --> 00:03:13,880
הולך להיות קוגניטיבית.

59
00:03:13,880 --> 00:03:17,341
אז ניתוח נתונים הוא בעיה קשה מאוד.

60
00:03:17,341 --> 00:03:19,340
בין אם אתה עושה
למידת מכונה או שאתה

61
00:03:19,340 --> 00:03:22,550
עושה בדיוק איזה
חקר נתונים בסיסי,

62
00:03:22,550 --> 00:03:25,290
אתה לא רוצה שתהיה לי
לקחת מסמך

63
00:03:25,290 --> 00:03:27,440
ואז לקמפל
משהו בכל פעם ש

64
00:03:27,440 --> 00:03:31,010
רוצה לראות מה טור נראה כמו,
מה מיוחד ערכים במטריצה

65
00:03:31,010 --> 00:03:32,195
נראה.

66
00:03:32,195 --> 00:03:34,320
אז אתה פשוט רוצה שתהיה לי
כמה ממשק ממש נחמד

67
00:03:34,320 --> 00:03:37,740
אתה יכול להריץ פונקציה פשוטה
כי מדדים לכל מה ש

68
00:03:37,740 --> 00:03:41,870
אתה רוצה ופשוט להפעיל אותו משם.

69
00:03:41,870 --> 00:03:44,190
ואתה צריך תחום
שפות ספציפיות לזה.

70
00:03:44,190 --> 00:03:51,750
וR באמת יעזור לך להגדיר את
בעיה ולפתור אותה בצורה זו.

71
00:03:51,750 --> 00:03:58,690
>> אז הנה תכנות מראה עלילה
פופולריות של R כזה נעלם עם זמן.

72
00:03:58,690 --> 00:04:04,060
אז כפי שאתם יכולים לראות, כמו 2013 או
אז זה פשוט פוצץ מאוד.

73
00:04:04,060 --> 00:04:09,570
וזה היה רק ​​בגלל ש
מגמה ענק בתעשיית הטכנולוגיה

74
00:04:09,570 --> 00:04:10,590
נתונים גדולים עליו.

75
00:04:10,590 --> 00:04:13,010
כמו כן, לא רק הטכנולוגיה
תעשייה, אבל באמת

76
00:04:13,010 --> 00:04:16,490
כל that-- כי תעשייה
הרבה תעשיות

77
00:04:16,490 --> 00:04:20,589
הם סוג של יסוד ל
מנסה לפתור את הבעיות הללו.

78
00:04:20,589 --> 00:04:24,590
ובדרך כלל, אתה יכול לקבל כמה טוב
אפשרות למדוד את הבעיות האלה

79
00:04:24,590 --> 00:04:29,720
או אפילו מגדיר אותם או
פתרונן תוך שימוש בנתונים.

80
00:04:29,720 --> 00:04:35,430
אז אני חושב שעכשיו הוא R ה -11
רוב השפה הפופולרית בTIOBE

81
00:04:35,430 --> 00:04:38,200
וזה כבר גדל מאז.

82
00:04:38,200 --> 00:04:40,740

83
00:04:40,740 --> 00:04:43,080
>> אז הנה עוד קצת
תכונותיו של ר 'יש לו

84
00:04:43,080 --> 00:04:46,900
מספר עצום של חבילות ו
לכל הדברים השונים הללו.

85
00:04:46,900 --> 00:04:52,470
אז כל זמן שיש לך
בעיה מסוימת, רוב

86
00:04:52,470 --> 00:04:55,060
R הזמן יהיה לי
פונקציה זה בשבילך.

87
00:04:55,060 --> 00:04:58,520
אז אם אתה רוצה
לבנות איזה מכונה

88
00:04:58,520 --> 00:05:02,770
אלגוריתם למידה הנקרא
אקראי יער או עצי החלטות,

89
00:05:02,770 --> 00:05:07,530
או אפילו מנסה לקחת הממוצע של
פונקציה או כל הדברים האלה,

90
00:05:07,530 --> 00:05:10,000
R יהיה ש.

91
00:05:10,000 --> 00:05:14,190
>> ואם אתה עושה שאכפת לך
אופטימיזציה, דבר אחד זה נפוץ

92
00:05:14,190 --> 00:05:17,430
הוא שלאחר שתסיים prototyping
איזה שפה ברמה גבוהה,

93
00:05:17,430 --> 00:05:19,810
אתה תזרוק שin--
אתה פשוט יציאה שמעל

94
00:05:19,810 --> 00:05:21,550
לכמה שפה ברמה נמוכה.

95
00:05:21,550 --> 00:05:26,090
מה טוב בR הוא שברגע שאתה
עשה prototyping את זה, אתה יכול לרוץ C ++,

96
00:05:26,090 --> 00:05:29,510
או Fortran, או כל אחד מאלה
אלה ברמה נמוכה יותר באופן ישיר לר '

97
00:05:29,510 --> 00:05:32,320
אז זה באמת
תכונה מגניב על R,

98
00:05:32,320 --> 00:05:35,930
אם אתה באמת אכפת לי
נקודת אופטימיזציה.

99
00:05:35,930 --> 00:05:39,490
>> וזה גם ממש טוב
לפריטים חזותיים אינטרנט.

100
00:05:39,490 --> 00:05:43,530
אז D3.js, למשל, הוא
אני מניח שסמינר אחר

101
00:05:43,530 --> 00:05:45,130
שהצגנו היום.

102
00:05:45,130 --> 00:05:48,510
וזה באמת מדהים עבור
עושה חזותיים אינטראקטיבי.

103
00:05:48,510 --> 00:05:54,460
וD3.js מניח שיש לך
איזה נתונים כדי להתוות

104
00:05:54,460 --> 00:05:58,080
וR הוא דרך של להיות מסוגל לעשות גדולה
ניתוח הנתונים לפני שאתה לייצא אותו

105
00:05:58,080 --> 00:06:04,220
מעל לD3.js או אפילו רק לרוץ
D3.js פקודות לR עצמו,

106
00:06:04,220 --> 00:06:08,240
כמו גם את כל אלה
ספריות אחרות גם כן.

107
00:06:08,240 --> 00:06:13,041
>> אז זה היה רק ​​המבוא ל
מה הוא R ומדוע אתה עלול להשתמש בו.

108
00:06:13,041 --> 00:06:14,790
אז אני מקווה, יש לי
שכנעתי אותך משהו

109
00:06:14,790 --> 00:06:18,460
על רק מנסה לראות איך זה.

110
00:06:18,460 --> 00:06:23,930
אז אני הולך קדימה ולעבור
כמה יסודות על אובייקטי R

111
00:06:23,930 --> 00:06:26,150
ומה שאתה באמת יכול לעשות.

112
00:06:26,150 --> 00:06:29,690
>> אז הנה הוא רק
חבורה של פקודות מתמטיקה.

113
00:06:29,690 --> 00:06:35,000
כך אומר you're-- אתה רוצה לבנות
את עצמך שפה ואתה רק רוצה

114
00:06:35,000 --> 00:06:38,080
יש חבורה של כלים שונים.

115
00:06:38,080 --> 00:06:42,520
כל סוג של פעולה שאתה חושב שאתה
רוצה הולך להיות פחות או יותר בר '

116
00:06:42,520 --> 00:06:44,150
>> אז הנה הוא 2 ועוד 2.

117
00:06:44,150 --> 00:06:46,090
הנה pi 2 פעמים.

118
00:06:46,090 --> 00:06:51,870
יש R חבורה של קבועים מובנים
כי אתה משתמש לעתים קרובות כמו פאי, e.

119
00:06:51,870 --> 00:06:56,230
>> ואז, הנה 7 בתוספת
runif, כך runif של 1.

120
00:06:56,230 --> 00:07:02,450
זוהי פונקציה שזה יוצרת
אחיד אקראית אחד 0-1.

121
00:07:02,450 --> 00:07:04,400
ואז יש 3 לכח של 4.

122
00:07:04,400 --> 00:07:06,430
יש שורשים מרובעים.

123
00:07:06,430 --> 00:07:07,270
>> יש יומן.

124
00:07:07,270 --> 00:07:14,500
אז להיכנס יעשה בסיס
מעריכי בכוחות עצמו.

125
00:07:14,500 --> 00:07:18,337
ולאחר מכן, אם תציין בסיס, לאחר מכן
אתה יכול לעשות מה שאתה רוצה בסיס.

126
00:07:18,337 --> 00:07:19,920
ואז הנה כמה פקודות אחרות.

127
00:07:19,920 --> 00:07:22,180
אז יש לך 23 mod 2.

128
00:07:22,180 --> 00:07:24,910
אז יש לך את השארית.

129
00:07:24,910 --> 00:07:27,110
אז אתה צריך מדעי
סימון גם אם אתה

130
00:07:27,110 --> 00:07:34,060
רוצה לעשות רק יותר ו
דברים מסובכים יותר.

131
00:07:34,060 --> 00:07:37,320
>> אז הנה היא משימה.

132
00:07:37,320 --> 00:07:40,830
משימות אופייניות כל כך ב
R נעשה עם חץ

133
00:07:40,830 --> 00:07:43,440
כך שזה פחות מ ולאחר מכן המקף.

134
00:07:43,440 --> 00:07:47,250
אז הנה רק אני הקצאה
3 לval משתנה.

135
00:07:47,250 --> 00:07:50,160
>> ואז אני מדפיס את val
ואז זה מדפיס את שלוש.

136
00:07:50,160 --> 00:07:53,920
כברירת מחדל במתורגמן R, זה
יהיה להדפיס את הדברים בשבילך

137
00:07:53,920 --> 00:07:57,280
אז אתה לא צריך לציין להדפיס val
כל פעם שאתה רוצה להדפיס משהו.

138
00:07:57,280 --> 00:08:00,200
אתה פשוט יכול לעשות val ו
אז זה יעשה את זה בשבילך.

139
00:08:00,200 --> 00:08:04,380
>> כמו כן, ניתן להשתמש בשווה מבחינה טכנית
כמפעיל משימה.

140
00:08:04,380 --> 00:08:07,190
יש דקויות קלות
בין באמצעות החץ

141
00:08:07,190 --> 00:08:10,730
מפעיל והשווים
מפעיל למשימות.

142
00:08:10,730 --> 00:08:15,470
בעיקר על ידי אמנה, כולם
פשוט להשתמש במפעיל החץ.

143
00:08:15,470 --> 00:08:21,850
>> וכאן, אני הקצאה זו
סימון אלכסוני נקרא מעי גס 1 6.

144
00:08:21,850 --> 00:08:26,010
זה יוצר וקטור 1-6.

145
00:08:26,010 --> 00:08:29,350
וזה ממש נחמד כי אז
אתה פשוט להקצות את הווקטור לval

146
00:08:29,350 --> 00:08:34,270
וזה עובד על ידי עצמו.

147
00:08:34,270 --> 00:08:37,799
>> אז זה כבר הולך מ
single-- נתונים מאוד אינטואיטיבי

148
00:08:37,799 --> 00:08:41,070
מבנה פשוט כפול של
איזה סוג של סוג לוקטור

149
00:08:41,070 --> 00:08:45,670
ושיאסוף את כל
ערכי סקלר בשבילך.

150
00:08:45,670 --> 00:08:50,770
אז אחרי הולכים מסקלר, אתה
יש לי אובייקטי R וזה וקטור.

151
00:08:50,770 --> 00:08:55,610
וקטור הוא כל סוג של
אוסף מאותו הסוג.

152
00:08:55,610 --> 00:08:58,150
אז הנה חבורה של וקטורים.

153
00:08:58,150 --> 00:08:59,800
>> אז זה מספרי.

154
00:08:59,800 --> 00:09:02,440
המספרי הוא דרכו של R לומר כפול.

155
00:09:02,440 --> 00:09:07,390
וכך כברירת מחדל, כל
מספר יהיה כפול.

156
00:09:07,390 --> 00:09:13,150
>> אז אם יש לך ג של 1.1, 3,
שלילי של 5.7, ג הוא פונקציה.

157
00:09:13,150 --> 00:09:16,760
זה משרשר את כל שלוש
מספרים לתוך וקטור.

158
00:09:16,760 --> 00:09:19,619
וזה יהיה be-- כך שאם
אתה שם לב 3 על ידי עצמו,

159
00:09:19,619 --> 00:09:21,910
בדרך כלל היית להניח
שזה כמו מספר שלם,

160
00:09:21,910 --> 00:09:25,050
אבל בגלל שכל הווקטורים
הם אותו הסוג,

161
00:09:25,050 --> 00:09:28,660
זה הוא וקטור של זוגות
או מספרי במקרה זה.

162
00:09:28,660 --> 00:09:34,920
>> rnorm היא פונקציה שיוצרת
variables-- הנורמלי סטנדרטי

163
00:09:34,920 --> 00:09:36,700
או ערכים נורמלים סטנדרטיים.

164
00:09:36,700 --> 00:09:38,360
ואני מפרט שניים מהם.

165
00:09:38,360 --> 00:09:43,840
אז אני עושה rnorm 2, הקצאה של
devs, ואז אני מדפיס את devs.

166
00:09:43,840 --> 00:09:47,350
אז אלה הם רק שתיים
ערכים נורמלים אקראיים.

167
00:09:47,350 --> 00:09:50,060
>> ולאחר מכן INTs אם אתה עושה
אכפת לך מספרים שלמים.

168
00:09:50,060 --> 00:09:54,650
אז זה רק על זיכרון
הקצאה וגודל זיכרון חיסכון.

169
00:09:54,650 --> 00:10:01,460
אז היית צריך להוסיף
המספרים שלך על ידי ההון L.

170
00:10:01,460 --> 00:10:04,170
>> באופן כללי, זה
הסימון ההיסטורי של R

171
00:10:04,170 --> 00:10:06,940
למשהו שנקרא שלם ארוכה.

172
00:10:06,940 --> 00:10:09,880
אז רוב הזמן, אתה
להיות התמודדות עם זוגות.

173
00:10:09,880 --> 00:10:15,180
ואם אי פעם יהיו מאוחר יותר
על למטב את הקוד שלך,

174
00:10:15,180 --> 00:10:18,110
אתה יכול פשוט להוסיף אלה L's
לאחר מכן או במהלכה

175
00:10:18,110 --> 00:10:22,280
אם אתה ממש נבואי על מה
אתה הולך לעשות המשתנים הללו.

176
00:10:22,280 --> 00:10:25,340

177
00:10:25,340 --> 00:10:26,890
>> אז הנה הוא וקטור אופי.

178
00:10:26,890 --> 00:10:31,440
אז, שוב, אני שרשור
שלושה מיתרים הפעם.

179
00:10:31,440 --> 00:10:36,230
שימו לב שמייתרים כפולים ו
מחרוזות יחידים הן אותו הדבר בר '

180
00:10:36,230 --> 00:10:41,000
אז יש לי ארתור ומרווין של וכן
כשאני מדפיס את זה, כולם

181
00:10:41,000 --> 00:10:43,210
הולכים להראות מיתרים כפולים.

182
00:10:43,210 --> 00:10:45,880
ואם גם אתם רוצים לכלול
המחרוזת הכפולה או בודדת

183
00:10:45,880 --> 00:10:50,070
בדמויות שלך, אז אתה יכול
או להחליף המיתרים שלך.

184
00:10:50,070 --> 00:10:53,540
>> אז מרווין של ל
אלמנט שני, זה הוא

185
00:10:53,540 --> 00:10:56,380
הולך show--
רק צריכים מחרוזות כפולות

186
00:10:56,380 --> 00:10:59,050
ואז מחרוזת אחת
כך זה לסירוגין.

187
00:10:59,050 --> 00:11:04,040
אחרת, אם ברצונך להשתמש כפול
מפעיל מחרוזת במחרוזת כפולה

188
00:11:04,040 --> 00:11:07,090
כשאתה מכריז את זה, אז
אתה פשוט להשתמש במפעיל הבריחה.

189
00:11:07,090 --> 00:11:10,600
אז אתה עושה את המחרוזת הכפולה הקו הנטוי.

190
00:11:10,600 --> 00:11:13,330
>> ולבסוף, אנחנו גם
יש וקטורים הגיוניים.

191
00:11:13,330 --> 00:11:15,890
אז logical-- כל כך נכון
וFALSE, והם

192
00:11:15,890 --> 00:11:18,880
הולך להיות כל האותיות גדולות.

193
00:11:18,880 --> 00:11:22,370
ואז, שוב, אני שרשור
שלהם ולאחר מכן הקצאתם לbools.

194
00:11:22,370 --> 00:11:24,590
אז bools הולך להראות
אתה TRUE, FALSE, ואמיתי.

195
00:11:24,590 --> 00:11:28,280

196
00:11:28,280 --> 00:11:31,620
>> אז הנה אינדקס vectorized.

197
00:11:31,620 --> 00:11:34,870
אז בהתחלה, אני
אני לוקח function--

198
00:11:34,870 --> 00:11:39,230
זה נקרא sequence--
רצף 2-12.

199
00:11:39,230 --> 00:11:42,490
ואני לוקח את רצף על ידי 2.

200
00:11:42,490 --> 00:11:46,660
אז זה הולך לעשות
2, 4, 6, 8, 10 ו -12.

201
00:11:46,660 --> 00:11:50,080
ואז, אני אינדקס
כדי לקבל את האלמנט השלישי.

202
00:11:50,080 --> 00:11:55,770
>> אז דבר אחד שכדאי לזכור הוא
שמדדי R על ידי החל מיום 1.

203
00:11:55,770 --> 00:12:00,550
אז Vals 3 הוא הולך לתת לי
אתה המרכיב השלישי.

204
00:12:00,550 --> 00:12:04,580
זה סוג אחר של מאחר
שפות בו הוא מתחיל מאפס.

205
00:12:04,580 --> 00:12:09,780
אז בC או C ++, למשל, אתה
הולך לקבל את האלמנט הרביעי.

206
00:12:09,780 --> 00:12:13,280
>> וכאן הוא Vals 3-5.

207
00:12:13,280 --> 00:12:16,030
אז דבר אחד שהוא
ממש מגניב הוא שאתה

208
00:12:16,030 --> 00:12:20,410
יכול ליצור משתנים זמניים בתוך
ואז פשוט להשתמש בם במהירות ההבזק.

209
00:12:20,410 --> 00:12:21,960
אז הנה הוא 3 עד 5.

210
00:12:21,960 --> 00:12:25,070
אז אני יצירת וקטור
3, 4, ו -5 ולאחר מכן

211
00:12:25,070 --> 00:12:29,700
אני אינדקס כדי לקבל השלישי,
אלמנטים רביעי, וחמישי.

212
00:12:29,700 --> 00:12:32,280
>> אז באופן דומה, אתה יכול
מופשט זה פשוט לעשות

213
00:12:32,280 --> 00:12:35,280
כל סוג של וקטור
זה נותן לך לאינדקס.

214
00:12:35,280 --> 00:12:40,050
אז הנה הוא Vals ולאחר מכן
אלמנטים ראשון, שלישי, והשישי.

215
00:12:40,050 --> 00:12:42,800
ולאחר מכן, אם אתה רוצה
לעשות משלים,

216
00:12:42,800 --> 00:12:45,210
אז אתה פשוט עושה מינוס
שימצא אחר כך ו

217
00:12:45,210 --> 00:12:48,600
לתת לך את כל מה שלא
ראשון, שלישי, או אלמנט שישי.

218
00:12:48,600 --> 00:12:51,590
אז זה יהיה 4, 8, ו -10.

219
00:12:51,590 --> 00:12:54,380
>> ואם אתה רוצה לקבל
אפילו יותר מתקדם,

220
00:12:54,380 --> 00:12:57,610
אתה יכול לשרשר וקטורים בוליאנית.

221
00:12:57,610 --> 00:13:05,210
אז מדד זה הולך לתת לך
וקטור בוליאני זה באורך 6.

222
00:13:05,210 --> 00:13:07,280
אז פסיק אמיתי נציג 3.

223
00:13:07,280 --> 00:13:09,680
זה יחזור שלוש פעמים TRUE.

224
00:13:09,680 --> 00:13:12,900
אז זה ייתן לך
וקטור TRUE, TRUE, TRUE.

225
00:13:12,900 --> 00:13:17,470
>> נציג FALSE 4-- זה הולך לתת לך
וקטור של שקר, שקר, שקר, שקר.

226
00:13:17,470 --> 00:13:21,280
ולאחר מכן ג הולך לשרשר
אלה שני Booleans יחד.

227
00:13:21,280 --> 00:13:24,090
אז אתה הולך לקבל את שלוש
TRUEs ולאחר מכן ארבע FALSEs.

228
00:13:24,090 --> 00:13:28,460
>> כך שכאשר אתה Vals מדד, אתה
הולך לקבל אמיתי TRUE, TRUE,.

229
00:13:28,460 --> 00:13:31,420
אז זה הולך להגיד כן,
אני רוצה שלושת מרכיבים אלה.

230
00:13:31,420 --> 00:13:33,520
ואז שקר, שקר,
שקר שקר הולך,

231
00:13:33,520 --> 00:13:37,140
להגיד לא, אני לא רוצה אותם אלמנטים
כך שזה לא הולך להחזיר אותם.

232
00:13:37,140 --> 00:13:41,490
>> ואני מניח שיש בעצם טעות דפוס כאן
כי זה אומר חוזר אמיתי 3

233
00:13:41,490 --> 00:13:47,990
וחזור 4 FALSE, ומבחינה טכנית, אתה
רק יש לי שישה אלמנטים כל כך לחזור FALSE,

234
00:13:47,990 --> 00:13:50,470
זה צריך להיות חוזר FALSE 3.

235
00:13:50,470 --> 00:13:55,260
אני חושב שR הוא גם חכם מספיק כאלה
כי אם אתה רק לציין 4 כאן, אז

236
00:13:55,260 --> 00:13:56,630
זה אפילו לא שגיאה החוצה.

237
00:13:56,630 --> 00:13:58,480
זה פשוט ייתן לך ערך זה.

238
00:13:58,480 --> 00:14:00,970
אז זה פשוט להתעלם מזה FALSE הרביעי.

239
00:14:00,970 --> 00:14:05,310

240
00:14:05,310 --> 00:14:09,270
>> אז הנה היא משימת vectorized.

241
00:14:09,270 --> 00:14:15,480
אז set.seed-- זה רק מגדיר את
זרע למספרי פסוודו.

242
00:14:15,480 --> 00:14:20,110
אז אני הגדרת את הזרע ל
42, מה שאומרים שאם אני יוצר

243
00:14:20,110 --> 00:14:22,950
שלוש אקראי נורמלי
ערכים, ולאחר מכן אם אתה

244
00:14:22,950 --> 00:14:27,400
לרוץ set.seed בעצמך
מחשב משתמש באותו הערך 42,

245
00:14:27,400 --> 00:14:30,990
אז אתה גם מקבל
אותם שלוש נורמלים אקראיים.

246
00:14:30,990 --> 00:14:33,411
>> אז זה ממש טוב
לשחזור.

247
00:14:33,411 --> 00:14:35,910
בדרך כלל, כשאתה עושה קצת
סוג של ניתוח מדעי,

248
00:14:35,910 --> 00:14:37,230
היית רוצה להגדיר את הזרע.

249
00:14:37,230 --> 00:14:41,270
בדרך זו מדענים אחרים רק יכולים
לשחזר בדיוק את אותו קוד שיש לך

250
00:14:41,270 --> 00:14:44,790
עשה את זה כי יהיה להם מדויק
אותם משתנים אקראיים that-- או אקראי

251
00:14:44,790 --> 00:14:47,270
ערכים שאתה כבר לקח את גם כן.

252
00:14:47,270 --> 00:14:49,870

253
00:14:49,870 --> 00:14:53,910
>> וכך משימת vectorized
כאן הוא מראה Vals 1 עד 2.

254
00:14:53,910 --> 00:14:59,290
אז זה לוקח שני יסודות הראשונים
של Vals ולאחר מכן מקצה להם 0.

255
00:14:59,290 --> 00:15:03,940
ואז, אתה יכול גם פשוט לעשות
דבר דומה עם Booleans.

256
00:15:03,940 --> 00:15:09,340
>> אז Vals אינו שווה ל0-- רצון זה
אתן לך FALSE וקטור, FALSE, TRUE

257
00:15:09,340 --> 00:15:10,350
במקרה זה.

258
00:15:10,350 --> 00:15:13,770
ואז, זה הולך לומר כל
מאותם מדדים שהיו נכונים,

259
00:15:13,770 --> 00:15:15,270
אז זה הולך להקצות שעד 5.

260
00:15:15,270 --> 00:15:18,790
אז זה לוקח את האלמנט השלישי
כאן ולאחר מכן מקצה אותו ל5.

261
00:15:18,790 --> 00:15:22,300
>> וזה ממש נחמד
בהשוואה לשפות ברמה הנמוכה

262
00:15:22,300 --> 00:15:25,560
שבו אתה צריך להשתמש ללולאות
לעשות את כל דברים vectorized זה

263
00:15:25,560 --> 00:15:30,281
כי זה פשוט מאוד אינטואיטיבי
וזה אחד-אניה אחת.

264
00:15:30,281 --> 00:15:32,030
ומה על גדול
סימון vectorized

265
00:15:32,030 --> 00:15:37,020
הוא שבR, אלה הם סוג של
מובנה בכך שהם כמעט באותה מהירות

266
00:15:37,020 --> 00:15:42,490
כעושה בשפה ברמה נמוכה כ
בניגוד לעשיית ללולאה בR

267
00:15:42,490 --> 00:15:46,317
ואז שיש בו כדי לעשות
האינדקס הדינמי עצמו.

268
00:15:46,317 --> 00:15:48,900
וזה יהיה איטי יותר מאשר לעשות
דברים מהסוג הזה vectorized

269
00:15:48,900 --> 00:15:55,950
בו הוא יכול לעשות את זה במקביל, בי
זה עושה את זה בשחלה בעצם.

270
00:15:55,950 --> 00:15:58,650
>> אז הנה הוא vectorized פעולות.

271
00:15:58,650 --> 00:16:04,920
אז אני יצירת ערך 1 עד 3,
הקצאה שלvec1, 3 עד 5, vec2,

272
00:16:04,920 --> 00:16:05,950
מוסיף אותם יחד.

273
00:16:05,950 --> 00:16:11,490
זה מוסיף להם רכיב חכם כל כך
זה 1 ועוד 3, 2 ו- 4, וכן הלאה.

274
00:16:11,490 --> 00:16:13,330
>> vec1 vec2 פעמים.

275
00:16:13,330 --> 00:16:16,110
זה מכפיל את שני
ערכי רכיב חכם.

276
00:16:16,110 --> 00:16:21,830
אז זה 1 פעמים 3, 2 פעמים
4, ולאחר מכן 3 פעמים 5.

277
00:16:21,830 --> 00:16:28,250
>> ולאחר מכן, באופן דומה אתה יכול גם לעשות
comparisons-- השוואות לוגיות.

278
00:16:28,250 --> 00:16:33,640
אז זה שקר שקר אמיתי בזה
מקרה כי 1 אינו גדול מ 3,

279
00:16:33,640 --> 00:16:35,920
2 הוא לא יותר מ- 4.

280
00:16:35,920 --> 00:16:41,160
זה, אני מניח, טעות דפוס אחר, 3
בהחלט לא יותר מ -5.

281
00:16:41,160 --> 00:16:41,660
כן.

282
00:16:41,660 --> 00:16:45,770
ואז אתה יכול פשוט לעשות את כל
פעולות פשוטות הבאות

283
00:16:45,770 --> 00:16:48,350
בגלל הירושה שלהם
מהשיעורים עצמם.

284
00:16:48,350 --> 00:16:51,110

285
00:16:51,110 --> 00:16:52,580
>> אז זה היה רק ​​הווקטור.

286
00:16:52,580 --> 00:16:56,530
וזה סוג של הבסיסי ביותר
אובייקט R כי ניתנו וקטור,

287
00:16:56,530 --> 00:16:59,170
אתה יכול לבנות עצמים מתקדמים יותר.

288
00:16:59,170 --> 00:17:00,560
>> אז הנה מטריצה.

289
00:17:00,560 --> 00:17:05,030
זהו למעשה ההפשטה
ממה שמטריצה ​​היא עצמו.

290
00:17:05,030 --> 00:17:10,099
אז במקרה הזה, זה שלוש שונים
וקטורים, שבו כל אחד הוא טור,

291
00:17:10,099 --> 00:17:12,710
או שאתה יכול לשקול את זה
כמו כל אחד היא שורה.

292
00:17:12,710 --> 00:17:18,250
>> אז אני אחסון מטריצה ​​מ -1 עד
9 ואז אני מפרט 3 שורות.

293
00:17:18,250 --> 00:17:23,364
אז 1-9 ייתן לך וקטור 1,
2, 3, 4, 5, 6, וכל הדרך עד 9.

294
00:17:23,364 --> 00:17:29,250
>> דבר אחד גם לזכור הוא ש
חנויות R ערכים בפורמט טור-גדול.

295
00:17:29,250 --> 00:17:34,160
אז במילים אחרות, כשאתה רואה 1
ל -9, זה הולך לאחסון them--

296
00:17:34,160 --> 00:17:36,370
זה הולך להיות 1, 2,
3 בטור הראשון,

297
00:17:36,370 --> 00:17:38,510
ואז זה יעשה 4, 5,
6 בטור השני,

298
00:17:38,510 --> 00:17:41,440
ולאחר מכן 7, 8, 9 בעמודה השלישית.

299
00:17:41,440 --> 00:17:45,570
>> והנה כמה אחר
פונקציות נפוצות שאתה יכול להשתמש.

300
00:17:45,570 --> 00:17:49,650
אז מחצלת עמומה, זה ייתן לך
הממדים של המטריצה.

301
00:17:49,650 --> 00:17:52,620
זה הולך להחזיר אותך
וקטור של הממד.

302
00:17:52,620 --> 00:17:55,580
אז במקרה הזה, בגלל ש
המטריצה ​​שלנו היא 3 על 3,

303
00:17:55,580 --> 00:18:01,900
זה הולך לתת לך
וקטור מספרי זה 3 3.

304
00:18:01,900 --> 00:18:05,270
>> וכאן הוא רק מראה
כפל מטריצות.

305
00:18:05,270 --> 00:18:11,970
אז בדרך כלל, אם אתה רק עושה
asterisk-- כך מחצלת כוכבית mat--

306
00:18:11,970 --> 00:18:15,380
זה הולך להיות
פעולת רכיב חכם

307
00:18:15,380 --> 00:18:17,300
או מה שנקרא מוצר Hadamard.

308
00:18:17,300 --> 00:18:21,310
אז זה הולך לעשות כל
רכיב חכם אלמנט.

309
00:18:21,310 --> 00:18:23,610
עם זאת, אם אתה רוצה
multiplication-- מטריצה

310
00:18:23,610 --> 00:18:29,380
כך הכפלת הפעמים השורה הראשונה
הטור הראשון של המטריצה ​​השנייה

311
00:18:29,380 --> 00:18:34,510
וכך on-- היית להשתמש
פעולה זו אחוזים.

312
00:18:34,510 --> 00:18:38,110
>> ולא של שטיח הוא פשוט
פעולה ללשרבב.

313
00:18:38,110 --> 00:18:42,590
אז אני אומר לקחת את לשרבב ב
מטריקס, להכפיל את זה על ידי מטריקס

314
00:18:42,590 --> 00:18:43,090
עצמו.

315
00:18:43,090 --> 00:18:45,006
ואז זה הולך
אחזור אליך עוד 3

316
00:18:45,006 --> 00:18:50,700
על ידי 3 מראה מטריצה
המוצר שאתה רוצה.

317
00:18:50,700 --> 00:18:53,750
>> וכך הייתה מטריצה.

318
00:18:53,750 --> 00:18:56,020
הנה מה שנקרא מסגרת נתונים.

319
00:18:56,020 --> 00:19:00,780
מסגרת הנתונים שאתה יכול לחשוב על כ
מטריקס, אבל כל עמודה עצמו

320
00:19:00,780 --> 00:19:02,990
הולך להיות מסוג אחר.

321
00:19:02,990 --> 00:19:07,320
>> אז מה באמת מגניב על נתונים
מסגרות היא שבניתוח הנתונים עצמו,

322
00:19:07,320 --> 00:19:11,260
אתה הולך לקבל את כל זה
נתונים הטרוגניים וכל אלה באמת

323
00:19:11,260 --> 00:19:15,640
דברים מבולגנים שבו כל אחד מהעמודים
עצמם יכולים להיות מסוגים שונים.

324
00:19:15,640 --> 00:19:21,460
אז הנה אני אומר ליצור
מסגרת נתונים, לעשות ints 1-3,

325
00:19:21,460 --> 00:19:24,750
ואז יש גם וקטור אופי.

326
00:19:24,750 --> 00:19:28,470
אז אני יכול מדד דרך
כל אחד מעמודים אלה

327
00:19:28,470 --> 00:19:30,930
ואז אני אקבל את הערכים עצמם.

328
00:19:30,930 --> 00:19:34,370
ואתה גם יכול לעשות כלשהו
פעילות במסגרות נתונים.

329
00:19:34,370 --> 00:19:38,040
ורוב הזמן כשאתה
עושה ניתוח נתונים או סוג כלשהו

330
00:19:38,040 --> 00:19:42,042
עיבוד מקדים, אתה תהיה
עבודה עם מבני נתונים אלה

331
00:19:42,042 --> 00:19:44,250
שבו כל עמודה הולכת
להיות מסוג אחר.

332
00:19:44,250 --> 00:19:47,880

333
00:19:47,880 --> 00:19:52,970
>> לבסוף, ולכן אלה הם למעשה רק
ארבעה חפצים חיוניים ברשימת ר '

334
00:19:52,970 --> 00:19:55,820
פשוט לאסוף כל
חפצים אחרים שאתה רוצה.

335
00:19:55,820 --> 00:20:00,130
אז זה יהיה לאחסן את זה באחד
משתנה שאתה יכול בקלות לגשת.

336
00:20:00,130 --> 00:20:02,370
>> אז הנה, אני לוקח את רשימה.

337
00:20:02,370 --> 00:20:04,460
אני אומר דברים שווים 3.

338
00:20:04,460 --> 00:20:08,060
אז אני הולך להיות מרכיב אחד ב
הרשימה, וזה נקרא דברים,

339
00:20:08,060 --> 00:20:10,570
וזה הולך להיות הערך 3.

340
00:20:10,570 --> 00:20:13,140
>> אני יכול גם ליצור מטריצה.

341
00:20:13,140 --> 00:20:17,970
אז זה 1 עד 4 ושורת הסוף
שווה 2, כך 2 על ידי 2 מטריצה.

342
00:20:17,970 --> 00:20:20,270
גם ברשימה וזה נקרא מזרן.

343
00:20:20,270 --> 00:20:24,690
moreStuff, מחרוזת תווים,
ואפילו רשימה אחרת בעצמו.

344
00:20:24,690 --> 00:20:27,710
>> אז זה רשימה זה 5 ודוב.

345
00:20:27,710 --> 00:20:30,990
אז יש לו את הערך 5 ו
יש דוב מחרוזת תווים

346
00:20:30,990 --> 00:20:32,710
וזה רשימה בתוך רשימה.

347
00:20:32,710 --> 00:20:35,965
אז אתה יכול לקבל אלה
דברים רקורסיבית בי

348
00:20:35,965 --> 00:20:38,230
יש לך another--
הקלד בתוך הסוג.

349
00:20:38,230 --> 00:20:41,420
אז באופן דומה, אתה יכול לקבל מטריצה
בתוך מטריצה ​​אחרת וכן הלאה.

350
00:20:41,420 --> 00:20:44,264
ורשימה היא פשוט דרך טובה
של איסוף וצבירה

351
00:20:44,264 --> 00:20:45,430
כל האובייקטים השונים הללו.

352
00:20:45,430 --> 00:20:50,210

353
00:20:50,210 --> 00:20:57,150
>> ולבסוף, כאן הוא רק לעזור במקרה
זה פשוט נעלם מעל מהר מאוד.

354
00:20:57,150 --> 00:21:01,350
אז כל פעם שאתה מבולבל
על איזה פונקציה,

355
00:21:01,350 --> 00:21:03,510
אתה יכול לעשות בעזרת פונקציה ש.

356
00:21:03,510 --> 00:21:07,120
אז אתה יכול לעשות את מטריצת עזרה
או מטריצת סימן שאלה.

357
00:21:07,120 --> 00:21:11,430
ועזרה וסימן השאלה הן
רק קיצור לאותו הדבר

358
00:21:11,430 --> 00:21:13,040
כך הם כינויים.

359
00:21:13,040 --> 00:21:16,820
>> lm הוא פונקציה ש
פשוט עושה את מודל ליניארי.

360
00:21:16,820 --> 00:21:20,340
אבל אם רק יש לך מושג כמה ש
עבודות, אתה יכול פשוט לעשות את העזרה של lm

361
00:21:20,340 --> 00:21:24,610
ושאתן לך כמה
סוג של תיעוד ש

362
00:21:24,610 --> 00:21:27,960
נראה כמו סוג של
דף אדם ביוניקס, שבו

363
00:21:27,960 --> 00:21:34,210
יש לך תיאור קצר של מה ש
היא עושה, גם מה הן טענותיו,

364
00:21:34,210 --> 00:21:38,850
מה שהוא חוזר, ורק טיפים על איך
כדי להשתמש בו, וכמה דוגמאות, כמו גם.

365
00:21:38,850 --> 00:21:41,680

366
00:21:41,680 --> 00:21:52,890
>> אז תן לי ללכת קדימה ותכנית
כמה הדגמה של השימוש בר 'אישור'.

367
00:21:52,890 --> 00:21:55,470
אז ניגשתי מאוד
במהירות רק נתונים

368
00:21:55,470 --> 00:21:59,440
מבנים וסוג מסוים של
op-- חלק מהפעולות.

369
00:21:59,440 --> 00:22:02,960
הנה כמה פונקציות.

370
00:22:02,960 --> 00:22:06,750
>> אז הנה רק אני הולך
להגדיר פונקציה.

371
00:22:06,750 --> 00:22:09,970
אז גם אני משתמש
אופרטור השמה כאן,

372
00:22:09,970 --> 00:22:12,610
ואז אני אומר
להכריז עליו כפונקציה.

373
00:22:12,610 --> 00:22:14,140
וזה לוקח x הערך.

374
00:22:14,140 --> 00:22:18,210
אז זה כל ערך שאתה רוצה
ואני הולך לחזור x עצמו.

375
00:22:18,210 --> 00:22:20,840
אז זה פונקצית הזהות.

376
00:22:20,840 --> 00:22:23,670
>> ומה זה מגניב על זה
בהשוואה לשפות אחרות

377
00:22:23,670 --> 00:22:26,330
ורמה נמוכה עוד
שפות היא x ש

378
00:22:26,330 --> 00:22:29,350
יכול להיות מכל סוג עצמו
וזה יחזור סוג זה.

379
00:22:29,350 --> 00:22:35,251
אז אתה יכול imagine-- אז בוא
לי רק לרוץ במהירות זו.

380
00:22:35,251 --> 00:22:35,750
מצטער.

381
00:22:35,750 --> 00:22:40,300
>> אז דבר אחד אני צריך גם להזכיר
הוא שעורך זה אני משתמש ב

382
00:22:40,300 --> 00:22:41,380
נקרא rstudio.

383
00:22:41,380 --> 00:22:44,389
זה מה שנקרא IDE.

384
00:22:44,389 --> 00:22:46,180
ועוד דבר אחד זה
ממש נחמד על זה

385
00:22:46,180 --> 00:22:51,500
הוא שהיא משלבת הרבה
דברים שאתה רוצה לעשות בR על ידי עצמו

386
00:22:51,500 --> 00:22:53,180
פשוט מאוד אינטואיטיבי.

387
00:22:53,180 --> 00:22:55,550
>> אז הנה היא קונסולת מתורגמן.

388
00:22:55,550 --> 00:23:02,160
אז באופן דומה, ניתן גם לקבל את זה
גלם קונסולה רק על ידי עשיית ר הון

389
00:23:02,160 --> 00:23:05,630
וזה בדיוק
אותו דבר כמו הקונסולה.

390
00:23:05,630 --> 00:23:12,210
אז רק אני יכול לעשות x id פונקציה, x, x.

391
00:23:12,210 --> 00:23:16,130
וthen-- ולאחר מכן ש
יהיה בסדר עצמו.

392
00:23:16,130 --> 00:23:19,200

393
00:23:19,200 --> 00:23:21,740
>> אז rstudio הוא גדול
כי יש לו הקונסולה.

394
00:23:21,740 --> 00:23:25,360
כמו כן, יש מסמכים
אתה רוצה לרוץ על.

395
00:23:25,360 --> 00:23:28,629
ואז יש לו כמה משתנים
שאתה יכול לראות בסביבות.

396
00:23:28,629 --> 00:23:30,420
ולאחר מכן, אם יש לך
לעשות חלקות, אז אתה

397
00:23:30,420 --> 00:23:33,730
רק יכול לראות את זה כאן, בניגוד ל
ניהול כל חלונות שונים אלה

398
00:23:33,730 --> 00:23:35,940
על ידי עצמם.

399
00:23:35,940 --> 00:23:40,530
>> אני דווקא אישית משתמש Vim, אבל אני
מרגיש כמו rstudio הוא מצוין רק

400
00:23:40,530 --> 00:23:44,640
להשגת רעיון טוב
כיצד להשתמש ר 'בדרך כלל,

401
00:23:44,640 --> 00:23:47,040
כאשר אתה מנסה
ללמוד כמה משימה חדשה,

402
00:23:47,040 --> 00:23:49,590
אתה לא רוצה להתמודד
יותר מדי דברים בבת אחת.

403
00:23:49,590 --> 00:23:53,120
אז R הוא רק rstudio very--
היא דרך טובה מאוד של R הלמידה

404
00:23:53,120 --> 00:23:56,760
מבלי להתמודד עם
כל אלה דברים אחרים.

405
00:23:56,760 --> 00:23:58,600
>> אז הנה אני רץ id שלום.

406
00:23:58,600 --> 00:24:00,090
זה מחזיר שלום.

407
00:24:00,090 --> 00:24:01,740
id 123.

408
00:24:01,740 --> 00:24:04,610
כאן הוא וקטור של מספרים שלמים.

409
00:24:04,610 --> 00:24:08,620
אז באופן דומה, כי אתה יכול
לקחת כל סוג מסוים של ערך,

410
00:24:08,620 --> 00:24:16,060
אתה יכול לעשות חוזר id של
x, כך שהוא מחזיר 1,234 ו -5.

411
00:24:16,060 --> 00:24:22,210
>> ותן לי רק להראות לך ש
זה אכן מספר שלם.

412
00:24:22,210 --> 00:24:28,800
ובאופן דומה, אם אתה עושה בכיתה
x id, זה הולך להיות מספר שלם.

413
00:24:28,800 --> 00:24:34,170
ואז, אתה יכול גם
להשוות בין השניים וזה נכון.

414
00:24:34,170 --> 00:24:38,350
אז אני בודק אם id של x
שווה x השווה והודעה

415
00:24:38,350 --> 00:24:39,760
כי זה נותן לך שתי TRUEs.

416
00:24:39,760 --> 00:24:44,280
אז זה לא אומר הם
שני אובייקטים זהים,

417
00:24:44,280 --> 00:24:46,845
אך כל אחד מהערכים
בתוך הווקטורים זהים.

418
00:24:46,845 --> 00:24:50,000

419
00:24:50,000 --> 00:24:52,090
>> הנה bounded.compare.

420
00:24:52,090 --> 00:24:58,470
אז זה קצת יותר מסובך
שביש לו אם מצב ואחר

421
00:24:58,470 --> 00:25:00,960
ואז זה לוקח שני
טיעונים בכל פעם.

422
00:25:00,960 --> 00:25:02,640
אז x הוא מכל סוג.

423
00:25:02,640 --> 00:25:06,280
ואני אומר את זה
טיעון שני הוא.

424
00:25:06,280 --> 00:25:08,380
זה יכול להיות כל דבר, כמו גם.

425
00:25:08,380 --> 00:25:12,490
אבל כברירת מחדל, זה הולך לקחת
5 אם לא יציינו דבר.

426
00:25:12,490 --> 00:25:16,730
>> אז הנה אני הולך להגיד
אם x גדול מ.

427
00:25:16,730 --> 00:25:19,220
אז אם אני לא לציין, זה
אומר שאם x הוא יותר מ -5,

428
00:25:19,220 --> 00:25:20,470
אז אני הולך להחזיר TRUE.

429
00:25:20,470 --> 00:25:23,230
אחר, אני הולך לחזור FALSE.

430
00:25:23,230 --> 00:25:24,870
אז תן לי ללכת קדימה ולהגדיר את זה.

431
00:25:24,870 --> 00:25:30,600

432
00:25:30,600 --> 00:25:34,550
>> ועכשיו אני הולך ל
לרוץ bounded.compare 3.

433
00:25:34,550 --> 00:25:39,150
אז זה אומר שפחות 3
than-- הוא 3 גדול מ -5.

434
00:25:39,150 --> 00:25:41,830
לא, זה לא כל כך FALSE.

435
00:25:41,830 --> 00:25:46,550
>> וbounded.compare 3 ואני הולך
כדי להשוות אותו באמצעות שווה 2.

436
00:25:46,550 --> 00:25:50,700
אז עכשיו אני אומר כן, עכשיו אני
רוצה להיות משהו אחר.

437
00:25:50,700 --> 00:25:52,750
אז אני הולך להגיד, אתה צריך להיות 2.

438
00:25:52,750 --> 00:25:56,640
>> אני יכול גם לעשות את זה סוג של
סימון או אני אומר שווה 2.

439
00:25:56,640 --> 00:25:58,720
זה קריא יותר
שבכאשר אתה

440
00:25:58,720 --> 00:26:01,450
מסתכל על באמת אלה
פונקציות מסובכות ש

441
00:26:01,450 --> 00:26:08,110
לקחת arguments-- מרובה וזה
יכול להיות עשרות oftentimes-- רק אומרים

442
00:26:08,110 --> 00:26:11,140
שווה 2 הוא קריאים יותר ל
אתה כל כך שמאוחר יותר בעתיד

443
00:26:11,140 --> 00:26:13,020
אתה יודע מה שאתה עושה.

444
00:26:13,020 --> 00:26:17,120
>> אז במקרה הזה, אני
האמרה היא 3 גדולה מ -2.

445
00:26:17,120 --> 00:26:18,270
כן, זה הוא.

446
00:26:18,270 --> 00:26:22,350
ובאופן דומה, אני יכול רק להסיר
זה ואומר, הוא 3 גדול מ 2

447
00:26:22,350 --> 00:26:23,440
שבו שווה 2.

448
00:26:23,440 --> 00:26:26,230
וזה גם נכון.

449
00:26:26,230 --> 00:26:26,730
כן?

450
00:26:26,730 --> 00:26:29,670
>> קהל: האם אתה
ביצוע שורה אחר שורה?

451
00:26:29,670 --> 00:26:30,670
>> דסטין TRAN: כן אני.

452
00:26:30,670 --> 00:26:33,900
אז מה אני עושה כאן הוא
לוקח את הטקסט הזה document--

453
00:26:33,900 --> 00:26:39,825
ומה שיפה הוא שrstudio
אני רק יכול לרוץ short-- מקש קיצור.

454
00:26:39,825 --> 00:26:41,820
אז אני עושה את הבקרה-הזן.

455
00:26:41,820 --> 00:26:44,850
>> ואז, אני לוקח
קו במסמך הטקסט

456
00:26:44,850 --> 00:26:46,710
ולאחר מכן לשים בקונסולה.

457
00:26:46,710 --> 00:26:50,800
אז הנה אני אומר, bounded.compare
ואני עושה את הבקרה-X.

458
00:26:50,800 --> 00:26:52,540
אז אני יכול פשוט לרוץ גם כאן.

459
00:26:52,540 --> 00:26:54,920
ואז שתיקח את
קו ואז לשים אותו כאן.

460
00:26:54,920 --> 00:26:57,900
ולאחר מכן באופן דומה, אני יכול רץ כאן.

461
00:26:57,900 --> 00:27:04,630
ואז זה יהיה רק ​​לשמור על ההגדרה
הקווים לקונסולה כמו ש.

462
00:27:04,630 --> 00:27:10,690
>> ואם אתה גם שם לב המתולתל
פלטה נמצאות שם בדיוק כמו בתחביר C.

463
00:27:10,690 --> 00:27:13,910
x-- אם אם המצב הוא גם
הולך להשתמש בסוגריים ולאחר מכן

464
00:27:13,910 --> 00:27:15,350
אתה יכול להשתמש אחר.

465
00:27:15,350 --> 00:27:17,496
אחד נוסף הוא אם אחר.

466
00:27:17,496 --> 00:27:21,440
אז זה הולך להיות x
שווה שווה, למשל.

467
00:27:21,440 --> 00:27:24,190

468
00:27:24,190 --> 00:27:26,350
ואז אני הולך ל
לחזור כאן משהו.

469
00:27:26,350 --> 00:27:29,490
>> שים לב שיש שני שונים
פה דברים שקורה.

470
00:27:29,490 --> 00:27:34,360
אחת הוא שכאן אני מפרט
להחזיר TRUE הערך.

471
00:27:34,360 --> 00:27:35,950
כאן אני רק אומר x.

472
00:27:35,950 --> 00:27:39,970
אז R בדרך כלל כברירת מחדל
לקחת arguments-- האחרון

473
00:27:39,970 --> 00:27:43,510
או לקחת את השורה האחרונה של הקוד,
וזה יהיה מה שהוא חזר.

474
00:27:43,510 --> 00:27:46,920
אז הנה זה זהה
דבר עושה x תמורה.

475
00:27:46,920 --> 00:27:49,450

476
00:27:49,450 --> 00:27:50,540
>> ורק כדי להראות לך.

477
00:27:50,540 --> 00:27:54,000

478
00:27:54,000 --> 00:27:57,052
ואז, זה יעבוד ככה סתם.

479
00:27:57,052 --> 00:27:58,260
אז תן לי להמשיך עם זה.

480
00:27:58,260 --> 00:28:00,630
>> אז אחר אם.

481
00:28:00,630 --> 00:28:04,060
ובאמת, אני יכול לחזור
כל מה שאני רוצה.

482
00:28:04,060 --> 00:28:06,680
אז גם אין לי ל
התמורה Booleans כל הזמן,

483
00:28:06,680 --> 00:28:08,410
אני יכול רק לחזור למשהו אחר.

484
00:28:08,410 --> 00:28:10,670
אז אני יכול לעשות את דוב תמורה.

485
00:28:10,670 --> 00:28:12,989
>> אז אם x שווה שווה,
זה הולך לחזור דוב.

486
00:28:12,989 --> 00:28:14,530
אחרת, זה הולך להחזיר TRUE.

487
00:28:14,530 --> 00:28:19,310
אני יכול גם לעשות וקטור
או בעצם כל דבר.

488
00:28:19,310 --> 00:28:22,210
>> ובדרך כלל באופן סטטי
שפות מודפסות,

489
00:28:22,210 --> 00:28:23,840
היית צריך לציין כאן סוג.

490
00:28:23,840 --> 00:28:25,750
ושים לב שזה יכול להיות רק דבר.

491
00:28:25,750 --> 00:28:32,400
וR הוא אינטליגנטי מספיק ש
יהיה פשוט לעשות את זה וזה יעבוד בסדר.

492
00:28:32,400 --> 00:28:33,620
>> אז תן לי להגדיר את זה.

493
00:28:33,620 --> 00:28:39,460

494
00:28:39,460 --> 00:28:41,230
Unexpected-- הו מצטער.

495
00:28:41,230 --> 00:28:44,336
זה צריך להיות סד מתולתל כאן.

496
00:28:44,336 --> 00:28:44,836
OK.

497
00:28:44,836 --> 00:28:45,336
מגניב.

498
00:28:45,336 --> 00:28:52,580

499
00:28:52,580 --> 00:28:54,530
בְּסֵדֶר.

500
00:28:54,530 --> 00:28:58,250
אז עכשיו בואו להשוות 3 ושווה 3.

501
00:28:58,250 --> 00:29:01,860
כך זה צריך return--
yeah-- דוב הערך.

502
00:29:01,860 --> 00:29:06,740
>> אז עכשיו דבר כללי יותר הוא כמו
מה לגבי מבני נתונים אחרים.

503
00:29:06,740 --> 00:29:09,110
אז יש לך בפונקציה זו.

504
00:29:09,110 --> 00:29:15,360
זה הולך לעבוד על כל סוג
של ערך כמו 3 או כל מספרי,

505
00:29:15,360 --> 00:29:17,500
במילים אחרות, כפול.

506
00:29:17,500 --> 00:29:19,330
>> אבל מה עם משהו כמו וקטור.

507
00:29:19,330 --> 00:29:27,750
אז מה קורה אם אתה do-- אז אני
הולך להקצות val, נניח, 4 עד 6.

508
00:29:27,750 --> 00:29:31,640
אז אם אני חוזר זה, זה
הוא וקטור מ4, 5, 6.

509
00:29:31,640 --> 00:29:34,935
>> עכשיו בואו לראות מה קורה
אם אני עושה את bounded.compare val.

510
00:29:34,935 --> 00:29:37,680

511
00:29:37,680 --> 00:29:42,450
אז זה הולך לתת לך 15 1,251.

512
00:29:42,450 --> 00:29:46,440
אז במילים אחרות, זה אומר
אם אתה מסתכל על המצב הזה

513
00:29:46,440 --> 00:29:50,040
אז זה אומר x הוא פחות
מ או משהו.

514
00:29:50,040 --> 00:29:51,880
אז זה מעט
מבלבל כי עכשיו

515
00:29:51,880 --> 00:29:53,379
אתה פשוט לא יודע מה קורה.

516
00:29:53,379 --> 00:29:58,690
אז אני מניח שדבר אחד שבאמת
טוב על רק מנסה לאתר באגים

517
00:29:58,690 --> 00:30:04,600
הוא שאתה יכול פשוט לעשות את val גדול
מ ולראות מה קורה שם.

518
00:30:04,600 --> 00:30:09,720
>> אז val-- הוא כברירת מחדל 5 כל כך
בואו פשוט Val של יותר מ -5.

519
00:30:09,720 --> 00:30:14,280
אז זה שקר שקר וקטור TRUE.

520
00:30:14,280 --> 00:30:17,206
אז עכשיו כשאתה מסתכל על
זה, זה הולך לומר אם,

521
00:30:17,206 --> 00:30:20,080
ואז זה הולך לתת לך את זה
הוא וקטור של שקר שקר אמיתי.

522
00:30:20,080 --> 00:30:23,450
>> לכן, כאשר אתה עובר את זה בR, R
אין לו מושג מה אתה עושה.

523
00:30:23,450 --> 00:30:26,650
כי זה מצפה אחד
ערך, שבו הוא בוליאנית, ועכשיו

524
00:30:26,650 --> 00:30:29,420
אתה נותן את זה וקטור של Booleans.

525
00:30:29,420 --> 00:30:31,970
אז כברירת מחדל, R הוא פשוט
הולך להגיד מה לעזאזל,

526
00:30:31,970 --> 00:30:35,440
אני הולך להניח שאתה
הולך לקחת את האלמנט הראשון כאן.

527
00:30:35,440 --> 00:30:38,320
אז אני הולך לsay-- אני הולך
להניח שזה שקר.

528
00:30:38,320 --> 00:30:40,890
אז זה הולך להגיד
לא, זה לא בסדר.

529
00:30:40,890 --> 00:30:45,246
>> בדומה לכך, זה הולך
להיות val שווה שווה.

530
00:30:45,246 --> 00:30:47,244
לא, מצטער 5.

531
00:30:47,244 --> 00:30:48,910
וזה גם הולך להיות כוזב, כמו גם.

532
00:30:48,910 --> 00:30:52,410
אז זה הולך להגיד לא,
זה לא נכון, כמו גם אז זה

533
00:30:52,410 --> 00:30:53,680
עומד לחזור זה אחרון.

534
00:30:53,680 --> 00:30:56,420

535
00:30:56,420 --> 00:31:01,360
>> אז זה גם דבר טוב או רע
דבר, תלוי איך אתה מציג את זה.

536
00:31:01,360 --> 00:31:05,104
כי כשאתה
יצירת פונקציות אלה,

537
00:31:05,104 --> 00:31:06,770
אתה באמת לא יודע מה קורה.

538
00:31:06,770 --> 00:31:10,210
אז לפעמים היית רוצה שגיאה,
או אולי אתה פשוט רוצה אזהרה.

539
00:31:10,210 --> 00:31:12,160
במקרה זה, R לא עושה את זה.

540
00:31:12,160 --> 00:31:14,300
אז זה באמת תלוי בי
אתה מבוסס על הנחה של מה ש

541
00:31:14,300 --> 00:31:17,310
אתה חושב שפה
צריך לעשות במקרה זה

542
00:31:17,310 --> 00:31:22,920
אם אתה עובר בוקטור של Booleans
כאשר אתה עושה אם מצב.

543
00:31:22,920 --> 00:31:31,733
>> אז נניח שהיה לך מקורי
אחד עם אם אחר להחזיר TRUE ואתה

544
00:31:31,733 --> 00:31:34,190
הולך להחזיר FALSE.

545
00:31:34,190 --> 00:31:39,300
אז דרך אחת ההפשטה
זה אומר ש

546
00:31:39,300 --> 00:31:41,530
אפילו לא צריך דבר המותנה הזה.

547
00:31:41,530 --> 00:31:47,220
עוד דבר שאני יכול לעשות הוא פשוט
חוזר את הערכים עצמם.

548
00:31:47,220 --> 00:31:53,240
אז אם אתה שם לב, אם אתה
לעשות val הוא יותר מ -5,

549
00:31:53,240 --> 00:31:56,350
זה הולך לחזור
וקטור שקר שקר אמיתי.

550
00:31:56,350 --> 00:31:58,850
>> אולי זה מה שאתה
רוצה לbounded.compare.

551
00:31:58,850 --> 00:32:02,940
אתה רוצה לחזור וקטור של Booleans
שבו הוא משווה כל אחד מהערכים

552
00:32:02,940 --> 00:32:04,190
לעצמם.

553
00:32:04,190 --> 00:32:11,165
אז אתה יכול פשוט bounded.compare
x פונקציה, שווה 5.

554
00:32:11,165 --> 00:32:13,322

555
00:32:13,322 --> 00:32:15,363
ואז במקום לעשות
מצב זה אם אחר,

556
00:32:15,363 --> 00:32:21,430
אני רק הולך לחזור
x גדול מ -5.

557
00:32:21,430 --> 00:32:23,620
אז אם זה נכון, אז
זה הולך להחזיר TRUE.

558
00:32:23,620 --> 00:32:26,830
ואז אם זה לא, זה
הולך להחזיר FALSE.

559
00:32:26,830 --> 00:32:30,880
>> וזה יעבוד ל
כל המבנים הללו.

560
00:32:30,880 --> 00:32:41,450
אז אני יכול bounded.compare ג 1 6 או 9
ואז אני הולך להגיד שווה 6,

561
00:32:41,450 --> 00:32:42,799
לדוגמא.

562
00:32:42,799 --> 00:32:44,840
ואז זה הולך
אתן לך בוליאנית תקין

563
00:32:44,840 --> 00:32:48,240
וקטור שאתה מעצב.

564
00:32:48,240 --> 00:32:50,660
>> אז אלה הם רק פונקציות
ועכשיו תן לי רק

565
00:32:50,660 --> 00:32:54,980
להראות לך כמה חזותיים אינטראקטיביים.

566
00:32:54,980 --> 00:32:59,700
אני לא חושב שאני באמת צריך
Wi-Fi כאן אז תן לי רק קדימה

567
00:32:59,700 --> 00:33:01,970
ולדלג על זה אני מניח.

568
00:33:01,970 --> 00:33:05,260
>> אבל דבר אחד זה מגניב
למרות שהוא שאם אתה רק

569
00:33:05,260 --> 00:33:09,600
רוצה לבדוק את חבורה של
פקודות נתונים שונות,

570
00:33:09,600 --> 00:33:13,320
יש חבורה של מערכי נתונים שונים
כי הם כבר מראש לתוך ר '

571
00:33:13,320 --> 00:33:15,770
אז אחד מהם הוא
בשם בסיס נתוני קשתית.

572
00:33:15,770 --> 00:33:18,910
זהו אחד הידוע ביותר
אלה בלמידת מכונה.

573
00:33:18,910 --> 00:33:23,350
בדרך כלל אתה פשוט לעשות איזה
מקרי מבחן כדי לראות אם הקוד שלך פועל.

574
00:33:23,350 --> 00:33:27,520
אז בואו רק לבדוק מה היא קשתית.

575
00:33:27,520 --> 00:33:33,130
>> אז הדבר הזה הולך
להיות מסגרת נתונים.

576
00:33:33,130 --> 00:33:36,000
וזה סוג של ארוך, כי
אני רק הדפסתי איריס.

577
00:33:36,000 --> 00:33:38,810
זה מדפיס את כל הדבר.

578
00:33:38,810 --> 00:33:42,830
אז יש לו את כל שמות השונים אלה.

579
00:33:42,830 --> 00:33:45,505
אז איריס היא אוסף
פרחים שונים.

580
00:33:45,505 --> 00:33:48,830
במקרה זה, את אומר ל
אתה המינים שלו,

581
00:33:48,830 --> 00:33:54,760
כל רוחב שונה אלה ו
אורכים של עלה הגביע ועלה הכותרת.

582
00:33:54,760 --> 00:33:58,880
>> ואז בדרך כלל, אם
ברצונך להדפיס איריס,

583
00:33:58,880 --> 00:34:03,680
לדוגמא, אתה לא רוצה לעשות את זה
לעשות את כל זה בגלל שיכול להשתלט על

584
00:34:03,680 --> 00:34:05,190
הקונסולה כולו שלך.

585
00:34:05,190 --> 00:34:09,280
אז דבר אחד שבאמת
נחמד הוא פונקצית הראש.

586
00:34:09,280 --> 00:34:12,929
אז אם אתה פשוט עושה את הראש
איריס, זה ייתן לך

587
00:34:12,929 --> 00:34:17,389
חמש השורות הראשונות, או שש אני מניח.

588
00:34:17,389 --> 00:34:19,909
ולאחר מכן גם, אתה
רק יכול לציין כאן.

589
00:34:19,909 --> 00:34:22,914
אז 20-- זה ייתן לי
שלך 20 השורות הראשונות.

590
00:34:22,914 --> 00:34:24,830
ואני דווקא היה סוג
של מופתע שזה

591
00:34:24,830 --> 00:34:28,770
נתנו לי שש אז תן לי ללכת קדימה
וסמן את iris-- או הראש, מצטער.

592
00:34:28,770 --> 00:34:31,699

593
00:34:31,699 --> 00:34:34,960
וכאן זה ייתן לי
אתה התיעוד

594
00:34:34,960 --> 00:34:37,960
ממה שראש הערך עושה.

595
00:34:37,960 --> 00:34:40,839
אז זה מחזיר את ראשון
או אחרון של אובייקט.

596
00:34:40,839 --> 00:34:42,630
ואז אני הולך ל
מסתכל על ברירות המחדל.

597
00:34:42,630 --> 00:34:47,340
ואז זה אומר ברירת המחדל
x ראש השיטה וn שווה 6L.

598
00:34:47,340 --> 00:34:50,620
אז זה מחזיר את ששת היסודות הראשונים.

599
00:34:50,620 --> 00:34:55,050
ובאופן דומה, אם שמתם לב לכאן, אני
לא צריך לציין n שווה 6.

600
00:34:55,050 --> 00:34:56,840
כברירת מחדל הוא משתמש בשש, אני מניח.

601
00:34:56,840 --> 00:35:00,130
ולאחר מכן, אם אני רוצה לציין מסוים
ערך, אז אני יכול להציג את זה גם כן.

602
00:35:00,130 --> 00:35:02,970

603
00:35:02,970 --> 00:35:10,592
>> אז זה חלק מפקודות פשוטות ו
הנה עוד אחד שהוא פשוט- גם,

604
00:35:10,592 --> 00:35:12,550
אני can-- זה הוא למעשה
יותר מורכב מעט,

605
00:35:12,550 --> 00:35:17,130
אבל זה רק ייקח הכיתה
כל עמודה של בסיס נתוני הקשתית.

606
00:35:17,130 --> 00:35:20,910
אז זה ייראה לכם מה כל אחד מאלה
העמודות במונחים של סוגיהם.

607
00:35:20,910 --> 00:35:23,665
אז אורך עלה גביע הוא מספרי,
רוחב עלה גביע הוא מספרי.

608
00:35:23,665 --> 00:35:26,540
כל הערכים הללו הם רק מספריים
בגלל שאתה יכול להגיד לי מנתונים אלה

609
00:35:26,540 --> 00:35:29,440
מבנה אלה
כל הולך מספרי.

610
00:35:29,440 --> 00:35:34,310
>> וטור המינים
הולך להיות גורם.

611
00:35:34,310 --> 00:35:37,270
אז בדרך כלל, היית חושב ש
זה כמו מחרוזת תווים.

612
00:35:37,270 --> 00:35:48,830
אבל אם אתה רק עושה irisSpecies,
ואז אני הולך לעשות את הראש 5,

613
00:35:48,830 --> 00:35:51,820
וזה הולך להדפיס
חמישה הערכים הראשונים.

614
00:35:51,820 --> 00:35:54,150
>> ואז שם לב רמות זה.

615
00:35:54,150 --> 00:35:58,870
אז זה saying-- זו דרכו של R
שיש משתני קטגורי.

616
00:35:58,870 --> 00:36:03,765
אז במקום רק
יש מחרוזות תווים,

617
00:36:03,765 --> 00:36:06,740
יש לו ולציין רמות
שהדברים האלה הם.

618
00:36:06,740 --> 00:36:12,450
>> אז בואו נגיד שirisSpecies 1.

619
00:36:12,450 --> 00:36:17,690
אז מה אתה רוצה לעשות כאן הוא אני
subsetting לעמודה מין זה.

620
00:36:17,690 --> 00:36:21,480
אז זה לוקח
טור מינים ולאחר מכן

621
00:36:21,480 --> 00:36:23,820
מדדיו כדי לקבל את האלמנט הראשון.

622
00:36:23,820 --> 00:36:27,140
אז זה אמור לתת לך setosa.

623
00:36:27,140 --> 00:36:28,710
וזה גם נותן לך רמות כאן.

624
00:36:28,710 --> 00:36:32,812
>> אז אתה גם יכול להשוות
זה לsetosa האופי

625
00:36:32,812 --> 00:36:34,645
וזה לא הולך
להיות אמיתי, כי אחד

626
00:36:34,645 --> 00:36:37,940
הוא מסוג שונה מאחר.

627
00:36:37,940 --> 00:36:40,590
או אני מניח שזה נכון, כי R
הוא יותר אינטליגנטי מזה.

628
00:36:40,590 --> 00:36:45,420
וזה נראה בשלב זה ולאחר מכן
אומר, אולי זה מה שאתה רוצה.

629
00:36:45,420 --> 00:36:51,860
אז זה הולך לומר את האופי
setosa מחרוזת זהה לזה.

630
00:36:51,860 --> 00:37:01,290
ולאחר מכן באופן דומה, אתה יכול
גם פשוט לתפוס אלה כמו כן הלאה.

631
00:37:01,290 --> 00:37:05,580
>> אז זה פשוט סוג מסוים של
פקודות מהירות של בסיס הנתונים.

632
00:37:05,580 --> 00:37:08,030
אז הנה כמה חקר נתונים.

633
00:37:08,030 --> 00:37:11,360
אז זה קצת יותר
מעורב עם ניתוח נתונים.

634
00:37:11,360 --> 00:37:18,340
וזה נלקח מכמה
טירונות בR בברקלי.

635
00:37:18,340 --> 00:37:20,790
>> אז ספרייה זרה.

636
00:37:20,790 --> 00:37:24,880
אז אני הולך לטעון ב
ספרייה שנקראת זר.

637
00:37:24,880 --> 00:37:32,460
אז זה הולך לתת לי read.dta
כך מניח שיש לי במערך זה.

638
00:37:32,460 --> 00:37:39,000
זה מאוחסן בזרם
עובד בספרייה של הקונסולה שלי.

639
00:37:39,000 --> 00:37:42,190
אז בואו רק לראות מה
ספריית העבודה היא.

640
00:37:42,190 --> 00:37:44,620
>> אז הנה ספריית העבודה שלי.

641
00:37:44,620 --> 00:37:50,040
ולקרוא את נתוני נקודה, זה
דבר, הוא אומר בקובץ זה

642
00:37:50,040 --> 00:37:54,650
ממוקם בתיקיית נתונים של
ספריית עבודה הנוכחית.

643
00:37:54,650 --> 00:38:00,520
וread.dta זה לא
פקודת ברירת המחדל.

644
00:38:00,520 --> 00:38:02,760
אני מניח שאני טעון בזה כבר.

645
00:38:02,760 --> 00:38:04,750
IEI להניח אני טעון בזה כבר.

646
00:38:04,750 --> 00:38:08,115
>> אבל כל כך read.dta לא הולך
להיות פקודת ברירת המחדל.

647
00:38:08,115 --> 00:38:11,550
וזו הסיבה שאתה הולך יש לי
כדי לטעון בספרייה זו package--

648
00:38:11,550 --> 00:38:14,500
חבילה זו נקראת זרה.

649
00:38:14,500 --> 00:38:16,690
ואם אין לך
החבילה, אני חושב ש

650
00:38:16,690 --> 00:38:19,180
חוץ הוא אחד מאלה מובנים.

651
00:38:19,180 --> 00:38:31,150
אחרת, אתה גם יכול
לעשות install.packages

652
00:38:31,150 --> 00:38:33,180
וזה יהיה להתקין את החבילה.

653
00:38:33,180 --> 00:38:36,878
וזה ייתן לך ר 'אה, לא.

654
00:38:36,878 --> 00:38:39,830

655
00:38:39,830 --> 00:38:43,140
ואז אני פשוט הולך להפסיק
זה בגלל שיש לי כבר את זה.

656
00:38:43,140 --> 00:38:46,920
>> אבל מה שבאמת נחמד על R
הוא שניהול החבילות

657
00:38:46,920 --> 00:38:48,510
המערכת היא מאוד אלגנטית.

658
00:38:48,510 --> 00:38:52,470
כי זה יהיה לאחסן הכל
ממש יפה לך.

659
00:38:52,470 --> 00:38:59,780
אז במקרה הזה, זה הולך לאחסון
זה ב, אני מאמין, ספרייה זו כאן.

660
00:38:59,780 --> 00:39:02,390
>> אז כל פעם שאתה רוצה
להתקין חבילות חדשות,

661
00:39:02,390 --> 00:39:04,980
זה פשוט פשוט כמו
עושה install.packages

662
00:39:04,980 --> 00:39:07,500
וR ינהל את כל
החבילות בשבילך.

663
00:39:07,500 --> 00:39:12,900
אז אתה לא צריך לעשות משהו ב
Python, שבו יש לך חבילה חיצונית

664
00:39:12,900 --> 00:39:15,330
המנהלים כמו נייר
אנקונדה שבו אתה נמצא

665
00:39:15,330 --> 00:39:18,310
doing-- התקנה
חבילות מחוץ לפייתון

666
00:39:18,310 --> 00:39:20,940
ואז אתה מנסה להפעיל אותם בעצמך.

667
00:39:20,940 --> 00:39:22,210
אז זה באמת דרך נחמדה.

668
00:39:22,210 --> 00:39:25,590
>> וinstall.packages דורש אינטרנט.

669
00:39:25,590 --> 00:39:31,950
זה לוקח אותו משרת
והמאגר ש

670
00:39:31,950 --> 00:39:33,960
אוסף את כל
חבילות נקראת קראן.

671
00:39:33,960 --> 00:39:40,690
וניתן לציין איזה סוג של מראה
אתה רוצה להוריד את החבילות מ.

672
00:39:40,690 --> 00:39:43,420
>> אז הנה אני לוקח את בסיס הנתונים הזה.

673
00:39:43,420 --> 00:39:46,240
אני קוראת את זה בשימוש בפונקציה זו.

674
00:39:46,240 --> 00:39:49,360
אז תן לי ללכת קדימה ולעשות את זה.

675
00:39:49,360 --> 00:39:52,900
>> אז בואו נניח ש
יש לך מערך זה

676
00:39:52,900 --> 00:39:55,550
ויש לך לחלוטין
אין לי מושג מה זה.

677
00:39:55,550 --> 00:39:58,560
וזה בעצם עולה
לעתים קרובות למדי בתעשייה

678
00:39:58,560 --> 00:40:00,910
שבו אתה רק צריך אלה
טונות של דברים מבולגנים

679
00:40:00,910 --> 00:40:02,890
והם ללא תווית להפליא.

680
00:40:02,890 --> 00:40:06,380
אז הנה יש לי את זה
ובסיס נתונים אני לא יודע

681
00:40:06,380 --> 00:40:08,400
מה זה כל כך אני רק
מראה כדי לבדוק את זה.

682
00:40:08,400 --> 00:40:10,620
>> אז אני הולך ראשון לעשות את הראש.

683
00:40:10,620 --> 00:40:14,190
אז אני בודק את שש הראשונים
טורים של מה במערך זה.

684
00:40:14,190 --> 00:40:21,730
אז זה מצב, pres04, ולאחר מכן
כל סוג אחר של אלה עמודות.

685
00:40:21,730 --> 00:40:25,612
ומה שמעניין
כאן, אני מניח, הוא שאתה

686
00:40:25,612 --> 00:40:27,945
היה מניח שזה נראה
כמו איזה בחירות.

687
00:40:27,945 --> 00:40:30,482

688
00:40:30,482 --> 00:40:32,190
ואני מניח שרק מ
מסתכל על הקובץ

689
00:40:32,190 --> 00:40:41,070
שם זה סוג של אוסף
נתונים על מועמדים או בוחרים

690
00:40:41,070 --> 00:40:44,920
מי הצביע לנשיאים ספציפיים
או מועמדי נשיא

691
00:40:44,920 --> 00:40:46,550
לבחירות 2004.

692
00:40:46,550 --> 00:40:52,920
>> אז הנה הוא ערכי 1, 2
כך בדרך זו של אחסון

693
00:40:52,920 --> 00:40:56,540
מועמדי הנשיא
שמותיהם.

694
00:40:56,540 --> 00:40:59,780
במקרה זה, זה נראה כמו
הם ערכים רק מספר שלם.

695
00:40:59,780 --> 00:41:04,030
אז שנת 2004, זה היה בוש
לעומת קרי אני מאמין.

696
00:41:04,030 --> 00:41:09,010
ועכשיו, נניח שאתה פשוט לא יודע
אם 1, מקבילה בוש או 2

697
00:41:09,010 --> 00:41:11,703
מתאים לקרי או ו
כך הלאה וכך הלאה, נכון?

698
00:41:11,703 --> 00:41:15,860
>> וזה, רק לי,
בעיה נפוצה למדי.

699
00:41:15,860 --> 00:41:18,230
אז מה אפשר לעשות במקרה זה?

700
00:41:18,230 --> 00:41:20,000
אז בואו לבדוק את כל אלה דברים אחרים.

701
00:41:20,000 --> 00:41:22,790
>> מדינה, אני מניח שזה
מגיע ממדינות שונות.

702
00:41:22,790 --> 00:41:25,100
partyid, הכנסה.

703
00:41:25,100 --> 00:41:27,710
בואו נסתכל על partyid.

704
00:41:27,710 --> 00:41:32,800
אז אולי דבר יחיד שאתה יכול לעשות הוא
מסתכל על כל אחת מהתצפיות

705
00:41:32,800 --> 00:41:36,250
שיש לי partyid של רפובליקאים
או דמוקרט או משהו.

706
00:41:36,250 --> 00:41:38,170
אז בואו רק להסתכל על מה partyid הוא.

707
00:41:38,170 --> 00:41:41,946
>> אז אני הולך לקחת
dat ולאחר מכן אני הולך

708
00:41:41,946 --> 00:41:47,960
לעשות סימן דולר זה
מפעיל שעשיתי בעבר

709
00:41:47,960 --> 00:41:50,770
וזה הולך
משנה לטור זה.

710
00:41:50,770 --> 00:41:57,760
ואז אני הולך לעמוד בראש זה ב
20, רק כדי לראות איך זה נראה.

711
00:41:57,760 --> 00:42:00,170
>> אז זה פשוט חבורה של NAS.

712
00:42:00,170 --> 00:42:02,800
אז במילים אחרות, יש לך
נתונים חסרים על החבר'ה האלה.

713
00:42:02,800 --> 00:42:08,100
אבל אתה גם שם לב זה
dat partyid הוא גורם

714
00:42:08,100 --> 00:42:10,030
אז זה נותן לך קטגוריות שונות.

715
00:42:10,030 --> 00:42:14,170
אז במילים אחרות, partyid יכול לקחת
דמוקרט, רפובליקני, עצמאי,

716
00:42:14,170 --> 00:42:16,640
או משהו אחר.

717
00:42:16,640 --> 00:42:23,940
>> אז בואו נלך קדימה ובואו
לראות אילו של is-- אלה הו, בסדר.

718
00:42:23,940 --> 00:42:28,480
אז אני הולך לקבוצת משנה
לpartyid ולאחר מכן

719
00:42:28,480 --> 00:42:32,780
מסתכל אילו הם
דמוקרט, למשל.

720
00:42:32,780 --> 00:42:37,150
זה הולך לתת לך בוליאנית,
בוליאנית של TRUEs וFALSEs ענק.

721
00:42:37,150 --> 00:42:41,630
>> ועכשיו, בואו נגיד שאני רוצה
לקבוצת משנה לבחורים האלה.

722
00:42:41,630 --> 00:42:47,260
אז זה הולך לקחת dat שלי ו
משנה ללפי תצפיות

723
00:42:47,260 --> 00:42:48,910
יש שווים partyid שווה דמוקרט.

724
00:42:48,910 --> 00:42:52,830

725
00:42:52,830 --> 00:42:55,180
וזה די ארוך, כי
יש כל כך הרבה מהם.

726
00:42:55,180 --> 00:42:59,060
אז עכשיו, אני הולך לעמוד בראש זה ב -20.

727
00:42:59,060 --> 00:43:05,690

728
00:43:05,690 --> 00:43:11,270
>> וכמו שאתה שם לב, שווה שווה
מעניין שבאתה

729
00:43:11,270 --> 00:43:13,250
already-- אתה גם כולל NAS.

730
00:43:13,250 --> 00:43:19,010
אז במקרה הזה, אתה עדיין לא יכול לקבל
כל מידע כי עכשיו יש לך NAS

731
00:43:19,010 --> 00:43:22,650
ואתה רק רוצה לראות מי מ
תצפית מתאימות לדמוקרט

732
00:43:22,650 --> 00:43:24,670
ולא אלה חסרים ערכים עצמם.

733
00:43:24,670 --> 00:43:27,680
אז איך היית להיפטר מNAS אלה?

734
00:43:27,680 --> 00:43:36,410
>> אז הנה רק אני משתמש במפתח עליי
סמן ואז אומר מסתובב.

735
00:43:36,410 --> 00:43:39,778
ואז כאן אני פשוט הולך
לומר is.na datpartyid.

736
00:43:39,778 --> 00:43:48,970

737
00:43:48,970 --> 00:43:52,720
אז וזה וייקח
שני וקטורים בוליאנית שונים

738
00:43:52,720 --> 00:43:57,160
ואומר שזה הולך להיות
אמת ושקר לדוגמא.

739
00:43:57,160 --> 00:43:59,190
אז זה הולך לעשות רכיב חכם זה.

740
00:43:59,190 --> 00:44:02,910
אז הנה אני אומר לקחת
מסגרת הנתונים, משנה

741
00:44:02,910 --> 00:44:10,170
לאלה שמתאימים לדמוקרט,
ולהסיר כל אחד מהם, כי הם לא NA.

742
00:44:10,170 --> 00:44:13,540
>> אז will-- זה צריך
לתת לך משהו.

743
00:44:13,540 --> 00:44:16,540

744
00:44:16,540 --> 00:44:17,600
בואו לראות is.na.

745
00:44:17,600 --> 00:44:24,670

746
00:44:24,670 --> 00:44:27,690
בואו ננסה datpartyid is.na.

747
00:44:27,690 --> 00:44:36,290

748
00:44:36,290 --> 00:44:45,290
וזה אמור לתת לי you--
sorry-- רק וקטור בוליאנית.

749
00:44:45,290 --> 00:44:49,260
ואז, בגלל שזה כל כך הרבה זמן,
אני הולך לקבוצת משנה עד 20.

750
00:44:49,260 --> 00:44:49,760
OK.

751
00:44:49,760 --> 00:44:51,570
אז זה אמור לעבוד.

752
00:44:51,570 --> 00:44:54,700
>> וזה אחד יהיה גם TRUEs.

753
00:44:54,700 --> 00:45:01,830
אה, אז הטעות שלי כאן היא שאני I'm--
להשתמש C ++ ו- R לסירוגין כך אני עושה

754
00:45:01,830 --> 00:45:03,590
את הטעות הזאת כל הזמן.

755
00:45:03,590 --> 00:45:05,807
והמפעיל הוא
למעשה אחד שאתה רוצה.

756
00:45:05,807 --> 00:45:08,140
אתה לא רוצה להשתמש בשתי
סימן חיבור, רק אחד.

757
00:45:08,140 --> 00:45:14,970

758
00:45:14,970 --> 00:45:17,010
OK.

759
00:45:17,010 --> 00:45:18,140
>> אז בואו נראה.

760
00:45:18,140 --> 00:45:20,930

761
00:45:20,930 --> 00:45:23,920
אז אנחנו subsetted ל
partyid שבו הם דמוקרט

762
00:45:23,920 --> 00:45:25,300
והם לא חסרים ערכים.

763
00:45:25,300 --> 00:45:27,690
ועכשיו בואו נסתכל על
אילו הם הצביעו בעד.

764
00:45:27,690 --> 00:45:31,530
אז זה נראה כמו רוב
מהם הצביע בעד 1.

765
00:45:31,530 --> 00:45:36,090
אז אני הולך קדימה
ולומר שהוא קרי.

766
00:45:36,090 --> 00:45:39,507
>> ובאופן דומה, אתה יכול
גם ללכת רפובליקני

767
00:45:39,507 --> 00:45:41,090
ואנו מקווים, זה אמור לתת לך 2.

768
00:45:41,090 --> 00:45:49,730

769
00:45:49,730 --> 00:45:51,770
זה פשוט חבורה של עמודות שונות.

770
00:45:51,770 --> 00:45:53,070
ואכן, זה 2.

771
00:45:53,070 --> 00:45:55,750
אז partyid כל הרפובליקני,
רובם מצביעים עבור 2.

772
00:45:55,750 --> 00:45:58,390
>> אז זה נראה כאילו, רק
על ידי התבוננות בזה,

773
00:45:58,390 --> 00:46:00,600
הרפובליקני הולך להיות
very-- או partyid

774
00:46:00,600 --> 00:46:02,790
הולך להיות מאוד
גורם חשוב בקביעה

775
00:46:02,790 --> 00:46:05,420
שמועמד שהם
הולך להצביע.

776
00:46:05,420 --> 00:46:07,120
וזה כמובן נכון באופן כללי.

777
00:46:07,120 --> 00:46:10,139
וזו תואמת שלך
אינטואיציה, כמובן.

778
00:46:10,139 --> 00:46:11,930
כך זה נראה כאילו אני
אוזל זמן כל כך

779
00:46:11,930 --> 00:46:17,040
תן לי רק צריך ללכת קדימה
ולהראות כמה תמונות מהירות.

780
00:46:17,040 --> 00:46:21,120
אז הנה משהו שמעט
יותר מסובך עם הדמיה.

781
00:46:21,120 --> 00:46:26,450
אז במקרה הזה, זה מאוד
ניתוח פשוט של רק בודק מה

782
00:46:26,450 --> 00:46:28,500
נשיא '04 הוא.

783
00:46:28,500 --> 00:46:33,920
>> אז במקרה הזה, נניח שאתה
רציתי לענות על שאלה זו.

784
00:46:33,920 --> 00:46:38,540
אז נניח שאנחנו רוצים לדעת את ההצבעה
התנהגות בבחירות 2,004 הנשיא

785
00:46:38,540 --> 00:46:41,170
ואיך זה משתנה על פי גזע.

786
00:46:41,170 --> 00:46:44,380
אז לא רק שאתה רוצה
לראות את ההצבעה ההתנהגות,

787
00:46:44,380 --> 00:46:47,860
אבל אתה רוצה קבוצת משנה של כל אחד
גזע ומין לסכם ש.

788
00:46:47,860 --> 00:46:50,770
ואתה רק יכול לומר לי
על ידי סימון מורכב זו

789
00:46:50,770 --> 00:46:52,580
שזה סוג של מקבל מעורפל.

790
00:46:52,580 --> 00:46:56,390
>> אז אחת מR המתקדם יותר
חבילות שגם סוג של אחרונים

791
00:46:56,390 --> 00:47:00,070
נקרא dplyr.

792
00:47:00,070 --> 00:47:03,060
אז זה זה ממש כאן.

793
00:47:03,060 --> 00:47:08,080
וggplot2 ggg-- הוא רק נחמד
דרך לעשות חזותיים טוב יותר

794
00:47:08,080 --> 00:47:09,400
יותר מזה המובנה.

795
00:47:09,400 --> 00:47:11,108
>> אז אני הולך לטעינה
שתי ספריות אלה.

796
00:47:11,108 --> 00:47:13,200

797
00:47:13,200 --> 00:47:16,950
ולאחר מכן, אני מתכוון ללכת
קדימה ולהריץ את הפקודה.

798
00:47:16,950 --> 00:47:19,050
אתה פשוט יכול להתייחס לזה כמו קופסא שחורה.

799
00:47:19,050 --> 00:47:23,460
>> מה שקורה הוא שצינור זה
המפעיל עובר בטענה זו

800
00:47:23,460 --> 00:47:24,110
לכאן.

801
00:47:24,110 --> 00:47:28,070
אז אני אומר קבוצה על ידי dat
גזע ולאחר מכן נשיא 04.

802
00:47:28,070 --> 00:47:31,530
ולאחר מכן, כל פקודות אחרות אלה
מסננים ולאחר מכן סיכום

803
00:47:31,530 --> 00:47:34,081
שבו אני עושה ספירה ו
אז אני זומם אותו כאן.

804
00:47:34,081 --> 00:47:39,980

805
00:47:39,980 --> 00:47:42,500
אישור מגניב.

806
00:47:42,500 --> 00:47:44,620
אז בואו נלך קדימה ו
לראות מה זה נראה כמו.

807
00:47:44,620 --> 00:47:52,280

808
00:47:52,280 --> 00:47:57,290
>> אז מה שקורה פה זה אני ש
רק זממתי כל אחד מהגזעים ולאחר מכן

809
00:47:57,290 --> 00:47:59,670
אילו הם הצביעו בעד.

810
00:47:59,670 --> 00:48:03,492
ושני אלה שונים
ערכים מתאים ל- 2 ו -1.

811
00:48:03,492 --> 00:48:05,325
אם אתה רוצה להיות יותר
אלגנטי, אתה יכול גם

812
00:48:05,325 --> 00:48:11,770
רק לציין כי 2 הוא Kerry-- או
2 הוא בוש, ולאחר מכן 1 הוא קרי.

813
00:48:11,770 --> 00:48:13,700
ואתה גם יכול להיות
כי באגדה שלך.

814
00:48:13,700 --> 00:48:17,410
>> ואתה גם יכול לפצל גרפים בר אלה.

815
00:48:17,410 --> 00:48:19,480
כי דבר אחד הוא
כי, אם תשימו לב,

816
00:48:19,480 --> 00:48:24,560
זה לא קל מאוד לזהות
איזו משני ערכים אלה הם גדולים יותר.

817
00:48:24,560 --> 00:48:27,920
אז דבר אחד שהיית רוצה
לעשות הוא לקחת את אזור כחול זה

818
00:48:27,920 --> 00:48:31,855
ורק להעביר אותו לכאן כדי ש
יכול להשוות בין שתי תופעות אלה על ידי צד.

819
00:48:31,855 --> 00:48:34,480
ואני מניח שזה משהו ש
אין לי זמן לעשות עכשיו,

820
00:48:34,480 --> 00:48:36,660
אבל זה גם מאוד קל לעשות.

821
00:48:36,660 --> 00:48:40,310
אתה פשוט יכול להסתכל ל
דפי הגבר של ggplot.

822
00:48:40,310 --> 00:48:47,170
אז אתה יכול פשוט ggplot כמו
ושלקרוא לדף האיש הזה.

823
00:48:47,170 --> 00:48:51,920
>> אז תן לי רק במהירות
להראות לך כמה דברים מגניבים.

824
00:48:51,920 --> 00:48:57,610
בואו נלך קדימה וללכת to-- רק
יישום של למידת מכונה.

825
00:48:57,610 --> 00:49:02,450
אז בואו נגיד שיש לנו שלושה אלה
חבילות אז אני הולך לטעון אלה ב.

826
00:49:02,450 --> 00:49:05,500

827
00:49:05,500 --> 00:49:09,170
אז זה פשוט מדפיס את חלק
מידע אחרי שנטענתי בעניין.

828
00:49:09,170 --> 00:49:15,220
אז אני אומר read.csv זה,
מערך זה, ועכשיו

829
00:49:15,220 --> 00:49:18,940
אני הולך קדימה, אסתכל ו
לראות מה יש בפנים במערך זה.

830
00:49:18,940 --> 00:49:22,080
>> אז 20 התצפיות הראשונות.

831
00:49:22,080 --> 00:49:27,190
אז יש לי רק X1, X2, וי 'אז זה
נראה כמו חבורה של ערכים אלה

832
00:49:27,190 --> 00:49:31,640
הם נעים בין אולי 20 עד 80 או משהו כזה.

833
00:49:31,640 --> 00:49:37,700
ולאחר מכן באופן דומה לX2 ולאחר מכן
נראה Y זה להיות תוויות 0 ו -1.

834
00:49:37,700 --> 00:49:49,500
>> כדי לאמת את זה, אני יכול
פשוט לעשות את X1 נתוני סיכום.

835
00:49:49,500 --> 00:49:51,660
ולאחר מכן באופן דומה ל
כל אלה עמודות אחרות.

836
00:49:51,660 --> 00:49:55,300
אז סיכום היא דרך מהירה של
רק מראה לך ערכים מהירים.

837
00:49:55,300 --> 00:49:56,330
אה, סליחה.

838
00:49:56,330 --> 00:49:58,440
אחד זה צריך להיות י '

839
00:49:58,440 --> 00:50:03,420
>> אז במקרה הזה, נותן לי
quantiles, חציונים, maxes גם כן.

840
00:50:03,420 --> 00:50:07,130
במקרה זה, dataY, אתה יכול לראות
שזה פשוט הולך להיות 0 ו -1.

841
00:50:07,130 --> 00:50:10,100
גם הממוצע אומר
0.6, רק אומר שזה

842
00:50:10,100 --> 00:50:13,380
נראה כאילו יש לי יותר מ 1s 0s.

843
00:50:13,380 --> 00:50:16,160
>> אז תן לי ללכת קדימה ותכנית
לך מה זה נראה.

844
00:50:16,160 --> 00:50:17,470
אז אני פשוט הולך לחלקה זו.

845
00:50:17,470 --> 00:50:22,852

846
00:50:22,852 --> 00:50:24,636
בואו לראות איך לנקות את זה.

847
00:50:24,636 --> 00:50:30,492

848
00:50:30,492 --> 00:50:31,468
אה OK.

849
00:50:31,468 --> 00:50:35,840

850
00:50:35,840 --> 00:50:36,340
OK.

851
00:50:36,340 --> 00:50:37,590
>> אז זה מה שזה נראה.

852
00:50:37,590 --> 00:50:46,310
אז זה נראה כמו צהוב אני צוינו
כ0, ולאחר מכן אדומים אני צוין כ1s.

853
00:50:46,310 --> 00:50:52,190
אז הנה זה נראה כמו
נקודות תווית ו

854
00:50:52,190 --> 00:50:56,410
נראה כאילו אתה רק רוצה קצת
סוג של אשכולות על זה.

855
00:50:56,410 --> 00:51:01,020
>> ותן לי רק קדימה ותכנית
אתה חלק מפונקציות המובנות באלה.

856
00:51:01,020 --> 00:51:03,580
אז הנה הוא lm.

857
00:51:03,580 --> 00:51:06,060
אז זה הוא רק מנסה
כדי שיתאים לקו זה.

858
00:51:06,060 --> 00:51:08,640
אז מה היא הדרך הטובה ביותר
שאני יכול להתאים קו כזה

859
00:51:08,640 --> 00:51:14,020
שזה יהיה הטוב ביותר להפריד
סוג זה של קיבוץ באשכולות.

860
00:51:14,020 --> 00:51:21,790
ובאופן אידיאלי, אתה יכול פשוט לראות
כי אני פשוט להפעיל את כל הפקודות האלה

861
00:51:21,790 --> 00:51:25,450
ולאחר מכן, אני הולך
קדימה ולהוסיף את השורה.

862
00:51:25,450 --> 00:51:28,970
>> אז זה נראה כמו הניחוש הטוב ביותר.

863
00:51:28,970 --> 00:51:34,150
זה לוקח את הטוב ביותר שממזער
השגיאה בניסיון להתאים את הקו הזה.

864
00:51:34,150 --> 00:51:40,000
ברור, זה נראה סוג של
טוב, אבל זה לא הכי טוב.

865
00:51:40,000 --> 00:51:43,130
ומודלים ליניאריים, ב
כללי, הולכים להיות

866
00:51:43,130 --> 00:51:46,811
באמת נהדר לתאוריה ורק סוג
של יסודות בניין של מכונה

867
00:51:46,811 --> 00:51:47,310
למידה.

868
00:51:47,310 --> 00:51:50,330
אבל בפועל, אתה הולך
רוצה לעשות משהו יותר כללי.

869
00:51:50,330 --> 00:51:54,280
>> אז אתה יכול פשוט לנסות פועל
משהו שנקרא רשת עצבית.

870
00:51:54,280 --> 00:51:57,110
דברים אלה הם
יותר ויותר נפוץ.

871
00:51:57,110 --> 00:52:00,530
והם פשוט עובדים בצורה פנטסטית
למערכי נתונים גדולים.

872
00:52:00,530 --> 00:52:07,080
אז במקרה הזה, אנחנו have-- רק
בואו see-- יש לנו nrow.

873
00:52:07,080 --> 00:52:09,010
אז nrow הוא רק אומר מספר השורות.

874
00:52:09,010 --> 00:52:11,790
אז במקרה הזה, אני
יש לי 100 תצפיות.

875
00:52:11,790 --> 00:52:15,010
>> אז תן לי ללכת קדימה ו
להפוך את רשת עצבית.

876
00:52:15,010 --> 00:52:18,620
אז זה ממש נחמד
כי אני יכול רק לומר nnet

877
00:52:18,620 --> 00:52:21,767
ואז אני רגרסיה י '
אז Y הוא טור ש.

878
00:52:21,767 --> 00:52:23,850
ולאחר מכן נסוג אותו על
שני משתנים האחרים.

879
00:52:23,850 --> 00:52:27,360
אז זה קצר יותר
סימון לX1 וX2.

880
00:52:27,360 --> 00:52:29,741
>> אז בואו נלך קדימה ולהפעיל את זה.

881
00:52:29,741 --> 00:52:30,240
אה, סליחה.

882
00:52:30,240 --> 00:52:32,260
אני צריך להפעיל את כל הדבר הזה.

883
00:52:32,260 --> 00:52:37,500
וזו רק הדפסת סימון
לאיזו מהירות או לא במהירות זה

884
00:52:37,500 --> 00:52:38,460
התכנס.

885
00:52:38,460 --> 00:52:41,420
כך זה נראה כאילו זה לא להתכנס.

886
00:52:41,420 --> 00:52:44,970
אז תן לי ללכת קדימה והדפסה
מה זה נראה כמו.

887
00:52:44,970 --> 00:52:51,260
>> ראה הנה התמונה והנה היא
קווי המתאר מראה כמה טוב זה מתאים.

888
00:52:51,260 --> 00:52:56,380
וזה פשוט- אתה יכול לראות
זה שזה מאוד, מאוד נחמד.

889
00:52:56,380 --> 00:52:59,400
זה אפילו יכול להיות
overfitting, אבל אתה יכול גם

890
00:52:59,400 --> 00:53:03,390
דין וחשבון על זה עם אחרים
טכניקות כמו אימות צולבת.

891
00:53:03,390 --> 00:53:06,180
ואלה גם בנויים לתוך ר '

892
00:53:06,180 --> 00:53:09,170
>> ותן לי רק להראות לך
לתמוך במכונת וקטור.

893
00:53:09,170 --> 00:53:12,470
זהו עוד ממש נפוץ
טכניקה בלמידת מכונה.

894
00:53:12,470 --> 00:53:18,550
זה מאוד דומה למודלים ליניאריים, אבל
הוא משתמש במה שנקרא שיטת ליבה.

895
00:53:18,550 --> 00:53:22,790
ובואו נראה כמה טוב שעושה.

896
00:53:22,790 --> 00:53:26,430
אז זה אחד הוא דומה מאוד לאופן שבי
גם רשת עצבית מבצעת,

897
00:53:26,430 --> 00:53:27,900
אבל זה הרבה יותר חלק.

898
00:53:27,900 --> 00:53:35,740
וזה מבוסס על הנחה
של what-- איך עבודת SVMs.

899
00:53:35,740 --> 00:53:40,250
>> אז זה פשוט מאוד
סקירה מהירה של כמה

900
00:53:40,250 --> 00:53:43,822
של הפונקציות המובנות שאתה יכול לעשות
וגם חלק מחקר נתונים.

901
00:53:43,822 --> 00:53:45,905
אז תן לי רק קדימה
ונחזור לשקופיות.

902
00:53:45,905 --> 00:53:50,290

903
00:53:50,290 --> 00:53:53,670
>> אז ברור, זה הוא
לא מאוד מקיף.

904
00:53:53,670 --> 00:53:57,140
וזה באמת רק טיזר
מראה לך את מה שאתה באמת יכול לעשות בר '

905
00:53:57,140 --> 00:53:59,100
אז אם אתה הייתי בדיוק כמו
כדי ללמוד עוד, כאן

906
00:53:59,100 --> 00:54:01,210
חבורה של משאבים שונים.

907
00:54:01,210 --> 00:54:06,890
>> אז אם אתה אוהב ספרי לימוד או שאתה
פשוט אוהב לקרוא דברים באינטרנט,

908
00:54:06,890 --> 00:54:09,670
אז זה פנטסטי
אחד על ידי האדלי Wickham,

909
00:54:09,670 --> 00:54:13,010
כל אלה שגם יצרו
חבילות ממש מגניבים.

910
00:54:13,010 --> 00:54:17,420
אם אתה אוהב את קטעי וידאו, ולאחר מכן
יש ברקלי טירונות מדהימה

911
00:54:17,420 --> 00:54:21,060
זה several-- זה סוג של ארוך.

912
00:54:21,060 --> 00:54:24,210
והוא ילמד אותך כמעט
כל מה שאתה רוצה לדעת על ר '

913
00:54:24,210 --> 00:54:27,770
>> ובאופן דומה, יש Codeacademy
וכל סוג אחר אלה

914
00:54:27,770 --> 00:54:29,414
אתרים של אינטראקטיביים.

915
00:54:29,414 --> 00:54:31,580
הם גם מקבלים
common-- יותר ויותר נפוץ.

916
00:54:31,580 --> 00:54:33,749
אז זה מאוד דומה לCodeacademy.

917
00:54:33,749 --> 00:54:35,790
ולבסוף, אם אתה רק
רוצה קהילה ולעזור,

918
00:54:35,790 --> 00:54:38,800
אלה הם חבורה של
דברים שאתה יכול ללכת ל.

919
00:54:38,800 --> 00:54:40,880
כמובן, אנחנו עדיין
להשתמש ברשימות דיוור, רק

920
00:54:40,880 --> 00:54:44,860
כמו כמעט בכל אחר
קהילת שפת תכנות.

921
00:54:44,860 --> 00:54:47,880
ו#rstats, זה הוא
הקהילה שלנו בטוויטר.

922
00:54:47,880 --> 00:54:49,580
זה למעשה די נפוץ.

923
00:54:49,580 --> 00:54:50,850
ולאחר מכן משתמש!

924
00:54:50,850 --> 00:54:52,340
האם רק הכנס שלנו.

925
00:54:52,340 --> 00:54:55,390
>> ואז, כמובן, שאתה יכול
להשתמש בכל אלה הדברים Q & A אחרים,

926
00:54:55,390 --> 00:54:57,680
כמו הצפת מחסנית,
Google, ולאחר מכן GitHub.

927
00:54:57,680 --> 00:55:00,490
כיוון שרוב החבילות אלה
והרבה הקהילה

928
00:55:00,490 --> 00:55:03,420
יהיה מרוכז סביב פיתוח
קוד כי זה קוד פתוח.

929
00:55:03,420 --> 00:55:05,856
וזה פשוט ממש נחמד על GitHub.

930
00:55:05,856 --> 00:55:08,730
ולבסוף, אתה יכול לפנות אליי אם
רק יש לך שאלות מהירות.

931
00:55:08,730 --> 00:55:13,530
אז אתה יכול למצוא אותי בטוויטר כאן,
אתר האינטרנט שלי, ורק הדוא"ל שלי.

932
00:55:13,530 --> 00:55:17,840
אז אני מקווה, שהיה
something-- רק טיזר קצר

933
00:55:17,840 --> 00:55:20,900
ממה שR הוא ממש מסוגל לעשות.

934
00:55:20,900 --> 00:55:23,990
ואני מקווה, שאתה פשוט
לבדוק את שלושת הקישורים הללו

935
00:55:23,990 --> 00:55:25,760
ותראה מה אתה יכול לעשות יותר.

936
00:55:25,760 --> 00:55:28,130
ואני מניח שזה רק על זה.

937
00:55:28,130 --> 00:55:28,630
תודה.

938
00:55:28,630 --> 00:55:30,780
>> [מחיאות כפות]

939
00:55:30,780 --> 00:55:31,968