WEBVTT

00:00.270 --> 00:02.590
Ciao e benvenuto in questo tutorial Python.

00:02.820 --> 00:08.730
Va bene così oggi faremo la funzione di aggiornamento che aggiornerà tutto ciò che c'è fino

00:08.850 --> 00:12.240
ad oggi non appena l'occhio raggiunge un nuovo stato.

00:12.510 --> 00:16.140
Quindi, quando raggiunge la nuova fase, sai che dobbiamo aggiornare l'azione.

00:16.200 --> 00:19.320
L'ultimo in realtà arriva alla nuova azione appena giocata.

00:19.530 --> 00:22.630
Ma anche l'ultima data che diventa il nuovo stato.

00:22.680 --> 00:27.450
E infine l'ultima parola che diventa la nuova parola che otteniamo quando recitiamo l'azione.

00:27.480 --> 00:31.480
Quindi questo è il percorso logico che accade subito dopo aver selezionato un'azione.

00:31.530 --> 00:35.100
Abbiamo bisogno di aggiornare tutti gli elementi delle transizioni.

00:35.310 --> 00:37.370
E ovviamente avrai una nuova transizione.

00:37.420 --> 00:40.300
Quindi dovremo aggiungere questa nuova transizione alla memoria.

00:40.350 --> 00:46.200
E infine aggiorneremo o premierà la finestra che conosci per tenere d'occhio l'evoluzione di

00:46.200 --> 00:49.460
come sta andando l'allenamento e come procede l'esplorazione.

00:49.680 --> 00:55.380
finalmente stabilire una connessione tra l'intelligenza artificiale che stiamo implementando in questo momento sulla nostra mappa, perché

00:55.530 --> 01:01.650
se torniamo alla nostra mappa ricorda che c'è questa funzione di aggiornamento di Beiji nella classe di gioco e

01:01.650 --> 01:08.580
è lì che stavamo realizzando il gioco con la macchina e definendo come l'auto dovrebbe essere punita quando commette un errore.

01:08.580 --> 01:12.940
Ma ciò che è più importante per te capire è che ora possiamo

01:13.170 --> 01:19.140
Ma in questa classe di gioco abbiamo notato questa funzione di aggiornamento e in questa funzione di aggiornamento

01:19.500 --> 01:24.700
abbiamo notato questa azione di linea perché all'ultimo aggiornamento del cervello abbiamo lavorato meno segnale.

01:24.900 --> 01:28.410
E in realtà questo è esattamente ciò che stiamo per fare.

01:28.410 --> 01:36.300
Stiamo per fare questa funzione di aggiornamento che prenderà l'ultima parola e l'ultimo segnale per ottenere la prossima

01:36.300 --> 01:37.860
azione da giocare.

01:37.860 --> 01:41.640
Quindi non solo aggiorneremo tutti i diversi elementi della transizione.

01:41.910 --> 01:48.390
che stiamo per fare per selezionare la direzione da giocare oltre a fare tutti gli aggiornamenti.

01:48.390 --> 01:55.920
Ma per lo più giocheremo l'azione che dovremmo suonare quando riceviamo l'ultima parola e l'ultimo segnale e così,

01:55.920 --> 02:02.400
ovviamente, in questa funzione di aggiornamento useremo la funzione di azione selezionata che abbiamo appena implementato

02:02.400 --> 02:07.740
prima di integrare la funzione di azione selezionata nella funzione di aggiornamento futuro

02:07.860 --> 02:11.200
Quindi è davvero importante fare questa connessione con la mappa in questo momento.

02:11.310 --> 02:18.480
Quello che stiamo per fare è alla fine la connessione tra il nostro occhio e il gioco del gioco che

02:18.480 --> 02:19.750
facciamo in questa classe.

02:19.770 --> 02:24.030
E quindi quello che possiamo fare ora è prendere direttamente questo aggiornamento.

02:24.060 --> 02:29.970
abbiamo ricevuto meno segnali perché quella è in realtà la funzione che faremo con questi due argomenti qui.

