WEBVTT

00:00.240 --> 00:02.790
Olá e bem vindo a este tutorial do Python.

00:02.790 --> 00:07.230
Tudo bem, temos uma última função a ser implementada na nossa classe de memória de repetição.

00:07.230 --> 00:12.060
Essa é a função simples e é claro que obteremos amostras aleatórias da nossa memória.

00:12.210 --> 00:16.080
E, portanto, esta função irá retornar essas amostras aleatórias.

00:16.080 --> 00:17.850
Tudo bem, então vamos lá.

00:17.870 --> 00:20.630
Vamos chamar isso de simples.

00:20.640 --> 00:21.330
Aqui vamos nós.

00:21.420 --> 00:25.030
E esta função leva dois argumentos como entrada.

00:25.260 --> 00:32.490
O primeiro, como de costume, nosso futuro objeto para reproduzir a classe de memória e o segundo argumento é que

00:32.490 --> 00:33.430
você tenta adivinhar.

00:33.510 --> 00:40.290
Bem, estamos pegando algumas amostras de tamanho fixo e, portanto, precisamos escolher um tamanho para amostras e mais

00:40.290 --> 00:42.610
precisamente chamamos de tamanho de lote.

00:42.820 --> 00:47.910
Então esse é o nome que vamos dar ao nosso segundo tamanho de lote de argumento.

00:48.180 --> 00:49.530
E nós vamos lá.

00:49.560 --> 00:54.490
Nós temos nossos dois argumentos e agora podemos implementar a função simples.

00:54.500 --> 01:00.780
Então, agora, eu só quero avisar que isso vai ficar um pouco técnico, mas vou tentar o meu melhor para explicar.

01:01.250 --> 01:05.140
Então vamos começar criando a variável de amostras.

01:05.150 --> 01:09.620
Esta é apenas a variável que irá conter as amostras da memória.

01:09.620 --> 01:11.340
Tudo bem, tão simples é igual.

01:11.360 --> 01:14.090
E agora, como vamos pegar essas amostras.

01:14.450 --> 01:20.960
Bem antes de tudo, temos que levar nossa memória porque estamos recebendo as amostras da nossa memória.

01:20.960 --> 01:26.870
Então, provavelmente, precisamos do tamanho do lote, porque as amostras vão ter o tamanho

01:26.930 --> 01:27.720
do lote.

01:27.830 --> 01:33.920
tamanho do lote e, em seguida, precisamos de alguns truques de torche ou bison para obter um bom formato dessas amostras.

01:34.040 --> 01:35.600
Então, precisamos de memória, precisamos do

01:35.600 --> 01:40.790
Então, o que eu vou fazer, vou escrever a linha de código e então vou explicar

01:40.790 --> 01:41.900
esse elemento por elemento.

01:41.990 --> 01:42.860
Então, vamos fazê-lo.

01:42.860 --> 01:48.580
Estou começando a tomar uma função zip. Vou explicar muito em breve o que faz.

01:48.620 --> 01:51.980
E dentro desta função eu vou adicionar uma estrela.

01:52.100 --> 01:53.800
Eu também vou expandir isso.

01:53.900 --> 02:02.600
e o pensamento aleatório Central tão aleatório que você poderia ter adivinhado é a biblioteca aleatória que importamos aqui.

02:02.600 --> 02:03.360
O Star

02:03.410 --> 02:08.900
Então, essa é a principal razão pela qual devemos importar essas bibliotecas aleatórias porque estamos fazendo algumas

02:08.900 --> 02:09.730
amostras aleatórias.

02:10.040 --> 02:15.570
Então, a partir desta biblioteca aleatória, vamos usar a função simples.

02:15.600 --> 02:20.060
Então, estas são as nossas variáveis ​​e esta é uma função, então vou adicionar alguns parênteses.

02:20.210 --> 02:26.110
E agora, como você pode ver o exemplo, é uma função e temos que colocar alguns argumentos para que você possa

