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

2
00:00:00,750 --> 00:00:09,800
>> [Música tocando]

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

4
00:00:13,014 --> 00:00:13,680
DUSTIN TRAN: Hi.

5
00:00:13,680 --> 00:00:14,980
Dustin do meu nome.

6
00:00:14,980 --> 00:00:18,419
Então, eu vou estar apresentando
Análise de dados em R.

7
00:00:18,419 --> 00:00:19,710
Apenas um pouco sobre mim mesmo.

8
00:00:19,710 --> 00:00:24,320
Eu sou atualmente um estudante de pós-graduação em
as Ciências da Engenharia e aplicada.

9
00:00:24,320 --> 00:00:28,330
Eu estudo um cruzamento de
aprendizado de máquina e estatísticas

10
00:00:28,330 --> 00:00:31,375
Análise de dados de modo em que R é
realmente fundamental para o

11
00:00:31,375 --> 00:00:33,790
Eu faço em uma base diária.

12
00:00:33,790 --> 00:00:35,710
>> E R é especialmente
bom para a análise de dados

13
00:00:35,710 --> 00:00:39,310
porque é muito bom para prototipagem.

14
00:00:39,310 --> 00:00:43,590
E, normalmente, quando você está fazendo algum tipo
de análise de dados, um monte de problemas

15
00:00:43,590 --> 00:00:44,920
vão cognitiva.

16
00:00:44,920 --> 00:00:48,700
E assim, você só quer ter
alguns realmente boa linguagem que

17
00:00:48,700 --> 00:00:53,770
é apenas bom para fazer
built-in funções, em oposição

18
00:00:53,770 --> 00:00:57,430
a ter de lidar com as coisas de baixo nível.

19
00:00:57,430 --> 00:01:01,040
Então, no início, eu só vou
para introduzir o que é de R, por que

20
00:01:01,040 --> 00:01:04,540
você quiser usá-lo, e
em seguida, passar por cima em algum demo,

21
00:01:04,540 --> 00:01:07,060
e apenas ir a partir daí.

22
00:01:07,060 --> 00:01:08,150
>> Então, o que é de R?

23
00:01:08,150 --> 00:01:11,180
R é apenas uma linguagem desenvolvida
para computação estatística

24
00:01:11,180 --> 00:01:12,450
e visualização.

25
00:01:12,450 --> 00:01:16,000
Então, o que isto significa é que
é uma muito excelente língua

26
00:01:16,000 --> 00:01:22,400
para todo o tipo de coisa que lida com
incerteza ou visualização de dados.

27
00:01:22,400 --> 00:01:24,850
Então você tem tudo isso
distribuições de probabilidade.

28
00:01:24,850 --> 00:01:27,140
Não vão ser
built-in funções.

29
00:01:27,140 --> 00:01:31,650
Você também terá excelente
plotagem pacotes.

30
00:01:31,650 --> 00:01:34,110
>> Python é outro concorrente
idioma para dados.

31
00:01:34,110 --> 00:01:40,020
E uma coisa que eu acho que R
é muito melhor a é a visualização.

32
00:01:40,020 --> 00:01:45,200
Então, o que você vai ver na demo como
bem é apenas uma linguagem muito intuitiva

33
00:01:45,200 --> 00:01:48,050
que simplesmente funciona muito bem.

34
00:01:48,050 --> 00:01:53,140
Também é livre e de código aberto, como
é outra boa linguagem, eu acho.

35
00:01:53,140 --> 00:01:55,440
>> E aqui, um monte de apenas
palavras-chave jogado em você.

36
00:01:55,440 --> 00:02:00,450
É dinâmico, ou seja, se você tem um
tipo específico atribuído a um objeto

37
00:02:00,450 --> 00:02:02,025
que ele só vai mudá-lo on the fly.

38
00:02:02,025 --> 00:02:05,670
É preguiçoso, por isso é inteligente sobre
como o faz cálculos.

39
00:02:05,670 --> 00:02:12,250
Funcional que significa que pode realmente funcionar
baseado fora de funções tão anything--

40
00:02:12,250 --> 00:02:16,910
qualquer tipo de manipulação que você é
fazendo, ele será baseado funções.

41
00:02:16,910 --> 00:02:20,162
>> Assim, os operadores binários, por exemplo,
são funções apenas inerentemente.

42
00:02:20,162 --> 00:02:21,870
E tudo o que
você vai fazer é

43
00:02:21,870 --> 00:02:24,690
vai ser correr em si funções.

44
00:02:24,690 --> 00:02:27,140
E então orientada a objetos também.

45
00:02:27,140 --> 00:02:30,930
>> Então aqui está uma trama XKCD.

46
00:02:30,930 --> 00:02:34,350
Não só porque eu sinto que
XKCD é fundamental para qualquer tipo

47
00:02:34,350 --> 00:02:37,770
de apresentação, mas porque
Eu sinto que isso realmente

48
00:02:37,770 --> 00:02:42,160
martela o ponto em que uma grande parte do
momento em que você está fazendo algum tipo de dados

49
00:02:42,160 --> 00:02:46,570
análise, o problema não está
tanto o quão rápido ele é executado,

50
00:02:46,570 --> 00:02:49,850
mas quanto tempo isso vai
levá-lo para programar a tarefa.

51
00:02:49,850 --> 00:02:54,112
Então, aqui é apenas analisar se
estratégia a ou b é mais eficiente.

52
00:02:54,112 --> 00:02:55,820
Este vai ser
algo que você é

53
00:02:55,820 --> 00:02:58,290
vai lidar muito com em
tipo de linguagens de baixo nível

54
00:02:58,290 --> 00:03:03,440
onde você está lidando com falhas seg,
alocação de memória, initializations,

55
00:03:03,440 --> 00:03:05,270
mesmo fazendo as funções embutidas.

56
00:03:05,270 --> 00:03:09,920
E este material está tudo tratado
muito, muito elegantemente em R.

57
00:03:09,920 --> 00:03:12,839
>> Então, só para martelar este
ponto, o maior gargalo

58
00:03:12,839 --> 00:03:13,880
vai ser cognitivo.

59
00:03:13,880 --> 00:03:17,341
Assim, a análise de dados é um problema muito difícil.

60
00:03:17,341 --> 00:03:19,340
Se você está fazendo
aprendizado de máquina ou se você estiver

61
00:03:19,340 --> 00:03:22,550
fazendo apenas algum tipo de
exploração de dados de base,

62
00:03:22,550 --> 00:03:25,290
você não quer ter
para levar um documento

63
00:03:25,290 --> 00:03:27,440
e depois compilar
algo cada vez que você

64
00:03:27,440 --> 00:03:31,010
quero ver o que a coluna parece,
o que em particular entradas em uma matriz

65
00:03:31,010 --> 00:03:32,195
parece.

66
00:03:32,195 --> 00:03:34,320
Então você só quer ter
alguma interface muito legal

67
00:03:34,320 --> 00:03:37,740
você pode executar uma função simples
que os índices para o que quer que

68
00:03:37,740 --> 00:03:41,870
você gostaria e basta executá-lo de lá.

69
00:03:41,870 --> 00:03:44,190
E você precisa de domínio
linguagens específicas para isso.

70
00:03:44,190 --> 00:03:51,750
E R realmente vai ajudá-lo a definir o
problema e resolvê-lo deste modo.

71
00:03:51,750 --> 00:03:58,690
>> Então aqui vai uma que mostra a programação enredo
popularidade de R como ele foi embora com o tempo.

72
00:03:58,690 --> 00:04:04,060
Então, como você pode ver, como 2013 ou
por isso só explodido tremendamente.

73
00:04:04,060 --> 00:04:09,570
E isso tem sido só por causa disso
grande tendência na indústria de tecnologia

74
00:04:09,570 --> 00:04:10,590
sobre big data.

75
00:04:10,590 --> 00:04:13,010
Além disso, não apenas a tecnologia
indústria, mas realmente

76
00:04:13,010 --> 00:04:16,490
qualquer isso-- indústria, porque
muitas das indústrias

77
00:04:16,490 --> 00:04:20,589
são uma espécie de fundamental
para tentar resolver estes problemas.

78
00:04:20,589 --> 00:04:24,590
E, normalmente, você pode ter algum bom
forma de medir esses problemas

79
00:04:24,590 --> 00:04:29,720
ou até mesmo defini-los ou
resolvê-los usando dados.

80
00:04:29,720 --> 00:04:35,430
Então, eu acho que agora é o 11º R
língua mais popular na TIOBE

81
00:04:35,430 --> 00:04:38,200
e tem sido crescente desde então.

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

83
00:04:40,740 --> 00:04:43,080
>> Então, aqui está um pouco mais
características de R. Tem

84
00:04:43,080 --> 00:04:46,900
um enorme número de pacotes e
por todas estas coisas diferentes.

85
00:04:46,900 --> 00:04:52,470
Então, quando você tem um
determinado problema, a maioria

86
00:04:52,470 --> 00:04:55,060
o tempo de R terá
essa função para você.

87
00:04:55,060 --> 00:04:58,520
Então, se você quiser
construir algum tipo de máquina

88
00:04:58,520 --> 00:05:02,770
algoritmo de aprendizado chamado
Aleatória Floresta ou Árvores de Decisão,

89
00:05:02,770 --> 00:05:07,530
ou mesmo tentando tirar a média de
uma função ou algum deste material,

90
00:05:07,530 --> 00:05:10,000
R vai ter isso.

91
00:05:10,000 --> 00:05:14,190
>> E se você fizer você se preocupa com
otimização, uma coisa que é comum

92
00:05:14,190 --> 00:05:17,430
é que depois que você fez prototipagem
algum tipo de linguagem de alto nível,

93
00:05:17,430 --> 00:05:19,810
você vai jogar esse em--
Você só vai porto que mais de

94
00:05:19,810 --> 00:05:21,550
a alguma linguagem de baixo nível.

95
00:05:21,550 --> 00:05:26,090
O que é bom sobre R é que uma vez que você é
prototipagem feito isso, você pode executar C ++,

96
00:05:26,090 --> 00:05:29,510
ou Fortran, ou qualquer um desses
os de nível mais baixo diretamente na R.

97
00:05:29,510 --> 00:05:32,320
Então essa é uma verdade
recurso interessante sobre R,

98
00:05:32,320 --> 00:05:35,930
se você realmente se preocupam com
o ponto de otimização.

99
00:05:35,930 --> 00:05:39,490
>> E isso também é muito bom
para visualizações na web.

100
00:05:39,490 --> 00:05:43,530
Assim D3.js, por exemplo, é
Eu acho que um outro seminário

101
00:05:43,530 --> 00:05:45,130
que apresentamos hoje.

102
00:05:45,130 --> 00:05:48,510
E isso é realmente impressionante para
fazendo visualizações interativas.

103
00:05:48,510 --> 00:05:54,460
E D3.js pressupõe que você tenha
algum tipo de dados a ser plotados

104
00:05:54,460 --> 00:05:58,080
e R é uma ótima maneira de ser capaz de fazer
a análise dos dados antes de exportá-lo

105
00:05:58,080 --> 00:06:04,220
sobre a D3.js ou mesmo apenas correr
Comandos D3.js em si mesmo R,

106
00:06:04,220 --> 00:06:08,240
bem como todos estes
outras bibliotecas bem.

107
00:06:08,240 --> 00:06:13,041
>> Então essa foi apenas a introdução de
o que é R e por que você pode usá-lo.

108
00:06:13,041 --> 00:06:14,790
Portanto, esperamos que, eu tenho
Você está convencido algo

109
00:06:14,790 --> 00:06:18,460
sobre apenas tentando ver o que é.

110
00:06:18,460 --> 00:06:23,930
Então, eu estou indo para ir em frente e passar por
alguns fundamentos sobre os objetos R

111
00:06:23,930 --> 00:06:26,150
eo que você pode realmente fazer.

112
00:06:26,150 --> 00:06:29,690
>> Então, aqui é apenas um
bando de comandos de matemática.

113
00:06:29,690 --> 00:06:35,000
Então diga you're-- você quer construir
mesmo idioma e você só quer

114
00:06:35,000 --> 00:06:38,080
para ter um monte de ferramentas diferentes.

115
00:06:38,080 --> 00:06:42,520
Qualquer tipo de operação você acha que
quero é praticamente vai estar em R.

116
00:06:42,520 --> 00:06:44,150
>> Então aqui é 2 mais 2.

