WEBVTT

00:00.480 --> 00:03.160
Ciao e benvenuto in questo tutorial Python.

00:03.180 --> 00:03.520
Tutto ok.

00:03.520 --> 00:08.810
In questo olio creeremo la funzione che selezionerà l'azione giusta e ogni volta.

00:08.810 --> 00:13.650
Quindi fondamentalmente implementeremo la parte che renderà la macchina la mossa giusta.

00:13.740 --> 00:18.780
E ogni volta che sta andando a sinistra andando dritto o andando a destra per raggiungere l'obiettivo e

00:18.780 --> 00:20.640
per evitare gli ostacoli che è discesa.

00:21.000 --> 00:22.350
Quindi facciamolo adesso.

00:22.370 --> 00:28.320
azione select piuttosto che alcune parentesi e questa funzione di selezione select prenderà due argomenti.

00:28.320 --> 00:36.370
Cominceremo come al solito con i non udenti per definire una funzione e quindi daremo un nome alla nostra funzione

00:36.550 --> 00:37.410
che chiameremo

00:37.450 --> 00:43.960
Il primo è sé come si cresce per riferirsi all'oggetto e il secondo argomento

00:43.960 --> 00:46.150
che secondo te sarà quale.

00:46.390 --> 00:47.860
Bene, cosa potrebbe essere.

00:47.860 --> 00:54.220
neurale oi valori q per ciascuna delle tre azioni possibili e quindi l'azione che svolgiamo l'azione che

00:54.220 --> 00:59.890
sarà l'output di la rete neurale dipende dallo stato di input e gli stati di

00:59.890 --> 01:05.980
input è esattamente il secondo argomento di cui abbiamo bisogno con la funzione action selezionata.

01:05.980 --> 01:11.610
Se ci pensi, l'azione che selezioniamo viene dall'output della rete neurale perché l'output della rete

01:11.680 --> 01:16.310
È perché stiamo letteralmente prendendo l'output della rete neurale.

01:16.510 --> 01:22.180
E naturalmente l'uscita della rete neurale dipende direttamente dall'ingresso della rete neurale.

01:22.360 --> 01:24.010
Quindi questa sarà la nostra argomentazione.

01:24.280 --> 01:31.720
E ora possiamo dargli un nome qualsiasi, in realtà lo chiameremo stato perché l'input delle reti neurali sono gli stati

01:31.960 --> 01:38.280
di input che sono e codificati da un vettore di cinque dimensioni a tre segnali di orientamento

01:38.480 --> 01:39.920
e meno orientamento.

01:40.120 --> 01:42.120
E così ora le cose saranno facili.

01:42.160 --> 01:47.860
Inseriremo lo stato di input nella rete neurale che costruiamo qui sopra proprio qui con

01:47.860 --> 01:54.520
la classe successiva e quindi otterremo gli output che sono i valori chiave per ciascuna delle tre azioni

01:54.520 --> 01:59.530
possibili e quindi usando il metodo Max morbido che ho intenzione di spiegare

01:59.530 --> 02:00.360
in questo tutorial.

02:00.400 --> 02:03.140
Avremo l'azione finale da giocare.

02:03.280 --> 02:08.460
Quindi, facciamolo entrare nella funzione e implementiamo tutto questo.

02:08.470 --> 02:14.980
Quindi la prima cosa di cui abbiamo bisogno è iniziare da quello che ho appena menzionato. Max

02:14.980 --> 02:20.590
l'idea del morbido Max è che cercheremo di ottenere l'azione migliore da giocare ogni volta.

02:20.740 --> 02:25.000
Ma allo stesso tempo esploreremo le diverse azioni.

02:25.000 --> 02:25.950
E come lo facciamo.

02:25.960 --> 02:31.080
Come possiamo ottenere l'azione migliore da giocare mentre esploriamo ancora le altre azioni.

02:31.270 --> 02:39.250
Bene, abbiamo usato questa idea di cose che consiste nel generare una distribuzione di probabilità per ciascuno dei

02:39.250 --> 02:40.370
valori q.

02:40.420 --> 02:42.100
Q dichiara l'azione.

02:42.160 --> 02:46.600
Ora abbiamo un valore di Q per ogni azione andare a sinistra, andare dritto o andare a destra.

