WEBVTT

00:00.240 --> 00:06.600
Olá e seja bem vindo a este tutorial do Python no Statoil, vamos dar o primeiro passo na implementação

00:06.630 --> 00:08.270
do modelo de teoria profunda.

00:08.280 --> 00:13.590
Então, basicamente, estamos prestes a implementar todo o processo do algoritmo de difusão.

00:13.830 --> 00:16.580
E então vamos usar o que criamos antes.

00:16.590 --> 00:22.460
Essa é a arquitetura da rede neural para reproduzir a memória para integrar isso no

00:22.530 --> 00:24.180
processo de aprendizagem inteiro.

00:24.180 --> 00:28.320
E todo esse algoritmo de aprendizagem vai se encaixar em uma única classe.

00:28.380 --> 00:32.340
Esse é o último que estamos fazendo para implementar a inteligência artificial.

00:32.340 --> 00:35.650
E esta classe apenas irá conter funções diferentes.

00:35.700 --> 00:41.790
Então, teremos as funções que criarão e inicializarão todas as variáveis ​​associadas aos

00:41.790 --> 00:48.450
nossos futuros objetos de desvio que representarão o próprio modelo e terão outras funções.

00:48.510 --> 00:52.830
Um deles, obviamente, será selecionar a ação certa em cada momento.

00:52.950 --> 00:59.250
Também teremos uma função de função de atualização para obter esse núcleo e ter uma idéia de como a aprendizagem

00:59.250 --> 01:01.030
está indo se estiver indo bem.

01:01.090 --> 01:07.080
Se a exploração está indo bem e se pode passar para a exploração e então teremos uma função segura

01:07.080 --> 01:12.430
para economizar amanhã, que é para salvar o cérebro do carro e, em seguida, carregar a função.

01:12.480 --> 01:14.590
Então, temos algumas funções para fazer.

01:14.640 --> 01:17.440
Vamos fazer uma função para cada trabalho.

01:17.490 --> 01:22.820
E hoje vamos começar com a função final, como de costume, quando estamos fazendo uma aula.

01:23.010 --> 01:30.040
Mas primeiro não se esqueça de apresentar a aula, então vamos chamá-la de D.

01:30.200 --> 01:35.970
Q E para você rede, em seguida, alguns parênteses chamam.

01:36.030 --> 01:39.440
E então vamos com nossa primeira função.

01:39.500 --> 01:47.910
Então, vamos fazer isso, então, sublinhado duplo, então o sublinhado duplo novamente e os parênteses.

01:48.170 --> 01:53.530
Então, como você entendeu nesta função, vamos apresentar as variáveis ​​anexadas ao nosso objeto.

01:53.570 --> 01:59.240
Então, vamos ter um par de linhas começando por si só e basicamente criaremos

01:59.300 --> 02:03.530
e inicializaremos todas as variáveis ​​necessárias para implementar a rede D2.

02:03.530 --> 02:09.740
Então, vamos, por exemplo, criar um objeto ou rede porque, é claro, precisamos da nossa rede neural profunda,

02:10.310 --> 02:12.190
então precisaremos da nossa memória.

02:12.300 --> 02:14.630
Vamos criar outra variável para a memória.

02:14.740 --> 02:20.430
Então, teremos outra variável de memória autônoma, mas isso não é tudo o que teremos que criar também.

02:20.480 --> 02:22.390
Algumas variáveis ​​para a última data.

02:22.490 --> 02:24.820
A última ação e a última palavra.

02:24.920 --> 02:30.520
É claro que você conhece as variáveis ​​que você vê no algoritmo de difusão.

02:30.920 --> 02:31.830
E então, o que mais.

02:31.940 --> 02:38.150
Bem, também precisamos de um otimizador que você conheça para executar grade estocástica no sentido dos pesos de

02:38.510 --> 02:42.170
dados de acordo com o quanto eles contribuirão com o erro.

02:42.320 --> 02:48.650
Quando a AI está cometendo um erro e então acho que, basicamente, as variáveis ​​que agora

02:48.650 --> 02:50.230
precisamos criar e inicializar.

02:50.510 --> 02:58.460
Mas nessa função init, colocaremos um par de argumentos primeiro como auto usual, que são os argumentos