117
00:06:44,150 --> 00:06:46,090
Aqui é 2 vezes pi.

118
00:06:46,090 --> 00:06:51,870
R tem um monte de constantes internas
que você vai usar com freqüência como pi, e.

119
00:06:51,870 --> 00:06:56,230
>> E então, aqui está 7 mais
runif, assim runif de 1.

120
00:06:56,230 --> 00:07:02,450
Esta é uma função que é gera
um uniforme aleatória de 0 a 1.

121
00:07:02,450 --> 00:07:04,400
E depois há a 3 para o poder do 4.

122
00:07:04,400 --> 00:07:06,430
Há raízes quadradas.

123
00:07:06,430 --> 00:07:07,270
>> Há log.

124
00:07:07,270 --> 00:07:14,500
Então log vai fazer de base
exponencial por si só.

125
00:07:14,500 --> 00:07:18,337
E então, se você especificar uma base, em seguida,
você pode fazer o que você quer de base.

126
00:07:18,337 --> 00:07:19,920
E então aqui estão alguns outros comandos.

127
00:07:19,920 --> 00:07:22,180
Então você tem 23 mod 2.

128
00:07:22,180 --> 00:07:24,910
Então você tem o restante.

129
00:07:24,910 --> 00:07:27,110
Então você tem científica
notação se você também

130
00:07:27,110 --> 00:07:34,060
quero fazer apenas mais e
coisas mais complicadas.

131
00:07:34,060 --> 00:07:37,320
>> Então aqui está a atribuição.

132
00:07:37,320 --> 00:07:40,830
Então atribuições típicas em
R é feito com uma seta

133
00:07:40,830 --> 00:07:43,440
por isso é menos do que e, em seguida, o hífen.

134
00:07:43,440 --> 00:07:47,250
Então aqui eu só estou atribuindo
3 para o val variável.

135
00:07:47,250 --> 00:07:50,160
>> E então eu estou imprimindo val
e então ela mostra três.

136
00:07:50,160 --> 00:07:53,920
Por padrão em R intérprete, ele
irá imprimir as coisas para você

137
00:07:53,920 --> 00:07:57,280
assim você não tem que especificar imprimir um val
qualquer momento que você quiser imprimir algo.

138
00:07:57,280 --> 00:08:00,200
Você pode apenas fazer val e
em seguida, ele vai fazer isso por você.

139
00:08:00,200 --> 00:08:04,380
>> Além disso, você pode usar tecnicamente iguais
como um operador de atribuição.

140
00:08:04,380 --> 00:08:07,190
Há pequenas sutilezas
entre usar a seta

141
00:08:07,190 --> 00:08:10,730
operador e os iguais
operador de atribuições.

142
00:08:10,730 --> 00:08:15,470
Principalmente por convenção, todos
só vai usar o operador seta.

143
00:08:15,470 --> 00:08:21,850
>> E aqui, eu estou atribuindo este
notação oblíqua chamado 1 cólon 6.

144
00:08:21,850 --> 00:08:26,010
Isto gera um vector de 1 a 6.

145
00:08:26,010 --> 00:08:29,350
E isso muito bom porque, em seguida,
você acabou de atribuir o vector para val

146
00:08:29,350 --> 00:08:34,270
e que funciona por si só.

147
00:08:34,270 --> 00:08:37,799
>> Então, isso já está acontecendo a partir de um
single-- um dado muito intuitivo

148
00:08:37,799 --> 00:08:41,070
estrutura de apenas um casal de
algum tipo de tipo em um vetor

149
00:08:41,070 --> 00:08:45,670
e que irá recolher todos
os valores escalares para você.

150
00:08:45,670 --> 00:08:50,770
Então, depois de passar de escalar, você
ter objectos R e este é um vector.

151
00:08:50,770 --> 00:08:55,610
Um vetor é qualquer tipo de
recolha do mesmo tipo.

152
00:08:55,610 --> 00:08:58,150
Então, aqui estão um monte de vetores.

153
00:08:58,150 --> 00:08:59,800
>> Portanto, este é numérico.

154
00:08:59,800 --> 00:09:02,440
Numérico é o caminho de R de dizer dupla.

155
00:09:02,440 --> 00:09:07,390
E assim, por padrão, qualquer
número será um duplo.

156
00:09:07,390 --> 00:09:13,150
>> Então se você tem c de 1,1, 3,
negativa de 5,7, o c é uma função.

157
00:09:13,150 --> 00:09:16,760
Este encadeia os três
números num vector.

158
00:09:16,760 --> 00:09:19,619
E isso vai ser-- então se
você notar 3, por si só,

159
00:09:19,619 --> 00:09:21,910
normalmente você assumiria
que isso é como um número inteiro,

160
00:09:21,910 --> 00:09:25,050
mas porque todos os vectores
são do mesmo tipo,

161
00:09:25,050 --> 00:09:28,660
Este é um vetor de duplas
ou numérica neste caso.

162
00:09:28,660 --> 00:09:34,920
>> rnorm é uma função que gera
variables-- normal padrão

163
00:09:34,920 --> 00:09:36,700
ou valores normal padrão.

164
00:09:36,700 --> 00:09:38,360
E eu estou especificando dois deles.

165
00:09:38,360 --> 00:09:43,840
Então, eu estou fazendo rnorm 2, atribuindo isso a
devs, e então eu estou imprimindo devs.

166
00:09:43,840 --> 00:09:47,350
Então, esses são apenas dois
valores normais aleatórios.

167
00:09:47,350 --> 00:09:50,060
>> E então se você fizer INTS
você se preocupa com números inteiros.

168
00:09:50,060 --> 00:09:54,650
Portanto, esta é apenas sobre a memória
alocação e salvar o tamanho da memória.

169
00:09:54,650 --> 00:10:01,460
Então você teria que acrescentar
seus números pelo capital L.

170
00:10:01,460 --> 00:10:04,170
>> Em geral, este é
Notação histórico de R

171
00:10:04,170 --> 00:10:06,940
para algo chamado inteiro longo.

172
00:10:06,940 --> 00:10:09,880
Assim, a maior parte do tempo, você vai
estar lidando com duplos.

173
00:10:09,880 --> 00:10:15,180
E se você nunca será mais tarde
em otimizar seu código,

174
00:10:15,180 --> 00:10:18,110
você pode simplesmente adicionar estes L's
depois ou durante a mesma

175
00:10:18,110 --> 00:10:22,280
se você é como premonitório sobre o que
você vai fazer essas variáveis.

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

177
00:10:25,340 --> 00:10:26,890
>> Então, aqui é um vetor de caracteres.

178
00:10:26,890 --> 00:10:31,440
Então, novamente, eu estou concatenando
três cordas desta vez.

179
00:10:31,440 --> 00:10:36,230
Observe que cordas duplas e
cordas simples são as mesmas em R.

180
00:10:36,230 --> 00:10:41,000
Então, eu tenho arthur e Marvin e assim
quando estou imprimi-los, todos eles

181
00:10:41,000 --> 00:10:43,210
vão mostrar cordas duplas.

182
00:10:43,210 --> 00:10:45,880
E se você também quer incluir
a seqüência de casal ou solteiro

183
00:10:45,880 --> 00:10:50,070
em seus personagens, então você pode
ou alternar suas cordas.

184
00:10:50,070 --> 00:10:53,540
>> Então Marvin para o
segundo elemento, este é

185
00:10:53,540 --> 00:10:56,380
vai show-- você
só tem cordas duplas

186
00:10:56,380 --> 00:10:59,050
e, em seguida, uma única seqüência
de modo que este é alternada.

187
00:10:59,050 --> 00:11:04,040
Caso contrário, se você quiser usar um duplo
operador de cadeia em um cordão duplo

188
00:11:04,040 --> 00:11:07,090
quando você está declarando-o, em seguida,
basta usar o operador de escape.

189
00:11:07,090 --> 00:11:10,600
Então você faz a dupla cadeia barra invertida.

190
00:11:10,600 --> 00:11:13,330
>> E, finalmente, nós também
ter vectores lógicos.

191
00:11:13,330 --> 00:11:15,890
Então logical-- tão verdadeiro
e FALSE, e eles são

192
00:11:15,890 --> 00:11:18,880
vai ser todas as letras maiúsculas.

193
00:11:18,880 --> 00:11:22,370
E então, mais uma vez, eu estou concatenando
-los e, em seguida, atribuindo-lhes a bools.

194
00:11:22,370 --> 00:11:24,590
Então bools vai mostrar
você TRUE, FALSE e TRUE.

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

196
00:11:28,280 --> 00:11:31,620
>> Então aqui está a indexação vectorized.

197
00:11:31,620 --> 00:11:34,870
Assim, no início, eu
estou tomando um function--

198
00:11:34,870 --> 00:11:39,230
isso é chamado de sequence--
sequência de 2 a 12.

199
00:11:39,230 --> 00:11:42,490
E eu estou tendo uma sequência por 2.

200
00:11:42,490 --> 00:11:46,660
Por isso, vai fazer
2, 4, 6, 8, 10 e 12.

201
00:11:46,660 --> 00:11:50,080
E então, eu sou a indexação
para obter o terceiro elemento.

202
00:11:50,080 --> 00:11:55,770
>> Então, uma coisa a ter em mente é
de que R índices a partir de 1.

203
00:11:55,770 --> 00:12:00,550
Então vals 3 vai dar
você o terceiro elemento.

204
00:12:00,550 --> 00:12:04,580
Este é tipo de diferente de outros
línguas em que começa do zero.

205
00:12:04,580 --> 00:12:09,780
Assim, em C ou C ++, por exemplo, você está
indo para obter o quarto elemento.

206
00:12:09,780 --> 00:12:13,280
>> E aqui está vals 3-5.

207
00:12:13,280 --> 00:12:16,030
Então, uma coisa que é
muito legal é que você

208
00:12:16,030 --> 00:12:20,410
pode gerar variáveis ​​temporárias dentro
e depois é só usá-los em tempo real.

209
00:12:20,410 --> 00:12:21,960
Então aqui está 3-5.

210
00:12:21,960 --> 00:12:25,070
Então, eu estou gerando um vector
3, 4, e 5 e, em seguida

211
00:12:25,070 --> 00:12:29,700
Estou indexação para obter o terceiro,
quarto e quinto elementos.

212
00:12:29,700 --> 00:12:32,280
>> Então, da mesma forma, você pode
Resumo Este apenas fazer

213
00:12:32,280 --> 00:12:35,280
qualquer tipo de um vector
que lhe dá a indexação.

214
00:12:35,280 --> 00:12:40,050
Então aqui está vals e depois o
primeiro, terceiro e sexto elementos.

215
00:12:40,050 --> 00:12:42,800
E então, se você quiser
para fazer um complemento,

216
00:12:42,800 --> 00:12:45,210
então você apenas fazer o menos
depois e que vai

217
00:12:45,210 --> 00:12:48,600
dar-lhe tudo o que não é o
primeiro, terceiro, sexto ou elemento.

218
00:12:48,600 --> 00:12:51,590
Portanto, este será de 4, 8 e 10.

219
00:12:51,590 --> 00:12:54,380
>> E se você quiser começar
ainda mais avançado,

220
00:12:54,380 --> 00:12:57,610
você pode concatenar vectores booleanas.

221
00:12:57,610 --> 00:13:05,210
Portanto, este índice está indo dar-lhe
este vetor booleano de comprimento 6.

222
00:13:05,210 --> 00:13:07,280
Então rep VERDADEIRO vírgula 3.

223
00:13:07,280 --> 00:13:09,680
Isto irá repetir VERDADEIROS três vezes.

224
00:13:09,680 --> 00:13:12,900
Então, isso vai dar-lhe uma
vector TRUE, TRUE, TRUE.

225
00:13:12,900 --> 00:13:17,470
>> rep FALSE 4-- isso vai dar-lhe
um vetor de FALSE, FALSE, FALSE, FALSE.

226
00:13:17,470 --> 00:13:21,280
E, em seguida, c vai concatenar
esses dois Booleans juntos.

227
00:13:21,280 --> 00:13:24,090
Então, você está indo para obter três
TRUEs e, em seguida, quatro FALSEs.

228
00:13:24,090 --> 00:13:28,460
>> De modo que quando você vals índice, você é
indo para obter a verdade, verdade, TRUE.

229
00:13:28,460 --> 00:13:31,420
Então, isso vai dizer que sim,
Quero esses três elementos.

230
00:13:31,420 --> 00:13:33,520
E então FALSE, FALSE,
FALSE, FALSE vai