02:46.850 --> 02:49.680
Ma questo valore q dipende anche dallo stato di input.

02:49.690 --> 02:52.720
Questo è esattamente l'uso della funzione Q sulle lezioni di intuizione.

02:52.870 --> 02:56.280
Questa funzione Q è una funzione dello stato e dell'azione.

02:56.320 --> 03:02.540
Quindi, dato che qui abbiamo uno stato di input che è lo stato qui e

03:02.540 --> 03:09.070
tre azioni possibili abbiamo tre nuovi valori Q. Azione statale 1 Azione stato Q 2 e azione 2

03:09.070 --> 03:13.760
stati 3 e genereremo una distribuzione di probabilità rispetto a questi tre valori chiave.

03:13.930 --> 03:19.420
Cioè avremo una probabilità per il primo valore Q una delle probabilità per il secondo valore Q

03:19.420 --> 03:25.490
e una terza probabilità per il terzo Q E tutte e tre le probabilità saranno pari a 1.

03:25.670 --> 03:31.840
tutto questo con Massimi sgraziati e Massimi sgraziati attribuiremo una grande probabilità al massimo Q intorno.

03:32.170 --> 03:33.530
E così faremo

03:33.820 --> 03:41.050
Ecco perché un'alternativa al soft Max è un semplice RMX che non prende direttamente il massimo dei valori q, ma

03:41.530 --> 03:44.860
in questo caso non stiamo esplorando le altre azioni.

03:44.920 --> 03:50.500
Grazie a queste probabilità possiamo esplorare da qualche altra parte utilizzando un parametro di temperatura

03:50.500 --> 03:51.900
che vedremo molto rapidamente.

03:52.210 --> 03:55.990
Possiamo ancora esplorarli configurando questo parametro di temperatura.

03:56.020 --> 04:03.380
Ecco perché, in generale, per la sicurezza consiglio vivamente di utilizzare una x soft anziché una semplice RMX.

04:03.460 --> 04:06.990
Va bene quindi facciamo gli strumenti di X e quindi come hai capito.

04:07.060 --> 04:12.990
Dal momento che Soughed Max restituisce le probabilità di ciascuno dei tre valori Q per le tre azioni possibili.

04:13.180 --> 04:20.120
Bene, la prima variabile che stiamo per creare probabilmente si riferirà naturalmente a queste probabilità.

04:20.450 --> 04:26.680
Quindi gli oggetti di scena sono uguali e ora prenderemo la nostra prossima funzione a lungo e in base

04:26.680 --> 04:28.070
a dove la prenderemo.

04:28.330 --> 04:31.600
Beh, certo, ricorda che abbiamo importato il.

04:31.700 --> 04:38.130
E poi il sottomodulo funzionale che ricordo è il modulo che contiene la maggior parte delle azioni per

04:38.140 --> 04:39.790
implementare una rete neurale.

04:39.820 --> 04:44.980
e quindi è proprio da questo sottomodulo funzionale che ci occuperemo della prossima funzione.

04:44.980 --> 04:46.990
Gli abbiamo dato la scorciatoia F

04:47.290 --> 04:53.830
Ma dal momento che gli abbiamo dato una scorciatoia, iniziamo qui con un Neph che rappresenta il funzionale dal quale

04:54.040 --> 04:56.080
prendiamo la nostra prossima funzione soughed.

04:56.080 --> 04:56.920
Ecco qui.

04:56.980 --> 04:59.540
Questo è il primo e una parentesi.

04:59.770 --> 05:00.160
Tutto ok.

05:00.200 --> 05:03.920
Ora cosa dobbiamo inserire nella prossima funzione.

05:04.150 --> 05:10.020
Beh, questo è ovviamente le entità per le quali vogliamo generare una distribuzione di probabilità.

05:10.190 --> 05:11.430
E quali sono queste entità.

05:11.550 --> 05:13.870
Bene, questi sono ovviamente i valori chiave.

05:13.870 --> 05:16.790
Quindi ora la domanda è come possiamo ottenere i valori di q.

05:16.960 --> 05:22.720
Bene, ovviamente i valori q sono l'output della rete neurale e ottengono questi output della

05:22.720 --> 05:23.410
rete neurale.

05:23.590 --> 05:24.560
Bene, qui andiamo

