WEBVTT

00:00.330 --> 00:05.940
Olá e bem-vindo a este tutorial, este brinquedo especial vai ser super emocionante porque nos aproximamos

00:05.940 --> 00:08.540
do A. S. C. algoritmo.

00:08.700 --> 00:14.190
Você vai ver que o que estamos prestes a implementar e que é chamado de rastreamento de

00:14.520 --> 00:20.250
elegibilidade ou Sarsour é realmente um algoritmo dos algoritmos de agentes de críticos ativos síncrona que não podemos

00:20.250 --> 00:20.380
considerá-lo.

00:20.380 --> 00:25.290
um agente, mas ainda assim você verá que o que estamos prestes a

00:25.290 --> 00:32.010
implementar é realmente tirado do seguinte artigo, que é este documento como método Synchronoss para aprendizagem de reforço

00:32.130 --> 00:38.280
profundo e é Neste artigo, você encontrará algoritmos A-3 que implementaremos como bônus final deste curso.

00:38.280 --> 00:40.840
E nós vemos porque ainda vamos ter

00:41.010 --> 00:47.580
Mas, como eu disse, estamos nos aproximando porque o modelo que vai implementar agora é realmente

00:48.420 --> 00:55.620
esse, o síncrono e o secularizado, aquele que é quase o A3 C que está fazendo depois disso,

00:55.620 --> 01:03.490
mas com um agente e o poderoso sobre isso é Este e passo Cunanan, vamos aprender a acumular recompensas

01:03.490 --> 01:09.520
e aprender o alvo cumulativo em etapas finais em vez de um passo como Priestley.

01:09.690 --> 01:15.250
E é isso que vai fazer o treinamento muito mais desempenho e, portanto, são muito mais poderosos.

01:15.300 --> 01:21.080
Então, nós realmente temos o pseudo código para este algoritmo, é esse algoritmo aqui.

01:21.180 --> 01:23.230
Então vamos clicar nele e lá vamos nós.

01:23.250 --> 01:25.740
Esse é o algoritmo que estamos prestes a implementar.

01:25.890 --> 01:30.960
Mas lembre-se com apenas um agente, a diferença é que eles tomam uma ação.

01:30.990 --> 01:37.380
80 de acordo com a política do presidente Greely com base nos valores de q para o estado atual e a

01:37.380 --> 01:38.020
ação tocada.

01:38.190 --> 01:42.050
Mas, no nosso caso, não implementamos uma excelente política verde.

01:42.090 --> 01:43.770
Implementamos um Max macio.

01:43.890 --> 01:46.110
Mas o resto é o mesmo que você pode ver.

01:46.110 --> 01:50.210
Vamos calcular o acumulado em que trabalhamos e, na verdade, 10 etapas.

01:50.220 --> 01:52.340
Lembre-se que os passos são iguais a 10.

01:52.440 --> 01:58.170
E então vamos implementar esta linha de código em nosso algoritmo que estamos prestes a implementar agora.

01:58.170 --> 01:59.010
Nós vamos conseguir isso.

01:59.010 --> 02:02.150
E principalmente, vamos implementar isso também.

02:02.160 --> 02:07.590
Você verá que obteremos o máximo dos valores de q para o estado atual e a

02:07.590 --> 02:08.820
ação atual neste theta.

02:08.820 --> 02:11.150
Aqui está apenas um parâmetro de destino.

02:11.430 --> 02:15.350
Então, vamos fazer isso, vamos atacar esse algoritmo.

02:15.360 --> 02:18.730
Este é chamado de aprendizado síncrono e avançado.

02:18.900 --> 02:24.490
Mas não temos o direito de dizer síncrono, tanto quanto estamos preocupados, porque só temos um motor.

02:24.670 --> 02:29.830
Mas, portanto, podemos chamá-lo e aprender o rastreio de elegibilidade ou mesmo o Sarsour.

02:30.270 --> 02:31.780
Tudo bem, então vamos fazer isso.

02:31.800 --> 02:33.080
Vai ser muito divertido.

02:33.090 --> 02:37.460
Nós podemos basicamente seguir o código aqui e é isso que vamos fazer.

02:37.460 --> 02:43.980
E, assim como você pode ver um parâmetro que precisaremos, é novamente o parâmetro que é o

02:44.280 --> 02:50.820
parâmetro de decaimento e, portanto, vamos começar por introduzir uma variável para este parâmetro Gahanna e escolhê-los.

02:50.820 --> 02:51.840
Então vamos fazer isso.