02:58.460 --> 03:00.190
referentes ao nosso objeto.

03:00.200 --> 03:05.210
Então, como você sabe, vamos criar um objeto da classe de rede.

03:05.390 --> 03:12.740
Bem, uma vez que a classe de rede toma como argumento no tamanho da entrada da função init e na ação Bem, isso é

03:12.740 --> 03:13.740
o mesmo aqui.

03:13.850 --> 03:19.110
Ao criar um objeto da classe de rede, precisaremos escolher um argumento de tamanho de entrada e

03:19.160 --> 03:20.180
o argumento atual.

03:20.180 --> 03:22.140
Portanto, podemos copiá-los aqui

03:25.660 --> 03:27.520
e aqui vamos.

03:27.710 --> 03:30.450
Então, esses argumentos agora se tornarão.

03:30.560 --> 03:33.160
Também alguns argumentos não duraram.

03:33.170 --> 03:39.680
Sempre que criamos alguns objetos futuros da classe diferente que alguns modelos voltados para o futuro. Bem, precisamos especificar

03:39.680 --> 03:45.010
o tamanho de entrada que eu lembro é o número de dimensões nos vetores que

03:45.010 --> 03:46.330
estão incluindo seus estados.

03:46.370 --> 03:52.940
Os seus estados de entrada e uma série de ações que é o número de possíveis ações que o carro pode fazer.

03:53.150 --> 03:54.000
Então eu lembro para você.

03:54.110 --> 03:57.830
Estes são ou vão para a esquerda, vá direto ou vá para a direita.

03:58.190 --> 03:59.270
Ok, perfeito.

03:59.270 --> 04:04.640
Então você sabe que você estará criando um novo objeto da classe de memória de repetição para

04:04.640 --> 04:10.680
criar o objeto de memória para obter nossa memória das transições e na informação que temos o argumento de capacidade.

04:10.850 --> 04:16.640
Mas uma vez que só vamos usá-lo uma vez, na verdade, quando criamos memória e não a

04:16.640 --> 04:20.000
partir de então, não precisamos especificar o argumento da capacidade.

04:20.030 --> 04:25.330
Poderíamos fazer isso, mas entraremos diretamente no número de transições que queremos que nossa memória tenha.

04:26.150 --> 04:32.390
Mas, então, precisamos de um último argumento para obter o parâmetro no modelo do professor.

04:32.480 --> 04:35.470
Lembre-se que este parâmetro gama é o atraso.

04:35.750 --> 04:41.300
parâmetro da equação e, portanto, vamos colocá-lo aqui porque vamos usá-lo depois várias vezes.

04:41.510 --> 04:42.920
E esse é um

04:43.160 --> 04:44.990
Então, vamos colocá-lo aqui.

04:45.070 --> 04:47.140
Nós vamos chamá-lo Gamma.

04:47.150 --> 04:52.610
Então, para isso é apenas o nome do argumento e, em seguida, vamos todos os argumentos que você precisará para

04:52.610 --> 04:53.740
isso em sua função.

04:53.750 --> 05:00.320
Isso significa que sempre que criamos nosso modelo de dicionário que é sempre que criamos um objeto do professor em

05:00.320 --> 05:01.390
sala de aula.

05:01.520 --> 05:08.060
Bem, precisamos especificar como argumentos o tamanho da entrada o número de ação e o parâmetro.

05:08.360 --> 05:10.590
E acabaremos com os valores reais para eles.

05:11.210 --> 05:13.870
Tudo bem, então, vamos dentro da função.

05:14.100 --> 05:14.400
ESTÁ BEM.

05:14.410 --> 05:16.480
Então agora basicamente isso vai ser fácil.

05:16.510 --> 05:21.090
Estamos prestes a criar e inicializar todas as variáveis ​​que precisamos.

05:21.110 --> 05:22.770
E então vamos começar com o primeiro.

05:22.910 --> 05:24.460
Vamos começar com a gama.

05:24.530 --> 05:26.090
Na verdade, o coeficiente de atraso.

05:26.330 --> 05:31.850
Então, como este é um Voivode quer ser anexado ao seu objeto, começamos com o eu.

