WEBVTT

00:00.330 --> 00:02.170
Olá e bem-vindo ao Statoil.

00:02.400 --> 00:06.270
OK, então calculamos a entropia e a adicionamos à lista de entropias.

00:06.270 --> 00:11.640
E agora o que vamos fazer é tirar uma queda aleatória de uma ação de acordo com a

00:11.700 --> 00:13.190
distribuição das probabilidades do próximo.

00:13.200 --> 00:14.540
Então vamos fazer isso.

00:14.540 --> 00:15.780
Esse é o próximo passo.

00:15.870 --> 00:19.910
Ainda estamos no circuito porque ainda estamos executando as etapas aqui.

00:20.160 --> 00:22.550
E então você agora sabe como jogar a ação.

00:22.590 --> 00:28.740
Em primeiro lugar, vamos introduzir uma variável para a ação chamada ação e, em

00:28.740 --> 00:37.350
seguida, tomamos nossa distribuição de probabilidades e vamos usar a função multi neural para tirar um sorteio aleatório dessa

00:37.350 --> 00:41.390
distribuição de probabilidades e, em seguida, adicionamos esses dados.

00:41.500 --> 00:48.550
Portanto, é importante notar que a ação será realmente um tensor com apenas um valor, mas você não deve

00:48.550 --> 00:51.010
ver isso como um valor simples.

00:51.010 --> 00:57.050
Você deve ver isso como uma condenação de tensor uma por uma que contém esse valor para a ação.

00:57.190 --> 01:02.970
E isso é porque não é espremido ainda no mesmo loop.

01:02.970 --> 01:09.880
Nós vamos obter a probabilidade de log associada à ação que acabou de ser jogada.

01:10.170 --> 01:16.750
E então, quando eu estou namorando a chance da minha chance aqui, tomando a anterior, a sorte

01:16.810 --> 01:25.480
anterior daquilo que calculamos aqui e depois eu vou usar o outro método ao qual eu vou entrar 1 e a ação

01:25.480 --> 01:31.510
que foi apenas jogando porque queremos ter a chance de chance associada a essa ação.

01:31.510 --> 01:38.230
E então o segundo argumento aqui vou colocar minha ação, mas tem que haver como uma tortura horrível,

01:38.860 --> 01:44.530
conforme exigido pela função reunida e a função reunida apenas indexa com um inteiro de tensor.

01:44.530 --> 01:48.910
Tudo bem, então agora acabamos de ter o aspecto de associado à ação que foi exibida.

01:49.030 --> 01:53.790
E agora o próximo passo é acrescentar o que chegamos à lista aqui.

01:53.800 --> 01:55.570
Então, conseguimos o valor.

01:55.750 --> 01:58.820
Isso é o que chegamos aqui como o resultado do modelo.

01:58.840 --> 02:00.880
Então, nós também conseguimos o problema de bloqueio.

02:00.910 --> 02:04.030
Então, vamos adicionar o bloqueio à lista de apoios de bloqueio.

02:04.180 --> 02:09.610
Nós já acrescentamos que a entropia para a entropia é menos boa e as recompensas serão obtidas depois.

02:09.700 --> 02:15.250
Então, vamos abrir o valor e procurar a lista de valores e o processo da lei.

02:15.520 --> 02:16.180
Vamos fazer isso.

02:16.180 --> 02:23.800
que usamos a função de gasto e adicionamos o valor que foi retornado pelo modelo perfeito, então, o mesmo

02:23.920 --> 02:32.700
para os problemas de bloqueio. Nós acabamos de receber nossos novos adereços e vamos anexá-lo à lista de apoios de bloqueio.

02:32.710 --> 02:36.080
Nós levamos a nossa lista de valores, adicionamos

02:36.180 --> 02:43.960
E então, nesta função de anexação, podemos colocar um registro de nossa sorte, provavelmente, foi calculado aqui.

02:43.960 --> 02:47.320
Tudo bem, então nossas listas estão agora bem atualizadas.

02:47.350 --> 02:53.060
Agora, o que vamos fazer é jogar a ação porque na verdade, aqui selecionamos a

02:53.060 --> 02:56.570
ação, tirando um desenho aleatório da distribuição de probabilidades aqui.

02:56.650 --> 03:03.040
Mas, na verdade, ainda não jogamos e vamos jogar agora para que possamos alcançar o novo estado

03:03.220 --> 03:06.150
e, portanto, obter a nova transição e tocá-la.

03:06.170 --> 03:10.960
porque jogamos a ação em nosso ambiente, então vamos usar o método passo.

03:10.960 --> 03:12.990
Nós vamos levar nosso ambiente

03:13.210 --> 03:20.650
E dentro, especificamos a ação que foi selecionada para tocá-la e, para isso, adotamos nossa ação e acrescentamos

03:20.650 --> 03:25.280
que nenhuma, porque é o que se espera que seja a função.

03:25.750 --> 03:35.820
Ok, mas isso retorna realmente o novo estado e também a nova recompensa porque ao alcançar o novo estado obtemos uma nova

03:36.000 --> 03:43.500
recompensa e também obtemos um novo valor para Dunn saber se o jogo está pronto ou não.

03:43.500 --> 03:49.180
Tudo bem, então, com isso, tocamos a ação, chegamos a um novo estado e recebemos uma recompensa e sabemos se

03:49.200 --> 03:50.510
acabamos com o jogo.

03:50.520 --> 03:52.740
E falando em ser feito com o jogo.

03:52.990 --> 03:58.590
Bem, vamos apenas adicionar algo aqui que assegurará que um agente não seja empilhado em

