WEBVTT

00:00.330 --> 00:05.940
Ciao e benvenuto in questo tutorial questo giocattolo speciale sarà super eccitante perché ci stiamo avvicinando

00:05.940 --> 00:08.540
alla A. S. C. algoritmo.

00:08.700 --> 00:14.190
Vedrai ciò che stiamo per implementare e che è chiamato traccia di eleggibilità o Sarsour

00:14.520 --> 00:20.250
è in realtà un algoritmo degli algoritmi degli agenti critici attivi sincroni che non possiamo considerare.

00:20.250 --> 00:20.380
 

00:20.380 --> 00:25.290
ma continuerai a vedere che ciò che stiamo per implementare è in realtà

00:25.290 --> 00:32.010
tratto dal seguente articolo che è questo documento come metodo Synchronoss per l'apprendimento del rinforzo profondo ed

00:32.130 --> 00:38.280
è in questo articolo troverai algoritmi A-3 che implementeremo come bonus finale di questo corso.

00:38.280 --> 00:40.840
E vediamo perché avremo ancora un agente,

00:41.010 --> 00:47.580
Ma come ho detto ci stiamo avvicinando perché il modello che verrà implementato in questo momento è

00:48.420 --> 00:55.620
in realtà questo il sincrono e secolarizzato che è quello che è quasi l'A3 C che sta facendo dopo,

00:55.620 --> 01:03.490
ma con un agente e la cosa più potente di questo è questo e il passo Cunanan impareremo ad accumulare

01:03.490 --> 01:09.520
premi e ad imparare il bersaglio cumulativo sui passi finali invece di un passo come Priestley.

01:09.690 --> 01:15.250
Ed è questo che renderà l'allenamento molto più performante e quindi molto più potente.

01:15.300 --> 01:21.080
Quindi abbiamo effettivamente lo pseudo-codice per questo algoritmo, è questo algoritmo come qui.

01:21.180 --> 01:23.230
Quindi facciamo clic su di esso e ci andiamo.

01:23.250 --> 01:25.740
Questo è l'algoritmo che stiamo per implementare.

01:25.890 --> 01:30.960
Ma ricorda con un solo agente che la differenza è che qui intraprendono un'azione.

01:30.990 --> 01:37.380
80 secondo la politica Greely del presidente basata sui valori q per lo stato attuale e

01:37.380 --> 01:38.020
l'azione giocata.

01:38.190 --> 01:42.050
Ma nel nostro caso non abbiamo implementato una politica ecologica eccellente.

01:42.090 --> 01:43.770
Abbiamo implementato un massimo morbido.

01:43.890 --> 01:46.110
Ma il resto è lo stesso che puoi vedere.

01:46.110 --> 01:50.210
Stiamo andando a calcolare il cumulativo su cui abbiamo lavorato e abbiamo effettivamente 10 passi.

01:50.220 --> 01:52.340
Ricorda che i passaggi sono pari a 10.

01:52.440 --> 01:58.170
Quindi implementeremo questa linea di codice nel nostro algoritmo che stiamo per implementare in questo momento.

01:58.170 --> 01:59.010
Abbiamo intenzione di ottenere questo.

01:59.010 --> 02:02.150
E per lo più implementeremo anche questo.

02:02.160 --> 02:07.590
Vedrai che otterremo il massimo dei valori q per lo stato corrente e l'azione corrente

02:07.590 --> 02:08.820
in questo theta.

02:08.820 --> 02:11.150
Qui c'è solo un parametro target.

02:11.430 --> 02:15.350
Facciamo così, attacciamo questo algoritmo.

02:15.360 --> 02:18.730
Questo è chiamato apprendimento sincrono e continuo.

02:18.900 --> 02:24.490
Ma non abbiamo il diritto di dire sincrono per quanto ci riguarda perché abbiamo un solo motore.

02:24.670 --> 02:29.830
Ma quindi possiamo chiamarlo e imparare la traccia dell'ammissibilità o anche Sarsour.

