Olá e bem vindo a este tutorial do Python.
Tudo bem, temos uma última função a ser implementada na nossa classe de memória de repetição.
Essa é a função simples e é claro que obteremos amostras aleatórias da nossa memória.
E, portanto, esta função irá retornar essas amostras aleatórias.
Tudo bem, então vamos lá.
Vamos chamar isso de simples.
Aqui vamos nós.
E esta função leva dois argumentos como entrada.
O primeiro, como de costume, nosso futuro objeto para reproduzir a classe de memória e o segundo argumento é que
você tenta adivinhar.
Bem, estamos pegando algumas amostras de tamanho fixo e, portanto, precisamos escolher um tamanho para amostras e mais
precisamente chamamos de tamanho de lote.
Então esse é o nome que vamos dar ao nosso segundo tamanho de lote de argumento.
E nós vamos lá.
Nós temos nossos dois argumentos e agora podemos implementar a função simples.
Então, agora, eu só quero avisar que isso vai ficar um pouco técnico, mas vou tentar o meu melhor para explicar.
Então vamos começar criando a variável de amostras.
Esta é apenas a variável que irá conter as amostras da memória.
Tudo bem, tão simples é igual.
E agora, como vamos pegar essas amostras.
Bem antes de tudo, temos que levar nossa memória porque estamos recebendo as amostras da nossa memória.
Então, provavelmente, precisamos do tamanho do lote, porque as amostras vão ter o tamanho
do lote.
tamanho do lote e, em seguida, precisamos de alguns truques de torche ou bison para obter um bom formato dessas amostras.
Então, precisamos de memória, precisamos do
Então, o que eu vou fazer, vou escrever a linha de código e então vou explicar
esse elemento por elemento.
Então, vamos fazê-lo.
Estou começando a tomar uma função zip. Vou explicar muito em breve o que faz.
E dentro desta função eu vou adicionar uma estrela.
Eu também vou expandir isso.
e o pensamento aleatório Central tão aleatório que você poderia ter adivinhado é a biblioteca aleatória que importamos aqui.
O Star
Então, essa é a principal razão pela qual devemos importar essas bibliotecas aleatórias porque estamos fazendo algumas
amostras aleatórias.
Então, a partir desta biblioteca aleatória, vamos usar a função simples.
Então, estas são as nossas variáveis ​​e esta é uma função, então vou adicionar alguns parênteses.
E agora, como você pode ver o exemplo, é uma função e temos que colocar alguns argumentos para que você possa
ver o primeiro argumento em si.
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.
E, na verdade, falando de si
Então, vou adicionar aqui a mesma memória e, em seguida, o segundo argumento é como você deve ter adivinhado que o
tamanho do Bechuana tira aleatoriamente da nossa memória e que lhe damos um nome que é o tamanho do lote.
Então, o segundo argumento vai ser Bachche é uma merda.
Tudo bem.
Então, a linha de código é digitada e eu vou explicar o que faz.
Então, antes de tudo, com essa função de ponto aleatório simples, estamos levando algumas amostras aleatórias da
memória que tinham um tamanho fixo desse tamanho.
Então isso é compreensível.
Mas, então, o que essa função estrela Zipp faz.
Bem, não há nenhum mistério sobre isso.
É como uma função de remodelação.
Então, por exemplo, eu vou adicionar um pouco, venha aqui apenas para explicar que vou removê-lo.
Então, digamos que, por exemplo, temos uma lista dos seguintes elementos, por exemplo.
Primeiro dois dois.
E então o segundo elemento.
Quatro cinco seis.
Então, temos uma lista de dois duplos de três elementos, um dois três quatro cinco seis.
Bem, então, se eu aplicar a função zip com a estrela.
Bem, o que se tornaria para que a lista de estrelas Zip seja igual a uma nova lista, mas
de uma forma diferente e uma forma diferente será uma para então duas e cinco e cinco.
Tudo bem.
Então é exatamente o que ele faz.
Ele apenas remodela sua lista.
Ok, agora que você entende o que essa lista de estrelas Zipp faz.
Bem, agora vamos explicar o porquê nós precisamos fazer isso.
Então, como você entende, vamos adicionar os eventos à memória e os eventos têm o formulário.
Primeiro o estado, em seguida, a ação e depois a recompensa.
Mas, para o nosso algoritmo, não queremos esse formato que realmente queremos que nossas amostras tenham o seguinte formato.
Um formato é composto por três amostras de uma amostra para os estados uma amostra para as ações e uma amostra
para a recompensa.
Então, por exemplo, digamos que este um a três é uma ação de um estado.
Nós queremos um e depois declaramos a ação dois e nós devemos bem o que queremos é um lote para cada lote
para o estado e o estado dois.
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.
Esse é apenas o formato que será esperado em seguida, porque então vamos embrulhar esses lotes
em uma torta em direção a um impacto horrível, o que nos lembramos é uma variável que contém um tensor e
um gradiente.
E isso para poder diferenciar em relação a um tensor para poder se diferenciar com respeito
a mais intenso dentro da estrutura de um tensor contendo horrível e um gradiente.
Mais uma vez é assim que a tocha Pi funciona.
Então, para resumir, criamos um lote para cada uma das ações e recompensas do estado e, em seguida, vamos
colocar cada uma dessas ervas separadamente em alguns bytes que o Horrible é que cada um terá
um gradiente para que, eventualmente, possamos diferenciar cada um deles.
Tudo bem, então esse é o propósito da função Zipp.
Então, deixe-me simplesmente remover este comentário.
E agora o único que temos que fazer é retornar as amostras.
as amostras diretamente pela simples razão de que queremos colocar as amostras em um por torche viável.
Então, como acabei de explicar, não podemos devolver
Então, para fazer isso para cada uma das amostras, vamos usar a função do mapa e esta função
do mapa fará o mapeamento das amostras para as variáveis ​​de tortura que conterão um tensor e um gradiente.
Então, como você pode ver, essa função do mapa leva vários argumentos.
O primeiro argumento é uma função e esta função será a função que irá converter
as amostras em algumas variáveis ​​torche.
E o segundo argumento é o que queremos aplicar nesta função.
Então, esses serão os argumentos desta função e, portanto, o que será.
É claro que vão ser as amostras.
Então, o segundo argumento aqui será os símbolos.
Mas então vamos definir a função sobre a qual queremos aplicar.
Cada um dos símbolos.
Então, para definir uma função, precisamos primeiro dar um nome à função que chamará de lambda.
Isso é apenas um nome e dando Lenda, em seguida, X, que será a variável desta função.
Então, esse é apenas um nome e dando para a variável e então.
suposto ser algo que irá converter nossas amostras em uma variável de tocha e para fazer isso.
E aqui nós damos a expressão da função que é o que queremos que esta função lambda retornar e
ver o que vai ser bom é
Já mencionamos isso em alguns tutoriais anteriores.
Bem, nós temos a função Voivode para eles.
A Voz funcionará, faremos essa conversão de um dançarino de tocha para uma variável que conterá
o sensor e o maior.
Então, a primeira coisa que vou adicionar aqui é a variável variável dentro da qual eu vou
converter o X porque o X será os simples que serão aplicados nas amostras.
Mas, então, isso é tudo, há uma última coisa técnica que precisamos implementar é o fato de que,
para cada lote que está contido na amostra, por exemplo, o lote de ações a 1 8
2 3 e as outras ações que temos de concatê-la com respeito para o primeiro motor que corresponde aos Estados.
E por que temos que fazer essa concatenação.
É apenas para que tudo esteja bem alinhado.
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.
Então, como podemos fazer essa concatenação.
Bem, precisamos usar a função de gato da biblioteca da tocha.
Então, vamos adicionar aqui a tocha à qual adicionamos
que é aplicada ao X, mas, nessa função, precisamos especificar a dimensão em relação à qual queremos fazer essa concatenação.
E, como acabei de mencionar, este é o primeiro motor de tempos que tem era índice.
E aqui vamos nós, nossa função está pronta para essa Lunda, que irá
levar as amostras a concatê-las em relação ao motor da primeira vez e, em seguida, converteremos os sensores
em algumas variáveis ​​de torche que contenham um tensor e um gradiente para que, mais tarde,
quando nós aplique para castigar no sentido em que poderemos diferenciar para ter pesos de dados.
Tudo bem, então esta função está pronta.
E então aqui está o segundo argumento da função do mapa.
Precisamos especificar o que queremos aplicar a esta função e está em todas as nossas amostras.
Aqui vamos nós.
Vamos aplicar esta
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.
Tudo bem, então foi bastante técnico, mas agora, pelo menos, tudo funcionará bem.
Queremos usar essa técnica.
a tocha como você quiser.
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,
é 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
Mas agora a boa notícia é que acabamos com essa experiência de classe
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.
Então, neste modelo, teremos, naturalmente, nossa rede que
experimentará repetição e, em seguida, todo o resto do algoritmo de segurança.
Então, será uma classe muito maior.
que você possa entender melhor o que está acontecendo.
Nós faremos cerca de 10 funções, mas isso é apenas porque estamos fazendo isso passo a passo para
Então eu não posso esperar para implementar nosso modelo de segurança.
E até então eu.