WEBVTT

00:00.450 --> 00:02.670
Ciao e benvenuto in questo modello è orrore.

00:02.850 --> 00:06.890
Bene, abbiamo appena aggiornato la memoria dopo aver raggiunto il nuovo stato.

00:06.900 --> 00:09.010
E ora prendiamoci cura del giorno dopo.

00:09.330 --> 00:12.810
Secondo te ora quale sarà il prossimo aggiornamento.

00:12.810 --> 00:20.040
Beh, in pratica abbiamo finito con una transizione che abbiamo datato l'ultimo elemento della transizione che è il

00:20.040 --> 00:20.960
nuovo stato.

00:21.150 --> 00:23.340
Quindi ora è come se stessimo ricominciando da capo.

00:23.520 --> 00:25.530
E quando stavamo ricominciando tutto da capo.

00:25.650 --> 00:31.320
È come se sapessimo che siamo in questo nuovo stato dell'ambiente e quindi cosa dobbiamo fare ora in modo naturale.

00:31.500 --> 00:37.170
Beh, certo, è un'azione da svolgere perché abbiamo già avuto l'osservazione degli Stati di notizie.

00:37.410 --> 00:43.290
Ora la cosa che dobbiamo fare è giocare un'azione e quindi quello che dobbiamo fare ora

00:43.290 --> 00:46.960
è ovviamente usare la funzione azione selezionata per giocare l'azione.

00:47.010 --> 00:54.320
Facciamo così, creiamo una nuova azione Voivode e giochiamo l'azione con l'azione selezionata,

00:54.320 --> 00:55.240
quindi prendo.

00:55.380 --> 01:03.150
Bene prima di tutto per specificare che la funzione di azione di selezione è un metodo dell'oggetto della classe

01:03.150 --> 01:04.300
che verrà creato.

01:04.470 --> 01:08.610
Quindi un sé che seleziona l'azione.

01:08.640 --> 01:09.520
Eccoci qui.

01:09.560 --> 01:11.090
Quindi questa è la prossima azione.

01:11.310 --> 01:17.560
E poi, naturalmente, poiché la funzione di azione di selezione prende lo stato come input perché ovviamente la

01:17.560 --> 01:24.270
funzione di azione di selezione restituirà l'uscita della rete neurale quando lo stato di ingresso corrente è entrato nella

01:24.270 --> 01:25.220
rete neurale.

01:25.500 --> 01:31.650
dato che sono gli stati che abbiamo appena raggiunto nell'ambiente in questo momento in cui lo stato di input è

01:31.650 --> 01:37.350
ovviamente lo stato perché questo stato che abbiamo appena raggiunto al momento in cui ci troviamo ora è Newstead.

01:37.350 --> 01:40.070
Quindi dobbiamo inserire lo stadio di input qui e

01:40.290 --> 01:45.140
Quindi in questa funzione di selezione prescelta, intendo mettere nuovi bastoncini.

01:45.150 --> 01:51.710
Va bene così con questa linea di codice semplicemente giochiamo la nuova azione dopo aver raggiunto il nuovo stato.

01:52.140 --> 01:58.780
OK e ora che abbiamo giocato un'azione Bene otteniamo la ricompensa e quindi otteniamo un riscontro con la ricompensa.

01:59.010 --> 02:04.550
E quindi se abbiamo più di 100 elementi nella memoria Beh, sarebbe tempo di imparare.

02:04.860 --> 02:10.830
E quindi quello che dobbiamo fare ora è ciò che logicamente viene dopo aver selezionato un'azione che è

02:10.830 --> 02:13.830
naturalmente quella di abbassare l'IA necessario per iniziare l'apprendimento.

02:13.950 --> 02:15.620
Se sta facendo le cose nel modo giusto.

02:15.870 --> 02:22.530
E ora, dato che ha appena giocato bene l'azione, faremo imparare l'IA dalle sue azioni negli

02:22.530 --> 02:23.940
ultimi 100 eventi.

02:24.130 --> 02:31.320
Ma prima di applicare questa funzione appresa dobbiamo fare questa condizione per assicurarci di aver già raggiunto

02:31.320 --> 02:37.380
più di 100 eventi perché sai che stiamo imparando dai campioni casuali della memoria.

02:37.530 --> 02:41.110
Sai che abbiamo questo enorme ricordo di 10000 elementi.

02:41.190 --> 02:48.930
Stiamo prendendo alcuni campioni casuali della memoria di 100 elementi e l'IA sta imparando dalle informazioni

02:48.990 --> 02:52.850
contenute in questo campione di 100 transizioni casuali.

02:52.860 --> 03:00.690
della tua classe di memoria di replay, ma poi la classe di memoria di replay ha un attributo che è memoria.