05:31.880 --> 05:39.500
Então, gamma vai ser uma variável do nosso professor e do próprio modelo, que gama é igual aos argumentos que

05:39.530 --> 05:42.930
serão dados ao criar um objeto da classe detune.

05:42.950 --> 05:46.900
Então, Janna e aí vamos com o segundo argumento.

05:47.040 --> 05:50.560
O segundo argumento será a janela de recompensa.

05:50.840 --> 05:52.340
Então, qual é essa janela?

05:52.520 --> 05:57.950
da média das últimas 100 palavras que você usará apenas para avaliar a evolução da performance

05:58.010 --> 06:04.280
que você conhece terá o significado da palavra nesta guerra Windu que irá deslizar ao longo do tempo.

06:04.280 --> 06:06.320
Bem, essa será a janela deslizante

06:06.440 --> 06:11.680
E o que queremos observar é o significado das últimas 100 palavras aumentando com o tempo.

06:11.930 --> 06:18.610
Então, vamos iniciá-lo com a auto-estima que a janela de sublinhado de recompensa.

06:18.710 --> 06:24.690
E assim, uma vez que esta será uma janela deslizante do significado crescente das últimas 100 palavras.

06:24.860 --> 06:31.710
Bem, vamos iniciá-lo como uma lista vazia e então expandiremos para significar que trabalhamos horas extras.

06:32.860 --> 06:35.320
Tudo bem, então, mais emocionante.

06:35.420 --> 06:37.430
Vamos criar nossa rede neural.

06:37.580 --> 06:43.780
Então, vamos chamar de Mario autodidata porque basicamente esse é o coração dos modelos.

06:43.790 --> 06:51.890
Eu estou chamando de modelo e esse modelo não será mais que um assunto nessa classe e

06:51.890 --> 06:53.270
criará esse objeto.

06:53.300 --> 07:02.630
Nós levamos nossa rede de classe entre parênteses e aqui nós apenas colocamos os argumentos da classe, mas colocamos esses

07:02.750 --> 07:08.930
argumentos nos argumentos da função de inicialização e, portanto, precisamos copiá-los aqui e apenas

07:08.930 --> 07:15.290
colá-los na classe de rede e então nós vá com esta linha de código.

07:15.350 --> 07:22.690
Criamos uma rede neural para aprender modelo perfeito então vamos criar uma memória.

07:22.880 --> 07:29.930
Então, novamente, vamos criar um novo Vargo que chamamos de memória autodidata.

07:29.930 --> 07:34.190
E novamente isso vai ser um objeto da classe de memória de repetição.

07:34.220 --> 07:42.320
Então, vamos apenas pegar o nome ou a classe, vamos copiar ainda vamos enfrentar isso aqui e, em alguns parênteses, precisamos

07:42.320 --> 07:48.680
colocar a capacidade porque a capacidade é um argumento da função e esse é o único argumento

07:48.680 --> 07:49.880
que precisamos aqui.

07:50.240 --> 07:55.100
Então, qual a capacidade que vamos escolher, lembre-se que corresponde ao número de transições o número

07:55.100 --> 07:59.800
de eventos último estado em que você declara a última ação e a última palavra.

07:59.830 --> 08:07.550
E, assim como mencionado em um dos problemas do Priester, vamos levar cem mil cem mil transições para

08:07.550 --> 08:14.390
a memória e então amostraremos a partir desta memória para obter um pequeno número de transições

08:14.390 --> 08:18.670
aleatórias e aquela em que o modelo será OK.

08:18.720 --> 08:21.210
Então, agora temos nossa memória perfeita.

08:21.210 --> 08:23.180
Agora vamos buscar o nosso otimizador.

08:23.430 --> 08:31.800
Então, novamente, nós criamos uma nova variável que chamamos otimizador, então otimizador é outra variável do nosso

08:31.800 --> 08:35.320
futuro dequeue, um objeto que o otimizador.

08:35.520 --> 08:44.130
E agora, se voltarmos para cima, você pode ver que importámos o Upton torturado, que é uma tocha modular que contém todas

08:44.160 --> 08:47.080
as ferramentas para realizar a grade no centro.

08:47.130 --> 08:54.260
otimizadores e nós lhe demos o atalho Upton e, portanto, aqui o que vamos fazer é levar o modelo