02:26.110 --> 02:27.850
ver o primeiro argumento em si.

02:27.850 --> 02:34.660
mesmo, isso corresponde à memória de auto-conversa a memória do nosso futuro exemplo objeto de nossa memória de repetição para nós.

02:34.870 --> 02:36.970
E, na verdade, falando de si

02:37.180 --> 02:44.290
Então, vou adicionar aqui a mesma memória e, em seguida, o segundo argumento é como você deve ter adivinhado que o

02:44.530 --> 02:51.360
tamanho do Bechuana tira aleatoriamente da nossa memória e que lhe damos um nome que é o tamanho do lote.

02:51.550 --> 02:55.690
Então, o segundo argumento vai ser Bachche é uma merda.

02:55.870 --> 02:56.410
Tudo bem.

02:56.470 --> 03:01.080
Então, a linha de código é digitada e eu vou explicar o que faz.

03:01.510 --> 03:08.260
Então, antes de tudo, com essa função de ponto aleatório simples, estamos levando algumas amostras aleatórias da

03:08.800 --> 03:11.820
memória que tinham um tamanho fixo desse tamanho.

03:12.550 --> 03:13.940
Então isso é compreensível.

03:14.150 --> 03:18.230
Mas, então, o que essa função estrela Zipp faz.

03:18.530 --> 03:20.500
Bem, não há nenhum mistério sobre isso.

03:20.540 --> 03:22.870
É como uma função de remodelação.

03:22.880 --> 03:28.460
Então, por exemplo, eu vou adicionar um pouco, venha aqui apenas para explicar que vou removê-lo.

03:28.460 --> 03:34.680
Então, digamos que, por exemplo, temos uma lista dos seguintes elementos, por exemplo.

03:34.820 --> 03:37.900
Primeiro dois dois.

03:38.180 --> 03:39.680
E então o segundo elemento.

03:39.680 --> 03:43.180
Quatro cinco seis.

03:43.190 --> 03:48.020
Então, temos uma lista de dois duplos de três elementos, um dois três quatro cinco seis.

03:48.380 --> 03:52.690
Bem, então, se eu aplicar a função zip com a estrela.

03:52.880 --> 04:02.840
Bem, o que se tornaria para que a lista de estrelas Zip seja igual a uma nova lista, mas

04:03.380 --> 04:12.440
de uma forma diferente e uma forma diferente será uma para então duas e cinco e cinco.

04:12.460 --> 04:12.770
Tudo bem.

04:12.800 --> 04:13.950
Então é exatamente o que ele faz.

04:13.970 --> 04:16.640
Ele apenas remodela sua lista.

04:16.990 --> 04:21.610
Ok, agora que você entende o que essa lista de estrelas Zipp faz.

04:21.680 --> 04:24.560
Bem, agora vamos explicar o porquê nós precisamos fazer isso.

04:24.590 --> 04:30.360
Então, como você entende, vamos adicionar os eventos à memória e os eventos têm o formulário.

04:30.440 --> 04:34.530
Primeiro o estado, em seguida, a ação e depois a recompensa.

04:34.820 --> 04:40.330
Mas, para o nosso algoritmo, não queremos esse formato que realmente queremos que nossas amostras tenham o seguinte formato.

04:40.330 --> 04:47.540
Um formato é composto por três amostras de uma amostra para os estados uma amostra para as ações e uma amostra

04:47.540 --> 04:48.660
para a recompensa.

04:48.800 --> 04:53.690
Então, por exemplo, digamos que este um a três é uma ação de um estado.

04:53.800 --> 05:01.100
Nós queremos um e depois declaramos a ação dois e nós devemos bem o que queremos é um lote para cada lote

05:01.100 --> 05:03.630
para o estado e o estado dois.

05:03.680 --> 05:10.090
Um é um jogo para a ação um na ação dois e um terço que para nós éramos um e nós éramos dois.

05:10.190 --> 05:15.680
Esse é apenas o formato que será esperado em seguida, porque então vamos embrulhar esses lotes