02:30.270 --> 02:31.780
Va bene, facciamolo

02:31.800 --> 02:33.080
Sarà molto divertente.

02:33.090 --> 02:37.460
Possiamo sostanzialmente seguire il codice qui ed è quello che faremo.

02:37.460 --> 02:43.980
E così come puoi vedere un parametro di cui abbiamo bisogno è di nuovo il parametro che

02:44.280 --> 02:50.820
è il parametro di decadimento e quindi inizieremo introducendo una variabile per questo parametro di Gahanna e selezionandoli.

02:50.820 --> 02:51.840
Quindi facciamolo.

02:51.900 --> 02:57.040
In realtà non abbiamo bisogno di un'aula tremenda Possiamo semplicemente implementarlo con una funzione perché sai che

02:57.040 --> 03:01.830
non abbiamo davvero bisogno di creare oggetti per questo per tracciare il modello, una funzione sarà

03:02.190 --> 03:08.500
sufficiente perché in pratica quello che vogliamo fare è restituire gli input e il target in modo che in seguito,

03:08.500 --> 03:14.460
quando si allena l'IA, siamo pronti a ridurre al minimo la distanza tra le previsioni e l'obiettivo e per

03:14.470 --> 03:19.950
ottenere le previsioni abbiamo bisogno degli input perché applicheremo il nostro cervello sull'input per ottenere l'output segnali che

03:19.950 --> 03:21.300
saranno le nostre previsioni.

03:21.300 --> 03:26.730
pronti ad addestrare l'intelligenza artificiale cercando di ridurre al minimo questa grande distanza tra le previsioni e le toilette.

03:26.730 --> 03:30.680
E poi, una volta che avremo le nostre previsioni e i nostri obiettivi, saremo

03:30.690 --> 03:32.780
Quindi questo è il punto di tutto questo in questo momento.

03:32.880 --> 03:38.130
Stiamo implementando questa funzione per poter restituire questi input nei Soviet in modo da essere pronti per

03:38.130 --> 03:43.010
l'allenamento per ridurre al minimo le previsioni di distanza quadrata per gestire i servizi igienici.

03:43.020 --> 03:46.400
Va bene, facciamolo mentre abbiamo detto che vogliamo implementare le funzioni.

03:46.410 --> 03:47.910
Iniziamo da questo.

03:47.940 --> 03:52.680
Questo lo chiameremo traccia di sottolineatura dell'ammissibilità.

03:52.860 --> 03:54.210
Puoi anche chiamarlo Sarsour.

03:54.240 --> 04:00.660
Puoi anche chiamarlo step per suonare quello che vuoi ma chiamiamolo traccia di

04:00.660 --> 04:07.530
eleggibilità e questa funzione prenderà un argomento che sarà un batch e perché è

04:07.530 --> 04:13.460
perché otterremo input e alcuni target perché addestreremo l'intelligenza artificiale sui lotti.

04:13.530 --> 04:19.170
E così gli input e gli obiettivi andranno all'interno di alcuni batch e quindi l'argomento di

04:19.410 --> 04:25.090
input qui è questo batch che conterrà diversi input e quindi diversi target che verranno calcolati.

04:25.500 --> 04:26.730
Quindi eccoci.

04:26.730 --> 04:28.310
Questa è l'unica argomentazione di cui abbiamo bisogno.

04:28.500 --> 04:32.280
Ora entriamo in una funzione e definiamo ciò che dovevamo fare.

04:32.370 --> 04:40.140
Così come abbiamo visto nella Basilica del foglio abbiamo bisogno di nuovo i parametri, così come abbiamo detto

04:40.440 --> 04:45.390
iniziamo introducendo questo parametro gamma semi-close e possiamo già decifrare il valore.

04:45.450 --> 04:51.780
E sceglieremo quattro punti novantanove che è un classico buon valore per il Ghana e Norreys.