08:54.270 --> 09:00.900
até ele, que é tocha que ele e a partir deste módulo, vamos levar um dos otimizadores.

09:00.900 --> 09:03.060
Então, é claro, ele contém alguns

09:03.180 --> 09:05.670
Então, como você pode ver, eles estão todos listados aqui.

09:05.880 --> 09:10.630
Muitos deles são excelentes, por exemplo, o Propp da armadura é um excelente otimizador.

09:10.640 --> 09:16.170
Existe, por exemplo, altamente recomendado para registro de redes neurais ou aprendizagem profunda sem supervisão.

09:16.230 --> 09:22.140
Mas o outro que é excelente e que ele escolherá é o otimizador de átomos.

09:22.500 --> 09:26.400
Esse é o que você verá que com este receberá um bom carro auto-dirigido.

09:26.580 --> 09:32.000
Mas, novamente, você é bem-vindo para tentar outros, você pode tentar os braços, mas, para o metal,

09:32.000 --> 09:32.810
escolheremos o Adam.

09:32.850 --> 09:34.290
Então estou pressionando Enter.

09:34.560 --> 09:37.240
E na verdade você notará que há o Capitólio aqui.

09:37.260 --> 09:40.430
Isso porque estamos criando um objeto da classe Atom.

09:40.430 --> 09:44.990
Esta é uma classe, mas o objeto será um otimizador de átomos em si.

09:45.060 --> 09:50.970
Mas uma vez que esta é uma classe, precisamos colocar alguns argumentos, os argumentos da classe Atom e

09:51.060 --> 09:55.270
os argumentos são todos os parâmetros que podem personalizar o seu otimizador.

09:55.380 --> 10:00.330
Então, por exemplo, é tipicamente a taxa de aprendizagem a decadência ou alguns outros parâmetros.

10:00.510 --> 10:05.690
E, além de tomar todos os parâmetros de Ormeau, especificaremos uma taxa de aprendizado.

10:05.970 --> 10:08.650
Então, está começando os parâmetros do nosso modelo.

10:08.670 --> 10:12.830
Podemos obtê-los com um modelo de dúvida de si.

10:12.870 --> 10:17.530
Então, esse é o modelo que criamos aqui modelo autodidacta de nossa própria classe.

10:17.580 --> 10:24.780
Então modelo autodidacta e, em seguida, para acessar os parâmetros do modelo, adicionamos outro ponto e, em seguida,

10:25.500 --> 10:28.170
parâmetros com alguns parênteses, muito simplesmente.

10:28.170 --> 10:35.860
Então, é só conectar o otimizador addon à nossa rede neural que criamos aqui novamente, como acabamos

10:35.880 --> 10:42.810
de mencionar, vamos adicionar uma taxa de aprendizado e o argumento para isso é nosso.

10:43.170 --> 10:50.540
que a aprendizagem não aconteça muito rápido se obtivermos uma taxa de aprendizado muito grande, então a AI AI aprenderá corretamente.

10:50.540 --> 10:53.910
E vamos configurá-lo igual a um valor, de modo

10:53.910 --> 10:58.890
Queremos dar a nossa AI algum tempo para explorar aprender com seus erros.

10:58.890 --> 11:04.320
Você sabe quando nós puni-lo quando está cometendo alguns erros como entrar em algum sentido ou chegar muito

11:04.320 --> 11:05.510
perto de um muro.

11:05.770 --> 11:08.780
Bem, queremos dar algum tempo para aprender.

11:08.880 --> 11:12.030
Queremos que uma maneira para a rede neural até o momento corretamente.

11:12.180 --> 11:21.010
E, portanto, um bom valor para a taxa de aprendizado que acabei depois de tentar vários deles é 0. 2 ou um.

11:21.210 --> 11:24.540
Tudo bem e é tudo o que precisamos para criar um otimizador.

11:24.720 --> 11:28.320
Então, basicamente, você está criando um objeto da classe Atom.

11:28.530 --> 11:29.050
Ótimo.

11:29.070 --> 11:35.980
E então as últimas três variáveis ​​que precisamos são as variáveis ​​que compõem nossos eventos de transição.

