WEBVTT

00:00.580 --> 00:02.850
Olá e seja bem vindo à loja.

00:03.040 --> 00:07.040
Tudo bem, então agora vamos implementar inteligência artificial a partir do zero.

00:07.040 --> 00:08.870
Vamos cortá-lo linha a linha.

00:09.070 --> 00:12.550
E nesta primeira boa seção vamos importar as bibliotecas.

00:12.550 --> 00:17.880
Mas antes de começar com esta primeira seção de código, gostaria de explicar a conexão

00:17.890 --> 00:20.140
entre o AI eo nosso mapa.

00:20.560 --> 00:24.000
É por isso que estamos implementando isso para eles.

00:24.040 --> 00:27.880
Qual é o propósito de nossa AI e onde iremos usá-la.

00:27.880 --> 00:30.160
Então, na verdade, é muito simples.

00:30.170 --> 00:34.900
Nós estamos fazendo apenas a nossa IA para selecionar a ação correta e cada vez.

00:35.140 --> 00:42.390
Então, importamos a classe do nosso arquivo, então vamos fazer este D2 em sala de aula neste arquivo.

00:42.580 --> 00:51.220
Mas então, importamos apenas para selecionar a ação correta para jogar em cada momento e selecionamos essa ação

00:51.490 --> 00:53.070
exatamente nesta linha.

00:53.080 --> 01:00.580
Ação é igual a atualização cerebral menos recompensa menos sinal menos sinal será a entrada da rede neural.

01:00.760 --> 01:05.950
Você sabe que é composto dos três sinais dos sensores mais a orientação e orientação negativa.

01:06.130 --> 01:09.890
Então, essas são as entradas, mas a saída é a ação a ser executada.

01:10.030 --> 01:14.970
E é só o que vamos tomar da nossa AI. Eu senti que estamos prestes a fazer.

01:15.250 --> 01:16.310
Portanto, tenha isso em mente.

01:16.390 --> 01:17.590
É muito simples.

01:17.590 --> 01:25.900
Primeiro importamos a descriminalização da IA ​​AI, então criamos o cérebro do objeto da classe humana, que toma como entradas

01:25.990 --> 01:32.110
os vetores codificados para os estados de cinco dimensões, os três sinais mais a orientação,

01:32.290 --> 01:33.970
além da orientação negativa.

01:34.030 --> 01:36.910
Reacções vão para a esquerda, siga em frente ou vá para a direita.

01:37.030 --> 01:38.470
E, em seguida, esse parâmetro gama.

01:38.560 --> 01:42.410
Esse é o único parâmetro da aula que faremos.

01:42.490 --> 01:50.140
E então, uma vez que criamos esse objeto, selecionamos na classe do jogo a ação a ser tocada em cada momento.

01:50.140 --> 01:51.760
E isso depende da última palavra.

01:51.940 --> 01:58.450
E o Lusignan que é o insumo e é tudo o que é o único propósito de fazer isso

01:58.450 --> 02:03.620
dizer que, para ter uma inteligência artificial real, jogando as ações corretas, cada vez que

02:04.030 --> 02:08.480
o movimento direito, ao invés de ter ações aleatórias, como observamos no tutorial anterior.

02:08.500 --> 02:12.620
Tudo bem, então vamos fazer isso, vamos implementar nossa inteligência artificial.

02:12.760 --> 02:18.430
E, como dissemos, vamos começar por importar todas as bibliotecas que usaremos para implementar.

02:18.460 --> 02:21.160
Então, assim, teremos todas as ferramentas de que precisamos.

02:21.160 --> 02:22.790
Tudo bem, então comecemos com o primeiro.

02:22.810 --> 02:28.870
A primeira é a inevitável biblioteca não-pagadora da biblioteca não-tailandesa.

02:28.870 --> 02:35.270
Eu sempre recomendo importá-lo, é a biblioteca que nos permite jogar e trabalhar com os iraquianos.

02:35.620 --> 02:40.180
E isso aqui é apenas um atalho mais conveniência quando queremos usar o número.

02:40.590 --> 02:44.050
Tudo bem, então a segunda biblioteca é aleatória.

02:44.050 --> 02:50.530
Então, isso é apenas porque iremos tirar algumas amostras aleatórias de lotes diferentes ao implementar a

02:50.530 --> 02:51.770
repetição da experiência.

02:51.940 --> 02:54.650
Então, temos que importar esta biblioteca aleatória também.

02:54.880 --> 03:02.470
Então, iremos importar os que serão úteis quando queremos carregar o modelo porque você sabe que, uma vez que o modelo

03:02.470 --> 03:08.710
esteja pronto, implementaremos algum código para salvar o modelo e depois outro código para carregar o modelo.

