WEBVTT

00:00.300 --> 00:06.120
Ciao e benvenuto nella parte super eccitante della nostra creazione, la parte in cui la rendiamo intelligente.

00:06.270 --> 00:08.540
Quindi questo è esattamente quello che succede quando si allena l'aria.

00:08.590 --> 00:13.200
Formerò la sua intelligenza per raggiungere l'obiettivo che volevamo raggiungere.

00:13.350 --> 00:18.870
E per fare questo, addestreremo fondamentalmente la rete neurale per produrre le previsioni giuste.

00:19.110 --> 00:24.360
E poi tutto è già pronto perché questi segnali in uscita dal cervello hanno già la giusta

00:24.360 --> 00:27.300
trasmissione al corpo per svolgere le azioni finali.

00:27.660 --> 00:32.130
Quindi in pratica ora quello che stiamo per fare è qualcosa che abbiamo già fatto prima.

00:32.280 --> 00:37.680
Prenderemo solo alcuni batch casuali dalla memoria, riceveremo il nostro input da questi campioni, ottenere

00:37.680 --> 00:42.930
l'output, ottenere l'obiettivo, ottenere le previsioni, calcolare l'ultimo errore tra le previsioni e l'obiettivo,

00:42.930 --> 00:48.360
quindi eseguire la propagazione all'indietro era per ottenere la discesa del gradiente aggiornare i pesi in

00:48.360 --> 00:51.430
base a quanto hanno contribuito a quest'ultimo errore.

00:51.900 --> 00:53.040
Quindi facciamo tutto questo.

00:53.040 --> 00:58.020
Vedrai come sarà così facile perché abbiamo già tutti gli strumenti per implementarlo.

00:58.200 --> 01:04.230
Non solo abbiamo il percorso verso strumenti come l'ottimizzatore e le funzioni di perdita, ma abbiamo anche tutte

01:04.440 --> 01:09.600
le classi che abbiamo creato prima, come il nostro cervello, ovviamente, che useremo per ottenere

01:09.600 --> 01:10.290
le previsioni.

01:10.620 --> 01:17.970
Quindi la nostra esperienza, la traccia di idoneità dell'implementazione del replay e tutti questi strumenti combinati al pilota,

01:17.970 --> 01:23.790
quali strumenti renderanno la formazione super performante e quindi alla fine otterremo un super potente

01:23.790 --> 01:26.250
A. IO. Quindi facciamo in modo che questa formazione avvenga.

01:26.400 --> 01:28.110
Rendiamo i nostri occhi intelligenti.

01:28.290 --> 01:33.380
E la prima cosa che faremo ora è ottenere l'ultima funzione che useremo

01:33.390 --> 01:36.200
durante l'addestramento per calcolare l'errore e ottimizzarlo.

01:36.540 --> 01:37.680
Questa è la prima cosa che faremo.

01:37.980 --> 01:40.590
Quindi creiamo una variabile per l'ultima funzione.

01:40.590 --> 01:42.150
La chiameremo perdita.

01:42.810 --> 01:50.340
E questo sarà uguale alla funzione di perdita MSE dal modulo finale.

01:50.850 --> 01:52.470
E poi quel Mercilus.

01:52.740 --> 01:56.940
Questa è l'ultima funzione che useremo perché fondamentalmente le nostre previsioni sono valori.

01:56.940 --> 01:59.940
Sai, stiamo prevedendo i valori fondamentali delle diverse azioni.

01:59.940 --> 02:05.970
E quindi, poiché questi sono numeri reali, beh, stiamo facendo una sorta di rete neurale per la regressione e quindi

02:05.970 --> 02:08.910
la funzione di perdita è il mezzo per l'errore.

02:09.120 --> 02:11.880
Questa è la funzione di perdita che usiamo in generale per la regressione.

02:12.450 --> 02:12.960
Tutto ok.

02:13.080 --> 02:18.180
Quindi ora che abbiamo la nostra ultima funzione, ottimizziamo il nostro ottimizzatore qui.

