WEBVTT

00:02.930 --> 00:08.810
Até agora, analisamos a teoria para construir um plano baseado em caprinos, mas agora temos que programar

00:08.810 --> 00:09.260
um.

00:09.290 --> 00:15.440
No final das contas, o que procuramos é um algoritmo que classifica as ações e combina seus efeitos

00:15.440 --> 00:18.890
com outras condições prévias para construir um plano.

00:19.490 --> 00:23.870
Portanto, começamos por obter todas as ações disponíveis e o agente pode realizar.

00:23.990 --> 00:30.980
Estes são dados ao planejador, que verifica através de todos eles para ver se, em princípio, eles são realizáveis.

00:31.010 --> 00:36.960
Lembre-se, esse pouco é um método realizável que escrevemos para as ações que sempre retornam verdadeiras.

00:36.980 --> 00:38.870
Bem, este é o teste para isso.

00:38.900 --> 00:44.210
Agora, se você precisasse colocar alguma outra lógica nesse método, isso teria uma ação rejeitada

00:44.210 --> 00:47.440
pelo planejador antes mesmo que o planejamento ocorresse.

00:47.450 --> 00:49.400
Então é aqui que você o colocaria.

00:49.400 --> 00:54.590
Mas estamos apenas trabalhando com base no princípio de que todas as ações serão realizáveis.

00:55.070 --> 00:59.000
Então começamos a construir um gráfico começando com um nó inicial.

00:59.330 --> 01:04.170
Agora este nó inicial vai ter como efeitos os estados do mundo.

01:04.190 --> 01:10.220
Em seguida, examinamos todas as ações realizáveis para aquelas que podem ser realizadas, dados os estados

01:10.220 --> 01:11.510
no primeiro nó.

01:11.660 --> 01:17.750
Cada ação correspondente cria um novo nó e um novo ramo no gráfico que estamos construindo.

01:18.200 --> 01:25.700
Em seguida, exploramos cada ramo para outra ação que pode ser anexada utilizando as condições prévias e os efeitos.

01:26.390 --> 01:34.670
Este processo continua em cada ramo até que um caminho coincida com o objetivo inicial ou que o planejador

01:34.670 --> 01:36.500
fique sem ações.

01:37.300 --> 01:44.380
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.

01:45.070 --> 01:48.310
Portanto, vamos começar a criar esta classe de planejamento.

01:48.430 --> 01:52.660
Clique com o botão direito do mouse em seus bens e adicione outro C-sharp.

01:52.660 --> 01:55.510
Vamos chamar isto de um planejador G.

01:55.900 --> 01:57.760
Então, abra isso.

01:57.760 --> 02:07.090
E a primeira coisa que vamos fazer é adicionar no topo usando o link do sistema novamente para classificar coisas como

02:07.090 --> 02:12.910
nosso dicionário e também vamos criar uma classe de ajuda no topo.

02:12.910 --> 02:16.120
Portanto, uma classe pública para nossos nós.

02:16.120 --> 02:23.200
Portanto, lembre-se que estamos construindo um gráfico e estamos fazendo isso com o planejador que ligará todas

02:23.200 --> 02:28.690
as nossas ações em um plano, mas ao invés de ligar as ações a outras ações, na verdade vamos

02:28.690 --> 02:35.770
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

02:35.770 --> 02:38.680
volta para uma determinada ação.

02:38.860 --> 02:39.160
Certo.

02:39.220 --> 02:47.530
Portanto, antes de tudo, vamos ter um nó público que é o pai deste nó, depois um público.

02:48.750 --> 02:55.170
Float, que será um custo da ação que será utilizado para determinar qual plano é realmente

02:55.170 --> 02:56.240
o mais barato.

02:56.250 --> 02:58.200
Deve haver vários planos?

02:58.320 --> 03:00.420
Então queremos um público.

03:02.320 --> 03:06.400
Dicionário e você provavelmente pode imaginar o que vai entrar aqui.

03:06.400 --> 03:06.820
Sim.