04:51.780 --> 04:55.640
Ho verificato che questo è un buon valore per la nostra IA.

04:55.650 --> 05:04.120
Bene, allora il prossimo passo successivo è preparare il nostro input e i nostri obiettivi perché è esattamente ciò

05:04.120 --> 05:05.260
che vogliamo tornare.

05:05.260 --> 05:08.980
Vogliamo restituire gli input in target per preparare la formazione.

05:08.980 --> 05:15.520
lista e questo è quando inizializzeremo gli input come una lista così come gli obiettivi che andremo.

05:15.790 --> 05:21.130
E così possiamo già inizializzarli con una lista vuota, perché ovviamente questi input

05:21.430 --> 05:25.000
All'interno del meglio avremo diversi input tutti in una

05:25.000 --> 05:31.420
Quindi abbiamo inizializzato il nostro e inserito i nostri obiettivi e alla fine questa funzione di tracciabilità consentirà

05:31.540 --> 05:33.320
di restituire esattamente questi input.

05:33.330 --> 05:36.180
E questi sì erano ovviamente Filton.

05:36.290 --> 05:42.300
Abbiamo diversi input e diversi target associati in quello che verrà restituito dalla funzione.

05:42.300 --> 05:48.820
Tutto il prossimo passo successivo è iniziare un ciclo ed è esattamente perché stiamo seguendo il

05:48.880 --> 05:50.290
codice lento del foglio.

05:50.290 --> 05:51.400
Questo tipo di codice.

05:51.490 --> 05:58.420
E come puoi vedere c'è questa sezione del codice di ripetizione e ripetuta esattamente un ciclo completo nel codice.

05:58.470 --> 06:03.870
Stiamo andando a calcolare la ricompensa cumulativa qui accumulata nei 10 passaggi.

06:03.940 --> 06:05.130
E come è calcolato.

06:05.290 --> 06:10.480
Bene, in ogni passaggio che non è l'ultimo passo, otterremo il massimo dei valori fondamentali della valuta in

06:10.480 --> 06:13.070
cui ci troviamo durante questo ed i passaggi eseguiti.

06:13.240 --> 06:17.790
E se raggiungiamo l'ultimo stato dei 10 passi, questo sarà uguale a zero.

06:17.890 --> 06:19.810
Questo è che non vogliamo più farlo.

06:20.080 --> 06:23.320
E poi abbiamo questo ciclo, che sarà un altro.

06:23.470 --> 06:28.390
Non dicono ripetere qui ma è lo stesso che sarà il secondo ciclo completo nel nostro algoritmo.

06:28.600 --> 06:34.570
Bene, avremo che siamo in questo modo moltiplicando per il parametro di decadimento gamma e aggiungendo

06:34.840 --> 06:35.660
la parola.

06:36.010 --> 06:41.510
Facciamo così, torniamo a Python e iniziamo così.

06:41.980 --> 06:44.920
E quale sarà la variabile iterativa.

06:45.070 --> 06:47.820
Beh, questa sarà la nostra serie di 10 passi.

06:47.890 --> 06:55.510
quindi chiameremo questa serie variabile che rappresenta una serie di 10 transizioni come una sequenza di 10 transizioni.

06:55.600 --> 06:58.820
Conoscete la nostra serie di 10 transizioni

06:58.860 --> 07:00.910
Quindi per le serie in.

07:01.210 --> 07:02.400
E poi cosa ne pensi.

07:02.620 --> 07:05.570
Bene, la nostra serie sarà nel nostro gruppo.

07:05.680 --> 07:12.040
Ci sono i lotti su cui si allenerà l'IA e così via in serie che è per tutte le serie

07:12.040 --> 07:14.540
di 10 transizioni nel nostro lotto di input.

07:14.800 --> 07:20.710
Bene, dove andremo a fare bene per ottenere una ricompensa cumulativa vedrete nella silice che abbiamo

