Ciao e benvenuto in questo tutorial Python.
Va bene così oggi faremo la funzione di aggiornamento che aggiornerà tutto ciò che c'è fino
ad oggi non appena l'occhio raggiunge un nuovo stato.
Quindi, quando raggiunge la nuova fase, sai che dobbiamo aggiornare l'azione.
L'ultimo in realtà arriva alla nuova azione appena giocata.
Ma anche l'ultima data che diventa il nuovo stato.
E infine l'ultima parola che diventa la nuova parola che otteniamo quando recitiamo l'azione.
Quindi questo è il percorso logico che accade subito dopo aver selezionato un'azione.
Abbiamo bisogno di aggiornare tutti gli elementi delle transizioni.
E ovviamente avrai una nuova transizione.
Quindi dovremo aggiungere questa nuova transizione alla memoria.
E infine aggiorneremo o premierà la finestra che conosci per tenere d'occhio l'evoluzione di
come sta andando l'allenamento e come procede l'esplorazione.
finalmente stabilire una connessione tra l'intelligenza artificiale che stiamo implementando in questo momento sulla nostra mappa, perché
se torniamo alla nostra mappa ricorda che c'è questa funzione di aggiornamento di Beiji nella classe di gioco e
è lì che stavamo realizzando il gioco con la macchina e definendo come l'auto dovrebbe essere punita quando commette un errore.
Ma ciò che è più importante per te capire è che ora possiamo
Ma in questa classe di gioco abbiamo notato questa funzione di aggiornamento e in questa funzione di aggiornamento
abbiamo notato questa azione di linea perché all'ultimo aggiornamento del cervello abbiamo lavorato meno segnale.
E in realtà questo è esattamente ciò che stiamo per fare.
Stiamo per fare questa funzione di aggiornamento che prenderà l'ultima parola e l'ultimo segnale per ottenere la prossima
azione da giocare.
Quindi non solo aggiorneremo tutti i diversi elementi della transizione.
che stiamo per fare per selezionare la direzione da giocare oltre a fare tutti gli aggiornamenti.
Ma per lo più giocheremo l'azione che dovremmo suonare quando riceviamo l'ultima parola e l'ultimo segnale e così,
ovviamente, in questa funzione di aggiornamento useremo la funzione di azione selezionata che abbiamo appena implementato
prima di integrare la funzione di azione selezionata nella funzione di aggiornamento futuro
Quindi è davvero importante fare questa connessione con la mappa in questo momento.
Quello che stiamo per fare è alla fine la connessione tra il nostro occhio e il gioco del gioco che
facciamo in questa classe.
E quindi quello che possiamo fare ora è prendere direttamente questo aggiornamento.
abbiamo ricevuto meno segnali perché quella è in realtà la funzione che faremo con questi due argomenti qui.
Infine
E proprio come un cervello promemoria veloce è il nostro oggetto IA che è l'oggetto della classe Dejuan.
Quindi quello che faremo ora è copiare questo aggiornamento meno parole meno segnale e questa sarà la
nostra prossima funzione che stiamo facendo.
E quindi, e incollando ciò qui, quindi, per fare attenzione, vorrei solo dare dei nomi diversi
rispetto ai nomi che abbiamo qui.
Sai che abbiamo l'ultima parola qui e non voglio confondere quest'ultima parola con questa.
Questo può essere pericoloso.
Quindi sostituirò l'ultima parola qui per parola.
E allo stesso modo per meno segnale, mettiamo solo un segnale o anche un nuovo segnale per specificare che sai che
vogliamo misurarlo al raggiungimento di un nuovo stato e quindi ottenere un nuovo segnale.
Ma ovviamente questa parola qui sarà l'ultima ricompensa che otterremo qui.
Sai quando vai sulla sabbia o peggio per avvicinarti troppo a un bordo della mappa, dove
viene definita l'ultima parola.
Quest'ultima parola sarà l'input della funzione di aggiornamento, ecco perché abbiamo l'ultima parola qui.
Ma proprio qui sto dando un altro nome per l'argomento.
Vogliamo non confonderlo con l'ultima parola qui.
Va bene, questa è la funzione di aggiornamento.
E ora entriamoci dentro e facciamo queste due cose.
Questi sono i dati di tutti gli elementi della nostra transizione e, naturalmente, selezionare l'azione.
OK, quindi cosa dobbiamo aggiornare prima.
Bene, come hai capito, vogliamo stabilire una data per raggiungere qualsiasi stato.
Quindi la prima cosa che aggiorneremo è ovviamente questa notizia che questa è la notizia che stiamo raggiungendo.
Quindi chiamerò questo nuovo stato nuovo stato e poi lo farà.
E quindi come possiamo ottenere questo nuovo stato.
Beh, certo che dipende dal segnale il nuovo segnale che i sensori hanno appena rilevato.
E come promemoria lo stato è il segnale stesso composto dai tre segnali che i sensori
segnalano un segnale per segnalare tre più orientamento e meno orientamento.
Questo è il nostro stato.
Quindi assicurati di capire che il segnale è lo stato.
Ma al momento è una semplice lista di cinque elementi.
questo sarà l'input per fare tutto ciò che funziona, ricordati di convertirlo in un sensore di torcia.
E poiché
Questo è esattamente ciò che faremo ora.
Prenderemo la nostra libreria torcia e poi prendiamo la classe tensoriale che andremo a convertire il nostro nuovo segnale in
una torcia più densa, quindi è meglio assicurarsi che tutti gli elementi della torcia a cui rispondere siano
galleggianti, quindi ho intenzione di fai una conversione di tipo per convertirli in float come questo.
E poi finalmente provare a ottenere un riflesso di ciò che dobbiamo fare dopo.
Ovviamente è quello di creare quel motore finto per aggiungere diamanti e corrispondere
al lotto e lo facciamo naturalmente con la funzione squeeze a cui dobbiamo mettere l'indice di questo grande diamante.
E vogliamo per il batch che è zero.
Tutto ok.
E ora abbiamo i nostri nuovi stati composti dai tre segnali dei tre sensori
più l'orientamento meno l'orientamento e, naturalmente, ciò dipenderà dal nuovo segnale che riceviamo con questa funzione di aggiornamento.
Proprio in questo momento ultimo segnale otteniamo i tre segnali.
Quindi in più meno o in aggiunta e come promemoria i tre segnali sono la densità del
sensore rilevato intorno ai sensori.
Tutto ok.
Quindi abbiamo appena creato una nuova tappa, quindi abbiamo raggiunto la nuova fase e ora dobbiamo fare il prossimo aggiornamento.
Quindi secondo te cosa dobbiamo aggiornare ora.
Quale sarebbe la cosa logica ad oggi in questo momento dopo aver raggiunto questo nuovo stato.
Bene, quello che dobbiamo datare ora è il ricordo.
Perché.
È perché in ogni momento t una transizione è composta dallo stato attuale Estey il giorno successivo come
tipis quando la ricompensa arti e l'azione 80.
team e ne abbiamo già 80 e abbiamo appena ottenuto l'ultimo elemento della transizione Estep più uno.
E ora abbiamo già S-T, abbiamo già il nostro
Quindi, ottenendo questo nuovo stato così profondo come quello che stiamo ottenendo una nuova transizione della memoria e quindi
dobbiamo aggiungere questa nuova transizione alla memoria perché questa è semplicemente la nostra prossima transizione.
Ecco perché abbiamo quel ricordo in questo momento.
E quindi quello che ho intenzione di fare è prendere la mia memoria creata dalla
classe di memoria di replay e quindi prenderò la memoria per riferirmi all'oggetto.
Ma dal momento che sto usando me stesso devo includere il sé in quella funzione.
Quindi ora puoi davvero vedere a cosa serve questo sé.
È ogni volta che si utilizza una variabile creata e inizializzata nella funzione init a quella memoria.
E ora ce l'abbiamo fatta.
E secondo te come lo aggiorneremo.
Bene, la buona notizia è che abbiamo già fatto una funzione per farlo.
È la funzione push che vieta un evento o una transizione alla memoria.
Quindi questo è esattamente ciò che useremo ora.
pendere la nostra nuova transizione che abbiamo appena fatto nella memoria e quindi qui non sto
prendendo parte allo stesso modo perché useremo il metodo e quindi possiamo usare direttamente quella spinta.
Useremo la funzione push per
E per prima cosa aggiungerò la transizione a questa nuova transizione che abbiamo appena ottenuto e che è la
prima dell'ultima data.
Quindi auto che ultimo appuntamento.
Quindi questo è S-T Questo è esattamente questo già esiste.
Quindi il prossimo elemento di questa transizione è ovviamente il nuovo stato che abbiamo appena raggiunto.
E quindi dato che non è fattibile per l'oggetto che abbiamo creato e inizializzato in questa funzione di init,
non lo mettiamo qui.
Inseriamo direttamente il Newstead, quindi il prossimo elemento della transizione è l'azione e diciamo che abbiamo già l'ultima
sezione che è questa stessa ultima azione qui.
Quindi ovviamente è uguale a zero.
Ma poi ovviamente sarà aggiornato con la funzione di azione selezionata.
Ma questo è questo.
Quindi allora è l'io che ultima azione.
Ma ora stai attento.
Gli elementi inclusi in questa transizione dovrebbero essere tutte risposte incendiate.
Come puoi vedere è il caso dell'ultima data.
È un sensore di torcia.
Il nuovo stato è anche una risposta incendiata.
E quindi questo deve essere lo stesso per l'azione e quindi la ricompensa, naturalmente.
Ma ora penserai come può essere una risposta incerta considerando che è semplicemente un numero.
Sai che l'azione è 0 1 o 2.
Ma in realtà non è un problema.
Possiamo ancora convertire questa variabile 0 1 o 2 in un sensore di torcia.
Questo sarà solo ciò che chiamiamo un lungo tensore.
Il lungo è un tipo e questo è il tensore che conterrà un numero intero perché l'ultima azione
è un numero intero è 0 1 o 2.
Quindi quello che stiamo per fare ora è la nostra biblioteca, quindi prenderemo la lunga classe
tensoriale che creerà un oggetto che sarà il non-sé stesso.
E prendendo questa funzione dell'ultima azione come input, creerà questo oggetto tensoriale lungo ma conterrà ancora 0
1 o 2 in un oggetto tensoriale lungo e che è solo per essere coerente con la transizione che contiene solo
tensioni perché siamo lavorando con torcia PI e stiamo lavorando con una rete neurale.
Quindi dobbiamo lavorare con i sensori in modo da andare molto a rispondere.
E un'ultima conversione da fare.
Dobbiamo essere sicuri che ciò che è contenuto in questa lunga risposta è un numero intero e per assicurarci
di ciò anche se sappiamo già che l'ultima azione è 0 1 o 2 per assicurarci che faremo di
nuovo questa conversione di tipo int convertiamo il nostro auto ultima azione in un numero intero.
Eccoci e quindi dobbiamo semplicemente mettere l'intera azione disinteressata tra parentesi qui in modo che ora otteniamo
un lungo tensore di un elemento che sarà quest'ultima azione 0 o 1 o 2 stessa.
Quindi il punto chiave è che è come convertire un semplice numero zero uno o due in un tensore con torcia.
Tutto ok.
E infine l'ultimo elemento della transizione e questa è ovviamente l'ultima parola che abbiamo ricevuto.
Questa è esattamente l'ultima parola pallavolo che abbiamo creato in qualsiasi funzione inizializzata a zero.
Ma poi, naturalmente, viene aggiornato proprio qui in questo codice o quando andiamo in un certo senso che è una parola
negativa o se ci allontaniamo dall'obiettivo che è di nuovo una ricompensa negativa.
Se ci avviciniamo all'obiettivo che è una ricompensa positiva e la peggiore punizione se ci avviciniamo troppo a un
bordo della mappa Beh, questa è una parola negativa terribile meno uno.
E questo è un
Quindi aggiungiamo questo ultimo elemento della transizione autodiretto alla parola.
Quindi sto copiando questo incollaggio qui e ora dobbiamo fare un'altra conversione che sarà ovviamente esattamente uguale
a questa solo perché la parola non è un numero intero ma un numero float.
Semplicemente realizzeremo una torcia per la conversione del tensore, ma senza di essa manterrà le parentesi qui perché prima sai
che dobbiamo inserire il numero in una lista e poi questa lista andrà a mettere la torcia
in classe ma non abbiamo per farlo in conversione perché l'ultima parola è un numero float.
Quindi, quello che faremo è semplicemente aggiungere qui il tensore del punto torcia a fuoco un tensore e poi parentesi parentesi.
E chiudiamo qui le parentesi e chiudiamo la parentesi.
Eccoci.
Quindi, per riassumere che hai detto che abbiamo appena raggiunto e la nostra parola osserviamo un nuovo evento di
transizione che aggiungiamo alla memoria.
E questa transizione contiene l'ultima data e vede il nuovo stato come tipis quando l'ultima
azione gioca 80 e l'ultima parola Archie.
Tutto ok.
E ora stiamo andando con la nostra memoria di date.
Quindi facciamo una breve pausa e ci occuperemo del prossimo aggiornamento nel prossimo tutorial.
Fino ad allora I.