WEBVTT

00:00.450 --> 00:05.700
Olá e bem-vindo ao Statoil e para falar, inicializamos o mapa.

00:05.850 --> 00:12.090
E agora o tempo para as coisas emocionantes, criamos o carro e nós fazemos isso com uma aula, claro.

00:12.090 --> 00:18.660
Você verá que a classe é muito prática para criar algumas coisas que têm muitas propriedades porque, como você

00:18.660 --> 00:25.300
pode ver, não só encontrando algumas variáveis ​​do meu carro, mas também algumas funções que, claro, é a função

00:25.300 --> 00:30.270
que fará o carro se mover para o esquerda para a direita ou indo direto.

00:30.720 --> 00:35.970
Então, temos algumas variáveis ​​que são importantes para descrever o ambiente que temos, por

00:35.970 --> 00:42.590
exemplo, o ângulo que é o ângulo entre o eixo x e o eixo da direção do carro.

00:42.630 --> 00:50.040
rotação que é a última rotação que lembra é 0 graus 20 graus ou menos 20 graus.

00:50.040 --> 00:51.550
Então, temos a

00:51.570 --> 00:57.690
Então, temos a velocidade da coordenada x do vetor de velocidade e as coordenadas y do vetor

00:57.690 --> 00:58.320
de velocidade.

00:58.470 --> 01:05.740
E então o vetor de coordenadas velocidade x e velocidade Y então temos os sensores e os sinais.

01:05.830 --> 01:12.280
E isso é muito importante, a chamada que estamos fazendo terá três sensores de sensor um sensor

01:12.310 --> 01:18.240
dois e sensores, três sensores estarão detectando se há algum sentido na frente do carro.

01:18.420 --> 01:25.070
Então, o sensor 2 é o sensor que detectará se há algum sentido à esquerda do carro e os sensores

01:25.080 --> 01:29.640
3 são o sensor que detectará se há algum sentido à direita do carro.

01:29.950 --> 01:37.080
E então, a partir desses três sensores, obtemos sinais de que os sinais recebidos por cada um dos sensores.

01:37.290 --> 01:43.320
Então, o sinal é o sinal recebido pelo sinal do sensor um é o sinal recebido pelo sensor 2 e

01:43.330 --> 01:46.370
o sinal 3 é o único recebido pelos sensores 3.

01:46.380 --> 01:47.700
E então, como isso funciona?

01:47.770 --> 01:54.310
O sinal 1 é a densidade de envio em torno de um sensor para um sinal é a densidade do centro em

01:54.820 --> 02:00.560
torno do sensor para indicar três é a densidade de sensibilidade enviada e como calculamos essa densidade de areia.

02:00.670 --> 02:01.690
Bem, isso é muito simples.

02:01.700 --> 02:06.110
Pegamos alguns grandes quadrados em torno de cada um dos sensores.

02:06.130 --> 02:12.490
Estes são, na verdade, quadrados de 200 por 200 e para cada um dos quadrados, dividimos o número de pessoas no

02:12.490 --> 02:17.840
quadrado pelo número total de células no quadrado que é 22 e 20 é igual a 400.

02:18.070 --> 02:22.530
E isso nos dá a densidade de areia porque os correspondem ao centro.

02:22.630 --> 02:27.790
Fazemos isso para cada sensor e isso nos dá a densidade de areia ao redor de cada sensor.

02:27.790 --> 02:29.550
São os sinais.

02:29.650 --> 02:35.450
Tudo bem, então agora temos tudo para detectar o sensor e depois temos a função de movimento.

02:35.450 --> 02:40.660
E é claro que a função de movimento é o que permitirá que o núcleo vá para a esquerda indo direto ou

02:40.660 --> 02:41.530
indo para a direita.

02:41.920 --> 02:43.360
Então vamos passar rapidamente.

02:43.360 --> 02:50.410
Temos aqui a atualização da posição do carro com sua última posição, que é auto passada aqui e

02:50.740 --> 02:52.400
o vetor de velocidade.

