WEBVTT

00:00.390 --> 00:02.710
Ciao e benvenuto alla spezia Intertoto.

00:03.000 --> 00:07.800
Bene, in questa nuova sezione di codice implementeremo l'esperienza con il gioco.

00:07.920 --> 00:13.850
Quindi creeremo una nuova classe che chiameremo memoria di replay e che implementerà l'esperienza per suonare

00:13.850 --> 00:16.700
esattamente come hai visto nelle lezioni di intuizione.

00:16.890 --> 00:21.540
Ma prima diamo un rapido promemoria su cosa è il replay dell'esperienza.

00:21.540 --> 00:27.750
Quindi sai che tutta questa intelligenza artificiale si basa sui processi decisionali di Markov e che i

00:27.750 --> 00:31.840
processi decisionali di Markov consistono nel guardare una serie di eventi.

00:32.010 --> 00:38.770
Quindi gli eventi si conoscono, ad esempio, passando da uno stato a uno successivo e uno a uno.

00:39.060 --> 00:44.410
Ma se gli eventi erano così bene dal giorno successivo è molto correlato allo stato attuale.

00:44.550 --> 00:46.820
Bene, la rete non andrebbe molto bene.

00:46.980 --> 00:52.710
Quindi per chi viene dal corso di deep learning è esattamente lo stesso di dove abbiamo imparato le

00:52.710 --> 00:54.860
nostre serie temporali con un solo timestep.

00:55.020 --> 01:00.300
Non stava imparando nulla perché un timestep non era abbastanza sufficiente per un modello per

01:00.300 --> 01:03.070
imparare a capire le correlazioni a lungo termine.

01:03.090 --> 01:07.060
Quindi è lo stesso qui ed è per questo che dobbiamo implementare la riproduzione dell'esperienza.

01:07.230 --> 01:08.230
Quindi, come funziona.

01:08.340 --> 01:13.960
Bene, è molto semplice invece di considerare solo lo stato corrente che è solo uno stato al

01:13.960 --> 01:14.640
tempo t.

01:14.680 --> 01:16.830
Considereremo di più in passato.

01:16.830 --> 01:22.560
Così esattamente come per i litio e quindi la nostra serie di eventi non sarà così.

01:22.560 --> 01:27.450
E suppongo che questo sarà per esempio i cento stati del passato.

01:27.450 --> 01:33.770
Così come T-meno cento ottanta meno 99 fino a meno 1 e poi S-T.

01:34.020 --> 01:40.830
in quella che chiamiamo memoria ed è per questo che abbiamo una memoria a lungo termine rispetto a una memoria

01:40.830 --> 01:47.040
a breve termine o anche dovrei dire una memoria istantanea e questo rende l'intero processo molto più efficace.

01:47.040 --> 01:49.950
Quindi, in altre parole, mettiamo 100 meno transizioni

01:50.310 --> 01:57.690
E poi, una volta creato questo ricordo degli ultimi 100 eventi, sarà semplicissimo che ci vorranno alcuni

01:57.690 --> 02:02.300
lotti casuali di queste transizioni per fare il nostro prossimo aggiornamento.

02:02.310 --> 02:09.270
Questa è la nostra prossima mossa selezionando la sezione successiva e quindi in questa classe di memoria

02:09.270 --> 02:13.450
di replay che implementeremo per la riproduzione dell'esperienza, faremo tre funzioni.

02:13.530 --> 02:17.490
Prima di tutto la funzione come al solito è il caso per qualsiasi classe.

02:17.520 --> 02:23.400
E così in questa funzione definiremo le variabili che saranno associate alle future istanze della classe

02:23.400 --> 02:27.210
che saranno gli oggetti futuri che verranno creati da questa classe.

02:27.540 --> 02:32.790
E quindi molto semplicemente queste variabili saranno la memoria delle 100 transizioni a 100 eventi.

02:32.970 --> 02:38.790
E la capacità che è il numero di 100 sarà il benvenuto per provare una memoria più lunga aumentando

02:38.790 --> 02:39.550
la capacità.

02:39.780 --> 02:46.170
Quindi questa è la prima funzione nella sua funzione e quindi faremo due altre funzioni una funzione push

02:46.500 --> 02:51.050
per assicurarci che la memoria non contenga mai più di 100 transizioni.

02:51.180 --> 02:57.150
E per questo useremo la capacità semplicemente facendo una semplice condizione e poi alla fine

02:57.360 --> 03:03.300
faremo la funzione semplice e questo sarà ovviamente per campionare alcune transizioni in questa memoria