02:29.970 --> 02:30.430
Infine

02:30.720 --> 02:38.530
E proprio come un cervello promemoria veloce è il nostro oggetto IA che è l'oggetto della classe Dejuan.

02:38.540 --> 02:45.690
Quindi quello che faremo ora è copiare questo aggiornamento meno parole meno segnale e questa sarà la

02:45.690 --> 02:48.390
nostra prossima funzione che stiamo facendo.

02:48.480 --> 02:54.120
E quindi, e incollando ciò qui, quindi, per fare attenzione, vorrei solo dare dei nomi diversi

02:54.120 --> 02:56.190
rispetto ai nomi che abbiamo qui.

02:56.200 --> 03:00.820
Sai che abbiamo l'ultima parola qui e non voglio confondere quest'ultima parola con questa.

03:00.900 --> 03:02.060
Questo può essere pericoloso.

03:02.220 --> 03:06.100
Quindi sostituirò l'ultima parola qui per parola.

03:06.390 --> 03:13.880
E allo stesso modo per meno segnale, mettiamo solo un segnale o anche un nuovo segnale per specificare che sai che

03:13.920 --> 03:18.900
vogliamo misurarlo al raggiungimento di un nuovo stato e quindi ottenere un nuovo segnale.

03:18.900 --> 03:26.100
Ma ovviamente questa parola qui sarà l'ultima ricompensa che otterremo qui.

03:26.280 --> 03:32.400
Sai quando vai sulla sabbia o peggio per avvicinarti troppo a un bordo della mappa, dove

03:32.670 --> 03:34.130
viene definita l'ultima parola.

03:34.200 --> 03:39.400
Quest'ultima parola sarà l'input della funzione di aggiornamento, ecco perché abbiamo l'ultima parola qui.

03:39.600 --> 03:43.660
Ma proprio qui sto dando un altro nome per l'argomento.

03:43.710 --> 03:47.640
Vogliamo non confonderlo con l'ultima parola qui.

03:47.640 --> 03:50.160
Va bene, questa è la funzione di aggiornamento.

03:50.310 --> 03:54.090
E ora entriamoci dentro e facciamo queste due cose.

03:54.090 --> 03:58.970
Questi sono i dati di tutti gli elementi della nostra transizione e, naturalmente, selezionare l'azione.

03:59.290 --> 04:01.670
OK, quindi cosa dobbiamo aggiornare prima.

04:01.950 --> 04:06.760
Bene, come hai capito, vogliamo stabilire una data per raggiungere qualsiasi stato.

04:06.840 --> 04:12.800
Quindi la prima cosa che aggiorneremo è ovviamente questa notizia che questa è la notizia che stiamo raggiungendo.

04:12.840 --> 04:17.340
Quindi chiamerò questo nuovo stato nuovo stato e poi lo farà.

04:17.340 --> 04:19.810
E quindi come possiamo ottenere questo nuovo stato.

04:20.040 --> 04:25.460
Beh, certo che dipende dal segnale il nuovo segnale che i sensori hanno appena rilevato.

04:25.830 --> 04:32.760
E come promemoria lo stato è il segnale stesso composto dai tre segnali che i sensori

04:32.760 --> 04:37.470
segnalano un segnale per segnalare tre più orientamento e meno orientamento.

04:37.530 --> 04:38.600
Questo è il nostro stato.

04:38.610 --> 04:42.470
Quindi assicurati di capire che il segnale è lo stato.

04:42.660 --> 04:46.160
Ma al momento è una semplice lista di cinque elementi.

04:46.200 --> 04:51.540
questo sarà l'input per fare tutto ciò che funziona, ricordati di convertirlo in un sensore di torcia.

04:51.540 --> 04:52.200
E poiché

04:52.490 --> 04:54.960
Questo è esattamente ciò che faremo ora.

04:54.960 --> 05:03.910
Prenderemo la nostra libreria torcia e poi prendiamo la classe tensoriale che andremo a convertire il nostro nuovo segnale in