231
00:13:33,520 --> 00:13:37,140
dizer não, eu não quero que esses elementos
por isso não vai devolvê-los.

232
00:13:37,140 --> 00:13:41,490
>> E eu acho que não há, na verdade, um erro de digitação aqui
porque este está dizendo repeat VERDADEIRO 3

233
00:13:41,490 --> 00:13:47,990
e repetir FALSE 4, e tecnicamente, você
só tem seis elementos para repetir FALSE,

234
00:13:47,990 --> 00:13:50,470
ele deve ser repeat FALSE 3.

235
00:13:50,470 --> 00:13:55,260
Eu acho que R também é inteligente o suficiente, tais
que, se você especificar apenas 4 aqui, então

236
00:13:55,260 --> 00:13:56,630
ele não vai mesmo erro fora.

237
00:13:56,630 --> 00:13:58,480
Ele vai apenas dar-lhe esse valor.

238
00:13:58,480 --> 00:14:00,970
Então, ele vai simplesmente ignorar essa quarta FALSE.

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

240
00:14:05,310 --> 00:14:09,270
>> Então aqui está a atribuição vectorized.

241
00:14:09,270 --> 00:14:15,480
Então set.seed-- isso só define o
semente para números pseudo-aleatórios.

242
00:14:15,480 --> 00:14:20,110
Então, eu estou definindo a semente
42, o que significa que se eu gerar

243
00:14:20,110 --> 00:14:22,950
três aleatória normal
valores e, em seguida, se você

244
00:14:22,950 --> 00:14:27,400
executar set.seed em seu próprio país
computador usando o mesmo valor 42,

245
00:14:27,400 --> 00:14:30,990
em seguida, você também terá a
mesmos três normais aleatórias.

246
00:14:30,990 --> 00:14:33,411
>> Então, isso é muito bom
para a reprodutibilidade.

247
00:14:33,411 --> 00:14:35,910
Normalmente, quando você está fazendo alguma
tipo de análise científica,

248
00:14:35,910 --> 00:14:37,230
você gostaria de definir a semente.

249
00:14:37,230 --> 00:14:41,270
Dessa forma, outros cientistas pode apenas
reproduzir exatamente o mesmo código que você tem

250
00:14:41,270 --> 00:14:44,790
feito porque eles terão a exata
mesmas variáveis ​​aleatórias isso-- ou aleatório

251
00:14:44,790 --> 00:14:47,270
valores que você tirou para fora também.

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

253
00:14:49,870 --> 00:14:53,910
>> E assim a atribuição vectorized
aqui está mostrando os vals 1-2.

254
00:14:53,910 --> 00:14:59,290
Por isso, leva os dois primeiros elementos
de vals e atribui-los a 0.

255
00:14:59,290 --> 00:15:03,940
E então, você também pode simplesmente fazer o
coisa semelhante com os Booleans.

256
00:15:03,940 --> 00:15:09,340
>> Então vals não é igual a 0-- esta vontade
dar-lhe uma falsa vector, FALSE, TRUE

257
00:15:09,340 --> 00:15:10,350
neste caso.

258
00:15:10,350 --> 00:15:13,770
E, em seguida, ele vai dizer qualquer
desses índices isso fosse verdade,

259
00:15:13,770 --> 00:15:15,270
em seguida, ele vai atribuir essa a 5.

260
00:15:15,270 --> 00:15:18,790
Por isso, leva o terceiro elemento
aqui e, em seguida, atribui a ele a 5.

261
00:15:18,790 --> 00:15:22,300
>> E isso é muito bom
em comparação com linguagens de baixo nível

262
00:15:22,300 --> 00:15:25,560
onde você tem que usar para loops
para fazer todas essas coisas vectorized

263
00:15:25,560 --> 00:15:30,281
porque é apenas muito intuitivo
e é uma única one-liner.

264
00:15:30,281 --> 00:15:32,030
E o que é grande sobre
notação vectorized

265
00:15:32,030 --> 00:15:37,020
é que no R, estes são uma espécie de
built-in de modo que eles são quase tão rápido

266
00:15:37,020 --> 00:15:42,490
como fazer em uma linguagem de baixo nível como
oposição a fazer um loop em R

267
00:15:42,490 --> 00:15:46,317
e depois ter que fazer
o próprio indexação dinâmica.

268
00:15:46,317 --> 00:15:48,900
E isso vai ser mais lento que fazer
esse tipo de coisa vectorized

269
00:15:48,900 --> 00:15:55,950
onde ele pode fazê-lo em paralelo, onde
é fazê-lo em enfiar basicamente.

270
00:15:55,950 --> 00:15:58,650
>> Então, aqui está vetorizado operações.

271
00:15:58,650 --> 00:16:04,920
Então, eu estou gerando um valor de 1 a 3,
atribuindo que a vec1, 3 a 5, vec2,

272
00:16:04,920 --> 00:16:05,950
adicionando-os juntos.

273
00:16:05,950 --> 00:16:11,490
Acrescenta-los em componentes tão sábio
é 1 + 3, 2 + 4, e assim por diante.

274
00:16:11,490 --> 00:16:13,330
>> vec1 vezes vec2.

275
00:16:13,330 --> 00:16:16,110
Este multiplica os dois
valoriza a componente sábio.

276
00:16:16,110 --> 00:16:21,830
Portanto, é um vezes 3, 2 vezes
4, e depois 3 vezes 5.

277
00:16:21,830 --> 00:16:28,250
>> E, em seguida, da mesma forma que você pode também fazer
comparisons-- comparações lógicas.

278
00:16:28,250 --> 00:16:33,640
Então é FALSE FALSE verdade neste
caso porque 1 não é maior do que 3,

279
00:16:33,640 --> 00:16:35,920
2 não é superior a 4.

280
00:16:35,920 --> 00:16:41,160
Isto é, eu acho, um outro erro de digitação, 3
definitivamente não é superior a 5.

281
00:16:41,160 --> 00:16:41,660
Sim.

282
00:16:41,660 --> 00:16:45,770
E assim você pode simplesmente fazer tudo
estas operações simples

283
00:16:45,770 --> 00:16:48,350
porque a sua herdado
a partir das próprias classes.

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

285
00:16:51,110 --> 00:16:52,580
>> Então, isso foi apenas o vetor.

286
00:16:52,580 --> 00:16:56,530
E isso é uma espécie de mais fundamental
R objecto porque dado um vector,

287
00:16:56,530 --> 00:16:59,170
você pode construir objetos mais avançados.

288
00:16:59,170 --> 00:17:00,560
>> Então aqui está uma matriz.

289
00:17:00,560 --> 00:17:05,030
Esta é essencialmente a abstração
de que é uma matriz em si.

290
00:17:05,030 --> 00:17:10,099
Portanto, neste caso, é de três diferentes
vetores, onde cada um é uma coluna,

291
00:17:10,099 --> 00:17:12,710
ou você pode considerá-lo
como cada um é uma linha.

292
00:17:12,710 --> 00:17:18,250
>> Então, eu estou armazenando uma matriz de 1 a
9 e, em seguida, eu estou especificando três linhas.

293
00:17:18,250 --> 00:17:23,364
Então 1-9 lhe dará um vector 1,
2, 3, 4, 5, 6, e todo o caminho até 9.

294
00:17:23,364 --> 00:17:29,250
>> Um aspecto a ter também em mente é que
R armazena valores em formato de coluna-major.

295
00:17:29,250 --> 00:17:34,160
Portanto, em outras palavras, quando você vê um
a 9, que vai armazenar eles--

296
00:17:34,160 --> 00:17:36,370
que vai ser 1, 2,
3, na primeira coluna,

297
00:17:36,370 --> 00:17:38,510
e, em seguida, ele vai fazer 4, 5,
6 na segunda coluna,

298
00:17:38,510 --> 00:17:41,440
e, em seguida, 7, 8, 9, na terceira coluna.

299
00:17:41,440 --> 00:17:45,570
>> E aqui estão algumas outras
funções comuns que você pode usar.

300
00:17:45,570 --> 00:17:49,650
Então dim esteira, isso vai lhe dar
as dimensões da matriz.

301
00:17:49,650 --> 00:17:52,620
Vai fazê-lo retornar
um vector de dimensão.

302
00:17:52,620 --> 00:17:55,580
Portanto, neste caso, porque
nossa matriz é de 3 por 3,

303
00:17:55,580 --> 00:18:01,900
ele vai dar-lhe uma
vetor numérico que é 3 3.

304
00:18:01,900 --> 00:18:05,270
>> E aqui é apenas mostrar
multiplicação de matrizes.

305
00:18:05,270 --> 00:18:11,970
Por isso, normalmente, se você acabou de fazer
asterisk-- tão mat asterisco mat--

306
00:18:11,970 --> 00:18:15,380
este vai ser
operação-componente sábio

307
00:18:15,380 --> 00:18:17,300
ou o que é chamado o produto Hadamard.

308
00:18:17,300 --> 00:18:21,310
Por isso, vai fazer a cada
elemento componente-wise.

309
00:18:21,310 --> 00:18:23,610
No entanto, se você quiser
multiplication-- matriz

310
00:18:23,610 --> 00:18:29,380
assim multiplicando os primeiros tempos de linha
primeira coluna da segunda matriz

311
00:18:29,380 --> 00:18:34,510
e assim on-- você usaria
esta operação por cento.

312
00:18:34,510 --> 00:18:38,110
>> E t de esteira é apenas um
operação para a transposição.

313
00:18:38,110 --> 00:18:42,590
Então, eu estou dizendo que tomar a transposta em
a matriz, multiplicá-lo pela matriz

314
00:18:42,590 --> 00:18:43,090
si.

315
00:18:43,090 --> 00:18:45,006
E então ele vai
voltar para você mais 3

316
00:18:45,006 --> 00:18:50,700
por 3 matriz de exibição
o produto que você gostaria.

317
00:18:50,700 --> 00:18:53,750
>> E assim que foi matriz.

318
00:18:53,750 --> 00:18:56,020
Aqui está o que é chamado um quadro de dados.

319
00:18:56,020 --> 00:19:00,780
A estrutura de dados que você pode pensar como
uma matriz, mas cada própria coluna

320
00:19:00,780 --> 00:19:02,990
vai ser de um tipo diferente.

321
00:19:02,990 --> 00:19:07,320
>> Então, o que é realmente legal sobre dados
quadros é que, em si, a análise dos dados,

322
00:19:07,320 --> 00:19:11,260
você vai ter tudo isso
dados heterogêneos e tudo isso realmente

323
00:19:11,260 --> 00:19:15,640
desarrumado coisas onde cada uma das colunas
eles próprios podem ser de diferentes tipos.

324
00:19:15,640 --> 00:19:21,460
Então aqui eu estou dizendo criar um
quadro de dados, fazer ints 1-3,

325
00:19:21,460 --> 00:19:24,750
e, em seguida, também têm um vector personagem.

326
00:19:24,750 --> 00:19:28,470
Então eu posso índice através
cada uma destas colunas

327
00:19:28,470 --> 00:19:30,930
e então eu vou começar os próprios valores.

328
00:19:30,930 --> 00:19:34,370
E você também pode fazer algum tipo
de operações em quadros de dados.

329
00:19:34,370 --> 00:19:38,040
E na maioria das vezes quando você está
fazendo análise de dados ou algum tipo

330
00:19:38,040 --> 00:19:42,042
de pré-processamento, você poderá
trabalhar com estas estruturas de dados

331
00:19:42,042 --> 00:19:44,250
onde cada coluna vai
ser de um tipo diferente.

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

333
00:19:47,880 --> 00:19:52,970
>> Finalmente, assim que estas são essencialmente apenas
os quatro objetos essenciais na Lista R.

334
00:19:52,970 --> 00:19:55,820
só vai recolher todas as
outros objetos que você deseja.

335
00:19:55,820 --> 00:20:00,130
Por isso, este irá armazenar em uma
variável que você pode acessar facilmente.

336
00:20:00,130 --> 00:20:02,370
>> Então, aqui, eu estou tendo uma lista.

337
00:20:02,370 --> 00:20:04,460
Eu estou dizendo coisas é igual a 3.

338
00:20:04,460 --> 00:20:08,060
Então, eu vou ter um elemento no
da lista, e isso é chamado de material,

339
00:20:08,060 --> 00:20:10,570
e ele vai ter o valor 3.