02:18.180 --> 02:21.240
Questa è la variabile che creiamo per l'ottimizzatore.

02:21.270 --> 02:23.940
E prenderemo come al solito.

02:23.940 --> 02:30.750
Per quanto riguarda l'auto a guida autonoma, l'ottimizzatore atomico, è un ottimizzatore molto potente che farà miracoli per

02:30.930 --> 02:31.710
l'allenamento.

02:32.130 --> 02:35.820
Quindi portiamo questo fino a quell'atomo.

02:36.810 --> 02:42.720
E ricorda, questo è esattamente ciò che l'auto a guida autonoma abbiamo per inserire due argomenti essenziali.

02:43.080 --> 02:49.200
Il primo è quello che farà il collegamento tra l'ottimizzatore ed i parametri della nostra rete

02:49.200 --> 02:52.650
neurale, cioè i pesi dei neuroni del nostro cervello.

02:53.040 --> 02:56.640
E per fare questo, prendiamo il nostro cervello, che abbiamo chiamato CNN.

02:57.030 --> 02:59.040
Questo è l'oggetto che abbiamo creato per il nostro cervello.

02:59.280 --> 03:05.860
E così la CNN che ricorda i parametri che andiamo e qualche parentesi.

03:06.270 --> 03:11.970
In questo modo la connessione tra l'ottimizzatore e i pesi dei neuroni nel cervello

03:11.970 --> 03:18.630
del nostro A. IO. E poi il secondo argomento è un tasso di apprendimento, ed è dato da l. R.

03:18.990 --> 03:24.510
E quindi qui dobbiamo prendere un tasso di apprendimento inferiore perché non vogliamo convergere troppo velocemente e vogliamo avere un po 'di

03:24.510 --> 03:29.370
esplorazione e quindi un buon modo di apprendimento che possiamo dire qui è un piccolo che è di

03:29.370 --> 03:33.150
quattro punti o uno che è 0. 01 percento.

03:33.390 --> 03:36.270
Penso che sia lo stesso che abbiamo usato per l'auto a guida autonoma.

03:37.320 --> 03:43.410
Va bene, quindi ora abbiamo un ottimizzatore di funzioni perse, quindi siamo quasi pronti per iniziare il ciclo completo.

03:43.470 --> 03:45.890
Bene, in realtà, inizieremo il ciclo completo proprio ora.

03:46.140 --> 03:52.100
Ma appena prima di farlo, decideremo la dimensione del numero di epoche in cui

03:52.100 --> 03:58.170
ci trasformeremo e quindi creeremo una nuova variabile qui che risponderà a questo numero di epoche.

03:59.320 --> 04:02.140
E impostiamolo uguale a cento.

04:02.530 --> 04:08.350
Questo andrà bene per addestrare l'aria e scommetto anche che l'aria riuscirà a raggiungere la via migliore

04:08.500 --> 04:11.140
prima di cento come venti o trenta.

04:11.500 --> 04:12.000
Vediamo.

04:12.010 --> 04:13.750
Ma per ora, prendiamone cento.

04:13.990 --> 04:15.940
E se ne avremo bisogno, lo aumenteremo.

04:16.090 --> 04:17.710
Ma non credo che sarà necessario.

04:18.370 --> 04:22.660
OK, quindi ora che abbiamo il nostro numero di aeroporti, possiamo iniziare a fare il

04:22.840 --> 04:26.680
giro completo, sai, questo ciclo completo principale dell'addestramento quando ci alleniamo sugli aeroporti.

04:27.010 --> 04:31.530
Quindi per allora tutta la pallavolo sarà al lavoro.

04:31.540 --> 04:34.240
È per questo che scegliamo di nuovo.

04:34.990 --> 04:42.310
Ora, ovviamente, useremo la funzione intervallo per dire che vogliamo passare dal primo a un

04:42.670 --> 04:44.500
numero di ca.

04:47.120 --> 04:52.730
Più uno, perché, ricorda, il limite superiore di un intervallo non è incluso, e quindi,