05:04.450 --> 05:12.420
una torcia più densa, quindi è meglio assicurarsi che tutti gli elementi della torcia a cui rispondere siano

05:12.420 --> 05:19.650
galleggianti, quindi ho intenzione di fai una conversione di tipo per convertirli in float come questo.

05:19.900 --> 05:24.500
E poi finalmente provare a ottenere un riflesso di ciò che dobbiamo fare dopo.

05:24.530 --> 05:29.590
Ovviamente è quello di creare quel motore finto per aggiungere diamanti e corrispondere

05:29.590 --> 05:37.080
al lotto e lo facciamo naturalmente con la funzione squeeze a cui dobbiamo mettere l'indice di questo grande diamante.

05:37.100 --> 05:40.210
E vogliamo per il batch che è zero.

05:40.770 --> 05:41.320
Tutto ok.

05:41.320 --> 05:47.110
E ora abbiamo i nostri nuovi stati composti dai tre segnali dei tre sensori

05:47.110 --> 05:54.290
più l'orientamento meno l'orientamento e, naturalmente, ciò dipenderà dal nuovo segnale che riceviamo con questa funzione di aggiornamento.

05:54.400 --> 05:57.940
Proprio in questo momento ultimo segnale otteniamo i tre segnali.

05:57.940 --> 06:04.450
Quindi in più meno o in aggiunta e come promemoria i tre segnali sono la densità del

06:04.720 --> 06:06.490
sensore rilevato intorno ai sensori.

06:06.490 --> 06:06.940
Tutto ok.

06:06.970 --> 06:13.710
Quindi abbiamo appena creato una nuova tappa, quindi abbiamo raggiunto la nuova fase e ora dobbiamo fare il prossimo aggiornamento.

06:13.750 --> 06:16.440
Quindi secondo te cosa dobbiamo aggiornare ora.

06:16.660 --> 06:22.320
Quale sarebbe la cosa logica ad oggi in questo momento dopo aver raggiunto questo nuovo stato.

06:22.630 --> 06:25.940
Bene, quello che dobbiamo datare ora è il ricordo.

06:25.960 --> 06:27.010
Perché.

06:27.010 --> 06:34.200
È perché in ogni momento t una transizione è composta dallo stato attuale Estey il giorno successivo come

06:34.220 --> 06:37.660
tipis quando la ricompensa arti e l'azione 80.

06:37.860 --> 06:44.020
team e ne abbiamo già 80 e abbiamo appena ottenuto l'ultimo elemento della transizione Estep più uno.

06:44.020 --> 06:47.540
E ora abbiamo già S-T, abbiamo già il nostro

06:47.590 --> 06:55.720
Quindi, ottenendo questo nuovo stato così profondo come quello che stiamo ottenendo una nuova transizione della memoria e quindi

06:55.720 --> 07:01.910
dobbiamo aggiungere questa nuova transizione alla memoria perché questa è semplicemente la nostra prossima transizione.

07:01.930 --> 07:03.980
Ecco perché abbiamo quel ricordo in questo momento.

07:04.120 --> 07:10.990
E quindi quello che ho intenzione di fare è prendere la mia memoria creata dalla

07:10.990 --> 07:17.130
classe di memoria di replay e quindi prenderò la memoria per riferirmi all'oggetto.

07:17.160 --> 07:22.700
Ma dal momento che sto usando me stesso devo includere il sé in quella funzione.

07:22.950 --> 07:25.440
Quindi ora puoi davvero vedere a cosa serve questo sé.

07:25.550 --> 07:32.600
È ogni volta che si utilizza una variabile creata e inizializzata nella funzione init a quella memoria.

07:32.600 --> 07:33.960
E ora ce l'abbiamo fatta.

07:34.190 --> 07:36.950
E secondo te come lo aggiorneremo.

07:37.160 --> 07:41.290
Bene, la buona notizia è che abbiamo già fatto una funzione per farlo.