340
00:20:10,570 --> 00:20:13,140
>> Eu também pode criar uma matriz.

341
00:20:13,140 --> 00:20:17,970
Portanto, este é de 1 a 4 e linha final
é igual a 2, de modo que uma matriz de 2 por 2.

342
00:20:17,970 --> 00:20:20,270
Também na lista e é chamado de mat.

343
00:20:20,270 --> 00:20:24,690
moreStuff, uma cadeia de caracteres,
e até mesmo uma outra lista em si mesmo.

344
00:20:24,690 --> 00:20:27,710
>> Portanto, esta é uma lista que é 5 e urso.

345
00:20:27,710 --> 00:20:30,990
Por isso, tem o valor de 5 e
tem o urso cadeia de caracteres

346
00:20:30,990 --> 00:20:32,710
e é uma lista dentro de uma lista.

347
00:20:32,710 --> 00:20:35,965
Assim, você pode ter estes
coisas recursiva onde

348
00:20:35,965 --> 00:20:38,230
você tem um another--
digite dentro do modelo.

349
00:20:38,230 --> 00:20:41,420
Então, da mesma forma, você pode ter uma matriz
dentro de outra matriz e assim por diante.

350
00:20:41,420 --> 00:20:44,264
E a lista é apenas uma boa maneira
de coletar e agregar

351
00:20:44,264 --> 00:20:45,430
todos estes diferentes objectos.

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

353
00:20:50,210 --> 00:20:57,150
>> E, finalmente, aqui é apenas ajudar no caso
Este foi apenas ido mais rapidamente.

354
00:20:57,150 --> 00:21:01,350
Então, quando você está confuso
sobre algum tipo de função,

355
00:21:01,350 --> 00:21:03,510
você pode fazer a ajuda dessa função.

356
00:21:03,510 --> 00:21:07,120
Assim você pode fazer ajuda matriz
ou uma matriz de ponto de interrogação.

357
00:21:07,120 --> 00:21:11,430
E a ajuda eo ponto de interrogação são
apenas uma abreviação para a mesma coisa

358
00:21:11,430 --> 00:21:13,040
por isso eles são aliases.

359
00:21:13,040 --> 00:21:16,820
>> lm é uma função que
só faz um modelo linear.

360
00:21:16,820 --> 00:21:20,340
Mas se você simplesmente não tem idéia de como isso
obras, você pode apenas fazer ajuda de lm

361
00:21:20,340 --> 00:21:24,610
e que vamos dar-lhe algumas
tipo de documentação que

362
00:21:24,610 --> 00:21:27,960
olha como uma espécie de
página homem em Unix, onde

363
00:21:27,960 --> 00:21:34,210
você tem uma breve descrição do que
que faz, também o que seus argumentos são,

364
00:21:34,210 --> 00:21:38,850
o que ele retorna, e apenas dicas sobre como
para usá-lo, e alguns exemplos bem.

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

366
00:21:41,680 --> 00:21:52,890
>> Então deixe-me ir em frente e mostrar
alguns de demonstração do uso de R. OK.

367
00:21:52,890 --> 00:21:55,470
Então eu fui muito
rapidamente apenas os dados

368
00:21:55,470 --> 00:21:59,440
estruturas e algum tipo de
op-- algumas das operações.

369
00:21:59,440 --> 00:22:02,960
Eis algumas funções.

370
00:22:02,960 --> 00:22:06,750
>> Então aqui eu só vou
para definir uma função.

371
00:22:06,750 --> 00:22:09,970
Então, eu também estou usando
operador de atribuição aqui,

372
00:22:09,970 --> 00:22:12,610
e então eu estou dizendo
declará-la como uma função.

373
00:22:12,610 --> 00:22:14,140
E leva o valor de x.

374
00:22:14,140 --> 00:22:18,210
Portanto, este é qualquer valor que você quer
e eu estou indo para retornar x si.

375
00:22:18,210 --> 00:22:20,840
Portanto, esta é a função identidade.

376
00:22:20,840 --> 00:22:23,670
>> E o que é legal sobre isso
em comparação com outros idiomas

377
00:22:23,670 --> 00:22:26,330
e outra de baixo nível
línguas é que x

378
00:22:26,330 --> 00:22:29,350
pode ser de qualquer tipo em si
e ele vai voltar desse tipo.

379
00:22:29,350 --> 00:22:35,251
Assim, você pode imagine-- então vamos
me basta executar este rapidamente.

380
00:22:35,251 --> 00:22:35,750
Desculpe.

381
00:22:35,750 --> 00:22:40,300
>> Então, uma coisa que eu também deveria mencionar
é que este editor que estou usando

382
00:22:40,300 --> 00:22:41,380
é chamado rstudio.

383
00:22:41,380 --> 00:22:44,389
Isto é o que é chamado de IDE.

384
00:22:44,389 --> 00:22:46,180
E uma coisa que é
realmente agradável sobre este

385
00:22:46,180 --> 00:22:51,500
é que incorpora uma grande parte do
as coisas que você quer fazer em R por si só

386
00:22:51,500 --> 00:22:53,180
apenas muito intuitiva.

387
00:22:53,180 --> 00:22:55,550
>> Então aqui está um console intérprete.

388
00:22:55,550 --> 00:23:02,160
Então, da mesma forma, você também pode obter este
consola-prima apenas fazendo uma R. capitais

389
00:23:02,160 --> 00:23:05,630
E este é exatamente o
mesma coisa que o console.

390
00:23:05,630 --> 00:23:12,210
Então eu só posso fazer a função id x, x, x.

391
00:23:12,210 --> 00:23:16,130
E entăo-- e, em seguida, que
vai ficar bem em si.

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

393
00:23:19,200 --> 00:23:21,740
>> Então rstudio é grande
porque tem o console.

394
00:23:21,740 --> 00:23:25,360
Ela também tem os documentos
você gostaria de correr.

395
00:23:25,360 --> 00:23:28,629
E então ele tem algumas variáveis
que você pode ver em ambientes.

396
00:23:28,629 --> 00:23:30,420
E então, se você tem
fazer parcelas, então você

397
00:23:30,420 --> 00:23:33,730
pode apenas vê-lo aqui, ao contrário de
gerenciar todos esses diferentes janelas

398
00:23:33,730 --> 00:23:35,940
por si.

399
00:23:35,940 --> 00:23:40,530
>> Na verdade, eu pessoalmente uso Vim, mas eu
sentir como rstudio é excelente apenas

400
00:23:40,530 --> 00:23:44,640
para obter uma boa idéia
de como usar R. Normalmente,

401
00:23:44,640 --> 00:23:47,040
quando você está tentando
aprender alguma nova tarefa,

402
00:23:47,040 --> 00:23:49,590
você não quer lidar com
muitas coisas ao mesmo tempo.

403
00:23:49,590 --> 00:23:53,120
Então R é apenas um rstudio very--
é uma boa forma de aprendizagem R

404
00:23:53,120 --> 00:23:56,760
sem ter que lidar com
todas essas outras coisas.

405
00:23:56,760 --> 00:23:58,600
>> Então, aqui estou id correndo Olá.

406
00:23:58,600 --> 00:24:00,090
Isso retorna Olá.

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

408
00:24:01,740 --> 00:24:04,610
Aqui é um vetor de números inteiros.

409
00:24:04,610 --> 00:24:08,620
Então, da mesma forma, porque você pode
tomar qualquer algum tipo de valor,

410
00:24:08,620 --> 00:24:16,060
você pode fazer voltar id
x para que ela retorne 1234 e 5.

411
00:24:16,060 --> 00:24:22,210
>> E deixe-me mostrar-lhe que
este é realmente um número inteiro.

412
00:24:22,210 --> 00:24:28,800
E da mesma forma, se você fizer classe
id x, que vai ser inteiro.

413
00:24:28,800 --> 00:24:34,170
E então, você também pode
comparar os dois e é verdade.

414
00:24:34,170 --> 00:24:38,350
Então, eu estou verificando se id x
é igual a igual ax e aviso

415
00:24:38,350 --> 00:24:39,760
que lhe dá duas TRUEs.

416
00:24:39,760 --> 00:24:44,280
Portanto, este não está dizendo são
os dois objetos idênticos,

417
00:24:44,280 --> 00:24:46,845
mas são cada uma das entradas
dentro dos vectores idênticos.

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

419
00:24:50,000 --> 00:24:52,090
>> Aqui está bounded.compare.

420
00:24:52,090 --> 00:24:58,470
Portanto, este é um pouco mais complicado
na medida em que se tem uma condição e outra

421
00:24:58,470 --> 00:25:00,960
e, em seguida, é preciso dois
argumentos de cada vez.

422
00:25:00,960 --> 00:25:02,640
Assim, x é de qualquer tipo.

423
00:25:02,640 --> 00:25:06,280
E eu estou dizendo isso
O segundo argumento é a.

424
00:25:06,280 --> 00:25:08,380
Isto pode ser qualquer coisa como bem.

425
00:25:08,380 --> 00:25:12,490
Mas por padrão, ele vai levar
5, se você não especificar nada.

426
00:25:12,490 --> 00:25:16,730
>> Então aqui eu vou dizer
Se x for maior do que um.

427
00:25:16,730 --> 00:25:19,220
Então, se eu não especificar um, ele
diz que se x é maior do que 5,

428
00:25:19,220 --> 00:25:20,470
então eu estou indo para retornar TRUE.

429
00:25:20,470 --> 00:25:23,230
outra coisa, eu estou indo para retornar FALSE.

430
00:25:23,230 --> 00:25:24,870
Então deixe-me ir em frente e definir isso.

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

432
00:25:30,600 --> 00:25:34,550
>> E agora eu vou
executar bounded.compare 3.

433
00:25:34,550 --> 00:25:39,150
Então, ele diz que é menos 3
than-- 3 é maior do que 5.

434
00:25:39,150 --> 00:25:41,830
Não, não é tão falso.

435
00:25:41,830 --> 00:25:46,550
>> E bounded.compare 3 e vou
para compará-lo utilizando um é igual a 2.

436
00:25:46,550 --> 00:25:50,700
Então agora eu estou dizendo sim, agora eu
quero um para ser outra coisa.

437
00:25:50,700 --> 00:25:52,750
Então, eu vou dizer uma, você deve ser 2.

438
00:25:52,750 --> 00:25:56,640
>> I pode fazer esse tipo de
notação ou digo um é igual a dois.

439
00:25:56,640 --> 00:25:58,720
Esta é uma forma mais legível
em que quando você está

440
00:25:58,720 --> 00:26:01,450
olhando para estes realmente
funções complicadas que

441
00:26:01,450 --> 00:26:08,110
tomar arguments-- múltipla e este
pode haver dezenas oftentimes-- apenas dizendo

442
00:26:08,110 --> 00:26:11,140
um é igual a 2 é mais legível para
você, para que, mais tarde, no futuro

443
00:26:11,140 --> 00:26:13,020
você vai saber o que você está fazendo.

444
00:26:13,020 --> 00:26:17,120
>> Portanto, neste caso, eu sou
provérbio é 3 superior a 2.

445
00:26:17,120 --> 00:26:18,270
Sim, é.

446
00:26:18,270 --> 00:26:22,350
E da mesma forma, eu posso simplesmente remover
isso e dizer, é de 3 superior a 2

447
00:26:22,350 --> 00:26:23,440
onde a é igual a 2.

448
00:26:23,440 --> 00:26:26,230
E isso também é verdade.

449
00:26:26,230 --> 00:26:26,730
Sim?

450
00:26:26,730 --> 00:26:29,670
>> AUDIÊNCIA: É você
executar linha por linha?

451
00:26:29,670 --> 00:26:30,670
>> DUSTIN TRAN: Sim, eu sou.

452
00:26:30,670 --> 00:26:33,900
Então o que eu estou fazendo aqui é
tomar este texto document--

453
00:26:33,900 --> 00:26:39,825
e que é grande sobre rstudio é que
Eu só posso executar um short-- uma tecla de atalho.

454
00:26:39,825 --> 00:26:41,820
Então, eu estou fazendo Control-Enter.

455
00:26:41,820 --> 00:26:44,850
>> E então, eu estou tomando o
linha no documento de texto

456
00:26:44,850 --> 00:26:46,710
e, em seguida, colocar no console.

457
00:26:46,710 --> 00:26:50,800
Então aqui eu estou dizendo, bounded.compare
e eu estou fazendo Control-X.

458
00:26:50,800 --> 00:26:52,540
Então, eu posso simplesmente não funcionar aqui também.