02:51.900 --> 02:57.040
Na verdade, não precisamos de uma sala de aula tremenda. Podemos simplesmente implementar isso com uma função,

02:57.040 --> 03:01.830
porque você sabe que realmente não precisamos criar objetos para que este seja um modelo de

03:02.190 --> 03:08.500
modelo, uma função será suficiente porque basicamente o que queremos fazer é devolver as entradas eo alvo para que, mais tarde,

03:08.500 --> 03:14.460
ao treinar o AI, estamos prontos para minimizar a distância entre as previsões e o alvo e para obter as

03:14.470 --> 03:19.950
previsões, precisamos das entradas, porque vamos aplicar o nosso cérebro na entrada para obter a saída sinais que

03:19.950 --> 03:21.300
serão nossas previsões.

03:21.300 --> 03:26.730
prontos para treinar a IA tentando minimizar essa grande distância entre as previsões e os banheiros.

03:26.730 --> 03:30.680
E então, uma vez que tenhamos nossas previsões e nossos objetivos, estaremos

03:30.690 --> 03:32.780
Então, esse é o objetivo de fazer isso agora.

03:32.880 --> 03:38.130
Estamos implementando esta função para poder retornar essas entradas nos soviéticos para que possamos estar

03:38.130 --> 03:43.010
prontos para o treinamento para minimizar as previsões de distância quadradas gerenciar banheiros.

03:43.020 --> 03:46.400
Tudo bem, então vamos fazer isso, como dissemos, queremos implementar funções.

03:46.410 --> 03:47.910
Começamos com isso.

03:47.940 --> 03:52.680
Isto, vamos chamar a elegibilidade, ressaltou o rastreamento.

03:52.860 --> 03:54.210
Você também pode chamá-lo de Sarsour.

03:54.240 --> 04:00.660
Você também pode chamá-lo de dar um passo para tocar o que quiser, mas vamos chamar ele

04:00.660 --> 04:07.530
de rastreabilidade e esta função vai levar um argumento que vai ser um lote e por que é

04:07.530 --> 04:13.460
porque vamos conseguir algumas insumos e alguns objetivos porque Nós vamos treinar o AI em lotes.

04:13.530 --> 04:19.170
E assim, as entradas e os alvos irão dentro de alguns lotes e, portanto, o argumento de

04:19.410 --> 04:25.090
entrada aqui é esse lote que conterá várias entradas e, em seguida, vários destinos que serão computados.

04:25.500 --> 04:26.730
Então vamos lá.

04:26.730 --> 04:28.310
Esse é o único argumento que precisamos.

04:28.500 --> 04:32.280
Agora vamos dentro de uma função e vamos definir o que precisávamos fazer.

04:32.370 --> 04:40.140
Então, como vimos na Basílica do artigo, precisamos novamente os parâmetros, como dissemos, começamos por introduzir

04:40.440 --> 04:45.390
este parâmetro gama semi-fechado e já podemos decifrar o valor.

04:45.450 --> 04:51.780
E vamos escolher quatro nove e nove, que é um bom valor clássico para o Gana e Norreys.

04:51.780 --> 04:55.640
Eu verifiquei que este é um bom valor para a nossa AI.

04:55.650 --> 05:04.120
Tudo bem, então, o próximo passo no próximo passo é preparar nossa entrada e nossos objetivos, porque é exatamente isso

05:04.120 --> 05:05.260
que queremos retornar.

05:05.260 --> 05:08.980
Queremos devolver os insumos em metas para preparar o treinamento.

05:08.980 --> 05:15.520
isso é ao inicializar as entradas como uma lista, bem como os alvos que vamos.

05:15.790 --> 05:21.130
E então podemos inicializá-los com uma lista vazia, claro, essas entradas dentro do

05:21.430 --> 05:25.000
melhor, vamos ter várias entradas em uma lista e

05:25.000 --> 05:31.420
Então, inicializamos nosso e colocamos nossos objetivos e, no final, essa função de rastreamento de elegibilidade

05:31.540 --> 05:33.320
retornará exatamente essas entradas.

05:33.330 --> 05:36.180
E estes sim eram, naturalmente, Filton.

05:36.290 --> 05:42.300
Temos várias entradas e as várias metas associadas no que será retornado pela função.

05:42.300 --> 05:48.820
Tudo bem próximo ao próximo passo é iniciar um loop e é exatamente porque estamos seguindo o

05:48.880 --> 05:50.290
código lento do papel.

05:50.290 --> 05:51.400
Esse tipo de código.