03:06.820 --> 03:14.260
String int para o estado que vamos armazenar inicialmente que serão os estados do

03:14.260 --> 03:23.530
mundo no primeiro nó e depois a ação pública g, a ação sobre a qual este nó está falando ou apontando.

03:24.980 --> 03:25.290
Certo.

03:25.360 --> 03:29.320
Portanto, essas são as propriedades desse nó.

03:29.320 --> 03:30.940
Agora vamos construí-la.

03:31.120 --> 03:34.330
Portanto, nó público de nó.

03:35.530 --> 03:39.490
Custo do carro alegórico dos pais.

03:41.130 --> 03:42.540
Dicionário.

03:43.450 --> 03:45.910
Int. de cordas

03:48.530 --> 03:49.880
Todos os estados.

03:51.660 --> 03:54.450
E finalmente, a ação g ação.

03:55.900 --> 03:56.620
Ação.

03:57.640 --> 04:06.460
E então, dentro daqui, nos certificamos de fixar cada um de nossos valores de propriedade aos valores desejados.

04:06.460 --> 04:07.780
Portanto, pai.

04:09.570 --> 04:11.580
Deveríamos dizer este pai.

04:12.600 --> 04:14.040
Igual ao pai.

04:15.780 --> 04:18.960
Este custo de ponto é igual ao custo.

04:19.890 --> 04:27.360
Este estado de ponto é igual a todos os estados, mas não a todos os estados porque apontará de volta para aquele dicionário.

04:27.360 --> 04:30.270
Na verdade, queremos que seja uma cópia desse dicionário.

04:30.270 --> 04:41.490
Assim, para fazer isso, criamos um novo dicionário de String iNts e o damos a todos os estados para ter certeza de que

04:41.490 --> 04:45.120
definitivamente fizemos uma cópia.

04:45.120 --> 04:51.600
E então esta ação de ponto igualará a ação, está bem, para nosso planejador.

04:51.600 --> 04:54.230
Assim, com o plano, podemos realmente nos livrar de nossa atualização.

04:54.240 --> 04:54.990
Agora comece.

04:54.990 --> 05:00.630
Vai fazer apenas o processamento em nosso gráfico e a construção do gráfico.

05:00.630 --> 05:03.000
Portanto, também não precisa ser um comportamento mona.

05:03.240 --> 05:03.690
Certo.

05:03.690 --> 05:06.810
Portanto, antes de mais nada, vamos criar nosso método.

05:06.810 --> 05:13.560
Portanto, é público, é devolver um Q e vai devolver um Q de ações G.

05:13.560 --> 05:16.320
Então, g ação.

05:17.360 --> 05:19.460
E vamos chamá-lo de plano.

05:20.180 --> 05:24.350
Vai exigir uma lista de todas as ações.

05:24.350 --> 05:30.020
Portanto, a ação que temos, o agente tem um controle sobre isso porque ele mesmo constrói um.

05:30.020 --> 05:44.270
Assim, ações o dicionário do objetivo desejado tão dicionário e string int objetivo e o mundo afirma também.

05:44.270 --> 05:49.070
Portanto, vamos colocar bem e chamar isso de Estado.

05:49.950 --> 05:51.020
Estados.

05:51.480 --> 05:51.670
Certo.

05:51.720 --> 05:58.800
Portanto, aqui, antes de tudo, vamos descobrir qual das ações que temos é realmente utilizável e nos

05:58.800 --> 06:00.130
agarramos a elas.

06:00.150 --> 06:05.610
Portanto, vamos criar uma lista de ações.

06:06.590 --> 06:13.670
Aqui está uma ação de touro igual a uma nova lista de ações.

06:14.330 --> 06:21.860
E então, para cada g de ação a em ações.

06:25.110 --> 06:32.640
Se um ponto for realizável, então acrescentaremos esse ponto a nossas ações utilizáveis.

06:32.640 --> 06:36.270
Portanto, ações utilizáveis não acrescentam.