05:15.770 --> 05:22.610
em uma torta em direção a um impacto horrível, o que nos lembramos é uma variável que contém um tensor e

05:22.610 --> 05:23.280
um gradiente.

05:23.510 --> 05:29.750
E isso para poder diferenciar em relação a um tensor para poder se diferenciar com respeito

05:29.750 --> 05:35.480
a mais intenso dentro da estrutura de um tensor contendo horrível e um gradiente.

05:35.540 --> 05:37.820
Mais uma vez é assim que a tocha Pi funciona.

05:37.820 --> 05:44.480
Então, para resumir, criamos um lote para cada uma das ações e recompensas do estado e, em seguida, vamos

05:44.480 --> 05:50.600
colocar cada uma dessas ervas separadamente em alguns bytes que o Horrible é que cada um terá

05:50.840 --> 05:54.360
um gradiente para que, eventualmente, possamos diferenciar cada um deles.

05:54.620 --> 05:57.430
Tudo bem, então esse é o propósito da função Zipp.

05:57.480 --> 06:00.350
Então, deixe-me simplesmente remover este comentário.

06:00.530 --> 06:05.980
E agora o único que temos que fazer é retornar as amostras.

06:06.230 --> 06:12.650
as amostras diretamente pela simples razão de que queremos colocar as amostras em um por torche viável.

06:12.830 --> 06:15.670
Então, como acabei de explicar, não podemos devolver

06:15.680 --> 06:22.580
Então, para fazer isso para cada uma das amostras, vamos usar a função do mapa e esta função

06:22.580 --> 06:30.180
do mapa fará o mapeamento das amostras para as variáveis ​​de tortura que conterão um tensor e um gradiente.

06:30.200 --> 06:33.550
Então, como você pode ver, essa função do mapa leva vários argumentos.

06:33.620 --> 06:38.600
O primeiro argumento é uma função e esta função será a função que irá converter

06:38.600 --> 06:40.590
as amostras em algumas variáveis ​​torche.

06:40.760 --> 06:45.340
E o segundo argumento é o que queremos aplicar nesta função.

06:45.590 --> 06:50.580
Então, esses serão os argumentos desta função e, portanto, o que será.

06:50.600 --> 06:52.780
É claro que vão ser as amostras.

06:52.790 --> 06:55.510
Então, o segundo argumento aqui será os símbolos.

06:55.870 --> 06:59.440
Mas então vamos definir a função sobre a qual queremos aplicar.

06:59.480 --> 07:00.620
Cada um dos símbolos.

07:01.040 --> 07:06.890
Então, para definir uma função, precisamos primeiro dar um nome à função que chamará de lambda.

07:07.070 --> 07:14.330
Isso é apenas um nome e dando Lenda, em seguida, X, que será a variável desta função.

07:14.420 --> 07:18.390
Então, esse é apenas um nome e dando para a variável e então.

07:18.500 --> 07:24.140
suposto ser algo que irá converter nossas amostras em uma variável de tocha e para fazer isso.

07:25.400 --> 07:32.010
E aqui nós damos a expressão da função que é o que queremos que esta função lambda retornar e

07:32.250 --> 07:34.800
ver o que vai ser bom é

07:34.800 --> 07:37.370
Já mencionamos isso em alguns tutoriais anteriores.

07:37.560 --> 07:39.880
Bem, nós temos a função Voivode para eles.

07:40.110 --> 07:46.680
A Voz funcionará, faremos essa conversão de um dançarino de tocha para uma variável que conterá

07:46.690 --> 07:48.590
o sensor e o maior.

07:48.810 --> 07:55.830
Então, a primeira coisa que vou adicionar aqui é a variável variável dentro da qual eu vou

07:56.010 --> 08:01.540
converter o X porque o X será os simples que serão aplicados nas amostras.

08:02.420 --> 08:09.080
Mas, então, isso é tudo, há uma última coisa técnica que precisamos implementar é o fato de que,