07:20.950 --> 07:26.560
bisogno dello stato della prima transizione della serie e anche dello stato dell'ultima transizione della serie.

07:26.740 --> 07:33.040
Quindi quello che dobbiamo fare adesso è ottenere questi stati di input e quindi metteremo questi

07:33.130 --> 07:39.380
due stati in una soluzione che chiameremo input e otterremo questi due stati di input.

07:39.400 --> 07:46.590
Il primo della serie e l'ultimo che inseriremo in un array non pilota, ma non ci saranno

07:46.800 --> 07:51.880
preoccupazioni, e Ampyra ovviamente lo convertirà in un orribile ma il primo

07:51.880 --> 07:56.930
passo è mettere questi due afferma il primo nell'ultimo in un impero.

07:57.240 --> 08:03.850
transizione della serie e che è Series e quindi per prenderlo per una transizione prendiamo l'indice zero della

08:03.850 --> 08:10.820
serie che è la prima transizione e quindi possiamo accedervi prendendo i suoi attributi che è stato e questo

08:10.820 --> 08:17.780
perché nel nostro file di replay dell'esperienza abbiamo trovato una struttura speciale per ciascuna transizione e conosciamo la struttura.

08:18.290 --> 08:24.200
E così proprio qui in questo array aggiungiamo il primo input che è lo stadio di

08:24.440 --> 08:25.660
input della prima

08:25.730 --> 08:29.380
Ogni transizione è composta da uno stato e una parola di azione.

08:29.570 --> 08:34.970
Ma poi l'ultimo elemento che è stato fatto in modo che questa struttura speciale che possiamo usare adesso

08:35.240 --> 08:39.250
provenga dal modo in cui abbiamo definito la transizione e la ripetizione dell'esperienza.

08:39.290 --> 08:45.380
Va bene così con questo otteniamo lo stato di input della prima transizione e ora otteniamo

08:45.380 --> 08:48.640
anche lo stadio di input dell'ultima transizione della serie.

08:48.800 --> 08:57.200
accedere con questo trucco meno una serie meno uno in cui lo stato otterrà lo stato di input dell'ultimo transizione della serie.

08:57.200 --> 09:04.040
E per fare questo è sufficiente dire che possiamo semplicemente copiare e incollare e sostituire come sei

09:04.100 --> 09:07.420
qui dall'ultimo indice della serie a cui possiamo

09:08.210 --> 09:16.310
Bene, allora abbiamo bisogno di mettere questi due elementi all'interno di alcune parentesi quadre perché questo è ciò che ci

09:16.310 --> 09:23.120
si aspetterebbe dall'arbitro una funzione e quindi una cosa importante da fare poiché convertiremo quella in

09:23.210 --> 09:26.140
una risposta torcia in una variabile torcia.

09:26.330 --> 09:31.810
Ricorda che un tensore della torcia è per definizione uno speciale array contenente un solo tipo.

09:31.940 --> 09:34.640
E quindi abbiamo bisogno di forzare un singolo tipo.

09:34.760 --> 09:42.020
il tipo float e così via aggiungendo questo parametro qui D type equals e P che float.

09:42.750 --> 09:45.030
E come al solito sceglieremo

09:45.320 --> 09:52.380
In modo da poter prendere questo e ora possiamo convertirlo in un tensore torcia in un voivode torcia.

09:52.550 --> 09:54.640
Quindi facciamo questo.

09:54.770 --> 09:57.470
Bene, prima trasformiamolo in un sensore di torcia.

09:57.590 --> 10:06.880
E ricorda che possiamo usare le torche che da non-prime andiamo e mettiamo tutta la matrice dei due stati di input all'interno

10:06.900 --> 10:15.180
di questo torcia ballerino con la torcia da loro per una funzione perfetta che convertirà questi array dei due

10:15.250 --> 10:18.230
stati di ingresso in una torcia sensore.

10:18.420 --> 10:26.560
la risposta in una torcia molto bene usando la classe variabile in modo tale che l'input sia un oggetto della classe preziosa.