04:52.730 --> 04:58.730
se vuoi salire a 100, beh, dobbiamo specificare ed essere uno più per andare fino a 100.

04:59.390 --> 04:59.840
Tutto ok.

04:59.840 --> 05:00.800
Allora, Colin.

05:00.980 --> 05:02.800
E ora entriamo nel circuito.

05:03.620 --> 05:03.980
Tutto ok.

05:03.980 --> 05:08.300
Quindi la prima cosa che faremo è fare 200 corse di dieci passaggi.

05:08.660 --> 05:13.630
Quindi ogni epoca sarà di 200 corse, una dopo l'altra di 10 passaggi.

05:13.940 --> 05:19.550
E per fare questo, abbiamo questa funzione di un passaggio dalla nostra classe di esperienza e quindi di

05:19.550 --> 05:24.770
usare questa funzione, che in realtà è un metodo perché lo otterremo dal nostro oggetto

05:24.770 --> 05:30.080
di memoria, che è un oggetto della classe sostitutiva per generare queste due corse di dieci passaggi.

05:30.320 --> 05:36.020
Bene, dobbiamo prendere il nostro oggetto di memoria che ti ricordo che abbiamo creato proprio qui.

05:36.170 --> 05:40.400
La memoria è un obiettivo per riprodurre la lezione di memoria con Insteps.

05:40.400 --> 05:43.300
Ovvero 10 passi e una capacità di diecimila.

05:43.910 --> 05:52.370
Abbiamo creato questo oggetto e da questo oggetto prendiamo bene, questa funzione di Rundstedt esegue i passaggi

05:52.370 --> 06:00.430
e specifichiamo duecento cicli successivi di dieci passaggi in modo che eseguiremo fondamentalmente 200 passaggi ciascuno.

06:00.860 --> 06:08.060
E ora che abbiamo questi 200 passaggi in esecuzione ad ogni apoc, beh, è il momento di campionare alcuni lotti da

06:08.060 --> 06:10.630
queste corse e di campionare questi lotti.

06:10.640 --> 06:16.700
Abbiamo un'altra funzione dalla nostra memoria, che è il batch di esempio, e che genererà esattamente alcuni

06:16.700 --> 06:18.910
batch da queste 200 esecuzioni.

06:19.400 --> 06:26.720
Ma ricorda, questi batch sono questa volta batch di una serie di transizioni che una serie di dieci passaggi rispetto a

06:27.020 --> 06:31.630
prima dove i batch erano solo alcuni batch di singole transizioni qui.

06:31.640 --> 06:37.040
Questa volta saranno batch di dieci passaggi, dieci transizioni, e quindi ora è il

06:37.040 --> 06:41.870
momento di ottenere dalla nostra memoria questi batch casuali e di ottenerli.

06:41.870 --> 06:48.320
Abbiamo utilizzato la funzione batch semplice a cui dobbiamo applicare la dimensione del batch e per la dimensione

06:48.320 --> 06:53.480
del batch in cui possiamo prendere trentadue o anche sessantaquattro o anche centoventotto.

06:54.080 --> 06:57.830
Ricorda, per quella dimensione è pratica comune usarne trentadue.

06:58.070 --> 07:03.470
Questo è ciò che vedrai in generale nelle architetture delle reti neurali quando esegui un apprendimento in batch.

07:03.740 --> 07:05.470
Ma questa volta è abbastanza diverso.

07:05.660 --> 07:11.530
Noi stiamo solo campionando alcuni lotti di 10 passaggi, quindi è meglio prendere lotti di dimensioni maggiori.

07:11.690 --> 07:14.710
Quindi è lì che possiamo prendere sessantaquattro, centoventotto.

07:15.170 --> 07:16.940
Quindi ne prenderemo centoventotto.

07:17.150 --> 07:25.130
E in realtà questo sarà all'interno del ciclo perché vogliamo prendere diversi batch e li stiamo prendendo in ciò

07:25.130 --> 07:28.870
che viene restituito da questa semplice funzione batch.