03:00.810 --> 03:06.390
Quindi, facciamo solo questa condizione, per accertarci che il numero di elementi della memoria di

03:06.390 --> 03:12.380
quella memoria e quindi fare attenzione solo un piccolo trucco qui la memoria autodidatta sia l'oggetto

03:12.510 --> 03:21.780
Quindi, in effetti, abbiamo bisogno di prendere un po 'della memoria che la memoria è la prima memoria

03:21.780 --> 03:28.170
della classe replay e la seconda memoria è l'attributo che la memoria.

03:28.200 --> 03:37.350
Quindi se il numero di elementi nella memoria è buono, vogliamo che sia più grande di 100, quindi Cullin e poi

03:37.860 --> 03:38.800
cosa succede.

03:38.970 --> 03:46.320
Bene, possiamo imparare, ma per l'apprendimento abbiamo bisogno di ottenere questo campione casuale di 100 transizioni e questo

03:46.320 --> 03:48.840
possiamo ottenere con la semplice funzione.

03:48.840 --> 03:55.140
E poiché la funzione semplice restituisce i diversi lotti agli stati al tempo t questi dati 20 più uno le

03:55.290 --> 03:57.950
azioni del tempo t e noi eravamo a 20.

03:58.200 --> 04:03.360
Bene, quello che dobbiamo fare ora è creare delle nuove revisioni che saranno il lotto

04:03.360 --> 04:08.580
degli stati al momento t il lotto delle prossime date il lotto delle parole e

04:08.580 --> 04:16.030
il lotto delle azioni e possiamo semplicemente dare gli stessi nomi come abbiamo dato per gli argomenti qui e sono qui.

04:16.200 --> 04:24.720
E queste variabili saranno uguali a ciò che restituisce la funzione semplice perché restituisce esattamente questi lotti e le

04:24.720 --> 04:28.320
successive azioni dello stato sono parole e azioni.

04:28.320 --> 04:35.570
oggetto di memoria e quindi da questo oggetto di memoria useremo il metodo semplice che prenderà come input.

04:35.620 --> 04:40.300
Quindi quello che dobbiamo semplicemente fare ora è ottenere prima il nostro

04:40.500 --> 04:46.370
Bene, il numero di transizioni che vogliamo che la nostra IA apprenda da questo è 100.

04:46.620 --> 04:50.540
Ecco perché abbiamo fatto in modo che avessimo più di cento transizioni.

04:50.610 --> 04:54.780
Quindi imparerà da 100 transizioni della memoria.

04:54.840 --> 04:56.500
Quindi l'apprendimento sarà molto meglio.

04:56.610 --> 04:59.560
E così ora facciamo in modo che questo accada davvero.

04:59.700 --> 05:04.560
Bene visto che il metodo di apprendimento è un metodo della nostra classe.

05:04.830 --> 05:11.180
oggetti futuri che verranno creati da una classe diversa e quindi ciò che dobbiamo prendere è self.

05:11.190 --> 05:14.300
Bene, dobbiamo accedere a questo metodo Learn dagli

05:14.430 --> 05:21.960
Il sé si riferisce a quell'obiettivo da fare durante le lezioni e poi impara come questo metodo appreso metodo

05:22.470 --> 05:29.340
appreso a cui, quando messo Ovviamente questi ragazzi qui, il cattivo stato, lo stato belga, il mondo naturale

05:29.340 --> 05:30.530
e l'azione Bachche.

05:30.630 --> 05:38.730
Questi sono i nostri lotti campionati dalla nostra memoria e ne riceviamo 100 perché abbiamo 100 transizioni

05:39.330 --> 05:47.750
da queste 100 transizioni prendiamo 100 stati 100 stati successivi 100 ricompensa e 100 azioni affrontiamo il

05:47.780 --> 05:51.530
qui e il là andiamo ora l'apprendimento avverrà.

05:51.850 --> 05:54.490
Succederà da tutti questi lotti casuali.

05:54.520 --> 05:55.850
Perfezionare.

05:55.960 --> 06:03.310
E ora quello che dobbiamo fare sono gli ultimi aggiornamenti dopo aver saputo raggiungere un nuovo stato e giocare

06:03.310 --> 06:04.140
in azione.

06:04.330 --> 06:08.890
Beh, abbiamo davvero giocato, ma non abbiamo ancora avuto questa reazione.

06:08.920 --> 06:11.590
Questo è il nostro sé che ultimo voivoda azione.

06:11.770 --> 06:13.730
Quindi assicuriamoci di non dimenticarlo.

06:13.780 --> 06:15.160
Facciamolo adesso.

06:15.190 --> 06:24.610
che l'ultima azione sia uguale e, naturalmente, eseguiamo l'azione che restiamo qui con questa funzione di azione selezionata.

