WEBVTT

00:00.450 --> 00:02.670
Olá e bem vindo a este padrão, é horror.

00:02.850 --> 00:06.890
Tudo bem, então acabamos de atualizar a memória depois de chegar ao novo estado.

00:06.900 --> 00:09.010
E agora vamos cuidar do dia seguinte.

00:09.330 --> 00:12.810
De acordo com você agora, qual será a próxima atualização.

00:12.810 --> 00:20.040
Bem, basicamente, terminamos com uma transição que datamos do último elemento da transição, que é o

00:20.040 --> 00:20.960
novo estado.

00:21.150 --> 00:23.340
Então agora é como se estivéssemos começando de novo.

00:23.520 --> 00:25.530
E quando começamos de novo.

00:25.650 --> 00:31.320
É como se você soubesse que estamos neste novo estado do meio ambiente e, portanto, o que precisamos fazer agora, naturalmente.

00:31.500 --> 00:37.170
Bem, é claro que é uma ação porque já recebemos a observação dos estados de notícias.

00:37.410 --> 00:43.290
Agora, o que temos que fazer é desempenhar uma ação e, portanto, o que precisamos fazer agora é,

00:43.290 --> 00:46.960
naturalmente, usar a função de ação selecionada para executar a ação.

00:47.010 --> 00:54.320
Então, vamos fazer isso, vamos criar uma nova ação Voivode e vamos tocar a ação com a ação selecionada, então

00:54.320 --> 00:55.240
eu estou tomando.

00:55.380 --> 01:03.150
Bem primeiro auto para especificar que a função de ação selecionada é um método do objeto da classe

01:03.150 --> 01:04.300
que será criado.

01:04.470 --> 01:08.610
Então, um eu que seleciona a ação.

01:08.640 --> 01:09.520
Aqui vamos nós.

01:09.560 --> 01:11.090
Então essa é a próxima ação.

01:11.310 --> 01:17.560
E então, claro, uma vez que a função de ação de seleção leva o estado como entrada porque,

01:17.560 --> 01:24.270
claro, a função de ação de seleção retornará a saída da rede neural quando o estado de entrada atual entrou

01:24.270 --> 01:25.220
na rede neural.

01:25.500 --> 01:31.650
e, dado que são os estados que acabamos de alcançar no ambiente agora, onde o estado de entrada é claro,

01:31.650 --> 01:37.350
você declara porque este estado que acabamos de chegar no momento em que estamos agora é o Newstead.

01:37.350 --> 01:40.070
Então, temos que inserir o estágio de entrada aqui

01:40.290 --> 01:45.140
Então, nesta função de ação seletiva, quero dizer, colocar novas varas.

01:45.150 --> 01:51.710
Tudo bem, então, com esta linha de código, simplesmente jogamos a nova ação depois de chegar ao novo estado.

01:52.140 --> 01:58.780
OK e agora que jogamos uma ação. Bem, recebemos a recompensa e, portanto, recebemos feedback com a recompensa.

01:59.010 --> 02:04.550
E, portanto, se tivermos mais de 100 elementos na memória, seria hora de aprender.

02:04.860 --> 02:10.830
E, portanto, o que devemos fazer agora é o que, logicamente, vem depois de selecionar uma ação que, é

02:10.830 --> 02:13.830
claro, para diminuir a AI precisa começar a aprender.

02:13.950 --> 02:15.620
Se estiver fazendo as coisas do jeito certo.

02:15.870 --> 02:22.530
E agora, uma vez que apenas jogou bem a ação, faremos o AI aprender com suas ações

02:22.530 --> 02:23.940
nos últimos 100 eventos.

02:24.130 --> 02:31.320
Mas antes de aplicar esta função aprendida, temos que fazer essa condição para garantir que já alcançamos mais

02:31.320 --> 02:37.380
de 100 eventos, porque você sabe que estamos aprendendo com as amostras aleatórias da memória.

02:37.530 --> 02:41.110
Você sabe que temos essa enorme memória de 10000 elementos.

02:41.190 --> 02:48.930
Nós estamos levando algumas amostras aleatórias da memória de 100 elementos e a AI está aprendendo com

02:48.990 --> 02:52.850
as informações contidas nesta amostra de 100 transições aleatórias.

02:52.860 --> 03:00.690
objeto de sua classe de memória de repetição, mas a classe de memória de repetição tem uma atributo que é memória.