05:51.490 --> 05:58.420
E, como você pode ver, há esta seção de código repetido e repetido exatamente um loop completo no código.

05:58.470 --> 06:03.870
Vamos calcular a recompensa cumulativa aqui acumulada durante as 10 etapas.

06:03.940 --> 06:05.130
E como é computado.

06:05.290 --> 06:10.480
Bem, em cada passo que não é o último passo, vamos conseguir o máximo dos valores principais da moeda

06:10.480 --> 06:13.070
em que estamos durante este e os passos executados.

06:13.240 --> 06:17.790
E se alcançarmos o último estado dos 10 passos, isso será igual a zero.

06:17.890 --> 06:19.810
Isso é que não queremos fazê-lo mais.

06:20.080 --> 06:23.320
E então temos esse loop para o qual será outro.

06:23.470 --> 06:28.390
Eles não dizem repetir aqui, mas é o mesmo, será o segundo ciclo completo em nosso algoritmo.

06:28.600 --> 06:34.570
Bem, nós teremos em que nós estávamos assim multiplicando pelo parâmetro de decaimento gama e adicionando

06:34.840 --> 06:35.660
a palavra.

06:36.010 --> 06:41.510
Então, vamos fazer isso, vamos voltar para Python e vamos começar o nosso completo.

06:41.980 --> 06:44.920
E qual será a variável iterativa.

06:45.070 --> 06:47.820
Bem, essa será a nossa série de 10 passos.

06:47.890 --> 06:55.510
vamos chamar essa série variável que representa uma série de 10 transições como uma seqüência de 10 transições.

06:55.600 --> 06:58.820
Você conhece nossa série de 10 transições, então

06:58.860 --> 07:00.910
Então, para séries em.

07:01.210 --> 07:02.400
E então, o que você acha.

07:02.620 --> 07:05.570
Bem, nossa série será baixa em nosso lote.

07:05.680 --> 07:12.040
Há os lotes em que irá treinar a AI e assim por diante série em lote que é para todas as séries

07:12.040 --> 07:14.540
de 10 transições em nosso lote de entrada.

07:14.800 --> 07:20.710
Bem, onde vamos fazer bem em obter uma recompensa cumulativa, você verá na sílica que precisamos

07:20.950 --> 07:26.560
do estado da primeira transição da série e também do estado da última transição da série.

07:26.740 --> 07:33.040
Então, o que temos que fazer agora é obter esses estados de entrada e, portanto, vamos colocar

07:33.130 --> 07:39.380
estes dois estados em uma viabilidade que chamaria entrada e nós obteremos esses dois estados de entrada.

07:39.400 --> 07:46.590
A primeira da série e a última que vamos colocar em uma matriz não-piloto, mas sem preocupações, não ficará

07:46.800 --> 07:51.880
com isso e Ampyra, claro, converterá isso em um horrível, mas o primeiro

07:51.880 --> 07:56.930
passo é colocar esses dois indica o primeiro no último em um império.

07:57.240 --> 08:03.850
da série e que é Series e, em seguida, levá-la para uma transição, tomamos o índice zero da

08:03.850 --> 08:10.820
série que é a primeira transição e depois podemos acessá-lo tomando seus atributos que é o estado e isso

08:10.820 --> 08:17.780
porque, em nosso arquivo de repetição de experiência, encontramos uma estrutura especial para cada transição e você conhece a estrutura.

08:18.290 --> 08:24.200
E então aqui mesmo, nesta matriz, adicionamos a primeira entrada, que é a fase de entrada

08:24.440 --> 08:25.660
da primeira transição

08:25.730 --> 08:29.380
Cada transição é composta por um estado de uma palavra de ação.

08:29.570 --> 08:34.970
Mas, em seguida, o último elemento que é feito para que esta estrutura especial que nós possamos usar

08:35.240 --> 08:39.250
agora venha da forma como definimos a transição e a experiência de repetição.

08:39.290 --> 08:45.380
Tudo bem, então, com isso, obtemos o estado de entrada da primeira transição e agora podemos obter também

08:45.380 --> 08:48.640
o estágio de entrada da última transição da série.

08:48.800 --> 08:57.200
podemos acessar com este truque menos uma série menos aquele que receberá o estado de entrada do último transição da série.

08:57.200 --> 09:04.040
E para fazer isso, é dizer que podemos copiar isso e colá-lo e substituir, como você está

09:04.100 --> 09:07.420
aqui, pelo último índice da série a que