07:41.300 --> 07:46.990
È la funzione push che vieta un evento o una transizione alla memoria.

07:47.190 --> 07:49.060
Quindi questo è esattamente ciò che useremo ora.

07:49.070 --> 07:55.460
pendere la nostra nuova transizione che abbiamo appena fatto nella memoria e quindi qui non sto

07:55.760 --> 08:01.820
prendendo parte allo stesso modo perché useremo il metodo e quindi possiamo usare direttamente quella spinta.

08:02.320 --> 08:04.200
Useremo la funzione push per

08:04.280 --> 08:10.010
E per prima cosa aggiungerò la transizione a questa nuova transizione che abbiamo appena ottenuto e che è la

08:10.010 --> 08:10.780
prima dell'ultima data.

08:10.850 --> 08:14.010
Quindi auto che ultimo appuntamento.

08:14.270 --> 08:18.680
Quindi questo è S-T Questo è esattamente questo già esiste.

08:18.680 --> 08:23.620
Quindi il prossimo elemento di questa transizione è ovviamente il nuovo stato che abbiamo appena raggiunto.

08:23.840 --> 08:29.720
E quindi dato che non è fattibile per l'oggetto che abbiamo creato e inizializzato in questa funzione di init,

08:30.080 --> 08:31.470
non lo mettiamo qui.

08:31.580 --> 08:39.940
Inseriamo direttamente il Newstead, quindi il prossimo elemento della transizione è l'azione e diciamo che abbiamo già l'ultima

08:39.940 --> 08:43.690
sezione che è questa stessa ultima azione qui.

08:43.840 --> 08:45.320
Quindi ovviamente è uguale a zero.

08:45.350 --> 08:50.050
Ma poi ovviamente sarà aggiornato con la funzione di azione selezionata.

08:50.170 --> 08:51.190
Ma questo è questo.

08:51.190 --> 08:55.620
Quindi allora è l'io che ultima azione.

08:55.840 --> 08:57.120
Ma ora stai attento.

08:57.190 --> 09:01.540
Gli elementi inclusi in questa transizione dovrebbero essere tutte risposte incendiate.

09:01.870 --> 09:03.860
Come puoi vedere è il caso dell'ultima data.

09:03.880 --> 09:05.200
È un sensore di torcia.

09:05.350 --> 09:07.860
Il nuovo stato è anche una risposta incendiata.

09:07.900 --> 09:12.050
E quindi questo deve essere lo stesso per l'azione e quindi la ricompensa, naturalmente.

09:12.190 --> 09:17.320
Ma ora penserai come può essere una risposta incerta considerando che è semplicemente un numero.

09:17.410 --> 09:20.700
Sai che l'azione è 0 1 o 2.

09:20.890 --> 09:22.370
Ma in realtà non è un problema.

09:22.390 --> 09:28.640
Possiamo ancora convertire questa variabile 0 1 o 2 in un sensore di torcia.

09:28.660 --> 09:31.530
Questo sarà solo ciò che chiamiamo un lungo tensore.

09:31.540 --> 09:36.910
Il lungo è un tipo e questo è il tensore che conterrà un numero intero perché l'ultima azione

09:36.910 --> 09:39.660
è un numero intero è 0 1 o 2.

09:39.670 --> 09:47.650
Quindi quello che stiamo per fare ora è la nostra biblioteca, quindi prenderemo la lunga classe

09:48.190 --> 09:53.470
tensoriale che creerà un oggetto che sarà il non-sé stesso.

09:53.710 --> 10:00.370
E prendendo questa funzione dell'ultima azione come input, creerà questo oggetto tensoriale lungo ma conterrà ancora 0

10:00.370 --> 10:08.590
1 o 2 in un oggetto tensoriale lungo e che è solo per essere coerente con la transizione che contiene solo

10:08.830 --> 10:14.070
tensioni perché siamo lavorando con torcia PI e stiamo lavorando con una rete neurale.

10:14.170 --> 10:18.480
Quindi dobbiamo lavorare con i sensori in modo da andare molto a rispondere.