03:00.810 --> 03:06.390
Então, vamos apenas fazer essa condição se para garantir que o número de elementos da memória

03:06.390 --> 03:12.380
dessa memória e, em seguida, ter cuidado apenas um pequeno truque aqui, a memória autodidata é o

03:12.510 --> 03:21.780
Então, de fato, precisamos tomar parte da memória de que a memória da primeira memória é o objeto da classe de

03:21.780 --> 03:28.170
memória de repetição e a segunda memória é o atributo aqui próprio dessa memória.

03:28.200 --> 03:37.350
Então, se o número de elementos na memória estiver bem, queremos que seja maior do que 100, então Cullin E então o

03:37.860 --> 03:38.800
que acontece.

03:38.970 --> 03:46.320
Bem, podemos aprender, mas para aprender precisamos obter essa amostra aleatória de 100 transições e isso

03:46.320 --> 03:48.840
podemos obter com a função simples.

03:48.840 --> 03:55.140
E uma vez que a função simples retorna os diferentes lotes para os estados no tempo t esses dados 20 mais uma

03:55.290 --> 03:57.950
das ações do tempo t e estávamos em 20.

03:58.200 --> 04:03.360
Bem, o que precisamos fazer agora é criar alguns novos avivamentos que irão ser o

04:03.360 --> 04:08.580
lote dos estados no tempo t o lote das datas seguintes o lote das palavras e

04:08.580 --> 04:16.030
o lote das ações e podemos simplesmente dar os mesmos nomes como nós demos para os argumentos aqui e eles estão aqui.

04:16.200 --> 04:24.720
E essas variáveis ​​serão iguais ao que a função simples retorna porque retorna exatamente esses lotes e o

04:24.720 --> 04:28.320
próximo do estado leva palavras e ações.

04:28.320 --> 04:35.570
de memória e, a partir desse objeto de memória, usaremos o método simples que será usado como entrada.

04:35.620 --> 04:40.300
Então, o que simplesmente precisamos fazer é obter primeiro o nosso objeto

04:40.500 --> 04:46.370
Bem, o número de transições que queremos que nossa AI aprenda com isso é 100.

04:46.620 --> 04:50.540
É por isso que nos certificamos de que tivemos mais de cem transições.

04:50.610 --> 04:54.780
Então, vai aprender de 100 transições da memória.

04:54.840 --> 04:56.500
Então, a aprendizagem será muito melhor.

04:56.610 --> 04:59.560
E agora vamos fazer isso realmente acontecer.

04:59.700 --> 05:04.560
Bem, uma vez que o método de aprendizado é um método do nosso na sala de aula.

05:04.830 --> 05:11.180
objetos futuros que serão criados a partir de uma classe diferente e, portanto, o que precisamos tomar é auto.

05:11.190 --> 05:14.300
Bem, precisamos acessar este método de Aprendizagem a partir dos

05:14.430 --> 05:21.960
O eu se refere a esse objetivo para fazer durante a aula e, em seguida, aprenda como este aprendido método método aprendido para

05:22.470 --> 05:29.340
o qual, quando colocado. É claro que esses caras aqui são o estado ruim do estado belga, o mundo natural e

05:29.340 --> 05:30.530
a ação Bachche.

05:30.630 --> 05:38.730
Estes são os nossos lotes amostrados da nossa memória e nós conseguimos 100 deles porque temos 100 transições

05:39.330 --> 05:47.750
dessas 100 transições que levamos 100 Estados 100 próximos estados 100 recompensas e 100 ações vamos enfrentar o

05:47.780 --> 05:51.530
aqui e aí vamos agora a aprendizagem acontecerá.

05:51.850 --> 05:54.490
Isso acontecerá a partir de todos esses lotes aleatórios.

05:54.520 --> 05:55.850
Perfeito.

05:55.960 --> 06:03.310
E agora o que precisamos fazer é as últimas atualizações depois de saber chegar a um novo estado e jogar

06:03.310 --> 06:04.140
em ação.

06:04.330 --> 06:08.890
Bem, nós realmente conseguimos jogar, mas ainda não tivemos essa reação.

06:08.920 --> 06:11.590
Esse é o nosso próprio voivode da última ação.

06:11.770 --> 06:13.730
Então, asseguremos que não esqueçamos isso.

06:13.780 --> 06:15.160
Vamos fazê-lo agora mesmo.