09:08.210 --> 09:16.310
Tudo bem, então, precisamos colocar esses dois elementos dentro de alguns colchetes porque é o que se espera do árbitro

09:16.310 --> 09:23.120
uma função e, então, uma coisa importante a fazer, uma vez que vamos converter isso em uma

09:23.210 --> 09:26.140
resposta de tocha em uma variável de tocha.

09:26.330 --> 09:31.810
Bem, lembre-se de um tensor da tocha é, por definição, uma matriz especial contendo um único tipo.

09:31.940 --> 09:34.640
E então precisamos forçar um único tipo.

09:34.760 --> 09:42.020
escolher o tipo de flutuador e, assim, adicionar esse parâmetro aqui D tipo igual e P que flutua.

09:42.750 --> 09:45.030
E, como de costume, vamos

09:45.320 --> 09:52.380
Para que você possa tomar este e agora podemos converter isso em um tensor de tocha em um voivode de tocha.

09:52.550 --> 09:54.640
Então, faça isso, faça isso.

09:54.770 --> 09:57.470
Bem, primeiro vamos converter isso em um sensor de tocha.

09:57.590 --> 10:06.880
E lembre-se de que podemos usar torche que de não-prime que nós vamos e colocamos toda a matriz dos dois estados de

10:06.900 --> 10:15.180
entrada dentro deste dançarino de tocha com a tocha deles por função perfeita que irá converter esses arrays dos dois

10:15.250 --> 10:18.230
estados de entrada em uma tocha sensor.

10:18.420 --> 10:26.560
a resposta em uma tocha muito bem usando a classe de variáveis, então a entrada será um objeto da classe valiosa.

10:26.560 --> 10:28.400
E agora colocamos esta tocha

10:28.480 --> 10:35.380
E na verdade, como você entendeu, essa classe de variáveis ​​leva tudo isso como argumento e isso

10:35.380 --> 10:36.680
cria o objeto.

10:36.680 --> 10:38.420
Tudo bem, então agora devemos ser bons.

10:38.450 --> 10:41.000
Nós temos nossos dois insumos que precisamos.

10:41.000 --> 10:45.440
Esse é o estado de entrada da primeira transição e, em seguida, a entrada diz que a última transição.

10:45.770 --> 10:51.890
E agora, agora que temos as entradas Bem, o que podemos obter, podemos obter o sinal de saída do cérebro

10:51.890 --> 10:52.560
da AI.

10:52.640 --> 10:56.160
Essa é a predição de que vamos chamar saídas.

10:56.630 --> 10:57.950
Esse é o sinal de saída.

10:58.130 --> 10:59.280
E para obter as saídas.

10:59.330 --> 11:04.670
Bem agora, isso é muito fácil porque já criamos um cérebro que é a nossa rede

11:04.670 --> 11:05.330
neural convolutiva.

11:05.570 --> 11:14.120
E assim podemos simplesmente levar o nosso cérebro CNN aplicado às entradas que irá retornar a previsão que é

11:14.120 --> 11:16.650
o resultado tão simples quanto isso.

11:16.820 --> 11:19.510
E agora já estamos prontos para avançar para o próximo passo.

11:20.730 --> 11:24.890
E o próximo passo é começar a calcular esta comunidade se desejar.

11:25.090 --> 11:30.690
Então, agora vamos fazer exatamente o mesmo que o nosso algoritmo como o Sarsour ou devemos

11:30.760 --> 11:32.300
chamá-lo e passos para aprender.

11:32.290 --> 11:39.990
Nós vamos apresentar a variável de recompensa cumulativa que será a recompensa cumulativa, vamos voltar ao artigo, como você pode

11:39.990 --> 11:45.120
ver agora, o que temos a fazer para obter essa recompensa comunitária que é

11:45.210 --> 11:46.000
nossa aqui.

11:46.170 --> 11:53.160
atualizá-lo adicionando um zero a esta comunidade se estivéssemos se alcançássemos a última etapa da série ou o máximo

11:53.160 --> 11:59.910
dos valores centrais se não alcançarmos a última etapa de A série é para todas as estaticas que duraram.

12:00.000 --> 12:03.410
Bem e cada passo dos 10 passos correu, precisamos

12:03.750 --> 12:05.890
Então, isso é simplesmente uma bonança.

12:06.000 --> 12:07.580
Voltemos para Piscean.

12:07.650 --> 12:16.490
Então, essa recompensa comunitária, como acabamos de ver, será igual a zero ponto zero se chegarmos ao último estado

12:16.490 --> 12:23.070
e podemos escrever esta condição dessa maneira se uma série de índice menos 1.