10:26.560 --> 10:28.400
E ora mettiamo questa torcia

10:28.480 --> 10:35.380
E infatti come hai capito questa classe variabile prende tutto questo come argomento

10:35.380 --> 10:36.680
e crea l'oggetto.

10:36.680 --> 10:38.420
Va bene, ora dovremmo essere bravi.

10:38.450 --> 10:41.000
Abbiamo i nostri due input di cui abbiamo bisogno.

10:41.000 --> 10:45.440
Questo è lo stato di input della prima transizione e quindi l'input dice che l'ultima transizione.

10:45.770 --> 10:51.890
E ora che abbiamo gli input Bene, cosa possiamo ottenere, possiamo ottenere il segnale di uscita del

10:51.890 --> 10:52.560
cervello dell'IA.

10:52.640 --> 10:56.160
Questa è la previsione che chiameremo output.

10:56.630 --> 10:57.950
Questo è il segnale di uscita.

10:58.130 --> 10:59.280
E per ottenere le uscite.

10:59.330 --> 11:04.670
Bene, ora è molto facile perché abbiamo già creato un cervello che è la nostra rete

11:04.670 --> 11:05.330
neurale convoluzionale.

11:05.570 --> 11:14.120
E così possiamo semplicemente prendere la nostra CNN cerebrale applicata agli input che restituirà la previsione

11:14.120 --> 11:16.650
che è l'output così semplice.

11:16.820 --> 11:19.510
E ora siamo già pronti per passare al prossimo passo.

11:20.730 --> 11:24.890
E il prossimo passo è iniziare a calcolare questa comunità, se vuoi.

11:25.090 --> 11:30.690
Quindi ora faremo esattamente come il nostro per l'algoritmo del Sarsour o dovremmo

11:30.760 --> 11:32.300
chiamarlo e per imparare.

11:32.290 --> 11:39.990
Introdurremo la variabile di ricompensa cumulativa che costituirà la ricompensa cumulativa. Torniamo al documento, come puoi vedere ora che

11:39.990 --> 11:45.120
cosa dobbiamo fare per ottenere questa ricompensa dalla comunità che è la

11:45.210 --> 11:46.000
nostra qui.

11:46.170 --> 11:53.160
aggiungendo uno zero a questa comunità se lo fossimo se avessimo raggiunto l'ultimo stadio della serie o il massimo dei

11:53.160 --> 11:59.910
valori fondamentali se non avessimo raggiunto l'ultimo stadio di la serie che è per tutte le statiche che sono durate.

12:00.000 --> 12:03.410
Bene e ogni fase dei 10 passi eseguiti dobbiamo aggiornarlo

12:03.750 --> 12:05.890
Quindi questo è semplicemente un bonanzas.

12:06.000 --> 12:07.580
Torniamo a Piscean.

12:07.650 --> 12:16.490
Quindi questa ricompensa della comunità, come abbiamo appena visto, sarà pari a zero punto zero se raggiungessimo l'ultimo stato

12:16.490 --> 12:23.070
e possiamo scrivere questa condizione in questo modo se serie di indice meno 1.

12:23.070 --> 12:25.940
Questa è l'ultima transizione della serie.

12:26.250 --> 12:32.280
abbiamo definito nell'esperienza giochiamo con la nostra esperienza replay fallo e questo viene dalle strutture di apertura

12:32.280 --> 12:38.400
in realtà perché se andiamo al sito aperto di Allergan che in realtà è giusto qui l'ho preparato

12:38.400 --> 12:44.550
Poi aggiungiamo che fatto perché fatto in realtà è un attributo di te che conosco questa struttura di

12:44.550 --> 12:45.240
transizione che

12:45.280 --> 12:47.160
Questo è il fare bene o il vizir.

12:47.340 --> 12:52.300
E se andiamo alla documentazione e poi se noi.