06:15.190 --> 06:24.610
ação que a última ação é igual e, claro, ação a ação que ficamos aqui com esta função de ação selecionada.

06:24.610 --> 06:27.020
Atualizaremos o último eu de

06:27.020 --> 06:30.520
Tudo agora a última seção é atualizada então.

06:30.520 --> 06:31.890
O mesmo para o novo estado.

06:31.930 --> 06:39.190
Chegamos ao novo estado, mas ainda não atualizamos a última data, porque, claro, o último foi antes do estado

06:39.280 --> 06:40.590
no tempo t.

06:40.750 --> 06:44.870
Mas, desde então, atingimos o novo superávit estadual quando é hora de passar um.

06:45.070 --> 06:48.180
Bem, o último se torna este, você disse aqui.

06:48.190 --> 06:50.290
Portanto, precisamos atualizar também.

06:50.290 --> 06:57.070
Aquele último estado é igual ao nosso novo estado.

06:57.280 --> 06:58.020
Aqui vamos nós.

06:58.210 --> 06:59.620
E agora, o que precisamos para namorar.

06:59.830 --> 07:01.640
Bem, só resta uma coisa.

07:01.660 --> 07:08.070
É claro que a palavra e a palavra são exatamente a palavra que recebemos na realidade.

07:08.290 --> 07:15.910
Então, esse será o argumento desta função que, se fizermos a conexão com o nosso mapa, será

07:15.910 --> 07:17.160
a última palavra.

07:17.200 --> 07:23.250
Essa é a palavra que temos logo depois de jogar a ação nestes estados novos alcançados.

07:23.470 --> 07:30.260
Então, se avançarmos para algum som, esta última palavra será aquela menos uma, se formos mais longe, vamos

07:30.290 --> 07:35.580
ter uma palavra ligeiramente ruim menos 0. 2 se nos aproximarmos do objetivo.

07:35.660 --> 07:38.680
Obteremos uma recompensa ligeiramente boa 0. 1.

07:38.830 --> 07:43.370
E se chegarmos muito perto de uma borda do mapa bem, isso será sobre punição.

07:43.510 --> 07:45.330
Obteremos menos um para cada um.

07:45.440 --> 07:47.110
Então, essa é a última palavra que recebemos.

07:47.110 --> 07:50.700
Na realidade, é quando isso acontece de forma real no mapa.

07:50.830 --> 07:53.550
E este será o argumento da função.

07:53.600 --> 07:54.690
A última palavra aqui.

07:54.700 --> 07:56.200
É exatamente esse.

07:56.250 --> 08:01.840
E assim, uma vez que este é o argumento da função de atualização

08:02.170 --> 08:11.590
bem que corresponde a isso, não estávamos aqui e, portanto, a nossa própria variável da palavra anterior inicializada no início nesta

08:12.070 --> 08:20.570
função torna-se a nova palavra que recebemos na realidade, que é a palavra ou aquilo a mesma última palavra.

08:20.730 --> 08:21.360
Tudo bem.

08:21.410 --> 08:23.680
Agora nós atualizamos nossa última palavra.

08:23.990 --> 08:27.240
E agora, já que acabamos de receber nossa última palavra.

08:27.500 --> 08:29.470
Bem, agora podemos namorar o mundo.

08:29.850 --> 08:37.140
Você se lembra da guerra quando inicializamos aqui como uma das variáveis ​​do objeto da nossa classe.

08:37.190 --> 08:42.500
Essa é a janela que vai acompanhar a forma como este trem está indo tomando a

08:42.500 --> 08:44.270
média da última recompensa 100.

08:44.300 --> 08:50.180
Então você sabe que será como uma janela deslizante mostrando-nos como a média do mundo está evoluindo.

08:50.180 --> 08:52.730
E assim que acabamos de receber nossa última palavra.

08:52.910 --> 08:56.910
Bem, podemos atualizar o que fomos direto para como atualizá-lo.

08:57.080 --> 09:03.680
de guerra para que digamos quando ouvirem isso e eu vou usar a função de anexar.

09:03.980 --> 09:12.350
Bem, simplesmente precisamos acrescentar esta última palavra à janela e, portanto, o que eu vou fazer é levar minha janela

09:12.530 --> 09:18.830
E dentro da função aberta, precisamos inserir o elemento que queremos acrescentar ao que

09:18.830 --> 09:21.480
estávamos ao fazer, é claro, queremos.

09:21.500 --> 09:22.610
Tudo bem perfeito.