07:29.420 --> 07:36.020
Quindi questo ciclo completo per lotto in lotto campione di memoria, centoventotto significa che ogni

07:36.020 --> 07:41.720
centoventotto passaggi, beh la nostra memoria ci darà un lotto di dimensioni,

07:41.720 --> 07:47.210
centoventotto, che conterrà effettivamente l'ultimo centoventotto passi che abbiamo appena eseguito.

07:47.960 --> 07:53.060
Stiamo solo ottenendo alcuni lotti di sei, centoventotto e l'apprendimento avverrà su

07:53.210 --> 07:54.080
questi lotti.

07:54.320 --> 07:58.910
E oltre a questi lotti, avremo vassoi di idoneità in esecuzione, sai, per imparare ogni 10

07:58.910 --> 07:59.480
passaggi.

08:00.230 --> 08:00.620
Tutto ok.

08:00.620 --> 08:06.950
Quindi ora all'interno di questo ciclo, che sta ancora accadendo in un'epoca, ma ora questa volta siamo in un lotto

08:06.950 --> 08:07.360
specifico.

08:07.790 --> 08:14.060
E quindi ora la prima cosa che faremo è ottenere i nostri input e il nostro obiettivo separatamente.

08:14.570 --> 08:16.610
E questo, come ti ho detto, è molto facile.

08:16.610 --> 08:21.290
Possiamo farlo con uno degli strumenti che abbiamo implementato, ovvero la traccia di ammissibilità.

08:21.620 --> 08:27.950
Come puoi vedere qui, questa funzione di traccia dell'eleggibilità prende come input e ora abbiamo il batch

08:28.310 --> 08:32.060
e i resi come output, gli input e gli obiettivi.

08:32.420 --> 08:37.490
Quindi in questo momento, quello che possiamo semplicemente fare è creare due nuove variabili, che saranno gli input

08:37.490 --> 08:38.300
e l'obiettivo.

08:38.690 --> 08:48.080
E in questo modo gli input arrivano a obiettivi uguali esattamente a ciò che restituisce questa funzione di traccia di ammissibilità applicare a un

08:48.080 --> 08:48.610
batch.

08:49.010 --> 08:51.950
Quindi applicheremo questa funzione al batch del nostro ciclo.

08:52.280 --> 08:55.160
E quindi quello che faremo è solo l'idoneità.

08:56.460 --> 09:00.110
Traccia applicata al lotto della nostra speranza.

09:00.660 --> 09:07.110
Va bene, questo ci fornisce gli input e gli obiettivi, ma in situazioni difficili, c'è sempre qualcosa in più che

09:07.110 --> 09:07.850
dobbiamo fare.

09:08.100 --> 09:13.530
E, naturalmente, questo serve a convertire l'input della rete neurale e anche l'obiettivo in alcune variabili

09:13.530 --> 09:14.030
tahj.

09:14.340 --> 09:16.170
Ma non c'è niente di nuovo.

09:16.200 --> 09:17.310
Noi sappiamo come farlo.

09:17.490 --> 09:18.450
Possiamo farlo in questo modo.

09:18.460 --> 09:24.930
Prendiamo i nostri input, poi i nostri obiettivi e beh, saranno uguali al verbale.

09:25.820 --> 09:26.510
Input's.

09:27.750 --> 09:30.210
Questo è per l'input e verbale.

09:31.150 --> 09:33.580
Obiettivi, e questo è per gli obiettivi.

09:34.090 --> 09:42.250
Va bene, quindi gli input del cervello vengono convertiti in alcune variabili tahj e anche gli obiettivi vengono convertiti in

09:42.250 --> 09:43.900
alcune variabili tahj.

09:44.320 --> 09:48.320
Quindi ora possiamo inserire gli input nella rete neurale.

09:48.640 --> 09:50.530
E perché dobbiamo farlo?

09:50.530 --> 09:55.270
Poiché il passo successivo è ottenere le previsioni, abbiamo gli input che dobbiamo indirizzare.