10:18.580 --> 10:20.780
E un'ultima conversione da fare.

10:20.860 --> 10:27.520
Dobbiamo essere sicuri che ciò che è contenuto in questa lunga risposta è un numero intero e per assicurarci

10:27.520 --> 10:34.000
di ciò anche se sappiamo già che l'ultima azione è 0 1 o 2 per assicurarci che faremo di

10:34.000 --> 10:39.310
nuovo questa conversione di tipo int convertiamo il nostro auto ultima azione in un numero intero.

10:39.310 --> 10:46.450
Eccoci e quindi dobbiamo semplicemente mettere l'intera azione disinteressata tra parentesi qui in modo che ora otteniamo

10:46.450 --> 10:52.810
un lungo tensore di un elemento che sarà quest'ultima azione 0 o 1 o 2 stessa.

10:52.810 --> 10:59.880
Quindi il punto chiave è che è come convertire un semplice numero zero uno o due in un tensore con torcia.

11:00.060 --> 11:00.360
Tutto ok.

11:00.360 --> 11:06.820
E infine l'ultimo elemento della transizione e questa è ovviamente l'ultima parola che abbiamo ricevuto.

11:06.880 --> 11:12.980
Questa è esattamente l'ultima parola pallavolo che abbiamo creato in qualsiasi funzione inizializzata a zero.

11:13.110 --> 11:19.720
Ma poi, naturalmente, viene aggiornato proprio qui in questo codice o quando andiamo in un certo senso che è una parola

11:19.770 --> 11:24.020
negativa o se ci allontaniamo dall'obiettivo che è di nuovo una ricompensa negativa.

11:24.180 --> 11:30.090
Se ci avviciniamo all'obiettivo che è una ricompensa positiva e la peggiore punizione se ci avviciniamo troppo a un

11:30.090 --> 11:34.080
bordo della mappa Beh, questa è una parola negativa terribile meno uno.

11:34.290 --> 11:36.190
E questo è un

11:36.260 --> 11:40.810
Quindi aggiungiamo questo ultimo elemento della transizione autodiretto alla parola.

11:41.060 --> 11:47.660
Quindi sto copiando questo incollaggio qui e ora dobbiamo fare un'altra conversione che sarà ovviamente esattamente uguale

11:47.750 --> 11:53.570
a questa solo perché la parola non è un numero intero ma un numero float.

11:53.780 --> 12:00.350
Semplicemente realizzeremo una torcia per la conversione del tensore, ma senza di essa manterrà le parentesi qui perché prima sai

12:00.350 --> 12:06.200
che dobbiamo inserire il numero in una lista e poi questa lista andrà a mettere la torcia

12:06.200 --> 12:11.510
in classe ma non abbiamo per farlo in conversione perché l'ultima parola è un numero float.

12:11.510 --> 12:21.400
Quindi, quello che faremo è semplicemente aggiungere qui il tensore del punto torcia a fuoco un tensore e poi parentesi parentesi.

12:21.680 --> 12:27.470
E chiudiamo qui le parentesi e chiudiamo la parentesi.

12:27.470 --> 12:28.820
Eccoci.

12:28.820 --> 12:35.180
Quindi, per riassumere che hai detto che abbiamo appena raggiunto e la nostra parola osserviamo un nuovo evento di

12:35.540 --> 12:37.150
transizione che aggiungiamo alla memoria.

12:37.550 --> 12:44.240
E questa transizione contiene l'ultima data e vede il nuovo stato come tipis quando l'ultima

12:44.540 --> 12:47.640
azione gioca 80 e l'ultima parola Archie.

12:48.020 --> 12:48.390
Tutto ok.

12:48.440 --> 12:51.220
E ora stiamo andando con la nostra memoria di date.

12:51.410 --> 12:55.710
Quindi facciamo una breve pausa e ci occuperemo del prossimo aggiornamento nel prossimo tutorial.

12:55.970 --> 12:57.440
Fino ad allora I.