09:22.610 --> 09:29.480
E então, uma vez que esta janela de guerra vai ter um tamanho fixo, você sabe que não vai ser uma janela

09:29.480 --> 09:35.300
crescente, será uma janela de tamanho fixo que desliza com o tempo para mostrar a evolução do mundo.

09:35.500 --> 09:38.590
E agora, precisamos decidir por um tamanho deste inverno.

09:38.750 --> 09:43.600
E é simplesmente o número de meios da recompensa que teremos nesta janela.

09:43.900 --> 09:49.330
E por isso, por exemplo, vamos fazer você conhecer os últimos 1000 meios das últimas 100 palavras.

09:49.340 --> 09:58.730
E para ter certeza de que vamos adicionar se planejar, então nós levamos nossa janela de trabalho e simplesmente

09:58.740 --> 10:05.810
adicionamos aqui se o número de elementos na janela for maior do que 1000.

10:05.990 --> 10:14.780
Bem, o que queremos fazer é excluir o primeiro elemento desse que nossa janela e o

10:14.780 --> 10:19.070
primeiro elemento desta janela tiveram que indexar zero.

10:19.150 --> 10:19.550
Tudo bem.

10:19.550 --> 10:24.620
Agora, certifique-se de que esta janela de guerra nunca terá mais de 1000 elementos.

10:24.620 --> 10:31.130
perfeitas, isto será uma janela de tamanho fixo para que possamos ver se a média da palavra está aumentando.

10:31.310 --> 10:34.360
Há mil meios das últimas 100 palavras que são

10:34.460 --> 10:39.560
E, portanto, se o treinamento está indo bem e, consequentemente, o tribunal faz o que queremos.

10:39.800 --> 10:40.760
Perfeito.

10:41.000 --> 10:46.010
E agora, uma pequena coisa pequena a fazer, de acordo com você, o que será.

10:46.190 --> 10:52.130
Bem, lembre-se desta função de atualização não só atualiza os diferentes elementos da transição na janela

10:52.140 --> 10:57.960
de guerra, mas também retorna a ação que foi tocada ao atingir esse novo estado.

10:58.190 --> 11:05.270
É por isso que temos e, em seguida, essa ação é igual a trazer essa data que somos menos sinal

11:05.360 --> 11:10.760
e, portanto, é suposto retornar algo e o que devemos retornar é, claro, a ação.

11:10.820 --> 11:18.950
Então, a simples última coisa que precisamos fazer aqui é apenas retornar a ação que foi jogada apenas ao chegar

11:18.950 --> 11:20.180
ao novo estágio.

11:20.600 --> 11:23.670
E essa é a nossa função de atualização está pronta.

11:23.840 --> 11:29.110
Ele vai fazer todas as atualizações necessárias e ele virará a ação ao atingir a nova etapa.

11:29.480 --> 11:30.650
Perfeito.

11:30.650 --> 11:35.230
Essa foi a última ação difícil para fazer de tudo isso um processo.

11:35.240 --> 11:37.120
Agora, o resto será bom.

11:37.220 --> 11:42.170
Nós simplesmente criaremos uma função central para retornar os meios que queremos na janela.

11:42.200 --> 11:47.450
Então, faremos uma função segura para salvar o cérebro do carro sempre que quiser sair do aplicativo

11:47.600 --> 11:48.840
e voltar para ele.

11:48.890 --> 11:53.720
E, claro, porque você quer carregar o cérebro do seu carro quando você voltar para ele, volte

11:53.720 --> 11:54.730
para o aplicativo.

11:55.040 --> 12:01.370
Bem, vamos acabar fazendo uma função de carga que irá carregar seu modelo depois de salvar seu modelo

12:01.370 --> 12:02.800
com a mesma função.

12:02.840 --> 12:06.470
Então, três funções para fazer isso, mas será simples.

12:06.500 --> 12:12.760
a seção mais emocionante deste primeiro módulo que é a demonstração, veremos se o ar funciona.

12:12.770 --> 12:13.840
E então teremos

12:13.850 --> 12:19.430
Veremos se o carro atinge os objetivos e veremos como podemos melhorar e, eventualmente,

12:19.430 --> 12:21.980
você terá que construir seu primeiro AI.

12:22.160 --> 12:24.010
Então eu não posso esperar para começar a demonstração.

12:24.140 --> 12:27.580
Vamos fazer essas três funções primeiro e até então I.