09:55.540 --> 09:59.980
Ora, ovviamente, abbiamo bisogno delle nostre previsioni perché ciò che accade è che calcoleremo la perdita

10:00.190 --> 10:02.120
tra le previsioni e gli obiettivi.

10:02.890 --> 10:06.350
Quindi otteniamo queste previsioni per ottenerle.

10:06.640 --> 10:07.930
Bene, ancora una volta, questo è così semplice.

10:07.930 --> 10:14.650
Ora dobbiamo solo prendere il nostro cervello, che è la CNN, la nostra rete neurale convoluzionale, e

10:14.830 --> 10:16.730
applicarlo ai nostri input.

10:17.320 --> 10:17.950
Ci siamo.

10:18.320 --> 10:23.320
Gli input vanno nella rete neurale e la rete neurale produrrà le previsioni.

10:24.170 --> 10:29.270
Perfetto, quindi ora abbiamo le previsioni, abbiamo gli obiettivi in modo da poter ottenere le leggi

10:29.270 --> 10:34.640
e questo è il passo successivo, introdurremo un altro nuovo perché in questo momento otterremo l'ultimo errore,

10:34.790 --> 10:39.660
che è diverso rispetto all'ultima funzione, perché la usiamo come funzione per ottenere l'ultimo errore.

10:40.100 --> 10:50.570
Quindi meno errori qui e che lo otterremo con la funzione meno applicata alle nostre previsioni e agli obiettivi che

10:50.570 --> 10:54.860
andiamo a vedere come tutto è liscio ora.

10:55.070 --> 10:56.170
Tutto è logico.

10:56.180 --> 11:00.590
Otteniamo prima l'input, gli obiettivi, quindi grazie all'input, otteniamo le previsioni.

11:00.590 --> 11:03.800
E poi grazie alle previsioni e agli obiettivi che otteniamo, meno errori.

11:05.070 --> 11:08.850
Quindi molto logico e fluido, e ora qual è il passo successivo?

11:09.150 --> 11:14.940
Bene, lo stesso percorso logico ora che abbiamo l'ultimo, possiamo propagare questo errore minore nella nuova

11:14.940 --> 11:16.890
rete per aggiornare i pesi.

11:17.190 --> 11:21.540
E lo facciamo con la discesa del gradiente stocastico e per eseguire la discesa del gradiente stocastico.

11:21.540 --> 11:24.010
Abbiamo bisogno del nostro ottimizzatore, ma lo abbiamo già.

11:24.030 --> 11:26.040
Ecco Adam Optimizer.

11:26.430 --> 11:29.010
Ma ora, a questo punto, ricorda cosa dobbiamo fare.

11:29.370 --> 11:32.380
Dobbiamo inizializzarlo e inizializzarlo.

11:32.400 --> 11:40.620
Ricorda, prendiamo il nostro oggetto ottimizzatore e quindi applichiamo il metodo zero grad.

11:41.440 --> 11:48.220
Ecco fatto, non dimentichiamo le parentesi che lo inizializzano, e ora il prossimo passo è propagare

11:48.220 --> 11:55.630
indietro l'ultimo errore nella nuova rete e per fare questo dove prendiamo il nostro ultimo errore e

11:55.630 --> 11:58.950
applichiamo su di esso il metodo all'indietro.

11:58.960 --> 12:01.800
Quindi questo è esattamente per applicare la propagazione all'indietro.

12:02.110 --> 12:06.380
E poi finalmente, ora che l'ultimo errore è tornato, propagalo nella nuova rete.

12:06.610 --> 12:09.610
Bene, possiamo aggiornare i pesi con la discesa in pendenza Cassi.

12:10.300 --> 12:16.950
E per fare questo, ricorda, prendiamo il nostro ottimizzatore e quindi applichiamo il metodo dei passaggi.

12:17.500 --> 12:18.210
Ci siamo.

12:18.400 --> 12:19.900
I pesi sono ora aggiornati.