02:52.540 --> 02:58.720
Assim, graças ao vetor de velocidade, a posição será atualizada na direção do vetor de velocidade.

02:58.930 --> 03:05.320
Então, nós conseguimos a rotação que vamos diminuir no código aqui.

03:05.320 --> 03:08.040
A rotação é igual a ação para ação de rotação.

03:08.040 --> 03:11.400
Ele selecionará a ação e depois entrará na rotação.

03:11.410 --> 03:15.580
E assim, essa auto-proteção equivale a rotação aqui.

03:15.610 --> 03:21.130
É essa rotação que sabemos saber como precisamos girar o carro que vai para a esquerda

03:21.130 --> 03:22.360
ou para a direita.

03:22.420 --> 03:28.510
Então, atualizamos o ângulo que eu lembro é o ângulo entre o eixo x e o eixo da

03:28.510 --> 03:29.560
direção do carro.

03:29.620 --> 03:35.350
E então, uma vez que o carro se moveu, temos que atualizar os sensores e o sinal

03:35.350 --> 03:41.380
porque, claro, quando o carro acaba de girar enquanto os sensores também giraram e, portanto, precisamos girá-los

03:41.380 --> 03:45.500
usando a função de rotação e à qual adicionamos a nova posição.

03:45.790 --> 03:48.950
E por que temos esse vetor de 30 0.

03:49.090 --> 03:54.070
Bem, isso é simplesmente porque 30 é a distância entre o carro e o sensor.

03:54.130 --> 03:59.080
Você sabe que é a distância entre o carro eo que o carro detecta.

03:59.230 --> 04:04.210
E então, uma vez que os sensores são atualizados. Bem, é hora de atualizar os sinais.

04:04.270 --> 04:07.110
E então, aqui, fazemos exatamente o que eu expliquei para você sinais de computador.

04:07.240 --> 04:13.780
Nós damos as coordenadas x do nosso sensor, então nós levamos todas as células de Manston para mais 10, então

04:13.780 --> 04:19.070
fazemos o mesmo para a coordenada y, levando todas as células de Madison para mais 10.

04:19.090 --> 04:27.040
Então, obtemos o quadrado de 20 por 20 pixels ao redor do sensor e dentro do quadrado nós

04:27.130 --> 04:28.280
alguns mais velhos.

04:28.300 --> 04:35.170
Então, basicamente, com algumas das células porque as células contêm 0 ou 1 e uma vez que em 20 por 20 quadrados

04:35.170 --> 04:38.060
há 20 vezes 20 é igual a 400 células.

04:38.200 --> 04:45.520
Bem, nós dividimos em 400 para obter a densidade de dentro da praça e é assim que obtemos o sinal da densidade

04:45.730 --> 04:52.090
de centros ao redor do sensor e fazemos o mesmo para o segundo sensor e o terceiro sensor para

04:52.360 --> 04:54.870
obter o segundo sinal e o terceiro sinal.

04:55.060 --> 04:55.340
ESTÁ BEM.

04:55.360 --> 05:00.220
Então, é para levar o sensor e, em seguida, essas três linhas de código aqui são muito importantes.

05:00.220 --> 05:05.710
que desejamos que desejemos chegar ao nosso carro quando chegar a uma das margens do mapa.

05:05.710 --> 05:06.290
É outro

05:06.290 --> 05:11.830
Você sabe que não queremos que o carro se precipite em algumas paredes e, portanto, queremos penalizá-lo para

05:11.830 --> 05:16.380
puni-lo quando está chegando muito perto de Wall e, portanto, é isso que fazemos aqui.

05:16.630 --> 05:24.970
Se o primeiro sensor for maior do que mais 10 menos 10 maior do que aqui, porque é mais longa essa distância

05:24.970 --> 05:27.580
aqui, portanto, mais 10 menos 10 aqui.

05:27.580 --> 05:33.550
Então, se o sensor um atua maior do que o longo, Manison diz respeito a todos os pontos estão aqui.

05:33.550 --> 05:40.930
se aproximando da borda esquerda do mapa ou se o sensor Y for maior do que maior menos 10 Essa é