03:08.700 --> 03:14.140
É quando queremos que você saiba, salve o cérebro e carregue o cérebro sempre que quiser desligar

03:14.140 --> 03:18.850
seu computador e nós usamos o cérebro que foi treinado antes para alguma experiência nova.

03:19.060 --> 03:20.410
Então isso é importante.

03:20.740 --> 03:27.230
Então, vamos importar a biblioteca da tocha essencial.

03:27.250 --> 03:32.170
muito mais do que os outros para a inteligência artificial, pois pode lidar com gráficos dinâmicos.

03:32.170 --> 03:36.670
Isso é porque vamos implementar nossa rede neural com minha tocha, o que eu recomendo

03:36.670 --> 03:46.150
Então, nós vamos com torche, então, do torche, vamos importar o início do torche e o final do módulo final é o mais essencial

03:46.150 --> 03:51.730
que é o módulo que contém todas as ferramentas para implementar algumas redes neurais.

03:51.820 --> 03:57.370
E é claro que haverá uma rede neural profunda que tomará como entradas os três

03:57.370 --> 04:03.910
sinais dos três sensores mais orientação e orientação negativa e retornará como saída a ação para jogar.

04:04.090 --> 04:09.220
Bem, na verdade, devolver os valores q das diferentes ações e usar um Max macio.

04:09.220 --> 04:15.970
Nós devolveremos a ação para jogar apenas uma a mais relevante para

04:16.000 --> 04:26.500
realizar os cartões para a tortura e, na maioria dos mais importantes, vamos dar um atalho ao pacote funcional.

04:26.550 --> 04:29.960
A partir daqui, vamos com o pacote funcional do final e Maggio.

04:29.970 --> 04:36.310
Portanto, este pacote funcional contém as diferentes funções que usamos ao implementar uma rede neural.

04:36.340 --> 04:42.240
Então, tipicamente, a última função usará a perda do Google porque isso melhora a

04:42.240 --> 04:46.950
convergência e a perda está contida neste submódulo funcional do módulo final.

04:47.190 --> 04:54.330
E, como tudo isso é bastante longo, nós vamos dar um atalho e nós vamos chamar isso simplesmente.

04:54.460 --> 04:57.260
Então, apenas 3 módulos para importar para a esquerda.

04:57.340 --> 05:05.710
Então, o próximo é outro central que cabe a ele e nós o aceitamos ainda da biblioteca de tortura

05:06.220 --> 05:12.870
e, em seguida, vamos e vamos chamá-lo para ele em vez de átomo de tortura.

05:13.030 --> 05:15.250
Isso é claro para o otimizador.

05:15.340 --> 05:22.030
Vamos importar alguns otimizadores para executar o grau C no sentido, então nós definitivamente

05:22.030 --> 05:25.100
precisamos dele e então precisamos importar autógrafos.

05:25.210 --> 05:28.670
E isso é apenas para tirar a classe variável de nosso arrependimento.

05:29.170 --> 05:31.630
Então, o objetivo é um pouco técnico.

05:31.630 --> 05:39.010
Basicamente, precisamos importar a classe variável para fazer alguma conversão de tensores que são como matrizes

05:39.010 --> 05:43.160
mais avançadas para evitar tudo que contenha um gradiente.

05:43.210 --> 05:46.640
Então, é como se não queremos ter apenas um tensor por si só.

05:46.660 --> 05:51.940
Queremos colocar o tensor em uma variável que também conterá um gradiente e, para isso,

05:51.940 --> 05:58.350
precisamos usar a classe variável para converter esse tensor em uma variável contendo o tensor e o gradiente.

05:58.520 --> 06:02.550
Então, isso é um pouco técnico, mas é o que temos a fazer quando trabalhamos com a tocha PI.

06:02.680 --> 06:04.830
E fazemos isso graças à classe de variáveis.

06:04.840 --> 06:13.220
Mas antes de obter a classe de variáveis, precisamos importar torche que

06:13.220 --> 06:26.430
grad e vamos dar um short-cut bem como undergrad e depois da tocha que undergrad importamos Roybal There we go.

06:26.560 --> 06:31.390
E agora temos todas as bibliotecas que usaremos para implementar nossa AI.

06:31.600 --> 06:34.050
Então, não vamos incomodar importar qualquer outra biblioteca.

06:34.060 --> 06:35.670
Temos todas as ferramentas que precisamos.

06:35.830 --> 06:40.000
E agora estamos prontos para criar a arquitetura da rede neural.

06:40.030 --> 06:42.680
Então é exatamente o que faremos no próximo tutorial.

06:42.760 --> 06:44.370
E até então, desfrute da AI.
