Ciao e benvenuto a questo tutorial Python in Statoil faremo il primo passo verso l'implementazione del
modello di teoria profonda.
Quindi in pratica stiamo per implementare l'intero processo dell'algoritmo di diffusione.
E quindi useremo ciò che abbiamo creato prima.
Questa è l'architettura della rete neurale per riprodurre la memoria per integrarla nell'intero processo
di apprendimento della dequeue.
E questo intero algoritmo di apprendimento si inserirà in una classe.
Questo è l'ultimo che stiamo facendo per implementare l'intelligenza artificiale.
E questa classe conterrà solo funzioni diverse.
Quindi avremo le funzioni in esso che creeranno e inizializzeranno tutte le variabili associate
ai nostri futuri oggetti devianti che rappresenteranno il modello stesso e avranno alcune altre funzioni.
Uno di questi sarà ovviamente quello di selezionare l'azione giusta in ogni momento.
Avremo anche una funzione di funzione di aggiornamento per ottenere questo nucleo e avere un'idea di come sta andando
l'apprendimento se sta andando bene.
Se l'esplorazione sta andando bene e se può passare allo sfruttamento, allora avremo una funzione
sicura per salvare domani, cioè salvare il cervello dell'auto e poi caricare la funzione.
Quindi abbiamo un paio di funzioni da fare.
Faremo una funzione per ciascuno a fatica.
E oggi inizieremo con la funzione di fine come al solito quando stiamo facendo una lezione.
Ma prima non dimentichiamo di introdurre la classe, quindi la chiameremo D.
D E per la tua rete, allora una parentesi chiama.
E poi andiamo con la nostra prima funzione.
Quindi facciamo questo def quindi doppio underscore poi il suo doppio underscore nuovamente e parentesi.
Quindi, come hai capito in questa funzione, introdurremo le variabili associate al nostro oggetto.
Quindi avremo un paio di righe che iniziano da sole e fondamentalmente creeremo e
inizializzeremo tutte le variabili necessarie per implementare la rete D2.
Quindi, ad esempio, creeremo un oggetto o una rete perché, ovviamente, abbiamo bisogno della nostra rete neurale profonda,
quindi avremo bisogno della nostra memoria.
Creeremo un'altra variabile per la memoria.
Quindi avremo un'altra variabile auto-memoria, ma non è tutto ciò che dovremo creare.
Alcune variabili per l'ultima data.
L'ultima azione e l'ultima parola.
Ovviamente conosci le variabili che vedi nell'algoritmo di diffusione.
E poi cos'altro.
Bene, avremo anche bisogno di un ottimizzatore che tu conosca per eseguire la griglia stocastica nel senso
dei pesi dei dati in base a quanto contribuiranno all'errore.
Quando l'intelligenza artificiale sta commettendo un errore, allora penso che quindi sono fondamentalmente le variabili che ora
dobbiamo creare e inizializzare.
Ma in questa funzione di init metteremo un paio di argomenti prima come al solito, che è gli argomenti che si
riferiscono al nostro oggetto.
Quindi poiché sai che creeremo un oggetto della classe di rete.
Bene visto che la classe di rete prende come argomento la dimensione dell'input della funzione init e l'azione Bene, qui
è lo stesso.
Quando creiamo un oggetto della classe di rete, dovremo scegliere un argomento di dimensioni di input
e l'argomento effettivo.
Quindi possiamo semplicemente copiarne alcuni
qui e qui andiamo.
Quindi questi argomenti diventeranno ora.
Inoltre alcuni argomenti non sono durati.
Ogni volta che creiamo alcuni oggetti futuri della classe diversa che alcuni futuri modelli di ruolo dical Bene, avremo bisogno
di specificare la dimensione di input che ricordo sia il numero di dimensioni nei vettori che
includono i tuoi stati.
I tuoi stati di input e un numero di azioni che è il numero di azioni possibili che l'auto può fare.
Quindi ti ricordo.
Questi sono o andare a sinistra andare dritto o andare a destra.
Ok perfetto
Quindi sai che creerai un nuovo oggetto della classe di memoria di replay per creare
l'oggetto di memoria per ottenere la nostra memoria delle transizioni e nelle informazioni abbiamo l'argomento della capacità.
Ma dal momento che lo useremo solo una volta in realtà quando creiamo memoria e non in
seguito, beh, non avremo bisogno di specificare l'argomento della capacità.
Potremmo farlo ma inseriremo direttamente il numero di transizioni che vogliamo che la nostra memoria abbia.
Ma poi abbiamo bisogno di un ultimo argomento che è quello di ottenere il parametro nel modello dell'insegnante.
Ricorda che questo parametro gamma è il ritardo.
parametro dell'equazione e quindi lo metteremo qui perché lo useremo più volte in seguito.
E questo è un
Quindi mettiamolo qui.
Lo chiameremo Gamma.
Quindi per questo è solo il nome dell'argomento e poi andiamo che tutti gli argomenti di cui avrai bisogno per
questo nella sua funzione.
Ciò significa che ogni volta che creiamo il nostro modello di dizionario, ogni volta che creiamo un oggetto
dell'insegnante in classe.
Bene, avremo bisogno di specificare come argomenti la dimensione di input il numero di azioni e il parametro.
E finiremo con i valori reali per loro.
Va bene, ora entriamo nella funzione.
OK.
Quindi ora fondamentalmente sarà facile.
Stiamo per creare e inizializzare tutte le variabili di cui abbiamo bisogno.
E quindi iniziamo con il primo.
Iniziamo con gamma.
In realtà il coefficiente di ritardo.
Quindi, poiché questo è un Voivode che vuole essere collegato al suo oggetto, iniziamo da soli.
Quindi gamma sarà una variabile del nostro insegnante e modello stesso che gamma equivale agli argomenti che verranno inseriti
quando si crea un oggetto della classe detune.
Quindi Janna e eccoci con il secondo argomento.
Il secondo argomento sarà la finestra di ricompensa.
Allora, cos'è questa finestra?
scorrevole della media delle ultime 100 parole che userete solo per valutare l'evoluzione della
performance che sapete avrà il significato della parola in questa guerra Windu che scivolerà nel tempo.
Bene, questa sarà la finestra
E ciò che vogliamo osservare è il significato delle ultime 100 parole che aumentano col tempo.
Inizializziamolo con se stessi che premia la finestra di sottolineatura.
E così da quando questa sarà una finestra scorrevole del significato in evoluzione delle ultime 100 parole.
Bene, lo inizializzeremo come una lista vuota e poi espanderemo per significare che lavoriamo fuori orario.
Va bene allora più eccitante.
Creiamo la nostra rete neurale.
Quindi lo chiameremo Mario autodidatta perché fondamentalmente è il cuore dei modelli.
Lo chiamo modello e questo modello non sarà altro che un soggetto in quella classe e per creare
un tale oggetto.
Prendiamo la nostra rete di classe tra parentesi e qui inseriamo gli argomenti della classe ma inseriamo questi argomenti
negli argomenti della funzione init e quindi dobbiamo solo copiarli proprio qui e
incollarli nella classe di rete e poi vai con questa linea di codice.
Creiamo una rete neurale per l'apprendimento del modello perfetto, quindi creiamo un ricordo.
Quindi, di nuovo, creeremo un nuovo Vargo che chiamiamo memoria autodidatta.
E ancora questo sarà un oggetto della classe di memoria di replay.
Quindi prendiamo semplicemente il nome o la classe, copiamo ancora, diciamoci che qui e in alcune parentesi abbiamo bisogno di mettere
la capacità perché la capacità è un argomento della funzione e questo è l'unico argomento di cui
abbiamo bisogno qui.
Quindi, quale capacità sceglieremo, ricorda che corrisponde al numero di transizioni il numero
di eventi dell'ultimo stato che hai dichiarato l'ultima azione e l'ultima parola.
E così come accennato in uno dei prati del Priester, prenderemo in memoria centomila centomila transizioni
e quindi campioneremo da questa memoria per ottenere un piccolo numero di transizioni casuali
e quello su cui il modello andrà bene.
Quindi ora abbiamo la nostra memoria perfetta.
Ora prendiamo il nostro ottimizzatore.
Quindi di nuovo noi creiamo una nuova variabile che chiamiamo ottimizzatore, in modo che l'ottimizzatore sia un'altra variabile del nostro
futuro che deseleziona un oggetto autonomo che ottimizza.
E ora, se torniamo indietro, possiamo vedere che abbiamo importato Upton torturato che è una torcia modulare che contiene tutti gli
strumenti per eseguire la griglia al centro.
e gli abbiamo dato la scorciatoia Upton e quindi qui quello che faremo è prendere il modello
da lui che è la torcia che è lui e da questo modulo prenderemo uno dei ottimizzatori.
Quindi ovviamente contiene alcuni ottimizzatori
Quindi come puoi vedere sono tutti elencati qui.
Molti di questi sono eccellenti, ad esempio l'armatura Propp è un ottimo ottimizzatore.
Ad esempio, è altamente raccomandato per un record di reti neurali o apprendimento profondo non supervisionato.
Ma l'altro che è eccellente e che sceglierà è l'ottimizzatore atom.
Questo è quello che vedrai che con questo si otterrà una buona auto a guida autonoma.
Ma di nuovo sei il benvenuto a provare altri che puoi provare con il prop di armi ma per il
metallo scegliamo Adam.
Quindi sto premendo enter.
E infatti noterai che qui c'è la capitale.
Questo perché stiamo creando un oggetto della classe Atom.
Questa è una classe ma l'oggetto sarà un atom optimizer stesso.
Ma dal momento che questa è una classe, abbiamo bisogno di mettere alcuni argomenti gli argomenti della classe Atom
e gli argomenti sono tutti i parametri che possono personalizzare il tuo e ottimizzatore.
Quindi, ad esempio, in genere è il tasso di apprendimento il decadimento o altri parametri.
E oltre a prendere tutti i parametri di Ormeau, specificheremo un tasso di apprendimento.
Quindi è l'inizio dei parametri del nostro modello.
Possiamo ottenerli con un modello di autodifesa.
Quindi questo è il modello che abbiamo creato qui, un modello autodidatta della nostra stessa classe.
Quindi modello autodidatta e quindi per accedere ai parametri del modello aggiungiamo un altro punto e quindi i
parametri con alcune parentesi molto semplicemente.
Quindi questo è solo per collegare l'addon optimizer alla nostra rete neurale, quella che abbiamo creato qui di nuovo,
quindi come abbiamo appena detto aggiungeremo un tasso di apprendimento e l'argomento per questo è il nostro.
non avviene troppo velocemente se otteniamo una velocità di apprendimento troppo grande di quella che l'IA AI apprenderà correttamente.
E lo imposteremo su un valore tale che l'apprendimento
Vogliamo dare tempo alla nostra intelligenza artificiale per esplorare imparare dai suoi errori.
Sai quando lo puniamo quando commette degli errori come andare in un certo senso o avvicinarsi
troppo al muro.
Bene, vogliamo dare un po 'di tempo per imparare.
Vogliamo un modo per la rete neurale di datare correttamente.
E quindi un buon valore per il tasso di apprendimento con cui ho finito dopo aver provato molti di loro è 0. 2 o uno.
Va bene e questo è tutto ciò di cui abbiamo bisogno per creare un ottimizzatore.
Quindi in pratica stai creando un oggetto della classe Atom.
Grande.
E poi le ultime tre variabili di cui abbiamo bisogno sono le variabili che compongono i nostri eventi di transizione.
Quindi questa è l'ultima data dell'ultima azione e l'ultima parola.
E quindi questo è fondamentalmente ciò che creeremo ora e avremo solo bisogno di inizializzarli.
Quindi iniziamo con l'ultima data dell'ultima data che chiameremo autodidatta.
Ultimo stato di sottolineatura e quindi come inizializzarlo.
che l'ultima data è un vettore di 5 dominazioni di un vettore che è codificato in uno stato dell'ambiente.
Bene, ricorda
E come promemoria queste cinque dimensioni sono i tre segnali dei
tre sensori sinistra e destra, orientamento e direzione negativa.
Quindi questo è un vettore e un senso intuitivo.
Ma per la torcia deve essere più che un vettore.
In realtà deve essere un tensore della torcia.
Ma non solo ha bisogno di essere un sensore di torcia, ma ha anche bisogno di avere una dimensione in
più che mi piace chiamare dimensione falsa che corrisponde al lotto.
E questo perché gli ultimi otto saranno l'input della rete neurale, ma quando si lavora con me quando funziona
in generale se è con un flusso più denso porta una torcia mentre i vettori di input non possono essere
un vettore semplice di per sé.
Deve essere in un lotto.
La rete può accettare solo batch di osservazioni di input e quindi non solo creerà un tensore
per i vettori di stato di input, ma creeremo anche questa dimensione falsa corrispondente al batch.
Quindi, facciamolo e iniziamo inizializzando un tensore della torcia, così per fare questo non c'è niente di
più semplice.
Prendiamo la nostra libreria di torche, quindi puntiamo e poi useremo la classe tensoriale perché, come avrete intuito,
questo creerà un oggetto della classe tensoriale che è un oggetto tensoriale.
E in questo tensore dobbiamo mettere un argomento che specificherà la dimensione del tensore.
Puoi immaginarlo come un array con un solo tipo.
Ma in sostanza ciò che questo rappresenterà ora è naturalmente questo stato di input che puoi vedere ha un vettore e
quindi specificare il numero di elementi che devono avere la distanza.
Bene, dobbiamo ovviamente utilizzare le dimensioni di input perché la dimensione di input è esattamente il numero di dimensioni
dei nostri vettori di stato di input.
Ora dovrei dire tensori.
E quindi ciò di cui abbiamo semplicemente bisogno di inserire nella nostra classe tensoriale per creare un oggetto tensoriale.
Beh, questo è impreciso.
E in seguito le dimensioni dell'input saranno quantificate.
Va bene, va bene.
Questa è la prima cosa che si fa.
Abbiamo appena inizializzato il tensore come dovrebbe essere.
danno che hai mettere nel gruppo sarà la prima volta che parlo di questo diciamo molto bene.
Ma poi ricorda che dobbiamo fare un'altra cosa che dobbiamo creare quella dimensione falsa perché questo è ciò che la rete
si aspetta per i suoi input e creare questo per l'esame che, tra l'altro, deve essere il motore
della prima volta che conosci il
Bene, per fare questo, abbiamo semplicemente bisogno di aggiungere quello e poi stringere e poi in alcune parentesi.
Dobbiamo mettere l'indice di questa grande dimensione.
E come ho appena detto questa dimensione fasulla deve essere la prima animazione dell'ultima data e, poiché indici
e byte e zero avviati, dobbiamo inserire zero in modo che questo nuovo motore di paradigma stia diventando il motore
di prima linea.
Quindi abbiamo un motore per la prima volta corrispondente al lotto e quindi il diamante dovrebbe
rispondere a quel sensore che conterrà i cinque elementi del tuo input, indicando i tre segnali di orientamento
e meno orientamento.
E poi andiamo abbiamo inizializzato correttamente i nostri stati di input.
Perfezionare.
E poi due variabili da percorrere e questo sarà molto più semplice perché la prossima variabile è
l'ultima azione.
Questo è un nuovo Roybal che stiamo creando per Object ultima azione.
E ricorda che nel primo tutorial della sezione ti ho detto che le azioni saranno
o 0 1 o 2 e quindi usando il vettore di rotazione dell'azione convertiremo questi indici di queste azioni negli
angoli della rotazione che ricordo ai nostri 0 20 o meno 20.
Possiamo davvero rinfrescare la nostra memoria con quello.
Beh, è ​​esattamente qui.
Azione alla rotazione se l'azione è zero.
Bene, questo corrisponderà al primo indice di zero se l'azione è 1.
avremo meno 20 gradi che sarà l'angolo di rotazione della nostra macchina quando giocheremo l'azione.
Questo corrisponderà all'indice di uno di questi vettori di 20 gradi e se l'azione è quella
Tutto ok.
E quindi poiché l'azione sarà 0 1 o 2 Bene, l'azione è lì per un
numero semplice.
E quindi molto semplicemente possiamo inizializzarlo a zero.
Non abbiamo bisogno di creare decine o sentire qualcos'altro.
Abbiamo solo bisogno di inizializzarlo con zero.
E infine.
Bene, questa è l'ultima parola.
È l'io che l'ultima parola.
Eccoci.
E ancora la parola è un numero float che ricordo è tra meno 1 e più 1.
Quindi questo è di nuovo il numero.
E per quanto riguarda l'azione.
Inizializzeremo a zero e poi andiamo.
Le congratulazioni sono in esso la funzione è pronta.
Quindi ora siamo pronti per passare alle cose eccitanti.
E in realtà la cosa più importante per l'intelligenza artificiale è decidere quale azione eseguire ogni volta
e ogni tanty. Ed è esattamente quello che faremo nel prossimo tutorial creando il metodo di azione selezionato.
Quindi facciamolo nel prossimo a fatica e fino a quel momento.