05:40.950 --> 05:48.250
a borda superior do mapa e ou se o auto-censurado Y é inferior a 10 que é a borda inferior do mapa.

05:48.250 --> 05:55.870
Isto é, se o carro estiver se aproximando da borda direita do mapa ou se o sensor de célula atinja menos de

05:55.870 --> 05:58.670
10, isso é certo se o carro estiver

05:58.720 --> 06:06.370
E, portanto, se o sensor estiver atingindo qualquer uma dessas quatro bordas Bem, colocaremos o sinal do sinal do

06:06.490 --> 06:08.760
sensor quando o sinal for enviado.

06:08.800 --> 06:10.290
Definiremos que seja um.

06:10.540 --> 06:11.610
E o que isso significa.

06:11.650 --> 06:15.390
Isso significa som completo como a densidade total da areia.

06:15.580 --> 06:17.270
É como o pior e você conseguiu.

06:17.330 --> 06:19.540
Há tantas sensações de que vai parar o seu carro.

06:19.660 --> 06:24.480
Então, o sinal será um e, portanto, o carro receberá uma recompensa terrível.

06:24.490 --> 06:24.830
Tudo bem.

06:24.820 --> 06:30.190
E então, fazemos o mesmo por sinal e sinalizamos três do sensor duas instâncias três.

06:30.410 --> 06:30.790
Tudo bem.

06:30.800 --> 06:36.470
E então, criamos a classe do jogo, de modo que basicamente seja a classe para criar o jogo, porque

06:36.470 --> 06:40.720
até agora só criamos o carro e, é claro, temos que criar o mapa.

06:40.820 --> 06:42.310
Temos que criar o próprio jogo.

06:42.410 --> 06:47.750
Então, não estaremos jogando o jogo é a nossa AI que estará jogando o jogo e o jogo

06:47.750 --> 06:52.240
é realmente evitar os obstáculos e ir do aeroporto para o centro da cidade e vice-versa.

06:52.520 --> 06:59.610
Então, nesta classe de jogo, precisamos criar alguns objetos como o carro, então precisamos definir a função

06:59.630 --> 07:00.540
de atualização.

07:00.590 --> 07:05.330
Esse é o mais importante e, na verdade, vamos nos concentrar nisso agora, porque está

07:05.330 --> 07:12.250
nesta função de atualização que selecionará a ação que o carro tem para fazer e cada vez para atingir seu objetivo.

07:12.350 --> 07:16.880
E esta ação é exatamente o resultado de nossa rede neural.

07:16.880 --> 07:20.860
A nova vontade desse trabalho que será o cerne da nossa inteligência artificial.

07:20.930 --> 07:27.550
E, portanto, essa ação é devolvida pelo cérebro do carro, que continua sendo objeto da nossa classe humana que

07:27.560 --> 07:29.780
estará fazendo em nosso arquivo AI.

07:29.930 --> 07:36.500
E este objeto tem um método chamado de atualização e leva como entrada a última palavra e

07:36.500 --> 07:37.590
o último sinal.

07:37.610 --> 07:43.250
Então, a última palavra é, naturalmente, a última palavra alcançada pelo carro e o último sinal é,

07:43.250 --> 07:50.480
é claro, o último sinal dos três sensores sinaliza um do sensor um sinal dois do sensor para o sinal três do

07:50.480 --> 07:51.240
sensor 3.

07:51.440 --> 07:56.870
Mas então eu estou adicionando duas outras entradas, que é a orientação do carro em relação ao objetivo.

07:56.900 --> 08:01.540
Então, por exemplo, se o carro se dirige para o objetivo, a orientação será igual a zero.

08:01.730 --> 08:06.730
Se ele for ligeiramente para a direita, a orientação será próxima a 45 graus.

08:06.920 --> 08:11.820
E se ele for ligeiramente para a esquerda, a orientação será próxima de menos 45 graus.

08:11.900 --> 08:15.380
Então, essa é a força de entrada de nossos estados de entrada.

