WEBVTT

00:00.520 --> 00:05.830
Olá e seja bem vindo ao tutorial final da seção, vamos fazer a última função desse

00:06.180 --> 00:12.510
D2 na classe, o que certamente será a função de carga que vem naturalmente após a mesma função.

00:12.580 --> 00:17.450
Você salva seu modelo e então deseja que ele seja carregado sempre que você voltar para o aplicativo.

00:17.500 --> 00:18.940
Então vamos fazer isso.

00:18.940 --> 00:22.420
Nós vamos fazer def então carregar.

00:22.480 --> 00:29.230
Chamamos a função de função de carga novamente, esta função de carga tomará como argumentos próprios e você provavelmente

00:29.230 --> 00:35.210
adivinhará onde esse auto será para ele será exatamente carregar o que foi salvo na mesma função.

00:35.230 --> 00:37.170
Então, tomaremos auto-direto amanhã.

00:37.210 --> 00:39.310
E, claro, resolva esse otimizador.

00:39.550 --> 00:42.620
Portanto, a auto-cura será para o modelo e o otimizador.

00:43.030 --> 00:46.530
Então, Cullin E agora vamos diminuir o modelo.

00:46.900 --> 00:53.350
Então, como o Dymo está no último arquivo de arquivo brindled, queremos garantir que este arquivo exista e, portanto, é para

00:53.350 --> 00:54.620
isso que vamos começar.

00:54.690 --> 01:00.520
Nós vamos fazer uma condição IF para garantir que esse arquivo exista e, se existir, iremos carregar

01:00.790 --> 01:05.160
o que temos no dicionário que está neste último PDA de impressão.

01:05.500 --> 01:13.430
se, então, vamos levar nosso sistema operacional e o caminho que leva a esse último cérebro que PVH encontrou.

01:13.450 --> 01:14.980
Então, começamos com um

01:15.160 --> 01:19.730
Então esse caminho é exatamente o caminho que leva à pasta do diretório de trabalho.

01:19.810 --> 01:26.530
Portanto, no que me diz respeito, essa é esta área de trabalho rápida do que a minha inteligência artificial, é uma pasta, então,

01:26.530 --> 01:32.080
modelo um auto-dirigindo carro e, em seguida, o módulo de uma auto-dirigindo carro pasta há esta pasta aqui com

01:32.080 --> 01:33.970
a última impressão que você encontrou.

01:34.210 --> 01:39.570
E então, vamos adicionar ao arquivo de arquivo esse.

01:39.850 --> 01:40.990
Então, essa é uma função.

01:41.080 --> 01:42.700
Então, vou adicionar alguns parênteses.

01:42.850 --> 01:48.040
E, dentro dos parênteses, vou inserir o nome do nome do arquivo do arquivo que contém

01:48.040 --> 01:50.810
o modelo que é o último brain deth.

01:50.890 --> 01:53.660
Então, temos que colocá-lo entre aspas.

01:53.860 --> 02:04.000
E então estou entrando no último cérebro que de-th e assim é arquivo último cérebro que a página retornará verdadeira se o arquivo que

02:04.000 --> 02:10.750
é amigo dessa idade existe e cai se não existir e, portanto, essa condição se significa

02:10.990 --> 02:13.410
se tivermos o último renderizar.

02:13.630 --> 02:18.110
Bem, agora pasta de diretório de trabalho, então vamos.

02:18.110 --> 02:19.900
O que acontecerá nesse caso.

02:19.900 --> 02:22.470
Nesse caso, se esse arquivo existir.

02:22.660 --> 02:28.150
Bem, primeiro, vamos imprimir algo para dizer que você sabe que estamos carregando a

02:28.150 --> 02:35.900
moral, por exemplo, você pode dizer uma pequena flecha e depois carregar pontos de verificação com três pontos pequenos.

02:35.980 --> 02:36.320
Tudo bem.

02:36.340 --> 02:38.350
Isso é só para dizer que estamos carregando amanhã.

02:38.620 --> 02:41.050
E, claro, vamos carregar o modelo.

02:41.080 --> 02:46.690
e o otimizador e vamos colocar o que carregamos em um testamento que eu vou chamar iguais de

02:46.840 --> 02:54.040
ponto de controle e é aí que vamos usar a função de carga para carregar o que foi salvo na mesma função.

02:54.040 --> 02:54.920
Então, o moral

02:55.150 --> 03:02.530
Então, é claro, esta é uma função da biblioteca da tocha para o ponto da tocha e o nome da função

03:02.530 --> 03:08.990
Sloat é simplesmente esse parêntese e dentro dos parênteses de acordo com você, o que precisamos para inserir.

03:09.190 --> 03:15.340
Bem, muito simplesmente precisamos inserir o arquivo que contém o nosso amanhã salvo e

03:15.370 --> 03:24.150
otimizador de otimização salvo, simplesmente precisamos colocar o nome do arquivo que é o último que traz o ponto-de-dia.

03:24.390 --> 03:30.300
Vamos trazer esse BGH e nós carregamos esse arquivo somente na condição de que esse arquivo exista.

03:30.300 --> 03:33.040
Então é por isso que devemos chamar essa condição aqui.