11:36.150 --> 11:40.130
Então essa é a última data da última ação e a última palavra.

11:40.170 --> 11:45.280
E então é basicamente o que vamos criar agora e só precisaremos inicializá-los.

11:45.300 --> 11:50.130
Então vamos começar com a última data da última data em que a chamaremos de autodidataçao.

11:50.400 --> 11:56.000
O último estado de sublinhado e, em seguida, como você vai inicializar.

11:56.190 --> 12:03.840
que a última data é um vetor de 5 dominações, um vetor codificado em um estado do meio ambiente.

12:03.840 --> 12:04.700
Bem, lembre-se

12:04.950 --> 12:10.800
E, como lembrete, estas cinco dimensões são os três sinais dos três sensores

12:10.800 --> 12:15.180
que ficam retos e diretos e orientações e menos orientação.

12:15.210 --> 12:18.350
Então, este é um vetor e um sentido intuitivo.

12:18.420 --> 12:21.060
Mas por tocha precisa ser mais do que um vetor.

12:21.210 --> 12:23.640
Na verdade, ele precisa ser um tensor da tocha.

12:23.820 --> 12:29.970
Mas não só precisa ser um sensor de tocha, mas também precisa ter mais uma dimensão que eu

12:29.970 --> 12:33.510
gosto de chamar de dimensão falsa que corresponde ao lote.

12:33.630 --> 12:39.810
E isso ocorre porque os últimos oito serão a entrada da rede neural, mas quando trabalhar comigo quando isso

12:39.810 --> 12:46.220
funciona em geral, seja com um fluxo mais denso, carrega uma tocha, enquanto os vetores de entrada não podem ser

12:46.290 --> 12:48.040
um vetor simples por si só.

12:48.210 --> 12:49.760
Tem que estar em um lote.

12:49.830 --> 12:57.660
A rede só pode aceitar o lote de observações de entrada e, portanto, não só irá criar um

12:57.870 --> 13:05.140
tensor para vetores de estado de entrada, mas também criaremos essa dimensão falsa correspondente ao lote.

13:05.190 --> 13:11.490
Então, vamos fazer isso e vamos começar por inicializar um tensor da tocha para que isso não seja nada

13:11.490 --> 13:12.340
mais simples.

13:12.510 --> 13:21.810
Nós levamos a nossa biblioteca de torche, em seguida, e então vamos usar a classe do tensor porque, como você pode ter

13:21.810 --> 13:27.950
adivinhado, isso criará um objeto da classe do tensor que é um objeto tensor.

13:28.120 --> 13:34.660
E neste tensor precisamos colocar um argumento que especifique o tamanho do tensor.

13:34.660 --> 13:38.720
Você pode imaginar que leva você como uma matriz com um único tipo.

13:38.890 --> 13:45.430
Mas, basicamente, o que isso representará agora é, é claro, esse estado de entrada que você pode ver tem um vetor e,

13:46.180 --> 13:49.380
portanto, especificar o número de elementos que a distância deve ter.

13:49.570 --> 13:55.180
Bem, precisamos usar, é claro, o tamanho da entrada porque o tamanho da entrada é exatamente o número de dimensões

13:55.510 --> 13:57.520
de nossos vetores de estado de entrada.

13:57.520 --> 13:59.050
Agora devo dizer tensores.

13:59.170 --> 14:05.650
E então, o que simplesmente precisamos inserir na nossa classe de tensores para criar um objeto tensor.

14:06.010 --> 14:07.260
Bem, isso é impreciso.

14:07.540 --> 14:10.230
E mais tarde, o tamanho da entrada será quantificado.

14:11.350 --> 14:12.430
Tudo bem, isso é bom.

14:12.430 --> 14:13.670
Essa é a primeira coisa feita.

14:13.720 --> 14:17.390
Acabamos de inicializar o tensor como deveria ser.

14:17.530 --> 14:23.080
que você Coloque no lote será a primeira vez que eu mencionei isso, digamos muito bem.

14:23.080 --> 14:30.070
Mas então lembre-se de que precisamos fazer outra coisa, precisamos criar essa dimensão falsa, porque isso é o que a rede

14:30.070 --> 14:35.840
esperará por suas insumos e criará essa para exame que, de propósito, deve ser o motor da