06:24.610 --> 06:27.020
Aggiorneremo l'ultima azione in modo

06:27.020 --> 06:30.520
A questo punto l'ultima sezione viene aggiornata quindi.

06:30.520 --> 06:31.890
Lo stesso vale per il nuovo stato.

06:31.930 --> 06:39.190
Abbiamo raggiunto il nuovo stato ma non abbiamo ancora aggiornato l'ultima data perché, naturalmente, l'ultimo era prima dello

06:39.280 --> 06:40.590
stato all'ora t.

06:40.750 --> 06:44.870
Ma da adesso abbiamo raggiunto il nuovo surplus di stato quando è il momento di superarne uno.

06:45.070 --> 06:48.180
Bene, l'ultimo diventa questo che hai detto qui.

06:48.190 --> 06:50.290
Quindi abbiamo bisogno anche di aggiornamenti.

06:50.290 --> 06:57.070
Sé che l'ultimo stato è uguale al nostro nuovo stato.

06:57.280 --> 06:58.020
Eccoci.

06:58.210 --> 06:59.620
E ora cosa dobbiamo datare.

06:59.830 --> 07:01.640
Bene, c'è solo una cosa rimasta.

07:01.660 --> 07:08.070
Questa è ovviamente la parola e la parola è esattamente la parola che otteniamo nella realtà.

07:08.290 --> 07:15.910
Quindi questo sarà l'argomento di questa funzione che se avessimo stabilito la connessione con la nostra mappa sarebbe

07:15.910 --> 07:17.160
stata l'ultima parola.

07:17.200 --> 07:23.250
Questa è la parola che otteniamo subito dopo aver giocato l'azione in questo ha raggiunto nuovi stati.

07:23.470 --> 07:30.260
Quindi se andiamo ad un suono questa ultima parola sarà quella meno se andiamo più lontano avremo

07:30.290 --> 07:35.580
una parola leggermente cattiva meno 0. 2 se ci avviciniamo all'obiettivo.

07:35.660 --> 07:38.680
Otterremo un premio leggermente buono 0. 1.

07:38.830 --> 07:43.370
E se ci avviciniamo troppo a un bordo della mappa, questo riguarderà la punizione.

07:43.510 --> 07:45.330
Otterremo meno uno per ciascuno.

07:45.440 --> 07:47.110
Quindi questa è l'ultima parola che otteniamo.

07:47.110 --> 07:50.700
In realtà è quando ciò accade per davvero sulla mappa.

07:50.830 --> 07:53.550
E questo sarà l'argomento della funzione.

07:53.600 --> 07:54.690
L'ultima parola qui.

07:54.700 --> 07:56.200
Questo è esattamente questo.

07:56.250 --> 08:01.840
E siccome questo è l'argomento della funzione di aggiornamento che corrisponde a

08:02.170 --> 08:11.590
questo non eravamo qui e quindi il nostro sé che l'ultima variabile di parola inizializzata all'inizio in questa funzione diventa

08:12.070 --> 08:20.570
la nuova parola che otteniamo nella realtà che è la parola o che è la stessa ultima parola.

08:20.730 --> 08:21.360
Tutto ok.

08:21.410 --> 08:23.680
Ora abbiamo aggiornato la nostra ultima parola.

08:23.990 --> 08:27.240
E ora da quando abbiamo appena avuto la nostra ultima parola.

08:27.500 --> 08:29.470
Bene, ora possiamo uscire con il mondo.

08:29.850 --> 08:37.140
Ricordi la guerra quando inizializzammo qui come una delle variabili dell'oggetto della nostra classe.

08:37.190 --> 08:42.500
Questa è la finestra che terrà traccia di come questo treno sta andando prendendo la

08:42.500 --> 08:44.270
media degli ultimi 100 premi.

08:44.300 --> 08:50.180
Quindi sai che sarà come una finestra scorrevole che ci mostra come si sta evolvendo la media del mondo.

08:50.180 --> 08:52.730
E così da quando abbiamo appena avuto la nostra ultima parola.

08:52.910 --> 08:56.910
Bene, possiamo aggiornare la finestra su come aggiornarla.

08:57.080 --> 09:03.680
il mio sé della finestra di guerra che diciamo quando sentono questo e userò la funzione append.

09:03.980 --> 09:12.350
Beh, abbiamo semplicemente bisogno di aggiungere questa ultima parola alla finestra e quindi quello che ho intenzione di fare è prendere

09:12.530 --> 09:18.830
E all'interno della funzione aperta abbiamo bisogno di inserire l'elemento che vogliamo aggiungere al momento

09:18.830 --> 09:21.480
in cui lo facevamo, ovviamente lo vogliamo.

