Até agora, analisamos a teoria para construir um plano baseado em caprinos, mas agora temos que programar
um.
No final das contas, o que procuramos é um algoritmo que classifica as ações e combina seus efeitos
com outras condições prévias para construir um plano.
Portanto, começamos por obter todas as ações disponíveis e o agente pode realizar.
Estes são dados ao planejador, que verifica através de todos eles para ver se, em princípio, eles são realizáveis.
Lembre-se, esse pouco é um método realizável que escrevemos para as ações que sempre retornam verdadeiras.
Bem, este é o teste para isso.
Agora, se você precisasse colocar alguma outra lógica nesse método, isso teria uma ação rejeitada
pelo planejador antes mesmo que o planejamento ocorresse.
Então é aqui que você o colocaria.
Mas estamos apenas trabalhando com base no princípio de que todas as ações serão realizáveis.
Então começamos a construir um gráfico começando com um nó inicial.
Agora este nó inicial vai ter como efeitos os estados do mundo.
Em seguida, examinamos todas as ações realizáveis para aquelas que podem ser realizadas, dados os estados
no primeiro nó.
Cada ação correspondente cria um novo nó e um novo ramo no gráfico que estamos construindo.
Em seguida, exploramos cada ramo para outra ação que pode ser anexada utilizando as condições prévias e os efeitos.
Este processo continua em cada ramo até que um caminho coincida com o objetivo inicial ou que o planejador
fique sem ações.
Se um caminho é encontrado, esse caminho se torna a fila de ações dos agentes e então o agente começa a executá-las.
Portanto, vamos começar a criar esta classe de planejamento.
Clique com o botão direito do mouse em seus bens e adicione outro C-sharp.
Vamos chamar isto de um planejador G.
Então, abra isso.
E a primeira coisa que vamos fazer é adicionar no topo usando o link do sistema novamente para classificar coisas como
nosso dicionário e também vamos criar uma classe de ajuda no topo.
Portanto, uma classe pública para nossos nós.
Portanto, lembre-se que estamos construindo um gráfico e estamos fazendo isso com o planejador que ligará todas
as nossas ações em um plano, mas ao invés de ligar as ações a outras ações, na verdade vamos
apenas criar um conjunto de nós que estão ligados uns aos outros e então eles apenas se segurarão ou apontarão de
volta para uma determinada ação.
Certo.
Portanto, antes de tudo, vamos ter um nó público que é o pai deste nó, depois um público.
Float, que será um custo da ação que será utilizado para determinar qual plano é realmente
o mais barato.
Deve haver vários planos?
Então queremos um público.
Dicionário e você provavelmente pode imaginar o que vai entrar aqui.
Sim.
String int para o estado que vamos armazenar inicialmente que serão os estados do
mundo no primeiro nó e depois a ação pública g, a ação sobre a qual este nó está falando ou apontando.
Certo.
Portanto, essas são as propriedades desse nó.
Agora vamos construí-la.
Portanto, nó público de nó.
Custo do carro alegórico dos pais.
Dicionário.
Int. de cordas
Todos os estados.
E finalmente, a ação g ação.
Ação.
E então, dentro daqui, nos certificamos de fixar cada um de nossos valores de propriedade aos valores desejados.
Portanto, pai.
Deveríamos dizer este pai.
Igual ao pai.
Este custo de ponto é igual ao custo.
Este estado de ponto é igual a todos os estados, mas não a todos os estados porque apontará de volta para aquele dicionário.
Na verdade, queremos que seja uma cópia desse dicionário.
Assim, para fazer isso, criamos um novo dicionário de String iNts e o damos a todos os estados para ter certeza de que
definitivamente fizemos uma cópia.
E então esta ação de ponto igualará a ação, está bem, para nosso planejador.
Assim, com o plano, podemos realmente nos livrar de nossa atualização.
Agora comece.
Vai fazer apenas o processamento em nosso gráfico e a construção do gráfico.
Portanto, também não precisa ser um comportamento mona.
Certo.
Portanto, antes de mais nada, vamos criar nosso método.
Portanto, é público, é devolver um Q e vai devolver um Q de ações G.
Então, g ação.
E vamos chamá-lo de plano.
Vai exigir uma lista de todas as ações.
Portanto, a ação que temos, o agente tem um controle sobre isso porque ele mesmo constrói um.
Assim, ações o dicionário do objetivo desejado tão dicionário e string int objetivo e o mundo afirma também.
Portanto, vamos colocar bem e chamar isso de Estado.
Estados.
Certo.
Portanto, aqui, antes de tudo, vamos descobrir qual das ações que temos é realmente utilizável e nos
agarramos a elas.
Portanto, vamos criar uma lista de ações.
Aqui está uma ação de touro igual a uma nova lista de ações.
E então, para cada g de ação a em ações.
Se um ponto for realizável, então acrescentaremos esse ponto a nossas ações utilizáveis.
Portanto, ações utilizáveis não acrescentam.
Ei, então isso vai sugar qualquer ação que não possa ser executada no momento.
Depois disso, o que vamos fazer é preparar nossa primeira folha para nosso gráfico.
Está bem?
Portanto, queremos uma lista de nós, vamos chamá-los de folhas igual a uma nova lista de nós.
E o nó de partida começa.
Vai igualar um novo nó e vai ter um pai nulo porque é o primeiro.
Vai ter custo zero novamente porque é o primeiro, vai ter uma lista dos estados.
Portanto, isso vai estar dentro de nosso mundo.
Singleton Então essa é a instância G world dot, dot get world dot get states e depois nula para a ação para a qual está apontando.
Porque, mais uma vez, é apenas aquele primeiro nó, não está realmente apontando para uma ação em particular neste momento.
Uma vez que tenhamos feito isso, queremos construir o gráfico.
Portanto, vamos retornar verdadeiro ou falso com base no fato de termos realmente encontrado um caminho.
Portanto, será um sucesso e isso vai igualar o que retornamos da construção de gráficos que ainda não escrevemos.
Vamos passar o nó inicial, a lista de folhas que neste momento está vazia, a lista
de ações utilizáveis e o objetivo.
Portanto, este é o nosso gráfico de contas.
Agora, quando voltarmos do gráfico de construção, testaremos se temos sucesso.
Se não tivermos sucesso, então o que podemos fazer aqui é dizer que não encontramos um plano.
Agora vou colocar aqui um registro de depuração para garantir que tenhamos algum tipo de feedback, porque há muita coisa
acontecendo quando você começa a planejar e executar seus agentes para tentar descobrir o que está realmente
acontecendo dentro do sistema.
E você pode acabar com um monte de insetos ao longo de tudo, o que é, ok, isso
é bastante natural até que você se concentre na forma como esses nós e as ações se encaixam.
Portanto, neste momento, retornaremos nulos.
Portanto, na verdade não estamos retornando nenhum plano se não houver nenhum plano, o que faz sentido.
Certo.
O que vamos fazer então é, se chegamos até aqui, então temos um plano particular que podemos seguir para alcançar
nosso objetivo.
Então agora vamos encontrar o mais barato, então o nó mais barato é igual a zero inicialmente
e depois faremos um para cada folha de nó em folhas.
Certo.
E nós vamos dar a volta a tudo isso.
Agora, neste ponto, vamos verificar se a folha ou o nó mais barato.
Portanto, se o mais barato for igual a nulo, então o nó mais barato que temos será apenas colocado na folha.
Isso significa que não encontramos nada que seja realmente mais barato, então usaremos apenas o
que temos e depois colocaremos outro.
Se o custo da folha for inferior ao custo do ponto mais barato, então vamos dizer o mais barato.
Igual à vida.
Portanto, agora neste ponto, encontramos nosso nó de folha mais barato.
Uma vez que temos nosso nó mais barato, Rashi agora vai trabalhar de trás para frente através dele e apoiar a cadeia
para obter a seqüência de ações.
Como descemos pelo gráfico, encontramos nossa folha mais barata, que está bem no final do plano, e agora precisamos
fazer nosso caminho de volta para cima.
Certo, então vamos criar uma lista de ações G que será nosso plano resultante.
E isso vai igualar uma nova lista.
De ação G.
E então o nó n é igual ao mais barato.
E então enquanto um não é igual a nulo.
Indo dizer se uma ação não é igual a nula e só deve ser nula se tivermos atingido o nó inicial de qualquer maneira,
enquanto trabalhamos para trás ao longo do caminho.
Inserção de pontos de resultados no início e ação de pontos.
E depois em iguais em ponto pai.
Para que agora tenhamos o pai em um e vamos conseguir sua ação e, em seguida, vamos ter seu pai
e seu laço até conseguirmos todos esses.
Portanto, essencialmente você criou uma lista vinculada a partir destes nós que representam seu gráfico
agora mesmo que temos que podemos realmente criar nossa fila, que terá nossas ações que nosso agente pode ir
em frente e executar.
Então, ação em fila, vamos chamá-la de fila com letras minúsculas é igual a nova fila.
De ação G.
E então para cada g de ação i em resultado.
Nós vamos Q.
Ponto em q que coloca um item no final de nosso Q a.
E é só isso.
Portanto, estamos apenas fazendo a transição de nossa lista para nossa fila.
Agora, neste ponto, se chegamos até aqui, bem, obviamente temos um plano,
porque nós o montamos.
Então vamos apenas depurar os pontos de registro.
O plano é.
E, é claro, se você começar a obter muitas dessas linhas de depuração enquanto executa a simulação, é claro
que você pode comentá-las.
Assim, para cada g de ação A em Q.
E isto é puramente um looping através dele apenas para imprimi-los, para que você possa ver que tem um plano.
Portanto, depurar o atraso da fila de espera.
E mais um nome ou uso de um ponto de ação.
E então, finalmente, devolvemos o nosso.
P. E isso volta ao nosso agente com o plano.
Portanto, esta é a maior parte do método Q.
Agora temos que escrever o gráfico de construção e como ainda há muito mais código para digitar, vamos
fazer isso no próximo vídeo.