14:35.940 --> 14:37.800
primeira vez, você conhece o dano

14:38.230 --> 14:46.050
Bem, para fazer isso, simplesmente precisamos adicionar isso e espremer e, em alguns parênteses.

14:46.050 --> 14:49.580
Precisamos colocar o índice dessa grande dimensão.

14:49.620 --> 14:55.790
E, como acabei de dizer, essa dimensão falsa tem que ser a primeira animação da última data e, desde

14:55.790 --> 15:02.460
índices e bytes e início zero, precisamos inserir zero para que este novo mecanismo de paradigma esteja se tornando o primeiro

15:02.460 --> 15:03.570
motor de linha.

15:03.570 --> 15:09.360
Então, temos um motor de primeira vez correspondente ao lote e, em seguida, o diamante deve responder

15:09.360 --> 15:15.960
a esse sensor que conterá os cinco elementos de seus estados de entrada a orientação de três sinais e

15:15.990 --> 15:16.910
menos orientação.

15:17.370 --> 15:21.960
E então, nós iniciamos nossos estados de entrada corretamente.

15:21.960 --> 15:22.850
Perfeito.

15:23.310 --> 15:30.840
E, em seguida, duas variáveis ​​para ir e isso vai ser muito mais fácil porque a próxima variável é a

15:31.110 --> 15:31.850
última ação.

15:32.190 --> 15:36.340
Esse é um novo Roybal que estamos criando para a última ação do objeto.

15:36.510 --> 15:43.440
E lembre-se no primeiro tutorial da seção que eu disse que as ações serão 0

15:43.440 --> 15:52.470
1 ou 2 e, em seguida, usando o vetor de rotação de ação, converteremos esses índices dessas ações nos ângulos

15:52.470 --> 15:58.010
da rotação que eu lembro ao nosso 0 20 ou menos 20.

15:58.050 --> 16:00.980
Podemos realmente atualizar nossa memória com isso.

16:01.200 --> 16:03.170
Bem, é exatamente aqui.

16:03.170 --> 16:06.260
Ação para rotação se a ação for zero.

16:06.390 --> 16:11.650
Bem, isto corresponderá ao primeiro índice de zero se a ação for 1.

16:11.700 --> 16:17.310
20 graus, que será o ângulo de rotação de nosso carro quando tocarmos a ação.

16:17.310 --> 16:23.490
Isso corresponderá ao índice um desses vetores de 20 graus e, se a ação for, obteremos menos

16:23.510 --> 16:24.200
Tudo bem.

16:24.380 --> 16:31.040
E, portanto, uma vez que a ação vai ser 0 1 ou 2 Bem, a ação está lá para um

16:31.040 --> 16:31.740
número simples.

16:31.850 --> 16:35.440
E muito simplesmente podemos inicializá-lo para zero.

16:35.660 --> 16:38.330
Não precisamos criar dezenas nem ouvir nada mais.

16:38.360 --> 16:40.880
Nós precisamos inicializar com zero.

16:41.420 --> 16:42.850
E finalmente.

16:43.010 --> 16:44.460
Bem, essa é a última palavra.

16:44.550 --> 16:48.840
É o eu que última palavra.

16:48.860 --> 16:49.940
Aqui vamos nós.

16:49.940 --> 16:56.510
E novamente a palavra é um número flutuante que eu lembro é entre menos 1 e mais 1.

16:56.510 --> 16:57.790
Então esse é o número novamente.

16:57.860 --> 16:59.400
E quanto à ação.

16:59.510 --> 17:02.900
Vamos inicializá-lo para zero e depois vamos.

17:02.900 --> 17:06.330
Parabéns estão na função está pronta.

17:06.350 --> 17:08.930
Então, agora estamos prontos para seguir as coisas interessantes.

17:08.930 --> 17:16.040
E, na verdade, a coisa mais importante para a IA que está decidindo qual a ação a desempenhar em cada

17:16.080 --> 17:23.240
momento e cada tanty. E é exatamente isso que vamos fazer no próximo tutorial criando o método de ação selecionado.

17:23.510 --> 17:27.310
Então vamos fazer isso no próximo ao trabalho e até então eu.