09:21.500 --> 09:22.610
Va bene perfetto.

09:22.610 --> 09:29.480
E poi, dal momento che questa finestra di guerra avrà una dimensione fissa, sai che non sarà una finestra

09:29.480 --> 09:35.300
in crescita, sarà una finestra di dimensioni fisse che scorre col tempo per mostrare l'evoluzione del mondo.

09:35.500 --> 09:38.590
E così ora dobbiamo decidere per una taglia di questo inverno.

09:38.750 --> 09:43.600
Ed è semplicemente il numero di mezzi del premio che avremo in questa finestra.

09:43.900 --> 09:49.330
E così, per esempio, ti facciamo conoscere gli ultimi 1000 mezzi delle ultime 100 parole.

09:49.340 --> 09:58.730
E quindi, per assicurarcene, aggiungeremo se poi pianifichiamo la nostra finestra di lavoro e aggiungiamo semplicemente

09:58.740 --> 10:05.810
qui se il numero di elementi nella finestra è maggiore di 1000.

10:05.990 --> 10:14.780
Bene, quello che vogliamo fare è eliminare il primo elemento di questo che la nostra finestra e il

10:14.780 --> 10:19.070
primo elemento di questa era finestra deve indicizzare zero.

10:19.150 --> 10:19.550
Tutto ok.

10:19.550 --> 10:24.620
Ora ci assicuriamo che questa finestra di guerra non ottenga mai più di 1000 elementi.

10:24.620 --> 10:31.130
è perfetto questa sarà una finestra di dimensioni fisse in modo che possiamo vedere se la media della parola è in aumento.

10:31.310 --> 10:34.360
C'è un migliaio di mezzi delle ultime 100 parole che

10:34.460 --> 10:39.560
E quindi se la formazione sta andando bene e di conseguenza la corte fa quello che vogliamo.

10:39.800 --> 10:40.760
Perfezionare.

10:41.000 --> 10:46.010
E ora una piccola piccola cosa da lasciare a te secondo che cosa sarà.

10:46.190 --> 10:52.130
Ricorda che questa funzione di aggiornamento non solo aggiorna i diversi elementi della transizione nella finestra

10:52.140 --> 10:57.960
di guerra, ma restituisce anche l'azione che è stata giocata quando si raggiunge questo nuovo stato.

10:58.190 --> 11:05.270
Ecco perché abbiamo e poi quell'azione equivale a portare quella data che siamo meno segnale e quindi si suppone

11:05.360 --> 11:10.760
che restituisca qualcosa e il qualcosa che si suppone debba tornare è, naturalmente, l'azione.

11:10.820 --> 11:18.950
Quindi l'ultima cosa che dobbiamo fare qui è solo restituire l'azione che è stata appena giocata quando si raggiunge

11:18.950 --> 11:20.180
il nuovo stadio.

11:20.600 --> 11:23.670
E questa è la nostra funzione di aggiornamento è pronta.

11:23.840 --> 11:29.110
Farà tutti gli aggiornamenti richiesti e cambierà azione quando raggiungerà la nuova fase.

11:29.480 --> 11:30.650
È perfetto.

11:30.650 --> 11:35.230
Quella fu l'ultima azione difficile da fare per tutto questo un processo.

11:35.240 --> 11:37.120
Ora il resto sarà roba buona.

11:37.220 --> 11:42.170
Creeremo solo una funzione di base per restituire i mezzi che vogliamo nella finestra.

11:42.200 --> 11:47.450
Quindi faremo una funzione sicura per salvare il cervello dell'auto ogni volta che vuoi uscire dall'applicazione

11:47.600 --> 11:48.840
e tornare ad esso.

11:48.890 --> 11:53.720
E naturalmente dal momento che vuoi essere in grado di caricare il cervello della tua auto quando

11:53.720 --> 11:54.730
torni a tornare all'applicazione.

11:55.040 --> 12:01.370
Bene finiremo per creare una funzione di caricamento che caricherà il modello dopo aver salvato il modello

12:01.370 --> 12:02.800
con la stessa funzione.

12:02.840 --> 12:06.470
Quindi tre funzioni per farlo, ma sarà semplice.

12:06.500 --> 12:12.760
la sezione più eccitante di questo primo modulo che è la demo che vedremo se l'aria funziona.

12:12.770 --> 12:13.840
E poi avremo

12:13.850 --> 12:19.430
Vedremo se la macchina raggiungerà gli obiettivi e vedremo come possiamo migliorarla e poi alla

12:19.430 --> 12:21.980
fine dovrai costruire la tua prima IA.

12:22.160 --> 12:24.010
Quindi non vedo l'ora di iniziare la demo.

12:24.140 --> 12:27.580
Facciamo prima queste tre funzioni e fino a quel momento I.