05:24.610 --> 05:26.830
Dobbiamo prendere la nostra nuova rete.

05:27.100 --> 05:33.520
Ma in realtà lo abbiamo già perché è quello che inizializzato alla fine è la sua funzione.

05:33.530 --> 05:39.980
Sappiamo di aver creato un modello autodidatta che non è altro che non funzionerà perché è un nuovo oggetto

05:40.290 --> 05:41.540
della classe di rete.

05:41.600 --> 05:42.820
E così è perfetto.

05:42.830 --> 05:49.040
Possiamo semplicemente prendere il nostro modello qui e roba successiva applicare questo modello allo stato di input che

05:49.040 --> 05:52.950
è l'argomento qui e che restituirà le uscite che stiamo cercando.

05:53.090 --> 05:54.440
Questo è i valori chiave.

05:54.560 --> 06:00.260
E così ora il tuo intuito per cui abbiamo dovuto prendere il modello qui per introdurlo nella funzione

06:00.260 --> 06:00.840
potrebbe migliorare.

06:00.920 --> 06:06.410
Quelli di voi che iniziano con la programmazione orientata agli oggetti vedrete che tutto questo diventerà

06:07.100 --> 06:08.780
naturale così morbido in seguito.

06:08.870 --> 06:16.840
Quindi prendiamo i nostri modelli di auto-modello perché questo deve essere il modello dell'oggetto che abbiamo creato qui.

06:17.180 --> 06:24.350
Ma poi abbiamo bisogno di ottenere l'output del nostro modello di rete neurale e quindi

06:24.350 --> 06:30.400
sentiremo una parentesi in cui introdurremo lo stato di input denominato stato qui.

06:30.620 --> 06:39.350
Quindi quello che vogliamo fare all'inizio è entrare nello stato, ma ora dobbiamo stare attenti a qualcosa di stato che assomiglia ad un semplice

06:39.350 --> 06:40.560
set al momento.

06:40.790 --> 06:46.850
seguito useremo questa cella a un livello inferiore per metterla come argomento della funzione di azione Seleziona.

06:46.920 --> 06:52.190
Ma ricorda che lo stato sarà in realtà un sensore di torcia perché in

06:52.190 --> 06:57.430
L'argomento dello stato che è qui sta per diventare in seguito questo stato meno autodidatta.

06:57.680 --> 07:01.680
E poiché questo è un mondo di risposte torturato, il modello lo accetterà.

07:01.760 --> 07:02.690
Quindi va bene.

07:02.810 --> 07:05.000
Ma ora possiamo migliorare l'algoritmo.

07:05.180 --> 07:12.490
Quindi, non appena lo stato è un sensore di torcia e come abbiamo detto prima, la maggior parte dei sensori sono avvolti

07:12.500 --> 07:13.260
nel voivode.

07:13.320 --> 07:15.640
Questo conterrà anche un gradiente.

07:15.650 --> 07:22.110
Quindi adesso quello che faremo per prima cosa è avvolgere questo stato di input che è un tensore in

07:22.110 --> 07:27.990
una torcia molto bene, ma poiché questo è gli stati di input Beh, non ci sarà alcuna differenziazione.

07:28.160 --> 07:34.700
Non useremo il gradiente di questa torcia di stato Voivode e che possono

07:34.880 --> 07:45.530
essere stazioni e quindi quello che faremo ora è convertire lo stato di questo sensore torcia in una variabile torcia come tale.

07:45.780 --> 07:51.400
Ma poi per specificare che non vogliamo che le sfumature nel grafico siano tutte predatrici alla

07:51.400 --> 07:52.380
fine di Mudgal.

07:52.570 --> 07:57.800
Bene, a questo punto arriveremo volatili uguali veri.

07:58.150 --> 08:06.160
ora abbiamo il nostro stato torched sensore in una torcia molto bene ma grazie a questo Votel equivale a vero barometro.

08:06.160 --> 08:07.200
In modo che

08:07.390 --> 08:14.950
Bene includeremo i gradienti associati a questi stati di input al grafico di tutte le condizioni della fine

08:15.100 --> 08:16.530
in quel modello.

08:16.840 --> 08:18.530
Quindi questo è un altro trucco tecnico.