459
00:26:52,540 --> 00:26:54,920
E, então, que vou pegar o
linha e, em seguida, colocá-lo aqui.

460
00:26:54,920 --> 00:26:57,900
E, em seguida, da mesma forma, eu posso fazer correr aqui.

461
00:26:57,900 --> 00:27:04,630
E então ele vai apenas manter a definição
as linhas para o console assim.

462
00:27:04,630 --> 00:27:10,690
>> E se você também notar a cacheados
chaves estão lá apenas como na sintaxe C.

463
00:27:10,690 --> 00:27:13,910
x-- se o se a condição é também
vai usar parênteses e depois

464
00:27:13,910 --> 00:27:15,350
você pode usar outra coisa.

465
00:27:15,350 --> 00:27:17,496
Outra é else if.

466
00:27:17,496 --> 00:27:21,440
Portanto, esta vai ser x
é igual é igual a um, por exemplo.

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

468
00:27:24,190 --> 00:27:26,350
E então eu vou
retornar algo aqui.

469
00:27:26,350 --> 00:27:29,490
>> Observe que existem dois diferentes
coisas aqui que está acontecendo.

470
00:27:29,490 --> 00:27:34,360
Uma delas é que aqui eu estou especificando
devolver o valor TRUE.

471
00:27:34,360 --> 00:27:35,950
Aqui eu só estou dizendo x.

472
00:27:35,950 --> 00:27:39,970
Então R normalmente irá por padrão
tomar o último arguments--

473
00:27:39,970 --> 00:27:43,510
ou tomar a última linha do código,
e que vai ser o que ele é retornado.

474
00:27:43,510 --> 00:27:46,920
Então aqui é o mesmo
coisa como fazendo retorno x.

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

476
00:27:49,450 --> 00:27:50,540
>> E só para mostrar a você.

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

478
00:27:54,000 --> 00:27:57,052
E, em seguida, ele vai trabalhar apenas como aquele.

479
00:27:57,052 --> 00:27:58,260
Então deixe-me continuar com isso.

480
00:27:58,260 --> 00:28:00,630
>> Então else if.

481
00:28:00,630 --> 00:28:04,060
E realmente, eu posso voltar
qualquer coisa que eu gostaria.

482
00:28:04,060 --> 00:28:06,680
Então eu não tem sequer a
retorno Booleans o tempo todo,

483
00:28:06,680 --> 00:28:08,410
Eu só posso voltar outra coisa.

484
00:28:08,410 --> 00:28:10,670
Então eu posso fazer urso retorno.

485
00:28:10,670 --> 00:28:12,989
>> Portanto, se x é igual é igual a um,
ele vai voltar urso.

486
00:28:12,989 --> 00:28:14,530
Caso contrário, ele vai retornar TRUE.

487
00:28:14,530 --> 00:28:19,310
Eu também posso fazer um vector
ou realmente qualquer coisa.

488
00:28:19,310 --> 00:28:22,210
>> E normalmente em estaticamente
línguas digitado,

489
00:28:22,210 --> 00:28:23,840
você teria que especificar um tipo aqui.

490
00:28:23,840 --> 00:28:25,750
E note que ele pode ser qualquer coisa.

491
00:28:25,750 --> 00:28:32,400
E R é inteligente o suficiente para que ele
só vai fazer isso e ele vai funcionar bem.

492
00:28:32,400 --> 00:28:33,620
>> Então deixe-me definir isso.

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

494
00:28:39,460 --> 00:28:41,230
Unexpected-- oh desculpe.

495
00:28:41,230 --> 00:28:44,336
Deve ser uma chaveta aqui.

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

497
00:28:44,836 --> 00:28:45,336
Com estilo.

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

499
00:28:52,580 --> 00:28:54,530
Tudo certo.

500
00:28:54,530 --> 00:28:58,250
Então agora vamos comparar 3 e um é igual a 3.

501
00:28:58,250 --> 00:29:01,860
Por isso, deve return--
yeah-- o valor urso.

502
00:29:01,860 --> 00:29:06,740
>> Então, agora uma coisa mais geral é como
o que acontece com outras estruturas de dados.

503
00:29:06,740 --> 00:29:09,110
Então você tem esta função.

504
00:29:09,110 --> 00:29:15,360
Isso vai funcionar em qualquer tipo
de valor como 3 ou qualquer numérico,

505
00:29:15,360 --> 00:29:17,500
em outras palavras, duas vezes.

506
00:29:17,500 --> 00:29:19,330
>> Mas o que dizer algo como um vector.

507
00:29:19,330 --> 00:29:27,750
Então, o que acontece se você fazer-- por isso estou
vai atribuir val para, digamos, 4 a 6.

508
00:29:27,750 --> 00:29:31,640
Então, se eu voltar isso, este
é um vector a partir do 4, 5, 6.

509
00:29:31,640 --> 00:29:34,935
>> Agora vamos ver o que acontece
se eu fizer bounded.compare val.

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

511
00:29:37,680 --> 00:29:42,450
Então, isso vai lhe dar 15 1251.

512
00:29:42,450 --> 00:29:46,440
Portanto, em outras palavras, ele está dizendo
se você olhar para esta condição

513
00:29:46,440 --> 00:29:50,040
por isso diz x é menor
do que um ou algo assim.

514
00:29:50,040 --> 00:29:51,880
Portanto, este é ligeiramente
confusa porque agora

515
00:29:51,880 --> 00:29:53,379
você simplesmente não sabe o que está acontecendo.

516
00:29:53,379 --> 00:29:58,690
Então eu acho que uma coisa que é realmente
bom sobre apenas tentando depurar

517
00:29:58,690 --> 00:30:04,600
é que você pode apenas fazer val é maior
do que um e ver o que acontece lá.

518
00:30:04,600 --> 00:30:09,720
>> Então val-- um é, por padrão, 5 de modo
Vamos fazer Val superior a 5.

519
00:30:09,720 --> 00:30:14,280
Portanto, este é um vetor FALSE FALSE TRUE.

520
00:30:14,280 --> 00:30:17,206
Agora, quando você está olhando
isso, ele vai dizer se,

521
00:30:17,206 --> 00:30:20,080
e, em seguida, ele vai dar-lhe este
é um vetor de FALSE FALSE TRUE.

522
00:30:20,080 --> 00:30:23,450
>> Então, quando você passar isso em R, R
não tem idéia do que está fazendo.

523
00:30:23,450 --> 00:30:26,650
Porque ele espera que um único
valor, o que é um valor booleano, e agora

524
00:30:26,650 --> 00:30:29,420
você está dando-lhe um vetor de booleanos.

525
00:30:29,420 --> 00:30:31,970
Então, por padrão, R é apenas
vai dizer que o diabo,

526
00:30:31,970 --> 00:30:35,440
Eu vou assumir que você é
vai levar o primeiro elemento aqui.

527
00:30:35,440 --> 00:30:38,320
Então, eu estou indo para dizer-- eu vou
assumir que isso é falso.

528
00:30:38,320 --> 00:30:40,890
Por isso, vai dizer
Não, isso não está certo.

529
00:30:40,890 --> 00:30:45,246
>> Da mesma forma, ele vai
val ser igual é igual a um.

530
00:30:45,246 --> 00:30:47,244
Não, desculpe 5.

531
00:30:47,244 --> 00:30:48,910
E também vai ser falso também.

532
00:30:48,910 --> 00:30:52,410
Então, ele vai dizer que não,
Não é verdade, bem por isso é

533
00:30:52,410 --> 00:30:53,680
vai voltar este último.

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

535
00:30:56,420 --> 00:31:01,360
>> Portanto, este é tanto uma coisa boa ou ruim
coisa, dependendo de como você vê-lo.

536
00:31:01,360 --> 00:31:05,104
Porque quando você está
criar essas funções,

537
00:31:05,104 --> 00:31:06,770
você realmente não sabe o que está acontecendo.

538
00:31:06,770 --> 00:31:10,210
Então, às vezes você iria querer um erro,
ou talvez você quer apenas um aviso.

539
00:31:10,210 --> 00:31:12,160
Neste caso, R não faz isso.

540
00:31:12,160 --> 00:31:14,300
Então, é realmente até
você baseado fora do que

541
00:31:14,300 --> 00:31:17,310
Você acha que a língua
deve fazer neste caso

542
00:31:17,310 --> 00:31:22,920
se você passar em um vetor de booleanos
quando você está fazendo um se condição.

543
00:31:22,920 --> 00:31:31,733
>> Então, vamos dizer que você tinha o original
um com os outros, se retornar TRUE e você está

544
00:31:31,733 --> 00:31:34,190
vai retornar FALSE.

545
00:31:34,190 --> 00:31:39,300
Portanto, uma forma de abstrair
isso é para dizer que eu

546
00:31:39,300 --> 00:31:41,530
não precisa mesmo essa coisa condicional.

547
00:31:41,530 --> 00:31:47,220
Outra coisa que posso fazer é apenas
retornando os próprios valores.

548
00:31:47,220 --> 00:31:53,240
Então, se você observar, se você
Do Val é maior do que 5,

549
00:31:53,240 --> 00:31:56,350
isso vai voltar a
vector FALSE FALSE TRUE.

550
00:31:56,350 --> 00:31:58,850
>> Talvez isso é o que você
quer para bounded.compare.

551
00:31:58,850 --> 00:32:02,940
Você deseja retornar um vetor de booleanos
em que compara cada um dos valores

552
00:32:02,940 --> 00:32:04,190
para si mesmos.

553
00:32:04,190 --> 00:32:11,165
Assim, você pode simplesmente não bounded.compare
função de x, um é igual a 5.

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

555
00:32:13,322 --> 00:32:15,363
E então, em vez de fazê-
esta outra condição se,

556
00:32:15,363 --> 00:32:21,430
Eu só vou voltar
x é maior do que 5.

557
00:32:21,430 --> 00:32:23,620
Então, se é verdade, então
ele vai retornar TRUE.

558
00:32:23,620 --> 00:32:26,830
E então, se não é, é
vai retornar FALSE.

559
00:32:26,830 --> 00:32:30,880
>> E isso vai funcionar para
qualquer dessas estruturas.

560
00:32:30,880 --> 00:32:41,450
Então eu posso bounded.compare c 1 6 ou 9
e então eu vou dizer um é igual a 6,

561
00:32:41,450 --> 00:32:42,799
por exemplo.

562
00:32:42,799 --> 00:32:44,840
E então ele vai
dar-lhe o direito booleana

563
00:32:44,840 --> 00:32:48,240
vetor que você está projetando.

564
00:32:48,240 --> 00:32:50,660
>> Então, esses são apenas funções
e, agora, deixe-me apenas

565
00:32:50,660 --> 00:32:54,980
mostrar-lhe alguns recursos visuais interativos.

566
00:32:54,980 --> 00:32:59,700
Eu não acho que eu realmente tenho
Wi-Fi aqui, então deixe-me ir em frente

567
00:32:59,700 --> 00:33:01,970
e ignorar esta eu acho.

568
00:33:01,970 --> 00:33:05,260
>> Mas uma coisa que é legal
porém, é que se você apenas

569
00:33:05,260 --> 00:33:09,600
quer testar um monte de
diferentes comandos, dados

570
00:33:09,600 --> 00:33:13,320
há um monte de diferentes conjuntos de dados
que já estão pré-carregados no R.

571
00:33:13,320 --> 00:33:15,770
Então, um deles é
chamado o conjunto de dados da íris.

572
00:33:15,770 --> 00:33:18,910
Este é um dos mais conhecidos
os de aprendizado de máquina.

573
00:33:18,910 --> 00:33:23,350
Você geralmente apenas fazer algum tipo de
casos de teste para ver se o código é executado.

574
00:33:23,350 --> 00:33:27,520
Então vamos verificar o que é iris.

575
00:33:27,520 --> 00:33:33,130
>> Então, essa coisa está acontecendo
para ser um quadro de dados.

576
00:33:33,130 --> 00:33:36,000
E é uma espécie de tempo porque
Eu só impresso íris.

577
00:33:36,000 --> 00:33:38,810
Ele está imprimindo a coisa toda.

578
00:33:38,810 --> 00:33:42,830
Por isso, tem todas estas diferentes nomes.

579
00:33:42,830 --> 00:33:45,505
Assim íris é uma colecção
de flores diferentes.

580
00:33:45,505 --> 00:33:48,830
Neste caso, está dizendo
-lhe as espécies do mesmo,

