Ciao e benvenuto in questo tutorial Python.
Bene, abbiamo un'ultima funzione da implementare nella nostra classe di memoria di replay.
Questa è la funzione semplice e questo è ovviamente quello di ottenere alcuni campioni casuali dalla nostra memoria.
E quindi questa funzione restituirà questi campioni casuali.
Va bene, entriamoci dentro
Lo chiameremo semplice.
Eccoci qui.
E questa funzione prende due argomenti come input.
Il primo come al solito il nostro oggetto futuro per riprodurre la classe di memoria e il secondo argomento è possibile
provare a indovinare.
Bene, stiamo prendendo alcuni campioni di dimensioni fisse e quindi dobbiamo scegliere una dimensione per i campioni e più
precisamente la chiamiamo dimensione del lotto.
Questo è il nome che daremo alla nostra dimensione del secondo argomento.
E noi andiamo.
Abbiamo i nostri due argomenti e ora possiamo implementare la funzione semplice.
Quindi ora voglio solo avvertirti che questo diventerà un po 'tecnico, ma farò del mio meglio per spiegarlo.
Quindi inizieremo creando la variabile samples.
Questa è solo la variabile che conterrà i campioni della memoria.
Va bene così semplice è uguale.
E ora come facciamo a ottenere questi campioni.
Beh, prima di tutto dobbiamo prendere la nostra memoria perché stiamo ottenendo i campioni dalla nostra memoria.
Quindi probabilmente avremo bisogno della dimensione del batch, perché i campioni verranno ridimensionati in dimensioni
di Elon.
bisogno della dimensione del batch e quindi abbiamo bisogno di alcuni trucchi torche o bisonti per ottenere un buon formato di questi campioni.
Quindi abbiamo bisogno di memoria, abbiamo
Quindi cosa farò scriverò la riga di codice e poi spiegherò quell'elemento
per elemento.
Facciamolo.
Sto iniziando prendendo una funzione di zip che spiegherò molto presto cosa fa.
E all'interno di questa funzione aggiungerò una stella.
Ho intenzione di espandere anche quello.
e il pensiero casuale centrale così casuale come si potrebbe intuire è la libreria casuale che abbiamo importato qui.
La stella
Questa è la ragione principale per cui abbiamo dovuto importare queste librerie casuali perché stiamo prendendo alcuni
campioni casuali.
Quindi da questa libreria casuale useremo la funzione semplice.
Quindi queste sono le nostre variabili e questa è una funzione, quindi aggiungerò alcune parentesi.
E ora come puoi vedere sample è una funzione e dobbiamo mettere alcuni argomenti in modo che tu possa
vedere il primo argomento stesso.
questo corrisponde alla memoria di sé-parlare la memoria del nostro oggetto istanza futuro della nostra memoria di riproduzione per noi.
E in realtà parlando di sé
Quindi aggiungerò qui quella memoria e poi la seconda argomentazione è come potreste aver indovinato la dimensione del Bechuana presa
in modo casuale dalla nostra memoria e che gli abbiamo dato un nome che è la dimensione del batch.
Quindi il secondo argomento sarà Bachche sucks.
Tutto ok.
Quindi la riga di codice è stata scritta e ho intenzione di spiegare cosa fa.
Quindi, prima di tutto con questa semplice funzione di punto casuale, stiamo prendendo alcuni campioni casuali dalla memoria
che aveva una dimensione fissa di quella dimensione.
Quindi è comprensibile.
Ma allora cosa fa questa funzione stella Zipp.
Beh, non c'è alcun mistero al riguardo.
È proprio come la funzione di risagoma.
Quindi, per esempio, aggiungerò un po 'qui solo per spiegare che lo toglierò.
Quindi diciamo che ad esempio abbiamo un elenco dei seguenti elementi, ad esempio.
Primo uno due tre.
E poi il secondo elemento.
Quattro cinque sei.
Quindi abbiamo una lista di due doppi di tre elementi uno due tre quattro cinque sei.
Bene, allora se applico la funzione zip con la stella sopra.
Beh, cosa sarebbe diventato così Zip Star List sarà uguale a una nuova lista, ma di una
forma diversa e una forma diversa sarà uno per poi due tre e poi cinque sei.
Tutto ok.
Quindi è proprio quello che fa.
Rimodella la tua lista.
OK così ora che capisci cosa fa questa lista stellare di Zipp.
Bene, ora spieghiamo perché abbiamo dovuto farlo.
Quindi, come hai capito, aggiungeremo gli eventi alla memoria e gli eventi avranno la forma.
Prima lo stato poi l'azione e poi la ricompensa.
Ma per il nostro algoritmo non vogliamo questo formato, in realtà vogliamo che i nostri campioni abbiano il seguente formato.
Un formato è composto da tre campioni un campione per gli stati un campione per le azioni e un campione
per il premio.
Quindi per esempio diciamo che questo uno a tre è stato uno azione uno.
Vogliamo uno e poi dichiariamo all'azione due e dovremmo benissimo quello che vogliamo sia un lotto per ogni lotto per
lo stato uno e lo stato due.
Uno è un match per l'azione uno in azione due e un terzo che per noi eravamo uno e noi eravamo due.
Questo è solo il formato che ci si aspetta dopo, quindi avvolgeremo questi lotti in
una torta verso un impatto orribile che lontano ricorderemo è una variabile che contiene sia un tensore sia
un gradiente.
E questo per essere in grado di differenziare rispetto a un tensore per essere in grado di
differenziare rispetto all'intensità all'interno della struttura di un orribile contenente un tensore e un gradiente.
Di nuovo è così che funziona la torcia Pi.
Quindi, per riassumere, creiamo una partita per ciascuna azione e ricompensa dello stato e poi metteremo ciascuna di
queste vecce separatamente in alcuni byte che Horrible è quella che otterrà una sfumatura in modo che
alla fine saremo in grado di differenziare ognuno di loro.
Va bene, questo è lo scopo della funzione Zipp.
Quindi permettimi di rimuovere questo commento.
E ora l'unica cosa che dobbiamo fare è restituire i campioni.
restituire i campioni direttamente per il semplice motivo che vogliamo mettere i campioni in una soluzione redditizia.
Quindi, come ho appena spiegato, non possiamo
Quindi, per fare questo per ognuno degli esempi, useremo la funzione mappa e questa funzione
mappa eseguirà la mappatura dai campioni alle variabili di tortura che conterranno un tensore e un gradiente.
Quindi come puoi vedere questa funzione mappa richiede diversi argomenti.
Il primo argomento è una funzione e questa funzione sarà la funzione che convertirà
i campioni in alcune variabili torche.
E il secondo argomento è ciò su cui vogliamo applicare questa funzione.
Quindi saranno gli argomenti di questa funzione e quindi cosa sarà.
Ovviamente saranno i campioni.
Quindi il secondo argomento qui sarà i simboli.
Ma poi definiamo la funzione su cui vogliamo applicare.
Ciascuno dei simboli
Quindi per definire una funzione qui dobbiamo prima dare un nome alla funzione che chiameremo lambda.
Questo è solo un nome e dare a Lenda poi X che sarà la variabile di questa funzione.
Quindi questo è solo un nome e dare per la variabile e poi.
dovrebbe essere qualcosa che convertirà i nostri campioni in una variabile torcia e per farlo.
E qui diamo l'espressione della funzione che è ciò che vogliamo che questa funzione lambda ritorni e
veda che cosa sta per essere bene
L'abbiamo già menzionato in alcuni tutorial precedenti.
Bene, abbiamo la funzione Voivode per loro.
La Voce funzionerà, faremo quella conversione da un ballerino di torcia a una variabile che conterrà il
sensore e il più grande.
Quindi la prima cosa che aggiungerò qui è la variabile variabile all'interno della quale ho intenzione
di convertire X perché X saranno le semplici che verranno applicate ai campioni.
Ma ecco che c'è un'ultima cosa tecnica che dobbiamo implementare è il fatto che per ogni
lotto che è contenuto nel campione, ad esempio il lotto di azioni a 1 8 2
3 e le altre azioni, dobbiamo concatenarlo con rispetto al primo motore del tempo che corrisponde agli Stati.
E perché dobbiamo fare questa concatenazione.
È solo perché tutto sia ben allineato.
Quello è quello in ogni riga per dichiarare l'azione e la ricompensa corrisponde allo stesso tempo t. In modo che alla fine avremo una lista di lotti tutti ben allineati e ogni lotto è una torta verso Voivod.
Quindi, come possiamo rendere questa concatenazione.
Bene, dobbiamo usare la funzione cat dalla libreria torcia.
Quindi aggiungeremo qui la torcia a cui aggiungiamo che
viene applicata a X, ma in questa funzione dobbiamo specificare la dimensione rispetto alla quale vogliamo fare quella concatenazione.
E come ho appena detto questo è il motore del primo tempo che ha l'era dell'indice.
E qui andiamo abbiamo la nostra funzione pronta questa Lunda che la funzione
prenderà i campioni concatenandoli rispetto al primo motore del tempo e poi eventualmente convertiremo i sensori in alcune
variabili torche che contengono sia un tensore sia un gradiente in modo che più tardi quando
si applica a castigate nel senso che saremo in grado di differenziare per avere pesi di dati.
Va bene, questa funzione è pronta.
E poi ecco il secondo argomento della funzione mappa.
Dobbiamo specificare su cosa vogliamo applicare questa funzione e questo è su tutti i nostri campioni.
Eccoci.
Applicheremo questa funzione
lambda su tutti i campioni in modo che alla fine si ottenga un elenco di partite in cui ogni match è una torcia PI praticabile.
Va bene, era abbastanza tecnico ma ora almeno tutto funzionerà bene.
Vogliamo usare questa tecnica.
la torcia come vuoi
In seguito lo usiamo solo qui, quindi se non vuoi avere una profonda comprensione dei dettagli tecnici qui
va bene, puoi solo copiare queste tre righe di codice per semplificare la tua memoria se vuoi creare un'intelligenza artificiale con
Ma ora la buona notizia è che abbiamo finito con questa replaying
che la ripetizione dell'esperienza di classe è ora implementata e che possiamo passare alla prossima e ultima classe che sarà l'intera modalità di sicurezza.
Quindi in questo modello avremo ovviamente la nostra rete
che sperimenterà la riproduzione e quindi tutto il resto dell'algoritmo di sicurezza.
Quindi sarà una classe molto più grande.
che tu possa capire meglio cosa sta succedendo.
Faremo circa 10 funzioni, ma è solo perché stiamo facendo questo passo dopo passo in modo
Quindi non vedo l'ora di implementare il nostro modello di sicurezza.
E fino ad allora I.