12:20.200 --> 12:25.500
Come ti ho detto, non solo lo abbiamo già fatto, ma ora sembra così semplice e così naturale.

12:26.200 --> 12:28.440
Quindi ora faremo qualcosa di divertente.

12:28.600 --> 12:31.650
Stamperemo la ricompensa media ogni apoc.

12:31.840 --> 12:35.830
Quindi, sai, possiamo tenere traccia di come l'A. IO. come sta andando la formazione.

12:36.190 --> 12:40.420
Vogliamo vedere la ricompensa media aumentare durante i passaggi, oltre la scatola.

12:40.630 --> 12:44.070
E all'inizio, ovviamente, c'è questa fase di esplorazione.

12:44.080 --> 12:49.690
Quindi la ricompensa media potrebbe non aumentare all'inizio, ma poi una volta raggiunta la fase di

12:49.690 --> 12:56.050
sfruttamento, allora vedremo la ricompensa media aumentare decisamente e aumenterà fino a un certo livello, che è quando

12:56.290 --> 12:58.740
raggiungerà l'ovest alla velocità di possibile.

12:59.380 --> 13:01.210
Quindi iniziamo con la stampa.

13:02.200 --> 13:07.660
Sai, lo stiamo facendo in uno, quindi dobbiamo tornare alla stampa più loop

13:07.660 --> 13:12.610
e poi stamperemo bene, prima circa una colonna, poi la percentuale.

13:12.610 --> 13:18.850
S, perché convertiremo tutto in una stringa migliore e poi aggiungeremo

13:18.850 --> 13:21.100
la ricompensa media.

13:22.490 --> 13:27.620
E poi aggiungiamo anche la percentuale, quindi chiuderemo la citazione.

13:28.890 --> 13:35.220
E poi aggiungiamo una percentuale e dall'altra parte, sai, inseriamo le variabili che saranno la prima persona

13:35.220 --> 13:41.430
poiché questa è l'epica qui e la seconda variabile corrispondente alla ricompensa media, che verrà calcolata

13:41.610 --> 13:42.840
proprio ora.

13:43.020 --> 13:45.560
Quindi la variabile della ricompensa media non esiste ancora.

13:45.780 --> 13:47.600
Lo creeremo adesso.

13:48.120 --> 13:51.930
Quindi useremo ETR al lavoro.

13:52.470 --> 13:55.440
Anche se Époque è il numero, lo convertiremo in una stringa.

13:55.440 --> 13:57.090
Così va meglio e.

13:58.110 --> 14:03.150
Aggiungeremo, Estie, quella sarà la ricompensa media e quindi creeremo una

14:03.150 --> 14:09.810
variabile che chiameremo una grande ricompensa e ora creeremo questa variabile e la calcoleremo ?

14:10.560 --> 14:12.430
OK, quindi facciamolo.

14:12.450 --> 14:13.980
È l'unica cosa che ci resta da fare.

14:13.980 --> 14:15.900
Quindi Époque, l'abbiamo già fatto.

14:16.170 --> 14:20.040
Ora calcoliamo il mondo medio e dobbiamo calcolarlo proprio qui.

14:20.130 --> 14:27.090
Ancora nel ciclo, ma fuori dal ciclo, perché ora abbiamo il nostro batch campionato e abbiamo la nostra formazione in corso

14:27.090 --> 14:28.050
nel batch.

14:28.350 --> 14:31.940
Ma ora la propagazione in avanti più la propagazione all'indietro vengono eseguite nel batch.

14:32.190 --> 14:39.900
Quindi stiamo tornando al ciclo e ora possiamo calcolare i premi cumulativi che possiamo fare con il nostro

14:39.900 --> 14:41.100
oggetto insteps.

14:41.430 --> 14:47.910
Poiché il nostro oggetto insteps contiene questa funzione, avremmo dei passaggi che ci consentono di ottenere i premi cumulativi che si verificano

14:47.910 --> 14:51.250
nei passaggi, sai, durante la corsa del collo del piede.

14:51.660 --> 14:57.330
Quindi lo useremo adesso per aggiornare le nuove ricompense dei passaggi.