03:03.390 --> 03:05.060
delle ultime 100 transizioni.

03:05.520 --> 03:08.440
Va bene, iniziamo introducendo la lezione.

03:08.520 --> 03:17.460
Quindi, come sapete, iniziamo con la classe e poi li assegniamo alla classe che chiamiamo replay memory

03:17.460 --> 03:25.500
e quindi tra parentesi inseriamo l'oggetto poi Cullin e poi andiamo iniziamo con la prima funzione.

03:25.560 --> 03:26.860
La fine è la funzione.

03:27.150 --> 03:30.730
Quindi è esattamente lo stesso di prima che iniziamo con la morte.

03:30.870 --> 03:36.750
Quindi due trattini di sottolineatura in esso due sottolineano nuovamente e quindi le variabili.

03:36.750 --> 03:42.750
future istanze della classe degli oggetti futuri e quindi avremo un'altra variabile in modo che tu

03:42.750 --> 03:48.810
possa provare qualche altra esperienza con alcuni dei ricordi e che sta per essere la capacità.

03:48.810 --> 03:52.950
Quindi, naturalmente, c'è il sé che è la variabile associata alle

03:52.950 --> 03:58.020
Quindi questa capacità sarà semplicemente il numero cento perché faremo esperienza

03:58.020 --> 04:00.960
per giocare con le cento meno transizioni.

04:00.960 --> 04:03.910
Va bene e poi Collon Ed eccoci qui.

04:03.930 --> 04:10.430
Entriamo nella funzione e definiamo le variabili del nostro oggetto replay memory.

04:10.440 --> 04:19.400
Quindi il primo sarà la capacità di autodidatta e, come probabilmente avete capito, questa sarà la capacità che è il numero

04:19.670 --> 04:24.690
massimo di transizioni che vogliamo avere nella nostra memoria degli eventi.

04:24.830 --> 04:30.980
quando si crea un oggetto della classe di memoria di replay e quindi questa è la capacità.

04:31.000 --> 04:34.530
E questo sarà uguale agli argomenti che verranno inseriti

04:34.550 --> 04:36.480
Questo è l'argomento della funzione di init.

04:36.660 --> 04:38.180
Quindi capacità.

04:38.180 --> 04:44.960
Quindi, ancora una volta, non essere confuso da sé che la capacità è il nome della variabile che è

04:45.470 --> 04:52.670
collegata all'oggetto e la capacità qui è l'argomento che introdurrà quando creerà un oggetto della classe di memoria di replay.

04:52.810 --> 04:53.620
Tutto ok.

04:53.830 --> 04:55.880
E poi abbiamo un secondo voivode.

04:56.170 --> 04:57.890
Questo è, naturalmente, il ricordo.

04:58.000 --> 05:01.620
Così autodidatta Nemec.

05:01.760 --> 05:02.650
Tutto ok.

05:02.800 --> 05:05.730
E quindi a cosa servirà questo Voivode della memoria.

05:05.990 --> 05:13.950
Bene, questa memoria dovrebbe contenere gli ultimi 100 eventi e quindi questo dovrebbe essere un semplice test.

05:14.100 --> 05:20.300
Conoscete una lista che conterrà gli ultimi 100 eventi delle ultime 100 transizioni e per inizializzare la

05:20.300 --> 05:20.850
lista.

05:20.870 --> 05:24.620
Non c'è niente di più semplice, aggiungiamo solo alcune parentesi come quella.

05:24.740 --> 05:26.040
E qui andiamo.

05:26.060 --> 05:31.490
La nostra memoria è inizializzata così ovviamente all'inizio dell'esperimento o più precisamente all'inizio

05:31.490 --> 05:36.430
dell'esplorazione la memoria sarà una lista vuota e quindi metteremo le transizioni.

05:36.500 --> 05:38.350
Ogni volta che raggiungiamo uno stato futuro.

05:38.600 --> 05:43.370
E parlando di questo è esattamente ciò che faremo con la funzione successiva che

05:43.520 --> 05:44.720
chiameremo la funzione push.

05:44.790 --> 05:51.380
Faremo questa funzione push per mettere in fila gli eventi in questa lista di memoria e poi useremo

05:51.620 --> 05:57.170
la capacità per assicurarci che questa lista di memoria contenga sempre 100 eventi e mai più.

05:57.500 --> 05:59.660
Va bene, facciamolo anche nel prossimo.

05:59.690 --> 06:01.250
E fino ad allora I.