08:15.410 --> 08:18.950
E então há uma lição que é menos orientação.

08:19.010 --> 08:25.250
Assim, geralmente, as entradas da rede neural são independentes. Não existe multicolinearidade, mas não importa se nós

08:25.250 --> 08:29.360
somos, porque a rede neural apenas conserta isso com os pesos.

08:29.480 --> 08:35.450
esta orientação negativa bem que permite ao carro o treinamento do carro para estabilizar a aceleração.

08:35.450 --> 08:37.840
Mas ainda percebo que ao adicionar

08:37.940 --> 08:43.460
Você sabe que estamos fazendo isso é que o AI nem sempre explora na mesma direção, adicionando

08:43.460 --> 08:44.390
esta orientação negativa.

08:44.390 --> 08:48.680
Nós nos certificamos de que ele explore em ambos os sentidos, à direita ou à esquerda.

08:48.920 --> 08:55.780
E assim, estes três sinais. Mais a orientação e a orientação negativa são as cinco entradas do nosso

08:55.810 --> 09:03.020
vetor codificado que entrarão na rede que o nosso vetor de entrada que entrará na rede e depois que

09:03.050 --> 09:09.560
ele entrar na rede Bem, a rede retorna as saídas que é a ação a desempenhar.

09:09.650 --> 09:15.290
o estado de entrada e também a última palavra porque a ação para jogar também depende da última palavra.

09:15.290 --> 09:20.450
E cada vez e a saída é retornada por esta função de atualização que contém a própria rede

09:20.450 --> 09:26.110
e a saída da rede e, portanto, é por isso que temos que inserir o último sinal que é

09:26.950 --> 09:33.700
Tudo bem e depois atualizamos a pontuação principal das palavras que atualizamos a rotação, usamos a função de movimento para

09:33.700 --> 09:37.500
girar o carro de acordo com a ação que foi selecionada.

09:37.510 --> 09:44.230
Nós levamos a distância do carro para a estrada e nós obteremos as posições da bola de sensores uma bola

09:44.230 --> 09:48.490
dois na resposta de Rieker às bolas que representarão os sensores no mapa.

09:48.530 --> 09:49.880
Você verá isso muito rapidamente.

09:50.550 --> 09:56.230
ver, isso significa que se o carro estiver em certo sentido, isso será mais lento.

09:56.230 --> 10:04.060
E então, essa parte é muito importante porque é aí que penalizamos o carro se isso acontecer, porque, como você pode

10:04.150 --> 10:06.550
Então é aí que reduzimos sua velocidade.

10:06.590 --> 10:10.020
Você sabe que sua velocidade geralmente é 6 como você pode ver aqui.

10:10.150 --> 10:14.410
E se isso acontecer com algum sentido, será um que será abrandado para 1.

10:14.430 --> 10:17.810
Você verá como o carro será abrandado uma vez que ele entra em algum sentido.

10:18.030 --> 10:19.090
Então, é lento.

10:19.210 --> 10:23.610
E, além disso, obtém uma recompensa ruim que recebe um menos que queremos.

10:23.920 --> 10:26.140
E essa é realmente a pior recompensa que você conseguiu.

10:26.140 --> 10:32.100
A melhor recompensa é a pior que a palavra é menos uma ea recompensa está entre menos 1 e mais 1.

10:32.530 --> 10:33.450
E então, de outra forma.

10:33.570 --> 10:35.770
E o carro não está em alguma areia.

10:35.980 --> 10:41.000
Bem, ele mantém a velocidade de velocidade usual do sexo e depois adicionamos algo mais.

10:41.080 --> 10:45.710
Se estiver se aproximando do objetivo, ele receberá uma recompensa ligeiramente positiva.

10:45.910 --> 10:53.410
E se está ficando mais longe do objetivo Bem, ele recebe uma recompensa ligeiramente negativa menos 0. 2.

10:53.590 --> 10:54.830
E depois a última.

10:54.830 --> 10:57.280
Condições que estão relacionadas com a recompensa.