08:09.140 --> 08:15.680
para cada lote que está contido na amostra, por exemplo, o lote de ações a 1 8

08:15.680 --> 08:23.080
2 3 e as outras ações que temos de concatê-la com respeito para o primeiro motor que corresponde aos Estados.

08:23.120 --> 08:25.380
E por que temos que fazer essa concatenação.

08:25.550 --> 08:27.610
É apenas para que tudo esteja bem alinhado.

08:27.710 --> 08:34.740
Isso é que em cada linha para indicar a ação e a recompensa corresponde ao mesmo tempo t. Então, eventualmente, nós conseguimos uma lista de lotes bem alinhados e cada lote é uma torta em direção ao Voivod.

08:35.180 --> 08:42.240
Então, como podemos fazer essa concatenação.

08:42.470 --> 08:44.700
Bem, precisamos usar a função de gato da biblioteca da tocha.

08:44.840 --> 08:48.030
Então, vamos adicionar aqui a tocha à qual adicionamos

08:48.170 --> 08:55.400
que é aplicada ao X, mas, nessa função, precisamos especificar a dimensão em relação à qual queremos fazer essa concatenação.

08:55.400 --> 09:00.820
E, como acabei de mencionar, este é o primeiro motor de tempos que tem era índice.

09:00.860 --> 09:05.460
E aqui vamos nós, nossa função está pronta para essa Lunda, que irá

09:05.900 --> 09:12.320
levar as amostras a concatê-las em relação ao motor da primeira vez e, em seguida, converteremos os sensores

09:12.320 --> 09:18.110
em algumas variáveis ​​de torche que contenham um tensor e um gradiente para que, mais tarde,

09:18.110 --> 09:24.230
quando nós aplique para castigar no sentido em que poderemos diferenciar para ter pesos de dados.

09:24.230 --> 09:28.610
Tudo bem, então esta função está pronta.

09:28.610 --> 09:30.170
E então aqui está o segundo argumento da função do mapa.

09:30.410 --> 09:35.270
Precisamos especificar o que queremos aplicar a esta função e está em todas as nossas amostras.

09:35.270 --> 09:42.960
Aqui vamos nós.

09:43.040 --> 09:43.850
Vamos aplicar esta

09:43.850 --> 09:50.750
função lambda em todas as amostras, de modo que, eventualmente, obtenhamos uma lista de correspondências onde cada partida é uma tocha PI viável.

09:50.990 --> 09:53.840
Tudo bem, então foi bastante técnico, mas agora, pelo menos, tudo funcionará bem.

09:53.840 --> 09:58.810
Queremos usar essa técnica.

09:58.850 --> 10:00.060
a tocha como você quiser.

10:00.080 --> 10:05.150
Depois, nós só usamos isso aqui, então, se você não quiser ter uma compreensão profunda dos detalhes técnicos aqui bem,

10:05.150 --> 10:11.060
é bom, você pode apenas copiar estas três linhas de código para simples sua memória, se você quiser fazer uma inteligência artificial com

10:11.060 --> 10:14.460
Mas agora a boa notícia é que acabamos com essa experiência de classe

10:14.600 --> 10:21.110
de memória que a reprodução está sendo implementada e podemos passar para a próxima e última classe, que será todo o modo de segurança.

10:21.470 --> 10:26.780
Então, neste modelo, teremos, naturalmente, nossa rede que

10:26.960 --> 10:34.520
experimentará repetição e, em seguida, todo o resto do algoritmo de segurança.

10:34.640 --> 10:36.600
Então, será uma classe muito maior.

10:36.620 --> 10:39.150
que você possa entender melhor o que está acontecendo.

10:39.200 --> 10:44.240
Nós faremos cerca de 10 funções, mas isso é apenas porque estamos fazendo isso passo a passo para

10:44.240 --> 10:46.130
Então eu não posso esperar para implementar nosso modelo de segurança.

10:46.520 --> 10:49.260
E até então eu.

10:49.280 --> 10:50.900