06:37.360 --> 06:44.770
Ei, então isso vai sugar qualquer ação que não possa ser executada no momento.

06:44.770 --> 06:50.500
Depois disso, o que vamos fazer é preparar nossa primeira folha para nosso gráfico.

06:50.530 --> 06:50.890
Está bem?

06:50.920 --> 07:03.820
Portanto, queremos uma lista de nós, vamos chamá-los de folhas igual a uma nova lista de nós.

07:04.300 --> 07:08.140
E o nó de partida começa.

07:08.320 --> 07:14.920
Vai igualar um novo nó e vai ter um pai nulo porque é o primeiro.

07:14.920 --> 07:24.340
Vai ter custo zero novamente porque é o primeiro, vai ter uma lista dos estados.

07:24.340 --> 07:28.270
Portanto, isso vai estar dentro de nosso mundo.

07:28.270 --> 07:42.490
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.

07:42.490 --> 07:50.710
Porque, mais uma vez, é apenas aquele primeiro nó, não está realmente apontando para uma ação em particular neste momento.

07:50.710 --> 07:53.170
Uma vez que tenhamos feito isso, queremos construir o gráfico.

07:53.170 --> 07:58.600
Portanto, vamos retornar verdadeiro ou falso com base no fato de termos realmente encontrado um caminho.

07:58.600 --> 08:07.990
Portanto, será um sucesso e isso vai igualar o que retornamos da construção de gráficos que ainda não escrevemos.

08:08.020 --> 08:15.430
Vamos passar o nó inicial, a lista de folhas que neste momento está vazia, a lista

08:15.430 --> 08:18.970
de ações utilizáveis e o objetivo.

08:21.190 --> 08:22.450
Portanto, este é o nosso gráfico de contas.

08:22.510 --> 08:27.790
Agora, quando voltarmos do gráfico de construção, testaremos se temos sucesso.

08:28.240 --> 08:36.370
Se não tivermos sucesso, então o que podemos fazer aqui é dizer que não encontramos um plano.

08:36.400 --> 08:44.020
Agora vou colocar aqui um registro de depuração para garantir que tenhamos algum tipo de feedback, porque há muita coisa

08:44.020 --> 08:50.710
acontecendo quando você começa a planejar e executar seus agentes para tentar descobrir o que está realmente

08:50.710 --> 08:53.320
acontecendo dentro do sistema.

08:53.320 --> 08:58.210
E você pode acabar com um monte de insetos ao longo de tudo, o que é, ok, isso

08:58.210 --> 09:04.960
é bastante natural até que você se concentre na forma como esses nós e as ações se encaixam.

09:04.960 --> 09:07.240
Portanto, neste momento, retornaremos nulos.

09:07.240 --> 09:13.840
Portanto, na verdade não estamos retornando nenhum plano se não houver nenhum plano, o que faz sentido.

09:14.020 --> 09:14.260
Certo.

09:14.290 --> 09:22.390
O que vamos fazer então é, se chegamos até aqui, então temos um plano particular que podemos seguir para alcançar

09:22.390 --> 09:24.400
nosso objetivo.

09:24.400 --> 09:34.330
Então agora vamos encontrar o mais barato, então o nó mais barato é igual a zero inicialmente

09:34.330 --> 09:40.990
e depois faremos um para cada folha de nó em folhas.

09:42.970 --> 09:43.530
Certo.

09:43.540 --> 09:46.630
E nós vamos dar a volta a tudo isso.

09:47.050 --> 09:52.810
Agora, neste ponto, vamos verificar se a folha ou o nó mais barato.

09:52.810 --> 10:06.700
Portanto, se o mais barato for igual a nulo, então o nó mais barato que temos será apenas colocado na folha.

10:06.730 --> 10:12.430
Isso significa que não encontramos nada que seja realmente mais barato, então usaremos apenas o

10:12.700 --> 10:15.010
que temos e depois colocaremos outro.

10:15.010 --> 10:25.450
Se o custo da folha for inferior ao custo do ponto mais barato, então vamos dizer o mais barato.

