Olá e bem-vindo de volta.
Na última palestra, você viu como usamos nossas funções auxiliares para realmente configurar o núcleo de nossa funcionalidade para
treinar nossos modelos.
Então nós tínhamos nosso estado terminal, nosso local inicial, nossa próxima ação, próximo local e caminho mais
curto realmente define a maioria de como nosso agente ou como nosso ambiente vai funcionar.
A última coisa que temos que fazer é usar nosso treinamento para usar nosso treinamento.
É bastante simples no sentido do que precisamos incluir, mas como fazemos isso é uma história
diferente.
Dito isto, também, se vocês usarem uma abordagem diferente ou quiserem personalizar isso e
experimentar, é altamente recomendável.
Além disso, se você usar uma abordagem diferente e quiser discuti-la, sinta-se à vontade para compartilhar
nas perguntas e respostas.
Mais do que feliz em discutir isso com você.
É uma ótima ideia porque há muitas maneiras de resolver isso e você pode encontrar uma
maneira muito melhor, mais vantajosa.
Poderíamos analisar os prós e os contras novamente, mais do que felizes em discutir isso.
Tudo bem.
Então o que temos que fazer?
Temos que lançar nosso treinamento.
Para nosso treinamento.
Queremos usar o Epsilon.
Então, basicamente, a porcentagem que vamos tomar para a melhor ação para R em vez de uma ação aleatória.
Então vamos definir nosso epsilon e vamos defini-lo para 0. 9 e faremos algo semelhante com nossos valores para nosso fator
de desconto e nossa taxa de aprendizado.
Então vamos fazer o fator de desconto igual a 0. 9.
Vamos também pegar nossa taxa de aprendizado e defini-la como igual a 0. 9.
Essa será a taxa que nosso agente aprenderá ou deveria aprender.
E também queremos pegar o número de episódios de treinamento, vamos chamá-lo, e episódios de treinamento.
Então nós temos uma série de episódios de treinamento.
Vamos definir para mil.
Quantas vezes vai treinar ou em quantos episódios isso vai treinar?
Impressionante.
Agora, essencialmente, o que queremos fazer é percorrer cada episódio.
Queremos pegar o alcance do nosso número de episódios de treinamento e definir nosso basicamente nosso epsilon.
Queremos encontrar nossa diferença temporal.
Para definir isso, precisamos examinar alguns valores Q anteriores.
Precisamos calcular nossa posição inicial em nosso índice de ação.
Então vamos começar.
Vamos dar um grande laço for.
Então nós temos nossos quatro episódios.
No intervalo do nosso número de episódios de treinamento.
Aqui vamos nós.
Salvo qualquer erro de sintaxe da minha parte, queremos pegar o índice de linha e o índice de coluna de nossa grade para
nosso Ms. índice da coluna.
E disse um local inicial de destino, precisamos de um local inicial.
Então vamos ter aquela hora ruim a cada episódio.
Agora podemos definir nosso estado terminal while.
Não.
É estado terminal.
Queremos ver o índice de linha e o índice de coluna.
OK.
Em seguida, vamos definir nosso índice de ação para nossa próxima ação.
Então, precisamos de nossa próxima ação.
À medida que esse agente itera pelos meios para nosso índice de ação, podemos usar nossa próxima ação.
E podemos usar nosso índice de coluna de índice de linha e vamos chamar nosso epsilon.
Então, queremos ter isso em vez de nossa ação aleatória, vamos usar o índice da coluna.
E precisamos de Epsilon.
Impressionante.
Se eu pudesse soletrar corretamente.
Aqui, queremos Epsilon.
Tudo bem, deixe-me apenas excluir isso.
OK.
Deixe-me pegar o resto do código e vamos analisá-lo para que você não tenha que me ver digitando
cada linha.
Mas lembre-se de como queremos abordar isso.
Deslocando a linha antiga, precisaríamos de um índice de linha antigo.
Também gostaríamos de ter as recompensas para nossas colunas e nossas linhas.
Precisamos dar uma olhada nos valores da fila e nos valores antigos da fila, e precisamos calcular nossa diferença
temporal.
OK.
Então você vê a mudança no código ou a atualização do código.
Estamos pegando nosso índice de linha antigo e nosso índice de coluna antigo para examinar nosso índice de linha e índice de coluna.
Nosso índice de coluna de índice de linha é igual ao nosso próximo local.
E nosso próximo local precisaria do índice de linha, coluna, índice e ação.
Por último, estamos olhando para uma recompensa.
Nossos antigos valores de Q seriam valores de Q com o índice de linha antigo, o índice de coluna antigo e, novamente,
referenciando nosso índice de ação e o cálculo de nossa diferença temporal, que é nossa recompensa, mais o fator
de desconto vezes os valores de Q com a linha índice e índice de coluna menos o valor Q antigo do valor Q
anterior.
Quase pronto onde precisamos do nosso novo valor Q, que é o nosso valor de sugestão antigo, mais a taxa
de aprendizado, tempos, diferença temporal e nossos valores de sugestão com o índice de linha antigo em nosso índice de coluna antigo igual ao novo
valor de sugestão.
Se vocês quiserem discutir mais sobre isso, novamente, eu recomendo o Q&A.
Por favor, sinta-se livre para imprimir.
Tente experimentar com todas as variáveis usadas aqui.
Se você quiser ver sua forma, ver como eles podem ser usados, o que está referenciando, eu recomendo e estou
mais do que feliz em discutir mais.
Uma última coisa que podemos fazer, então temos uma pequena notificação.
Vamos adicionar uma instrução de impressão para sabermos quando o treinamento está concluído para nossas mil linhas.
Tudo bem.
Se não houver erros de sintaxe da minha parte, devemos estar prontos.
O bloco de notas da coluna é inicializado.
Eu repassei tudo, então deixe-me rodar isso.
Deve ser muito rápido, pois estamos usando apenas numpy.
É um modelo muito otimizado em certo sentido.
Deixe-me clicar aqui e então procuraremos o caminho mais curto.
Tudo bem.
Temos nosso treinamento completo.
Vamos também imprimir o caminho mais curto para algumas opções iniciais.
Então estamos começando uma linha três, coluna nove com a opção de caminho mais curto com nosso caminho mais curto.
Queremos olhar para a linha cinco e zero e começando na linha nove e coluna número cinco.
Vamos imprimir isso.
Impressionante.
Temos o caminho mais curto, mas não terminamos.
Estamos quase lá.
Podemos ver nosso carteiro obter automaticamente o caminho mais curto de um local legal que podemos considerar de nossa cidade até
a área de embalagem do item.
Mas e o inverso do cenário oposto, basicamente referindo-se, sabe, o nosso carteiro pode entregar um
item de qualquer lugar da cidade para a área de embalagem?
Mas depois do item teria que ir então daquela área, da área de embalagem para outro local da cidade,
porque teria que pegar o próximo item.
Então o que podemos fazer para resolver isso?
E na verdade é bem simples.
Você pode revisar a ordem do caminho mais curto.
Tente pensar nisso por um segundo e então esta seria a solução.
Podemos usar o caminho mais curto.
Então, vamos pegar a coluna cinco e a coluna dois e tudo o que você precisa fazer é usar a opção reversa com
o Python.
Usamos path dot reverse e podemos imprimir o caminho.
Então, estamos olhando para cinco e dois.
E lá vamos nós.
Temos o caminho mais curto.
E é realmente útil se você quiser pegar a imagem na célula e trazê-la para baixo para comparar e ver
esses caminhos.
Mas você pode realmente ver o caminho se você pegar o extrato impresso, olhar a coluna no
pedido e ver como o vendedor está viajando.
Trabalho tão incrível que você está usando.
Q Aprendizagem.
O que aprendemos com este curso tem um pouco de bônus e um cenário divertido na seção para resolver
esse tipo de problema essencialmente do caixeiro viajante.
Estamos olhando para o carteiro para entregar pacotes e itens na cidade para encontrar as opções mais curtas e os
caminhos mais curtos.
Eu recomendo que você personalize, teste outras opções, altere os hiperparâmetros e, se descobrir
algo melhor, se descobrir algum parâmetro otimizado ou melhor para usar, sinta-se à vontade para compartilhá-los nas
perguntas e respostas.
Incrível.
Espero que vocês realmente tenham gostado disso.
Por favor, personalize, experimente e continue aprendendo.
É muito divertido trabalhar com você.
Aprender e desfrutar I.