03:58.590 --> 03:59.180
algum estado.

03:59.280 --> 04:04.240
E para fazer isso, vamos atualizar isso feito muito bem da seguinte maneira.

04:04.860 --> 04:11.910
Bem, será igual ou vamos adicionar uma condição dizendo que o episódio do jogo não

04:11.910 --> 04:19.200
deve durar muito tempo e veremos na função principal que haverá um parâmetro de comprimento

04:19.200 --> 04:21.960
máximo que será igual para 10000.

04:22.170 --> 04:25.750
E não queremos que um episódio dure mais de 10000 unidades.

04:25.860 --> 04:34.200
uma condição maior do que o episódio máximo Lex, que na verdade não dissemos isso por completo.

04:34.830 --> 04:43.250
Então, vamos ouvir o comprimento do episódio, que é o comprimento de um episódio e vamos escrever

04:43.250 --> 04:49.210
Estamos obtendo isso de nossos parâmetros para um final aqui Paramjit, mas Ramstad.

04:49.210 --> 04:50.600
Max está ao longo do tempo.

04:50.600 --> 04:59.330
Então, isso significa que se o jogo estiver pronto ou o comprimento do episódio for maior do que o comprimento máximo do conjunto

04:59.330 --> 05:02.110
de episódios, que será igual a 10000.

05:02.270 --> 05:05.410
Bem, o jogo será feito e vamos começar um novo jogo.

05:05.960 --> 05:08.040
OK, então é apenas uma precaução.

05:08.180 --> 05:14.360
precaução, vamos adicionar outra precaução para apertar a recompensa entre menos 1 e mais 1.

05:14.360 --> 05:15.400
E, falando de

05:15.470 --> 05:20.450
Nós já conseguimos que estávamos aqui, mas queremos garantir que a recompensa seja entre menos 1 e

05:20.450 --> 05:20.960
mais 1.

05:21.140 --> 05:27.740
E para fazer isso, precisamos apenas atualizar a recompensa, fazendo isso levando o máximo, em seguida,

05:28.240 --> 05:31.060
levando os homens de recompensa e 1.

05:31.190 --> 05:37.790
E aqui nós levamos o máximo do mínimo de recompensa e 1 e menos 1 e isso garantirá que a

05:37.790 --> 05:40.040
recompensa esteja entre menos uma mais uma.

05:40.160 --> 05:40.910
Tudo bem.

05:40.910 --> 05:42.180
Então, outra percussão.

05:42.380 --> 05:49.070
E agora só queremos verificar se o jogo está pronto, caso em que vamos reiniciar o ambiente.

05:49.220 --> 05:53.010
E por que precisamos verificar que agora é porque acabamos de chegar a um novo estado.

05:53.090 --> 05:54.880
Acabamos de passar por uma nova transição.

05:54.890 --> 05:58.010
Portanto, precisamos verificar que depois de passar esta nova transição.

05:58.130 --> 06:06.860
Bem, o jogo não é feito, então, se feito novamente se for feito, nesse

06:07.250 --> 06:14.180
caso, vamos reiniciar os ambientes, estabelecendo o comprimento do episódio para zero.

06:14.330 --> 06:21.800
reinicializar à medida que tomamos nosso ambiente e usamos a função de reinicialização OK.

06:21.800 --> 06:25.270
E também o estado será reinicializado para

06:25.310 --> 06:29.040
Agora, saímos dessa condição que estava apenas a verificar.

06:29.230 --> 06:34.640
E agora, o que faremos é que chegamos a um novo estado, enquanto esse novo estado é agora e

06:34.640 --> 06:40.410
depois por Ray, porque lembre-se de que os estados são as imagens de entrada que originalmente são nomeadas por arrays.

06:40.570 --> 06:44.430
E agora, o que temos a fazer é converter o novo estado em uma resposta torturada.

06:44.600 --> 06:50.410
Então, vamos atualizar nosso estado e vamos usar a biblioteca da tocha.

06:50.630 --> 07:00.880
E, claro, a função não-tailandesa para converter esses não pagadores indica as imagens de entrada em um sensor

07:00.890 --> 07:01.800
de tocha.

07:02.150 --> 07:03.150
Perfeito.

07:03.260 --> 07:08.620
E agora a última coisa que precisamos fazer antes de sair deste loop para loop que é o

07:08.810 --> 07:13.030
loop em nossos passos Bem, é claro que gaste a recompensa para a Watchlist.

07:13.040 --> 07:18.310
Essa é a última coisa que precisa ser atualizada, atualizamos toda a lista, exceto a recompensa.

07:18.320 --> 07:24.830
Então, vamos fazer isso agora, nós levamos nossas recompensas e usamos sua função cerebral para acrescentar

07:24.830 --> 07:28.110
a última palavra que acabou de ser perfeita.

07:28.220 --> 07:36.110
E logo antes de sair do loop for, precisamos fazer uma última verificação para verificar se, se for

07:37.340 --> 07:39.490
feito, queremos interromper a expiração.

07:39.530 --> 07:42.550
E então, vamos simplesmente adicionar aqui um intervalo.

07:42.560 --> 07:48.590
O que significa que, se for feito, nós interrompemos a exploração e passamos diretamente para

07:48.590 --> 07:56.930
o próximo passo, que será a atualização do modelo compartilhado e agora terminamos com isso por enquanto que o agente fez

07:56.930 --> 07:57.980
sua exploração.

07:58.190 --> 08:04.910
Atualizará o modelo compartilhado e cuidaremos disso no próximo tutorial e então eu.