14:57.660 --> 15:05.640
Quindi aggiorneremo l'oggetto della media mobile aggiungendo i premi cumulativi all'oggetto quotidiano in movimento e

15:05.640 --> 15:07.770
quindi ricalcoleremo la media.

15:07.780 --> 15:09.910
Ed è così che otterremo la ricompensa media.

15:10.590 --> 15:11.510
Quindi facciamolo.

15:11.520 --> 15:14.640
La prima cosa di cui abbiamo bisogno sono i dati DARABA dei premi.

15:14.970 --> 15:16.950
Quindi chiamiamoli premi.

15:18.100 --> 15:27.700
Passi e poi, come abbiamo detto, prendiamo l'oggetto dei nostri passi finali, che è stato, ricordo, creato qui un oggetto della classe

15:27.700 --> 15:33.310
del progresso istantaneo dalla nostra esperienza che sporchiamo un soggetto così sensibile.

15:34.000 --> 15:39.410
Quindi aggiungiamo ricompense, passaggi e poi alcune parentesi.

15:39.760 --> 15:40.150
Tutto ok.

15:40.180 --> 15:43.690
Questo ci darà le nuove ricompense cumulative dei passaggi.

15:43.990 --> 15:44.500
Tutto ok.

15:45.310 --> 15:50.800
Ma poi dobbiamo aggiungere questi nuovi premi cumulativi nei nostri oggetti a media mobile.

15:50.980 --> 15:57.760
E per fare ciò, questa volta abbiamo un metodo nella classe della media mobile, che è questo metodo dell'annuncio molto

15:57.760 --> 15:58.210
semplice.

15:58.220 --> 16:03.190
Prendiamo il nostro oggetto medio mobile, che abbiamo creato qui con cento passaggi.

16:03.790 --> 16:11.710
Quindi useremo il nostro metodo ADD e quindi nell'atmosfera inseriremo i nostri passaggi di ricompensa e questo aggiungerà

16:11.710 --> 16:15.130
i premi dei passaggi nella media mobile.

16:15.970 --> 16:16.360
Tutto ok.

16:16.360 --> 16:21.960
E infine, possiamo calcolare la ricompensa media e questo è bene, sai, questa è la stessa variabile qui.

16:22.690 --> 16:26.440
Quindi questo è ciò che sarà uguale alla ricompensa media.

16:26.860 --> 16:33.250
E per ottenerlo, dobbiamo solo usare il metodo della media questa volta dal nostro oggetto a media mobile.

16:33.700 --> 16:41.470
E questo è quello che facciamo e una media di punti proprio così, perché la nostra media mobile era già stata aggiornata con i

16:41.710 --> 16:45.520
nuovi passaggi di ricompensa che abbiamo appena aggiunto al metodo ADD.

16:46.430 --> 16:46.890
Grande.

16:46.960 --> 16:52.990
Quindi ora abbiamo il nostro premio medio, quindi è molto popolare qui e verrà stampato ogni anno.

16:53.420 --> 16:54.990
Va bene, quindi abbiamo finito.

16:55.030 --> 16:57.170
Quindi sono così entusiasta di vedere i risultati.

16:57.170 --> 17:01.670
E in realtà, avrò una sorpresa per te nel prossimo tutorial mentre guardo i risultati.

17:01.700 --> 17:03.380
Quindi sarà piuttosto eccitante.

17:03.650 --> 17:06.740
E quindi ora credo che sia ora di giocare con l'aria e divertirsi.

17:07.610 --> 17:08.060
Tutto ok.

17:08.060 --> 17:11.240
Quindi preparatevi un buon caffè o un buon tè.

17:11.480 --> 17:17.410
Ora è il momento di sedersi comodamente sulla nostra sedia e guardare alcuni video molto interessanti del nostro aereo per vedere, che

17:17.430 --> 17:18.760
è nel prossimo tutorial.

17:18.770 --> 17:20.160
E fino ad allora, divertiti.