581
00:33:48,830 --> 00:33:54,760
todos estes diferentes larguras e
a comprimentos de sépalas e a pétala.

582
00:33:54,760 --> 00:33:58,880
>> E assim, normalmente, se
deseja imprimir íris,

583
00:33:58,880 --> 00:34:03,680
por exemplo, você não quer tê-lo
fazer tudo isso, porque isso pode levar mais

584
00:34:03,680 --> 00:34:05,190
todo o seu console.

585
00:34:05,190 --> 00:34:09,280
Então, uma coisa que é realmente
interessante é a função de cabeça.

586
00:34:09,280 --> 00:34:12,929
Então, se você acabou de fazer a cabeça
iris, isso vai lhe dar

587
00:34:12,929 --> 00:34:17,389
os primeiros cinco linhas ou seis anos, eu acho.

588
00:34:17,389 --> 00:34:19,909
E, em seguida bem de você,
pode apenas especificar aqui.

589
00:34:19,909 --> 00:34:22,914
Então 20-- isso vai dar
-lhe as primeiras 20 linhas.

590
00:34:22,914 --> 00:34:24,830
E eu, na verdade, era uma espécie
de surpreender que este

591
00:34:24,830 --> 00:34:28,770
me deu seis então deixe-me ir em frente
e verificar iris-- ou na cabeça, me desculpe.

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

593
00:34:31,699 --> 00:34:34,960
E aqui ele vai dar
você a documentação

594
00:34:34,960 --> 00:34:37,960
do que a cabeça de valor faz.

595
00:34:37,960 --> 00:34:40,839
Então, ela retorna a primeira
ou a última de um objeto.

596
00:34:40,839 --> 00:34:42,630
E então eu vou
olhar para os padrões.

597
00:34:42,630 --> 00:34:47,340
E, em seguida, ele diz que o default
método de cabeça x e n é igual a 6L.

598
00:34:47,340 --> 00:34:50,620
Portanto, este devolve os primeiros seis elementos.

599
00:34:50,620 --> 00:34:55,050
E da mesma forma, se você observar aqui, eu
não tem que especificar n é igual a 6.

600
00:34:55,050 --> 00:34:56,840
Por padrão, ele usa seis, eu acho.

601
00:34:56,840 --> 00:35:00,130
E então, se eu quiser especificar um determinado
valor, então eu posso ver isso também.

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

603
00:35:02,970 --> 00:35:10,592
>> Então esse é alguns comandos simples e
aqui está um outro que é apenas-- bem,

604
00:35:10,592 --> 00:35:12,550
I can-- esta é realmente
um pouco mais complexa,

605
00:35:12,550 --> 00:35:17,130
mas isso só vai levar a classe
de cada coluna do conjunto de dados da íris.

606
00:35:17,130 --> 00:35:20,910
Então, isso vai mostrar o que cada um deles
colunas são em termos de seus tipos.

607
00:35:20,910 --> 00:35:23,665
Então comprimento sepal é numérico,
width sepal é numérico.

608
00:35:23,665 --> 00:35:26,540
Todos estes valores são apenas numérico
porque você pode dizer a partir desses dados

609
00:35:26,540 --> 00:35:29,440
estruturar estes são
tudo vai numérico.

610
00:35:29,440 --> 00:35:34,310
>> E a coluna Espécies
vai ser um fator.

611
00:35:34,310 --> 00:35:37,270
Então, normalmente, você poderia pensar que
isto é como uma cadeia de caracteres.

612
00:35:37,270 --> 00:35:48,830
Mas, se você acabou de fazer irisSpecies,
e então eu vou fazer de cabeça 5,

613
00:35:48,830 --> 00:35:51,820
e isso vai imprimir
os primeiros cinco valores.

614
00:35:51,820 --> 00:35:54,150
>> E em seguida, observe esta níveis.

615
00:35:54,150 --> 00:35:58,870
Portanto, este é dizendo-- esta é a maneira do R
de ter variáveis ​​categóricas.

616
00:35:58,870 --> 00:36:03,765
Então, ao invés de apenas
Tendo em cadeias de caracteres,

617
00:36:03,765 --> 00:36:06,740
ele tem níveis especificando
que estas coisas são.

618
00:36:06,740 --> 00:36:12,450
>> Então, digamos que irisSpecies 1.

619
00:36:12,450 --> 00:36:17,690
Então, o que você quer fazer aqui é que eu sou
subsetting a esta coluna Espécies.

620
00:36:17,690 --> 00:36:21,480
Então, isso leva a
Espécies coluna e, em seguida,

621
00:36:21,480 --> 00:36:23,820
ele indexa para obter o primeiro elemento.

622
00:36:23,820 --> 00:36:27,140
Portanto, este deve dar-lhe setosa.

623
00:36:27,140 --> 00:36:28,710
E dá-lhe também os níveis aqui.

624
00:36:28,710 --> 00:36:32,812
>> Então, você também pode comparar
isso para o personagem setosa

625
00:36:32,812 --> 00:36:34,645
e isso não vai
a ser verdade, porque uma

626
00:36:34,645 --> 00:36:37,940
é de um tipo diferente do que o outro.

627
00:36:37,940 --> 00:36:40,590
Ou eu acho que isso é verdade, porque R
é mais inteligente do que isso.

628
00:36:40,590 --> 00:36:45,420
E ele olha para isso e, em seguida,
diz, talvez este seja o que você quer.

629
00:36:45,420 --> 00:36:51,860
Então, ele vai dizer que o personagem
cadeia setosa é o mesmo como esta.

630
00:36:51,860 --> 00:37:01,290
E, em seguida, da mesma forma, você pode
também basta pegar estes como assim por diante.

631
00:37:01,290 --> 00:37:05,580
>> Então, isso é apenas uma espécie de
comandos rápidos do conjunto de dados.

632
00:37:05,580 --> 00:37:08,030
Então aqui vai uma exploração de dados.

633
00:37:08,030 --> 00:37:11,360
Portanto, este é um pouco mais
envolvidas com a análise de dados.

634
00:37:11,360 --> 00:37:18,340
E este é retirado de alguns
bootcamp em R para em Berkeley.

635
00:37:18,340 --> 00:37:20,790
>> Assim biblioteca externa.

636
00:37:20,790 --> 00:37:24,880
Então, eu estou indo para carregar em um
biblioteca que é chamado estrangeira.

637
00:37:24,880 --> 00:37:32,460
Então, isso vai me dar read.dta
assim supor que eu tenho esse conjunto de dados.

638
00:37:32,460 --> 00:37:39,000
Este é armazenado na actual
diretório do meu console funcionando.

639
00:37:39,000 --> 00:37:42,190
Então vamos ver o que
o diretório de trabalho é.

640
00:37:42,190 --> 00:37:44,620
>> Então, aqui está o meu diretório de trabalho.

641
00:37:44,620 --> 00:37:50,040
E a leitura de dados de pontos, esta
coisa, está dizendo este arquivo

642
00:37:50,040 --> 00:37:54,650
está localizado na pasta de dados de
este diretório de trabalho atual.

643
00:37:54,650 --> 00:38:00,520
E este não é read.dta
um comando padrão.

644
00:38:00,520 --> 00:38:02,760
Eu acho que eu carregá-la no já.

645
00:38:02,760 --> 00:38:04,750
IEI assumido eu carreguei isso no já.

646
00:38:04,750 --> 00:38:08,115
>> Mas até read.dta não vai
para ser um comando padrão.

647
00:38:08,115 --> 00:38:11,550
E é por isso que você vai ter
para carregar nesta biblioteca package--

648
00:38:11,550 --> 00:38:14,500
este pacote chamado estrangeira.

649
00:38:14,500 --> 00:38:16,690
E se você não tem
o pacote, eu acho

650
00:38:16,690 --> 00:38:19,180
estrangeira é um dos mais integrados.

651
00:38:19,180 --> 00:38:31,150
Caso contrário, você também pode
fazer install.packages

652
00:38:31,150 --> 00:38:33,180
e isso vai instalar o pacote.

653
00:38:33,180 --> 00:38:36,878
E isso vai lhe dar R. Uh, não.

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

655
00:38:39,830 --> 00:38:43,140
E então eu só vou parar
isso porque eu já tenho.

656
00:38:43,140 --> 00:38:46,920
>> Mas o que é realmente agradável sobre R
é que o gerenciamento de pacotes

657
00:38:46,920 --> 00:38:48,510
sistema é muito elegante.

658
00:38:48,510 --> 00:38:52,470
Porque ele vai armazenar tudo
realmente muito bem para você.

659
00:38:52,470 --> 00:38:59,780
Portanto, neste caso, está indo para armazenar
-lo, creio eu, esta biblioteca aqui.

660
00:38:59,780 --> 00:39:02,390
>> Então, quando você quer
instalar novos pacotes,

661
00:39:02,390 --> 00:39:04,980
é tão simples como
fazendo install.packages

662
00:39:04,980 --> 00:39:07,500
e R gerenciará todos
os pacotes para você.

663
00:39:07,500 --> 00:39:12,900
Então você não tem que fazer alguma coisa em
Python, onde você tem pacote externo

664
00:39:12,900 --> 00:39:15,330
gestores como papel
Anaconda onde você está

665
00:39:15,330 --> 00:39:18,310
doing-- de instalar o
pacotes fora do Python

666
00:39:18,310 --> 00:39:20,940
e em seguida, tentar executá-los você mesmo.

667
00:39:20,940 --> 00:39:22,210
Portanto, esta é realmente boa maneira.

668
00:39:22,210 --> 00:39:25,590
>> E install.packages requer internet.

669
00:39:25,590 --> 00:39:31,950
Leva-o a partir de um servidor
e do repositório que

670
00:39:31,950 --> 00:39:33,960
recolhe todo o
pacotes é chamado CRAN.

671
00:39:33,960 --> 00:39:40,690
E você pode especificar que tipo de espelho
você quer fazer o download dos pacotes.

672
00:39:40,690 --> 00:39:43,420
>> Então aqui estou tendo este conjunto de dados.

673
00:39:43,420 --> 00:39:46,240
Eu estou lendo-o em utilizar esta função.

674
00:39:46,240 --> 00:39:49,360
Então deixe-me ir em frente e fazer isso.

675
00:39:49,360 --> 00:39:52,900
>> Então vamos supor que
você tem esse conjunto de dados

676
00:39:52,900 --> 00:39:55,550
e você não tem absolutamente
nenhuma idéia o que é.

677
00:39:55,550 --> 00:39:58,560
E isso, na verdade, trata-se
com bastante frequência na indústria

678
00:39:58,560 --> 00:40:00,910
onde você só tem esses
toneladas e toneladas de coisas sujas

679
00:40:00,910 --> 00:40:02,890
e eles são incrivelmente não marcado.

680
00:40:02,890 --> 00:40:06,380
Então aqui eu tenho essa
dataset e eu não sei

681
00:40:06,380 --> 00:40:08,400
o que é assim que eu sou apenas
mostrando para verificá-la.

682
00:40:08,400 --> 00:40:10,620
>> Então, eu vou fazer de cabeça.

683
00:40:10,620 --> 00:40:14,190
Então eu verificar os seis primeiros
colunas de que esse conjunto de dados é.

684
00:40:14,190 --> 00:40:21,730
Portanto, este é o estado, pres04, e em seguida
todos esses diferentes tipo de colunas.

685
00:40:21,730 --> 00:40:25,612
E o que é interessante
aqui, eu acho, é que você

686
00:40:25,612 --> 00:40:27,945
diria que isso parece
como uma espécie de eleição.

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

688
00:40:30,482 --> 00:40:32,190
E eu acho que só a partir de
olhando para o arquivo

689
00:40:32,190 --> 00:40:41,070
Nome Este é algum tipo de coleção
de dados sobre candidatos ou eleitores

690
00:40:41,070 --> 00:40:44,920
que votaram em presidentes específicas
ou candidatos presidente

691
00:40:44,920 --> 00:40:46,550
para a eleição de 2004.

692
00:40:46,550 --> 00:40:52,920
>> Então aqui está valores 1, 2
Portanto, uma forma de armazenar

693
00:40:52,920 --> 00:40:56,540
os candidatos presidente
são os seus nomes.

694
00:40:56,540 --> 00:40:59,780
Neste caso, parece que
eles são apenas valores inteiros.

695
00:40:59,780 --> 00:41:04,030
Então, 2004, era de Bush
contra Kerry eu acredito.