10:57.470 --> 11:02.840
Bem, isso é se o carro está chegando muito perto de uma das bordas, como falamos anteriormente.

11:02.910 --> 11:04.990
Lembre-se quando conversamos sobre o sensor de combustível.

11:05.220 --> 11:11.840
Bem, se o carro está ficando muito perto da margem esquerda do mapa, fica menos uma palavra se for muito

11:11.840 --> 11:15.440
próximo da borda direita do mapa, ela é recompensada menos uma.

11:15.710 --> 11:20.220
E se fica muito perto da borda inferior do mapa, você recebe ou menos um.

11:20.360 --> 11:25.230
E se ficar muito perto da parte superior esquerda do mapa, recebe recompensas menos uma.

11:25.230 --> 11:27.620
Então é um castigo terrível.

11:27.620 --> 11:31.910
E assim você verá como é cheio e rápido não se precipitar em outra coisa.

11:31.940 --> 11:36.600
Tudo bem e isso é atualizar o tempo quando o objetivo é alcançado.

11:36.620 --> 11:41.390
Então, você sabe quando o carro chega ao aeroporto, que é o primeiro a ir, é o canto superior esquerdo

11:41.390 --> 11:41.920
do mapa.

11:41.930 --> 11:45.990
Enquanto a meta muda para o canto inferior direito do mapa que está no centro.

11:46.250 --> 11:51.080
E é exatamente isso que fazemos aqui, atualizamos a coordenada x do Corvo e

11:51.140 --> 11:55.870
as coordenadas brancas da chamada e depois atualizamos a distância do carro ao carro.

11:55.880 --> 11:56.260
Tudo bem.

11:56.270 --> 11:58.320
E então isso é menos importante.

11:58.340 --> 12:04.130
Essa é apenas uma aula que irá adicionar as ferramentas de pintura que você conhece para podermos pintar algumas estradas ou

12:04.130 --> 12:10.790
alguns obstáculos no mapa mais relacionados a K. V. Pode dar uma olhada se quiser. Vou

12:10.790 --> 12:16.370
fornecer a versão condensada deste código e vou fornecer alguma referência se quiser aprofundar a forma de

12:16.370 --> 12:17.570
fazer isso com skivvy.

12:17.570 --> 12:22.730
Mas estamos ficando mais longe da inteligência artificial, então não vou entrar nos detalhes.

12:22.910 --> 12:30.110
E isso é o mesmo para a última seção de código com a classe de carro que é exatamente como os botões da API

12:30.110 --> 12:31.320
limpar salvar e carregar.

12:31.520 --> 12:32.810
Então é o que fazemos aqui.

12:32.820 --> 12:34.900
Limpar a tela segura.

12:34.940 --> 12:40.220
E isso é realmente muito importante, é para nós poder salvar o dia em que eu sei salvar

12:40.700 --> 12:46.520
o cérebro para que você possa reutilizá-lo mais tarde, levando a função de carga, que é outra ferramenta que adicionamos

12:46.520 --> 12:52.010
no mapa para carregar o cérebro do carro que é carregar a memória do carro como navegar no mapa.

12:52.250 --> 12:57.830
E, finalmente, temos a última seção do código que corre o que é o que

12:57.830 --> 13:00.660
executa o mapa e o próprio AI.

13:00.980 --> 13:03.340
E na verdade, é isso que vamos fazer agora.

13:03.590 --> 13:07.020
Vamos dar uma olhada em tudo o que fizemos neste código.

13:07.040 --> 13:10.520
Então, agora, o IA não é implementado.

13:10.520 --> 13:13.910
Então, o código terá um movimento muito aleatório.

13:13.940 --> 13:17.810
Na verdade, parecerá um inseto, mas não se preocupe, vamos consertar isso.

13:17.810 --> 13:24.860
Normalmente, vamos treiná-lo para mover-se como um carro real e treiná-lo para navegar seguindo algumas estradas e

13:24.920 --> 13:26.380
evitando alguns obstáculos.

13:26.660 --> 13:27.710
Vamos fazer isso.