10:27.270 --> 10:28.980
Igual à vida.

10:31.560 --> 10:38.550
Portanto, agora neste ponto, encontramos nosso nó de folha mais barato.

10:38.760 --> 10:45.690
Uma vez que temos nosso nó mais barato, Rashi agora vai trabalhar de trás para frente através dele e apoiar a cadeia

10:45.690 --> 10:47.910
para obter a seqüência de ações.

10:47.910 --> 10:54.390
Como descemos pelo gráfico, encontramos nossa folha mais barata, que está bem no final do plano, e agora precisamos

10:54.390 --> 10:57.290
fazer nosso caminho de volta para cima.

10:57.440 --> 11:03.990
Certo, então vamos criar uma lista de ações G que será nosso plano resultante.

11:04.920 --> 11:07.410
E isso vai igualar uma nova lista.

11:08.230 --> 11:10.000
De ação G.

11:12.380 --> 11:16.070
E então o nó n é igual ao mais barato.

11:18.210 --> 11:22.890
E então enquanto um não é igual a nulo.

11:26.110 --> 11:34.270
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,

11:34.270 --> 11:38.410
enquanto trabalhamos para trás ao longo do caminho.

11:38.680 --> 11:47.320
Inserção de pontos de resultados no início e ação de pontos.

11:48.880 --> 11:54.220
E depois em iguais em ponto pai.

11:55.690 --> 12:01.840
Para que agora tenhamos o pai em um e vamos conseguir sua ação e, em seguida, vamos ter seu pai

12:01.840 --> 12:04.900
e seu laço até conseguirmos todos esses.

12:04.900 --> 12:10.750
Portanto, essencialmente você criou uma lista vinculada a partir destes nós que representam seu gráfico

12:10.750 --> 12:16.810
agora mesmo que temos que podemos realmente criar nossa fila, que terá nossas ações que nosso agente pode ir

12:16.810 --> 12:18.370
em frente e executar.

12:18.470 --> 12:25.900
Então, ação em fila, vamos chamá-la de fila com letras minúsculas é igual a nova fila.

12:27.150 --> 12:30.060
De ação G.

12:32.470 --> 12:39.730
E então para cada g de ação i em resultado.

12:41.890 --> 12:44.590
Nós vamos Q.

12:45.980 --> 12:53.600
Ponto em q que coloca um item no final de nosso Q a.

12:55.030 --> 12:55.960
E é só isso.

12:55.960 --> 13:01.030
Portanto, estamos apenas fazendo a transição de nossa lista para nossa fila.

13:01.060 --> 13:06.790
Agora, neste ponto, se chegamos até aqui, bem, obviamente temos um plano,

13:06.790 --> 13:08.740
porque nós o montamos.

13:08.740 --> 13:12.460
Então vamos apenas depurar os pontos de registro.

13:14.330 --> 13:16.460
O plano é.

13:16.460 --> 13:22.640
E, é claro, se você começar a obter muitas dessas linhas de depuração enquanto executa a simulação, é claro

13:22.640 --> 13:24.440
que você pode comentá-las.

13:24.950 --> 13:30.110
Assim, para cada g de ação A em Q.

13:31.770 --> 13:37.800
E isto é puramente um looping através dele apenas para imprimi-los, para que você possa ver que tem um plano.

13:38.070 --> 13:42.450
Portanto, depurar o atraso da fila de espera.

13:44.200 --> 13:50.440
E mais um nome ou uso de um ponto de ação.

13:52.990 --> 13:55.900
E então, finalmente, devolvemos o nosso.

13:55.900 --> 14:00.430
P. E isso volta ao nosso agente com o plano.

14:01.880 --> 14:07.880
Portanto, esta é a maior parte do método Q.

14:07.910 --> 14:15.740
Agora temos que escrever o gráfico de construção e como ainda há muito mais código para digitar, vamos

14:15.740 --> 14:18.170
fazer isso no próximo vídeo.