12:23.070 --> 12:25.940
Essa é a última transição da série.

12:26.250 --> 12:32.280
definimos na experiência que jogamos nossa falta de repetição de experiência e isso é feito vem das

12:32.280 --> 12:38.400
estruturas de abertura, porque se vamos ao site aberto da Allergan que é realmente correto Aqui eu preparei.

12:38.400 --> 12:44.550
Então, adicionamos isso feito porque o fato é realmente um atributo de você conhecer esta estrutura de

12:44.550 --> 12:45.240
transição que

12:45.280 --> 12:47.160
Isso é bom ou vizir.

12:47.340 --> 12:52.300
E se nós vamos à documentação e depois, se nós.

12:52.380 --> 12:55.240
Esse é o tutorial que eu realmente incentivo você a dar uma olhada nisso.

12:55.470 --> 13:01.530
Você pode executar um ambiente que Knowsley você pode ver que nossas observações de que estas

13:01.950 --> 13:04.690
são transições são definidas por uma observação.

13:04.790 --> 13:12.150
Queremos que isso seja feito aqui e isso significa exatamente que uma transição ou um passo acabou.

13:12.150 --> 13:15.440
E então vamos usar isso feito aqui para nossa condição IF.

13:15.610 --> 13:23.460
Portanto, a loucura iSeries quando isso significa se a última transição da série acabou.

13:23.730 --> 13:29.290
E então, essa recompensa cumulativa será igual a zero se a última transição da série for feita.

13:29.330 --> 13:37.290
Caso contrário, se não tivermos alcançado a última recompensa cumulativa bem sucedida, será atualizado com

13:37.290 --> 13:40.950
o que dissemos o máximo de valores-chave.

13:41.220 --> 13:47.460
E como essa saída é a saída do cérebro que é a previsão da rede neural.

13:47.520 --> 13:53.640
E como você sabe, as previsões da rede neural são os valores previstos. Bem, esta saída

13:53.920 --> 13:55.040
contém os valores.

13:55.110 --> 14:01.130
E uma vez que precisamos ter o máximo de valores de q, precisamos adicionar primeiro esse

14:01.130 --> 14:04.620
índice porque essa estrutura contém dois valores-chave e o próximo.

14:04.620 --> 14:07.830
E então precisamos adicionar dados para acessar os dados.

14:07.830 --> 14:12.150
Esta estrutura de saída que você conhece tem a estrutura especial de um voivode de tocha.

14:12.270 --> 14:17.910
Então, com isso, obtemos nossos valores fundamentais e, em seguida, queremos tirar o máximo de nossos valores

14:17.910 --> 14:20.470
de sugestão e, portanto, adicionamos esse Max.

14:20.490 --> 14:27.820
E agora, obtemos exatamente o que queremos, como no papel, este máximo dos valores de cubo para

14:27.820 --> 14:30.240
os estados não-terminais, como para aperfeiçoar.

14:30.280 --> 14:33.460
E agora, o que vamos fazer é fazer a segunda dobra.

14:33.930 --> 14:40.830
Isso é para as 10 etapas da série que vamos atualizar o cumulativo foi assim multiplicando primeiro por

14:40.830 --> 14:46.170
Gamma o parâmetro de decaimento que já temos e depois adicionamos a palavra B.

14:46.410 --> 14:47.540
Então vamos fazer isso.

14:47.610 --> 14:52.260
Na verdade, vamos fazer exatamente o mesmo que no pseudocódigo, como você pode notar, eles começam

14:52.260 --> 14:52.970
pela direita.

14:53.040 --> 14:59.010
Então eles não estão começando com o primeiro passo e vão ao último teste que começam com o último passo.

14:59.040 --> 15:02.280
T-menos 1 para o primeiro passo para começar.

15:02.340 --> 15:06.520
Isso é exatamente o que vamos fazer e é por isso que

15:06.610 --> 15:15.840
queremos chegar no final a recompensa cumulativa igual à nossa igual ou zero mais a gama ou 1 mais gama quadrada ou duas mais que adicionou

15:15.840 --> 15:24.420
mais a gama no poder de 10 ou 10 onde são 1 ou 2 que são 10 são a palavra obtida em cada uma

15:24.420 --> 15:25.580
das etapas da série.

15:25.590 --> 15:29.870
Então, vamos dar uma pausa rápida antes de tomar o segundo ciclo completo e eu vou ver você no próximo tutorial.

15:30.030 --> 15:31.530
Até então, desfrute da AI.