13:27.710 --> 13:32.240
Vou selecionar tudo e executar.

13:32.510 --> 13:33.900
E aqui está o mapa.

13:33.950 --> 13:35.270
E aqui está o carro.

13:35.690 --> 13:36.070
Tudo bem.

13:36.080 --> 13:41.600
Então é a coisa pequena que você vê que parece um inseto no nosso carro.

13:41.630 --> 13:45.960
Então, como eu disse, as ações são totalmente aleatórias.

13:46.220 --> 13:53.890
Então, cada vez que o carro seleciona aleatoriamente uma ação, seja para ir direto para a esquerda ou para a direita.

13:53.930 --> 13:59.260
Então é por isso que está fazendo alguns movimentos sem sentido e é por isso que parece um inseto.

13:59.450 --> 14:01.460
Então vamos consertar isso, é claro.

14:01.730 --> 14:09.500
está indo para o objetivo que é o aeroporto aqui ou para o centro, no canto inferior direito do mapa.

14:09.500 --> 14:12.930
E, claro, desde que a AI está ativada, não

14:13.760 --> 14:21.850
E vamos consertar tudo isso fazendo os AIs que implementarão o AI neste carro ou este inseto para que você possa

14:21.860 --> 14:26.480
ver as três bolas aqui, o amarelo, o vermelho e o branco.

14:26.630 --> 14:28.190
São os nossos três sensores.

14:28.220 --> 14:30.020
Então é isso que vamos detectar.

14:30.020 --> 14:32.580
Há algum perfume em torno disso.

14:32.810 --> 14:35.720
E falando de cheiro, vamos lançar alguns.

14:35.720 --> 14:45.510
Então, para fazer isso, eu só preciso clicar aqui e você sabe, em algum sentido, seguir ensinando a esquerda.

14:45.510 --> 14:50.240
Então, agora estou adicionando alguma areia, podemos adicionar mais.

14:50.250 --> 14:57.360
Então, cada vez que voce fica louco como você pode ver que colocando na matriz central que é enviar uma

14:57.360 --> 15:00.100
matriz que é para 00 coordenadas da origem.

15:00.180 --> 15:01.990
E aqui há muitos outros.

15:02.080 --> 15:04.720
E como você pode ver bem, é bom ver o carro.

15:04.770 --> 15:07.240
Acabamos de descer e desaceleramos.

15:07.620 --> 15:12.230
Então, como você pode ver agora, é muito lento porque está entrando na areia.

15:12.510 --> 15:14.820
E agora está tentando escapar.

15:16.310 --> 15:23.030
E então, você sabe o que faremos é que vamos desenhar algumas estradas e vamos desenhar algumas estradas do aeroporto até

15:23.030 --> 15:28.490
o centro da cidade e vamos treinar o carro para ficar na estrada e evitar os obstáculos.

15:28.490 --> 15:28.830
Tudo bem.

15:28.850 --> 15:35.690
E, como você pode ver, há o botão claro para limpar a areia, há o botão Salvar para salvar

15:35.690 --> 15:37.230
o cérebro do carro.

15:37.310 --> 15:43.640
E, na verdade, existe essa curva central que falamos sobre essa segurança que salva seu modelo realmente o cérebro

15:43.640 --> 15:50.270
do seu carro e, então, você pode saber quando você deixa o seu frio ou desligar o computador e quer

15:50.270 --> 15:51.680
voltar para ele novamente.

15:51.920 --> 15:59.290
Você pode usar o botão de carga para carregar o modo que é carregar o cérebro e que irá obter

15:59.360 --> 16:01.760
os trens AI do seu carro.

16:01.820 --> 16:06.030
Tudo bem, então agora não posso esperar para começar a fazer a AI.

16:06.080 --> 16:07.450
Isso será muito divertido.

16:07.490 --> 16:13.910
Nós faremos nossa rede neural e puniremos o carro assim que não fizermos o que queremos.

16:14.120 --> 16:16.290
Então vamos fazer isso no próximo tutorial.

16:16.400 --> 16:18.140
E até então, desfrute de um.