12:52.380 --> 12:55.240
Questo è il tutorial che ti incoraggio davvero a dare un'occhiata.

12:55.470 --> 13:01.530
Puoi eseguire un ambiente in cui Knowsley puoi vedere che le nostre osservazioni che

13:01.950 --> 13:04.690
queste sono transizioni sono definite da un'osservazione.

13:04.790 --> 13:12.150
Vogliamo che ciò venga fatto qui e ciò significa esattamente che una transizione o un passaggio è finito.

13:12.150 --> 13:15.440
E quindi useremo questo fatto qui per la nostra condizione di IF.

13:15.610 --> 13:23.460
Quindi follia di iSeries quando ciò è fatto significa che l'ultima transizione della serie è finita.

13:23.730 --> 13:29.290
E quindi questa ricompensa cumulativa sarà pari a zero se viene eseguita l'ultima transizione della serie.

13:29.330 --> 13:37.290
Altrimenti se non abbiamo raggiunto l'ultima transizione, la ricompensa cumulativa verrà aggiornata

13:37.290 --> 13:40.950
con il massimo dei valori chiave.

13:41.220 --> 13:47.460
E poiché questo output qui è l'output del cervello che è le previsioni della rete neurale.

13:47.520 --> 13:53.640
E come sapete le previsioni della rete neurale sono i valori previsti Bene questo output

13:53.920 --> 13:55.040
contiene i valori.

13:55.110 --> 14:01.130
E dato che dobbiamo prendere il massimo dei valori q, dobbiamo prima aggiungere questo indice perché

14:01.130 --> 14:04.620
questa struttura contiene due valori chiave e il successivo.

14:04.620 --> 14:07.830
E poi abbiamo bisogno di aggiungere dati per accedere ai dati.

14:07.830 --> 14:12.150
Questa struttura di output si sa che ha la struttura speciale di un voivode della torcia.

14:12.270 --> 14:17.910
Quindi con questo otteniamo i nostri valori fondamentali e quindi vogliamo prendere il massimo dei nostri valori

14:17.910 --> 14:20.470
di cue e quindi aggiungiamo che Max.

14:20.490 --> 14:27.820
E ora otteniamo esattamente quello che vogliamo come nella carta questo massimo dei valori del cubo per

14:27.820 --> 14:30.240
gli stati non-terminali come perfetto.

14:30.280 --> 14:33.460
E quindi ora quello che faremo sarà la seconda.

14:33.930 --> 14:40.830
Vale a dire per i 10 passi della serie che stiamo per aggiornare il cumulativo andando in questo modo moltiplicando

14:40.830 --> 14:46.170
per primo Gamma il parametro di decadimento che abbiamo già e quindi aggiungendo la parola B.

14:46.410 --> 14:47.540
Quindi facciamolo.

14:47.610 --> 14:52.260
In realtà, faremo esattamente lo stesso dello pseudocodice, poiché è possibile notare che iniziano

14:52.260 --> 14:52.970
da destra.

14:53.040 --> 14:59.010
Quindi non iniziano con il primo passo e passano all'ultimo test che iniziano con l'ultimo passaggio.

14:59.040 --> 15:02.280
T-meno 1 al primo passo per iniziare.

15:02.340 --> 15:06.520
Questo è esattamente ciò che faremo e vogliamo ottenere la

15:06.610 --> 15:15.840
ricompensa cumulativa uguale ai nostri pari o zero più gamma o 1 più gamma al quadrato o due più che aggiunto più gamma

15:15.840 --> 15:24.420
alla potenza di 10 o 10 dove sono 1 o 2 che sono 10 sono le parole ottenute in ciascuna delle

15:24.420 --> 15:25.580
fasi della serie.

15:25.590 --> 15:29.870
Quindi facciamo una breve pausa prima di prendere il secondo ciclo completo e ci vediamo nel prossimo tutorial.

15:30.030 --> 15:31.530
Fino ad allora goditi l'intelligenza artificiale.