08:18.550 --> 08:23.130
Questo ci salverà un po 'di memoria e quindi questo migliorerà le prestazioni.

08:23.170 --> 08:27.850
Quindi consiglio vivamente di farlo e ora aggiungeremo qualcosa di più divertente.

08:27.910 --> 08:30.640
Riguarda questo parametro di temperatura che ho appena menzionato.

08:30.850 --> 08:36.190
di modulare come la rete neurale sarà sicura di quale azione dovrebbe decidere di giocare.

08:36.190 --> 08:40.040
Quindi questo parametro di temperatura è il parametro che ci permetterebbe

08:40.210 --> 08:47.290
Quindi questo parametro di temperatura sarà un numero positivo e più vicino è a zero meno la rete neurale sarà sicura

08:47.290 --> 08:53.200
quando si gioca in azione e più alto è il parametro di temperatura, più la rete neuronale

08:53.410 --> 08:56.540
sarà più sicura dell'azione che decide di giocare .

08:56.890 --> 09:04.480
E per aggiungere questo parametro, moltiplicherò le uscite che sono i Kugan usati da questo parametro

09:04.480 --> 09:05.250
di temperatura.

09:05.500 --> 09:13.440
Quindi iniziamo ad esempio con 7 e specificherò qui il piccolo commento T uguale a 7.

09:13.460 --> 09:15.610
Quindi questo è il parametro della temperatura.

09:15.690 --> 09:17.210
Mi dispiace andare a 7.

09:17.260 --> 09:21.010
Ne proveremo altri, ma voglio iniziare con uno piccolo perché lo

09:21.010 --> 09:22.470
vedrai con uno piccolo.

09:22.510 --> 09:28.150
La nostra macchina si comporterà ancora come una specie di insetto, ma aumentando il parametro di temperatura

09:28.510 --> 09:34.340
il nostro codice sembrerà più simile a una macchina e deciderà di vendere la guida sarà molto meglio.

09:34.480 --> 09:40.450
E quindi è logico perché più è alto questo parametro di temperatura, più alta sarà

09:40.450 --> 09:48.010
la probabilità di vincere il Juval me perché, per esempio, se abbiamo il massimo per i valori di q.

09:48.190 --> 09:54.850
Prendiamo alcuni semplici numeri uno due tre se riempiti max da uno a tre uguale.

09:54.850 --> 10:01.150
Ad esempio 0. 04 0. 11 e aperto ottantacinque.

10:01.270 --> 10:05.650
Quindi aumentando la temperatura aumentando la temperatura.

10:05.680 --> 10:13.360
In questo momento la temperatura è uguale a una prendendo una temperatura elevata, ad esempio sottotitoli

10:13.360 --> 10:22.210
di Tussaud, copiamo questo e moltiplicandolo per due o tre, quindi gli stessi valori sono moltiplicati per il parametro

10:22.210 --> 10:24.110
di temperatura di tre.

10:24.370 --> 10:31.390
Bene otterremo qualcosa come zero per il primo valore di Q perché questo ha avuto una probabilità molto bassa

10:31.530 --> 10:38.020
che qualcosa intorno allo zero quindi qualcosa di molto piccolo per la seconda probabilità perché questa era ancora

10:38.020 --> 10:39.260
una bassa probabilità.

10:39.410 --> 10:42.910
Quindi diciamo per esempio o punto 0 2.

10:43.320 --> 10:49.910
Ma poi questa terza probabilità poiché era la più grande e piuttosto alta.

10:50.140 --> 10:55.180
Beh, aumentando la temperatura questa probabilità sarà ancora più grande perché saremo

10:55.180 --> 11:02.230
ancora più sicuri che questo sia il valore Q corretto corrispondente all'azione che dobbiamo giocare e quindi

11:02.230 --> 11:05.630
sarà qualcosa come 0. 2 98.

11:05.980 --> 11:11.800
Ora aumentando il parametro della temperatura Bene, ora siamo ancora più sicuri che la terza azione qui dovrebbe

11:11.800 --> 11:17.530
essere l'azione da giocare perché la probabilità per il valore q di questa azione non è solo la

11:17.530 --> 11:19.590
più grande ma anche molto alta.

11:19.840 --> 11:22.600
Ecco, questo è il parametro di temperatura.