696
00:41:04,030 --> 00:41:09,010
E agora, vamos dizer que você só não sei
se 1 corresponde ao Bush ou 2

697
00:41:09,010 --> 00:41:11,703
corresponde a Kerry ou e
assim por diante e assim por diante, certo?

698
00:41:11,703 --> 00:41:15,860
>> E esta é, só para mim,
um problema bastante comum.

699
00:41:15,860 --> 00:41:18,230
Então, o que você pode fazer neste caso?

700
00:41:18,230 --> 00:41:20,000
Então, vamos verificar todas essas outras coisas.

701
00:41:20,000 --> 00:41:22,790
>> estado, estou assumindo este
vem de diferentes estados.

702
00:41:22,790 --> 00:41:25,100
partyid, renda.

703
00:41:25,100 --> 00:41:27,710
Vejamos partyid.

704
00:41:27,710 --> 00:41:32,800
Então, talvez uma coisa que você pode fazer é
olhar para cada uma das observações

705
00:41:32,800 --> 00:41:36,250
que têm um partyid do republicano
ou democrata ou algo assim.

706
00:41:36,250 --> 00:41:38,170
Então vamos apenas olhar para o que é partyid.

707
00:41:38,170 --> 00:41:41,946
>> Então, eu vou tomar
dat e então eu vou

708
00:41:41,946 --> 00:41:47,960
para fazer isso cifrão
operador que eu fiz anteriormente

709
00:41:47,960 --> 00:41:50,770
e isso vai
subconjunto para essa coluna.

710
00:41:50,770 --> 00:41:57,760
E então eu estou indo para a cabeça esta em
20, só para ver o que isto se parece.

711
00:41:57,760 --> 00:42:00,170
>> Portanto, este é apenas um monte de agências nacionais.

712
00:42:00,170 --> 00:42:02,800
Portanto, em outras palavras, você tem
falta de dados sobre esses caras.

713
00:42:02,800 --> 00:42:08,100
Mas você também perceber isso
dat partyid é um factor

714
00:42:08,100 --> 00:42:10,030
de modo que este dá-lhe diferentes categorias.

715
00:42:10,030 --> 00:42:14,170
Assim, em outras palavras, pode tomar partyid
Democrata, republicano, independente,

716
00:42:14,170 --> 00:42:16,640
ou qualquer outra coisa.

717
00:42:16,640 --> 00:42:23,940
>> Então, vamos em frente e vamos
ver qual delas é-- oh, OK.

718
00:42:23,940 --> 00:42:28,480
Então, eu estou indo para o subconjunto
para partyid e depois

719
00:42:28,480 --> 00:42:32,780
veja quais são
Democrata, por exemplo.

720
00:42:32,780 --> 00:42:37,150
Isto vai dar-lhe um valor booleano,
uma enorme booleano de TRUEs e FALSEs.

721
00:42:37,150 --> 00:42:41,630
>> E agora, vamos dizer que eu quero
para o subconjunto para esses caras.

722
00:42:41,630 --> 00:42:47,260
Então, isso vai levar a minha dat e
a qualquer subconjunto observações

723
00:42:47,260 --> 00:42:48,910
têm iguais partyid iguala democrata.

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

725
00:42:52,830 --> 00:42:55,180
E isso é bastante longo, porque
há tantos deles.

726
00:42:55,180 --> 00:42:59,060
Então, agora, eu estou indo para a cabeça esta em 20.

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

728
00:43:05,690 --> 00:43:11,270
>> E, como você observou, é igual a equals
é interessante na medida em que você está

729
00:43:11,270 --> 00:43:13,250
já-- você também está incluindo as agências nacionais.

730
00:43:13,250 --> 00:43:19,010
Portanto, neste caso, você ainda pode não chegar
qualquer informação, porque agora você tem AN

731
00:43:19,010 --> 00:43:22,650
e você só quer ver qual dos
observação correspondem ao Democrata

732
00:43:22,650 --> 00:43:24,670
e não estes valores em falta si.

733
00:43:24,670 --> 00:43:27,680
Então, como você se livrar desses NAS?

734
00:43:27,680 --> 00:43:36,410
>> Então, aqui estou apenas usando a chave no meu
cursor e, em seguida, dizendo se movimentar.

735
00:43:36,410 --> 00:43:39,778
E então aqui eu só vou
dizer is.na datpartyid.

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

737
00:43:48,970 --> 00:43:52,720
Portanto, este e e tomará
dois vectores diferentes booleanas

738
00:43:52,720 --> 00:43:57,160
e dizer que vai ser
TRUE e FALSE por exemplo.

739
00:43:57,160 --> 00:43:59,190
Por isso, vai fazer este componente-wise.

740
00:43:59,190 --> 00:44:02,910
Então aqui eu estou dizendo take
o quadro de dados, subconjunto

741
00:44:02,910 --> 00:44:10,170
para aqueles que correspondem a democrata,
e remover qualquer um deles que não são NA.

742
00:44:10,170 --> 00:44:13,540
>> Portanto, este deve will--
dar-lhe alguma coisa.

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

744
00:44:16,540 --> 00:44:17,600
Vamos ver is.na.

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

746
00:44:24,670 --> 00:44:27,690
Vamos tentar datpartyid is.na.

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

748
00:44:36,290 --> 00:44:45,290
E isso deve dar você--
sorry-- apenas um vetor booleano.

749
00:44:45,290 --> 00:44:49,260
E então, porque é muito longo,
Eu estou indo para o subconjunto a 20.

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

751
00:44:49,760 --> 00:44:51,570
Portanto, este deve funcionar.

752
00:44:51,570 --> 00:44:54,700
>> E este também será TRUEs.

753
00:44:54,700 --> 00:45:01,830
Ah, o meu erro aqui é que I'm-- I
usar C ++ e R alternadamente assim que eu faço

754
00:45:01,830 --> 00:45:03,590
esse erro o tempo todo.

755
00:45:03,590 --> 00:45:05,807
O operador e é
na verdade, o que você quer.

756
00:45:05,807 --> 00:45:08,140
Você não quer usar dois
ampersands, apenas um único.

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
>> Então vamos ver.

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

761
00:45:20,930 --> 00:45:23,920
Então, nós subsetted ao
partyid onde eles estão Democrata

762
00:45:23,920 --> 00:45:25,300
e eles não estão faltando valores.

763
00:45:25,300 --> 00:45:27,690
E agora vamos olhar para
quais os que votaram a favor.

764
00:45:27,690 --> 00:45:31,530
Assim, parece que a maioria
deles votou 1.

765
00:45:31,530 --> 00:45:36,090
Então, eu estou indo para a frente
e dizer que é Kerry.

766
00:45:36,090 --> 00:45:39,507
>> E da mesma forma, você pode
também vão para Republicano

767
00:45:39,507 --> 00:45:41,090
e, esperamos, isso deve dar-lhe 2.

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

769
00:45:49,730 --> 00:45:51,770
É apenas um monte de colunas diferentes.

770
00:45:51,770 --> 00:45:53,070
E, de fato, é 2.

771
00:45:53,070 --> 00:45:55,750
Então partyid tudo republicanos,
a maioria deles está votando para 2.

772
00:45:55,750 --> 00:45:58,390
>> Assim, parece que, apenas
olhando para isso,

773
00:45:58,390 --> 00:46:00,600
Republicano vai ser
um very-- ou o partyid

774
00:46:00,600 --> 00:46:02,790
vai ser muito
grande fator na determinação

775
00:46:02,790 --> 00:46:05,420
qual candidato eles são
vai votar.

776
00:46:05,420 --> 00:46:07,120
E isso é obviamente verdadeiro em geral.

777
00:46:07,120 --> 00:46:10,139
E este corresponde ao seu
intuição, é claro.

778
00:46:10,139 --> 00:46:11,930
Então, parece que eu sou
correndo contra o tempo para que

779
00:46:11,930 --> 00:46:17,040
deixe-me apenas deve ir em frente
e mostrar algumas imagens rápidas.

780
00:46:17,040 --> 00:46:21,120
Então aqui está algo que é ligeiramente
mais complicada com a visualização.

781
00:46:21,120 --> 00:46:26,450
Portanto, neste caso, este é um muito
simples análise de apenas verificar o que

782
00:46:26,450 --> 00:46:28,500
o presidente da '04 é.

783
00:46:28,500 --> 00:46:33,920
>> Portanto, neste caso, digamos que você
queria responder a essa pergunta.

784
00:46:33,920 --> 00:46:38,540
Então vamos supor que queria saber a votação
comportamento na eleição presidente 2004

785
00:46:38,540 --> 00:46:41,170
e como isso varia de acordo com a raça.

786
00:46:41,170 --> 00:46:44,380
Assim, não só que você quer
ver o comportamento de voto,

787
00:46:44,380 --> 00:46:47,860
mas você quer subconjunto de cada
raça e tipo de resumir isso.

788
00:46:47,860 --> 00:46:50,770
E você só pode dizer-
por este complexo notação

789
00:46:50,770 --> 00:46:52,580
que esta é uma espécie de obter nebuloso.

790
00:46:52,580 --> 00:46:56,390
>> Então, um dos mais avançados R
pacotes que é também uma espécie de recente

791
00:46:56,390 --> 00:47:00,070
é chamado dplyr.

792
00:47:00,070 --> 00:47:03,060
Por isso, é este aqui.

793
00:47:03,060 --> 00:47:08,080
E ggplot2 ggg-- é apenas um bom
maneira de fazer as melhores visualizações

794
00:47:08,080 --> 00:47:09,400
do que a um embutido.

795
00:47:09,400 --> 00:47:11,108
>> Então, eu estou indo para carregar
estas duas bibliotecas.

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

797
00:47:13,200 --> 00:47:16,950
E então, eu estou indo para ir
em frente e executar este comando.

798
00:47:16,950 --> 00:47:19,050
Você pode apenas tratar isso como uma caixa preta.

799
00:47:19,050 --> 00:47:23,460
>> O que está acontecendo é que esta tubulação
operador está passando neste argumento

800
00:47:23,460 --> 00:47:24,110
em aqui.

801
00:47:24,110 --> 00:47:28,070
Então, eu estou dizendo por grupo dat
raça e então presidente 04.

802
00:47:28,070 --> 00:47:31,530
E então, todos esses outros comandos
está filtrando e, em seguida, resumindo

803
00:47:31,530 --> 00:47:34,081
onde eu estou fazendo contagem e
então eu estou traçando-lo aqui.

804
00:47:34,081 --> 00:47:39,980

805
00:47:39,980 --> 00:47:42,500
OK legal.

806
00:47:42,500 --> 00:47:44,620
Então, vamos em frente e
ver o que isto se parece.

807
00:47:44,620 --> 00:47:52,280

808
00:47:52,280 --> 00:47:57,290
>> Então, o que está acontecendo aqui é que eu
apenas plotados cada uma das raças e, em seguida,

809
00:47:57,290 --> 00:47:59,670
quais os que votaram a favor.

810
00:47:59,670 --> 00:48:03,492
E estes dois diferentes
Os valores correspondem a 2 e 1.

811
00:48:03,492 --> 00:48:05,325
Se você quiser ser mais
elegante, você também pode

812
00:48:05,325 --> 00:48:11,770
apenas especificar que 2 é Kerry-- ou
2 é de Bush, e, em seguida, um é Kerry.

813
00:48:11,770 --> 00:48:13,700
E você também pode ter
que em sua lenda.

814
00:48:13,700 --> 00:48:17,410
>> E você também pode dividir esses gráficos de barras.

815
00:48:17,410 --> 00:48:19,480
Porque uma coisa é
que, se você observar,

816
00:48:19,480 --> 00:48:24,560
este não é muito fácil de identificar
qual destes dois valores são maiores.

817
00:48:24,560 --> 00:48:27,920
Então, uma coisa que você gostaria de
fazer é aproveitar esta área azul

818
00:48:27,920 --> 00:48:31,855
e apenas mova-o aqui para que você
pode comparar os dois lado a lado.

819
00:48:31,855 --> 00:48:34,480
E eu acho que é algo que eu
não tem tempo para fazer agora,

820
00:48:34,480 --> 00:48:36,660
mas isso é também muito fácil de fazer.

821
00:48:36,660 --> 00:48:40,310
Você pode apenas olhar para
as páginas do manual de ggplot.

822
00:48:40,310 --> 00:48:47,170
Assim, você pode simplesmente não ggplot como
que e ler nesta página homem.