03:33.860 --> 03:36.590
OK, então agora que carregamos o modelo eo otimizador.

03:36.690 --> 03:43.520
Bem, o que vamos fazer é atualizar separadamente o nosso modelo e o otimizador porque na verdade

03:43.530 --> 03:48.080
carregamos os parâmetros que carregamos os pesos e os parâmetros do otimizador.

03:48.160 --> 03:56.490
Então, agora, o que precisamos fazer é atualizar nosso modelo existente, esse é um modelo de bloco de

03:56.550 --> 04:04.890
célula e nosso otimizador existente resolveu esse otimizador com os parâmetros com os pesos que estão neste último Brender.

04:05.150 --> 04:10.680
Então, simplesmente precisamos fazer essas duas atualizações separadamente e, para isso, vamos usar um método

04:10.680 --> 04:11.980
dos módulos de tortura.

04:12.150 --> 04:17.970
Então, haverá herança que nos permitirá usar esse método que se chama Load state

04:17.970 --> 04:25.500
dict e o método estável retardado nos permitirá fechar todos os parâmetros do nosso modelo e nosso otimizador.

04:25.500 --> 04:28.710
Então, vamos fazer isso e vamos começar por atualizar nossos modelos.

04:28.710 --> 04:35.820
Então, nós tomamos nosso modelo que é um modelo autodidata, uma vez que o modelo autodidata herda dos métodos do

04:35.820 --> 04:40.530
módulo da tocha para usar o método do estado do estado do carregamento.

04:40.650 --> 04:43.190
Então esse é o método que estamos tirando da herança.

04:43.380 --> 04:48.490
E graças a este método, vamos atualizar todos os parâmetros do modelo que é todo o caminho.

04:48.810 --> 04:54.120
E então, o que precisamos para colocar neste método Dick Dick é o nosso ponto de controle muito bem.

04:54.180 --> 04:56.210
Esse é o resultado da função de carga.

04:56.290 --> 05:04.080
e agora precisamos inserir o nome da chave que corresponde ao nosso modelo que corresponde a uma data do estado do modelo de subdução.

05:04.470 --> 05:07.270
Então, os pontos de verificação, em seguida, os suportes

05:07.560 --> 05:09.490
E isso é estado.

05:09.800 --> 05:17.970
Assim, nos pontos de verificação e os parênteses que inserimos nos boletins de destaque dos Estados citados, essa linha

05:18.210 --> 05:20.170
de código atualizará seu modelo.

05:20.220 --> 05:23.440
Essa é uma ferramenta que aguarda os parâmetros do seu modelo.

05:23.580 --> 05:26.330
E agora precisamos fazer o mesmo para o otimizador.

05:26.520 --> 05:28.380
E isso vai ser quase o mesmo.

05:28.470 --> 05:33.290
Então vou copiar esta linha colada abaixo.

05:33.420 --> 05:40.620
E então, desta vez, vamos namorar não amanhã, mas o otimizador que otimizador.

05:40.650 --> 05:47.730
Então, novamente, usamos para carregar o método Dick Dick que herda dos métodos do módulo da tocha

05:47.730 --> 05:52.020
e aplicamos essa função ao ponto de controle do estado dict.

05:52.170 --> 05:56.970
Mas a chave que corresponde ao otimizador e que é otimizador.

05:57.150 --> 06:02.260
Então, aqui, basta substituir uma data por até o Mizer.

06:02.280 --> 06:03.180
Aqui vamos nós.

06:03.180 --> 06:04.880
Aqui atualizamos os pesos do.

06:04.920 --> 06:07.600
E aqui atualizamos os parâmetros do otimizador.

06:08.340 --> 06:15.870
Perfeito e, então, apenas para terminar, podemos imprimir um pouco feito assim.

06:15.870 --> 06:21.510
E, finalmente, precisamos especificar o que acontece se esta condição não for respeitada.

06:21.570 --> 06:29.670
Isto é, se não há muitos testes Pythia e, por isso, precisamos adicionar outra coisa além de Colin e Cindy, só

06:29.700 --> 06:32.630
vamos dizer que não há tal arquivo.

06:32.640 --> 06:34.110
Vamos trazer a idade da PTA.

06:34.200 --> 06:44.350
Então, vamos imprimir algo como nenhum ponto de verificação e três pouco, se você quiser.

06:44.360 --> 06:45.180
Tudo bem.

06:45.230 --> 06:50.500
E isso nos dá uma função de carga funcional e principalmente funcional.

06:50.540 --> 06:57.890
Você em aula e agora enormes parabéns porque nossa inteligência artificial está pronta, você provavelmente pode ouvir pelo som da minha

06:57.890 --> 07:02.230
voz e estou ficando muito animado porque agora é hora da demo.

07:02.330 --> 07:08.510
Nós acabamos de fazer um cérebro e vamos colocar esse cérebro no carro e veremos como é inteligente o suficiente para fazer essas

07:08.840 --> 07:13.440
viagens de ida e volta entre o aeroporto e o centro da cidade onde quer que esteja.

07:13.520 --> 07:15.310
Então eu não posso esperar para mostrar a demo.

07:15.410 --> 07:17.430
Esta será a próxima seção.

07:17.510 --> 07:19.100
E até então eu.