11:22.660 --> 11:27.340
Riguarda la certezza in quale direzione dovremmo decidere di giocare.

11:27.340 --> 11:27.610
Tutto ok.

11:27.610 --> 11:29.450
Quindi ho intenzione di rimuovere questo commento.

11:29.470 --> 11:31.000
Questo era solo per spiegare.

11:31.200 --> 11:33.490
E ora prendiamo la nostra azione.

11:33.490 --> 11:35.370
Quindi, come hai intenzione di farlo.

11:35.560 --> 11:41.440
probabilità per ciascuno dei valori chiave, ma anche e questo è il secondo passo del metodo successivo morbido.

11:41.440 --> 11:46.390
Bene, il principio del prossimo metodo non è solo quello di generare una distribuzione di

11:46.480 --> 11:51.820
Prendiamo un sorteggio casuale da questa distribuzione per ottenere la nostra azione finale.

11:52.010 --> 11:57.310
E naturalmente avremo un'alta probabilità di ottenere l'azione che corrisponde al valore Q che

11:57.310 --> 12:01.660
ha la più alta probabilità perché è esattamente come funziona la distribuzione.

12:01.660 --> 12:02.550
Quindi eccoci.

12:02.560 --> 12:04.040
Prendiamo la nostra azione.

12:04.060 --> 12:11.380
Quindi introdurremo un nuovo Voivode, chiameremo azione e questa azione rappresenterà un assaggio

12:11.380 --> 12:17.460
casuale della distribuzione di probabilità che abbiamo appena creato in precedenza.

12:17.510 --> 12:20.100
E quindi come possiamo ottenere un sorteggio così casuale.

12:20.200 --> 12:26.410
Bene, prenderemo le probabilità del nostro prop di ciascuno dei valori chiave che prendiamo per

12:26.650 --> 12:34.120
puntelli e poi dardeggiamo e poi useremo la funzione multi Gnomeo e questo ci darà un assaggio casuale

12:34.120 --> 12:36.030
da questo processo di distribuzione.

12:36.160 --> 12:38.420
Quindi è tutto ciò che otterrà la sua reazione.

12:38.470 --> 12:39.280
Perfezionare.

12:39.490 --> 12:42.790
E ora, naturalmente, restituiremo l'azione.

12:42.790 --> 12:44.730
C'è un piccolo trucco qui.

12:44.810 --> 12:51.460
Che cosa è il fatto che questo Propst che il multinomiale restituisca il PI verso il vitale con un badge falso.

12:51.490 --> 12:57.210
Conoscete questo falso diamanti e corrispondete al lotto e quindi per ottenere il risultato giusto

12:57.220 --> 13:00.540
che vogliamo sia l'azione in 0 1 o 2.

13:00.820 --> 13:08.200
Abbiamo solo bisogno di aggiungere qui i dati e poi alcune parentesi e le azioni qui sono uno o

13:08.230 --> 13:13.100
due che stiamo cercando è il contenuto e l'indice è 0 e 0.

13:13.570 --> 13:14.000
Tutto ok.

13:14.000 --> 13:14.730
E noi andiamo.

13:14.740 --> 13:21.420
Ora abbiamo la nostra azione grazie a questa funzione di azione selezionata l'IA ora saprà quale azione giocare.

13:21.490 --> 13:22.440
E ogni volta.

13:22.810 --> 13:23.460
Terrific.

13:23.500 --> 13:27.430
Quindi ora possiamo passare alla funzione successiva che sarà la funzione di apprendimento.

13:27.520 --> 13:32.410
Ed è qui che formeremo l'intera rete neurale che conosci con tutta la propagazione diretta

13:32.410 --> 13:35.790
e quindi la propagazione posteriore è quella di categorizzare nel senso.

13:35.950 --> 13:41.500
In pratica, implementeremo l'intera formazione del modello di apprendimento profondo che è il cuore

13:41.560 --> 13:43.340
della nostra intelligenza artificiale.

13:43.480 --> 13:44.680
Quindi non vedo l'ora di farlo.

13:44.680 --> 13:49.290
Questo sarà un tutorial eccitante e quindi ti vedrò nel prossimo Statoil.

13:49.510 --> 13:50.670
Fino ad allora divertiti.

13:50.720 --> 13:51.000
IO.