823
00:48:47,170 --> 00:48:51,920
>> Então deixem-me apenas rapidamente
mostrar-lhe algumas coisas legais.

824
00:48:51,920 --> 00:48:57,610
Vamos em frente e ir a-- apenas uma
aplicação de aprendizado de máquina.

825
00:48:57,610 --> 00:49:02,450
Então, digamos que temos estes três
pacotes assim que eu estou indo para carregá-los em.

826
00:49:02,450 --> 00:49:05,500

827
00:49:05,500 --> 00:49:09,170
Então, isso só imprime alguns
informações quando carreguei na coisa.

828
00:49:09,170 --> 00:49:15,220
Então, eu estou dizendo isso read.csv,
este conjunto de dados, e agora

829
00:49:15,220 --> 00:49:18,940
Eu estou indo para ir em frente e olhar e
ver o que tem dentro deste conjunto de dados.

830
00:49:18,940 --> 00:49:22,080
>> Assim, as primeiras 20 observações.

831
00:49:22,080 --> 00:49:27,190
Então, eu só tenho X1, X2, e Y. Por isso,
Parece que um monte desses valores

832
00:49:27,190 --> 00:49:31,640
estão variando de talvez 20 a 80 ou mais.

833
00:49:31,640 --> 00:49:37,700
E, em seguida, da mesma forma para X2 e depois
Y esta parece ser rótulos de 0 e 1.

834
00:49:37,700 --> 00:49:49,500
>> Para verificar isso, eu posso
apenas fazer X1 dados de resumo.

835
00:49:49,500 --> 00:49:51,660
E, em seguida, da mesma forma para
todas estas outras colunas.

836
00:49:51,660 --> 00:49:55,300
Então resumo é uma maneira rápida de
apenas mostrando valores rápidos.

837
00:49:55,300 --> 00:49:56,330
Oh, desculpe.

838
00:49:56,330 --> 00:49:58,440
Este deve ser Y.

839
00:49:58,440 --> 00:50:03,420
>> Portanto, neste caso, dá a
quantiles, medianas, maxes também.

840
00:50:03,420 --> 00:50:07,130
Neste caso, dataY, você pode ver
que ele só vai ser 0 e 1.

841
00:50:07,130 --> 00:50:10,100
Além disso, a média está dizendo
0,6, apenas significa que ele

842
00:50:10,100 --> 00:50:13,380
Parece que eu tenho mais do que 1s 0s.

843
00:50:13,380 --> 00:50:16,160
>> Então deixe-me ir em frente e mostrar
o que isso parece.

844
00:50:16,160 --> 00:50:17,470
Então, eu estou indo só para traçar este.

845
00:50:17,470 --> 00:50:22,852

846
00:50:22,852 --> 00:50:24,636
Vamos ver como limpar isso.

847
00:50:24,636 --> 00:50:30,492

848
00:50:30,492 --> 00:50:31,468
Oh 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
>> Portanto, este é o que parece.

852
00:50:37,590 --> 00:50:46,310
Assim, parece que os amarelos I especificados
como 0, e depois vermelho I especificado como 1s.

853
00:50:46,310 --> 00:50:52,190
Então, aqui parece que
pontos de etiqueta e que

854
00:50:52,190 --> 00:50:56,410
Parece que você só queria um pouco
tipo de agrupamento sobre este assunto.

855
00:50:56,410 --> 00:51:01,020
>> E deixe-me ir em frente e mostrar
você algumas dessas funções embutidas.

856
00:51:01,020 --> 00:51:03,580
Então aqui é lm.

857
00:51:03,580 --> 00:51:06,060
Portanto, esta é apenas a tentar
para ajustar uma linha a esta.

858
00:51:06,060 --> 00:51:08,640
Então, qual é a melhor maneira
que eu possa ajustar uma linha tal

859
00:51:08,640 --> 00:51:14,020
que será melhor separar
este tipo de clustering.

860
00:51:14,020 --> 00:51:21,790
E de preferência, você pode apenas ver
que eu simplesmente executar todos estes comandos

861
00:51:21,790 --> 00:51:25,450
e, em seguida, eu vou
em frente e adicionar a linha.

862
00:51:25,450 --> 00:51:28,970
>> Portanto, este parece ser o melhor palpite.

863
00:51:28,970 --> 00:51:34,150
É tomar o melhor que minimiza
o erro na tentativa de encaixar esta linha.

864
00:51:34,150 --> 00:51:40,000
Obviamente, isso parece meio
bom, mas não é o melhor.

865
00:51:40,000 --> 00:51:43,130
E os modelos lineares, em
geral, vão ser

866
00:51:43,130 --> 00:51:46,811
realmente grande para a teoria e apenas uma espécie
dos fundamentos de construção da máquina

867
00:51:46,811 --> 00:51:47,310
aprendendo.

868
00:51:47,310 --> 00:51:50,330
Mas, na prática, você vai
quero fazer algo mais geral.

869
00:51:50,330 --> 00:51:54,280
>> Assim, você pode apenas tentar correr
algo chamado de uma rede neural.

870
00:51:54,280 --> 00:51:57,110
Essas coisas são
cada vez mais comum.

871
00:51:57,110 --> 00:52:00,530
E eles simplesmente trabalhar fantasticamente
para grandes conjuntos de dados.

872
00:52:00,530 --> 00:52:07,080
Portanto, neste caso, só have--
vamos see-- temos nrow.

873
00:52:07,080 --> 00:52:09,010
Então nrow está apenas dizendo número de linhas.

874
00:52:09,010 --> 00:52:11,790
Portanto, neste caso, eu
tem 100 observações.

875
00:52:11,790 --> 00:52:15,010
>> Então deixe-me ir em frente e
fazer uma rede neural.

876
00:52:15,010 --> 00:52:18,620
Então, isso é muito bom
porque eu posso apenas dizer nnet

877
00:52:18,620 --> 00:52:21,767
e então eu estou regredindo Y.
Então o Y é aquela coluna.

878
00:52:21,767 --> 00:52:23,850
E então que a regressão no
as outras duas variáveis.

879
00:52:23,850 --> 00:52:27,360
Portanto, este é mais curto
notação para X1 e X2.

880
00:52:27,360 --> 00:52:29,741
>> Então, vamos em frente e executar este.

881
00:52:29,741 --> 00:52:30,240
Oh, desculpe.

882
00:52:30,240 --> 00:52:32,260
Eu preciso executar essa coisa toda.

883
00:52:32,260 --> 00:52:37,500
E esta é apenas a impressão de notação
para a rapidez ou não rapidamente ele

884
00:52:37,500 --> 00:52:38,460
convergiram.

885
00:52:38,460 --> 00:52:41,420
Portanto, parece que ele fez convergir.

886
00:52:41,420 --> 00:52:44,970
Então deixe-me ir em frente e de impressão
o que isso parece.

887
00:52:44,970 --> 00:52:51,260
>> Veja aqui a foto e aqui é
um contorno mostrando o quão bem ele se encaixa.

888
00:52:51,260 --> 00:52:56,380
E este é apenas-- você pode ver
este que isso é muito, muito bom.

889
00:52:56,380 --> 00:52:59,400
Pode até ser
overfitting, mas você pode também

890
00:52:59,400 --> 00:53:03,390
são responsáveis ​​por isso com outro
técnicas como a validação cruzada.

891
00:53:03,390 --> 00:53:06,180
E estes também são construídas em R.

892
00:53:06,180 --> 00:53:09,170
>> E deixe-me mostrar-lhe
apoiar máquina vector.

893
00:53:09,170 --> 00:53:12,470
Esta é outra realmente comum
técnica em aprendizado de máquina.

894
00:53:12,470 --> 00:53:18,550
É muito semelhante aos modelos lineares, mas
ele usa o que é chamado um método de kernel.

895
00:53:18,550 --> 00:53:22,790
E vamos ver o quão bem que faz.

896
00:53:22,790 --> 00:53:26,430
Assim, esta é muito semelhante à forma como
bem uma rede neural desempenha,

897
00:53:26,430 --> 00:53:27,900
mas é muito mais suave.

898
00:53:27,900 --> 00:53:35,740
E esta é baseado fora
de what-- como SVMs trabalho.

899
00:53:35,740 --> 00:53:40,250
>> Portanto, esta é apenas uma muito
resumo rápido de algumas

900
00:53:40,250 --> 00:53:43,822
das funções internas que você pode fazer
e também um pouco da exploração de dados.

901
00:53:43,822 --> 00:53:45,905
Então deixe-me ir em frente
e voltar para os slides.

902
00:53:45,905 --> 00:53:50,290

903
00:53:50,290 --> 00:53:53,670
>> Então, obviamente, este é
não muito abrangente.

904
00:53:53,670 --> 00:53:57,140
E isso é realmente apenas um teaser
mostrando-lhe o que você pode realmente fazer em R.

905
00:53:57,140 --> 00:53:59,100
Então, se você gostaria apenas de
para saber mais, aqui

906
00:53:59,100 --> 00:54:01,210
são um bando de diferentes recursos.

907
00:54:01,210 --> 00:54:06,890
>> Então, se você gosta de livros didáticos ou você está
só gostava de ler coisas on-line,

908
00:54:06,890 --> 00:54:09,670
então este é um fantástico
um por Hadley Wickham,

909
00:54:09,670 --> 00:54:13,010
que também criou todos esses
pacotes muito legal.

910
00:54:13,010 --> 00:54:17,420
Se você gosta de vídeos, em seguida,
Berkeley tem um bootcamp incrível

911
00:54:17,420 --> 00:54:21,060
isso é several-- esse é o tipo de comprimento.

912
00:54:21,060 --> 00:54:24,210
E ele vai te ensinar quase
tudo o que você gostaria de saber sobre R.

913
00:54:24,210 --> 00:54:27,770
>> E da mesma forma, não há Codeacademy
e todas estas outro tipo

914
00:54:27,770 --> 00:54:29,414
sites de interativos.

915
00:54:29,414 --> 00:54:31,580
Eles também estão recebendo
common-- cada vez mais comum.

916
00:54:31,580 --> 00:54:33,749
Então isso é muito semelhante ao Codeacademy.

917
00:54:33,749 --> 00:54:35,790
E, finalmente, se você acabou de
quer comunitário e ajudar,

918
00:54:35,790 --> 00:54:38,800
estes são um bando de
coisas que você pode ir.

919
00:54:38,800 --> 00:54:40,880
Obviamente, nós ainda
usar listas de discussão, apenas

920
00:54:40,880 --> 00:54:44,860
como quase todos os outros
comunidade linguagem de programação.

921
00:54:44,860 --> 00:54:47,880
E #rstats, este é
nossa comunidade Twitter.

922
00:54:47,880 --> 00:54:49,580
Isso é bastante comum.

923
00:54:49,580 --> 00:54:50,850
E então o usuário!

924
00:54:50,850 --> 00:54:52,340
É apenas a nossa conferência.

925
00:54:52,340 --> 00:54:55,390
>> E depois, claro, você pode
usar todas essas outras coisas Q & A,

926
00:54:55,390 --> 00:54:57,680
como Stack Overflow,
Google, e, em seguida, GitHub.

927
00:54:57,680 --> 00:55:00,490
Porque a maioria destes pacotes
e um lote da comunidade

928
00:55:00,490 --> 00:55:03,420
será centrada em torno de desenvolver
código porque é open source.

929
00:55:03,420 --> 00:55:05,856
E isso é apenas muito bom no GitHub.

930
00:55:05,856 --> 00:55:08,730
E, finalmente, você pode contactar-me se
você só tem quaisquer perguntas rápidas.

931
00:55:08,730 --> 00:55:13,530
Assim, você pode me encontrar no Twitter aqui,
meu site, e apenas o meu e-mail.

932
00:55:13,530 --> 00:55:17,840
Portanto, esperamos, que era
something-- apenas um teaser curto

933
00:55:17,840 --> 00:55:20,900
do que R é realmente capaz de fazer.

934
00:55:20,900 --> 00:55:23,990
E espero que, você só
confira essas três ligações

935
00:55:23,990 --> 00:55:25,760
e veja o que você pode fazer mais.

936
00:55:25,760 --> 00:55:28,130
E eu acho que é exatamente sobre isso.

937
00:55:28,130 --> 00:55:28,630
Obrigado.

938
00:55:28,630 --> 00:55:30,780
>> [Aplausos]

939
00:55:30,780 --> 00:55:31,968