WEBVTT

00:00.240 --> 00:06.600
Ciao e benvenuto a questo tutorial Python in Statoil faremo il primo passo verso l'implementazione del

00:06.630 --> 00:08.270
modello di teoria profonda.

00:08.280 --> 00:13.590
Quindi in pratica stiamo per implementare l'intero processo dell'algoritmo di diffusione.

00:13.830 --> 00:16.580
E quindi useremo ciò che abbiamo creato prima.

00:16.590 --> 00:22.460
Questa è l'architettura della rete neurale per riprodurre la memoria per integrarla nell'intero processo

00:22.530 --> 00:24.180
di apprendimento della dequeue.

00:24.180 --> 00:28.320
E questo intero algoritmo di apprendimento si inserirà in una classe.

00:28.380 --> 00:32.340
Questo è l'ultimo che stiamo facendo per implementare l'intelligenza artificiale.

00:32.340 --> 00:35.650
E questa classe conterrà solo funzioni diverse.

00:35.700 --> 00:41.790
Quindi avremo le funzioni in esso che creeranno e inizializzeranno tutte le variabili associate

00:41.790 --> 00:48.450
ai nostri futuri oggetti devianti che rappresenteranno il modello stesso e avranno alcune altre funzioni.

00:48.510 --> 00:52.830
Uno di questi sarà ovviamente quello di selezionare l'azione giusta in ogni momento.

00:52.950 --> 00:59.250
Avremo anche una funzione di funzione di aggiornamento per ottenere questo nucleo e avere un'idea di come sta andando

00:59.250 --> 01:01.030
l'apprendimento se sta andando bene.

01:01.090 --> 01:07.080
Se l'esplorazione sta andando bene e se può passare allo sfruttamento, allora avremo una funzione

01:07.080 --> 01:12.430
sicura per salvare domani, cioè salvare il cervello dell'auto e poi caricare la funzione.

01:12.480 --> 01:14.590
Quindi abbiamo un paio di funzioni da fare.

01:14.640 --> 01:17.440
Faremo una funzione per ciascuno a fatica.

01:17.490 --> 01:22.820
E oggi inizieremo con la funzione di fine come al solito quando stiamo facendo una lezione.

01:23.010 --> 01:30.040
Ma prima non dimentichiamo di introdurre la classe, quindi la chiameremo D.

01:30.200 --> 01:35.970
D E per la tua rete, allora una parentesi chiama.

01:36.030 --> 01:39.440
E poi andiamo con la nostra prima funzione.

01:39.500 --> 01:47.910
Quindi facciamo questo def quindi doppio underscore poi il suo doppio underscore nuovamente e parentesi.

01:48.170 --> 01:53.530
Quindi, come hai capito in questa funzione, introdurremo le variabili associate al nostro oggetto.

01:53.570 --> 01:59.240
Quindi avremo un paio di righe che iniziano da sole e fondamentalmente creeremo e

01:59.300 --> 02:03.530
inizializzeremo tutte le variabili necessarie per implementare la rete D2.

02:03.530 --> 02:09.740
Quindi, ad esempio, creeremo un oggetto o una rete perché, ovviamente, abbiamo bisogno della nostra rete neurale profonda,

02:10.310 --> 02:12.190
quindi avremo bisogno della nostra memoria.

02:12.300 --> 02:14.630
Creeremo un'altra variabile per la memoria.

02:14.740 --> 02:20.430
Quindi avremo un'altra variabile auto-memoria, ma non è tutto ciò che dovremo creare.

02:20.480 --> 02:22.390
Alcune variabili per l'ultima data.

02:22.490 --> 02:24.820
L'ultima azione e l'ultima parola.

02:24.920 --> 02:30.520
Ovviamente conosci le variabili che vedi nell'algoritmo di diffusione.

02:30.920 --> 02:31.830
E poi cos'altro.

02:31.940 --> 02:38.150
Bene, avremo anche bisogno di un ottimizzatore che tu conosca per eseguire la griglia stocastica nel senso

02:38.510 --> 02:42.170
dei pesi dei dati in base a quanto contribuiranno all'errore.

02:42.320 --> 02:48.650
Quando l'intelligenza artificiale sta commettendo un errore, allora penso che quindi sono fondamentalmente le variabili che ora

02:48.650 --> 02:50.230
dobbiamo creare e inizializzare.

02:50.510 --> 02:58.460
Ma in questa funzione di init metteremo un paio di argomenti prima come al solito, che è gli argomenti che si

02:58.460 --> 03:00.190
riferiscono al nostro oggetto.

03:00.200 --> 03:05.210
Quindi poiché sai che creeremo un oggetto della classe di rete.

03:05.390 --> 03:12.740
Bene visto che la classe di rete prende come argomento la dimensione dell'input della funzione init e l'azione Bene, qui

03:12.740 --> 03:13.740
è lo stesso.

03:13.850 --> 03:19.110
Quando creiamo un oggetto della classe di rete, dovremo scegliere un argomento di dimensioni di input

03:19.160 --> 03:20.180
e l'argomento effettivo.

03:20.180 --> 03:22.140
Quindi possiamo semplicemente copiarne alcuni

03:25.660 --> 03:27.520
qui e qui andiamo.

03:27.710 --> 03:30.450
Quindi questi argomenti diventeranno ora.

03:30.560 --> 03:33.160
Inoltre alcuni argomenti non sono durati.

03:33.170 --> 03:39.680
Ogni volta che creiamo alcuni oggetti futuri della classe diversa che alcuni futuri modelli di ruolo dical Bene, avremo bisogno

03:39.680 --> 03:45.010
di specificare la dimensione di input che ricordo sia il numero di dimensioni nei vettori che

03:45.010 --> 03:46.330
includono i tuoi stati.

03:46.370 --> 03:52.940
I tuoi stati di input e un numero di azioni che è il numero di azioni possibili che l'auto può fare.

03:53.150 --> 03:54.000
Quindi ti ricordo.

03:54.110 --> 03:57.830
Questi sono o andare a sinistra andare dritto o andare a destra.

03:58.190 --> 03:59.270
Ok perfetto

03:59.270 --> 04:04.640
Quindi sai che creerai un nuovo oggetto della classe di memoria di replay per creare

04:04.640 --> 04:10.680
l'oggetto di memoria per ottenere la nostra memoria delle transizioni e nelle informazioni abbiamo l'argomento della capacità.

04:10.850 --> 04:16.640
Ma dal momento che lo useremo solo una volta in realtà quando creiamo memoria e non in

04:16.640 --> 04:20.000
seguito, beh, non avremo bisogno di specificare l'argomento della capacità.

04:20.030 --> 04:25.330
Potremmo farlo ma inseriremo direttamente il numero di transizioni che vogliamo che la nostra memoria abbia.

04:26.150 --> 04:32.390
Ma poi abbiamo bisogno di un ultimo argomento che è quello di ottenere il parametro nel modello dell'insegnante.

04:32.480 --> 04:35.470
Ricorda che questo parametro gamma è il ritardo.

04:35.750 --> 04:41.300
parametro dell'equazione e quindi lo metteremo qui perché lo useremo più volte in seguito.

04:41.510 --> 04:42.920
E questo è un

04:43.160 --> 04:44.990
Quindi mettiamolo qui.

04:45.070 --> 04:47.140
Lo chiameremo Gamma.

04:47.150 --> 04:52.610
Quindi per questo è solo il nome dell'argomento e poi andiamo che tutti gli argomenti di cui avrai bisogno per

04:52.610 --> 04:53.740
questo nella sua funzione.

04:53.750 --> 05:00.320
Ciò significa che ogni volta che creiamo il nostro modello di dizionario, ogni volta che creiamo un oggetto

05:00.320 --> 05:01.390
dell'insegnante in classe.

05:01.520 --> 05:08.060
Bene, avremo bisogno di specificare come argomenti la dimensione di input il numero di azioni e il parametro.

05:08.360 --> 05:10.590
E finiremo con i valori reali per loro.

05:11.210 --> 05:13.870
Va bene, ora entriamo nella funzione.

05:14.100 --> 05:14.400
OK.

05:14.410 --> 05:16.480
Quindi ora fondamentalmente sarà facile.

05:16.510 --> 05:21.090
Stiamo per creare e inizializzare tutte le variabili di cui abbiamo bisogno.

05:21.110 --> 05:22.770
E quindi iniziamo con il primo.

05:22.910 --> 05:24.460
Iniziamo con gamma.

05:24.530 --> 05:26.090
In realtà il coefficiente di ritardo.

05:26.330 --> 05:31.850
Quindi, poiché questo è un Voivode che vuole essere collegato al suo oggetto, iniziamo da soli.

05:31.880 --> 05:39.500
Quindi gamma sarà una variabile del nostro insegnante e modello stesso che gamma equivale agli argomenti che verranno inseriti

05:39.530 --> 05:42.930
quando si crea un oggetto della classe detune.

05:42.950 --> 05:46.900
Quindi Janna e eccoci con il secondo argomento.

05:47.040 --> 05:50.560
Il secondo argomento sarà la finestra di ricompensa.

05:50.840 --> 05:52.340
Allora, cos'è questa finestra?

05:52.520 --> 05:57.950
scorrevole della media delle ultime 100 parole che userete solo per valutare l'evoluzione della

05:58.010 --> 06:04.280
performance che sapete avrà il significato della parola in questa guerra Windu che scivolerà nel tempo.

06:04.280 --> 06:06.320
Bene, questa sarà la finestra

06:06.440 --> 06:11.680
E ciò che vogliamo osservare è il significato delle ultime 100 parole che aumentano col tempo.

06:11.930 --> 06:18.610
Inizializziamolo con se stessi che premia la finestra di sottolineatura.

06:18.710 --> 06:24.690
E così da quando questa sarà una finestra scorrevole del significato in evoluzione delle ultime 100 parole.

06:24.860 --> 06:31.710
Bene, lo inizializzeremo come una lista vuota e poi espanderemo per significare che lavoriamo fuori orario.

06:32.860 --> 06:35.320
Va bene allora più eccitante.

06:35.420 --> 06:37.430
Creiamo la nostra rete neurale.

06:37.580 --> 06:43.780
Quindi lo chiameremo Mario autodidatta perché fondamentalmente è il cuore dei modelli.

06:43.790 --> 06:51.890
Lo chiamo modello e questo modello non sarà altro che un soggetto in quella classe e per creare

06:51.890 --> 06:53.270
un tale oggetto.

06:53.300 --> 07:02.630
Prendiamo la nostra rete di classe tra parentesi e qui inseriamo gli argomenti della classe ma inseriamo questi argomenti

07:02.750 --> 07:08.930
negli argomenti della funzione init e quindi dobbiamo solo copiarli proprio qui e

07:08.930 --> 07:15.290
incollarli nella classe di rete e poi vai con questa linea di codice.

07:15.350 --> 07:22.690
Creiamo una rete neurale per l'apprendimento del modello perfetto, quindi creiamo un ricordo.

07:22.880 --> 07:29.930
Quindi, di nuovo, creeremo un nuovo Vargo che chiamiamo memoria autodidatta.

07:29.930 --> 07:34.190
E ancora questo sarà un oggetto della classe di memoria di replay.

07:34.220 --> 07:42.320
Quindi prendiamo semplicemente il nome o la classe, copiamo ancora, diciamoci che qui e in alcune parentesi abbiamo bisogno di mettere

07:42.320 --> 07:48.680
la capacità perché la capacità è un argomento della funzione e questo è l'unico argomento di cui

07:48.680 --> 07:49.880
abbiamo bisogno qui.

07:50.240 --> 07:55.100
Quindi, quale capacità sceglieremo, ricorda che corrisponde al numero di transizioni il numero

07:55.100 --> 07:59.800
di eventi dell'ultimo stato che hai dichiarato l'ultima azione e l'ultima parola.

07:59.830 --> 08:07.550
E così come accennato in uno dei prati del Priester, prenderemo in memoria centomila centomila transizioni

08:07.550 --> 08:14.390
e quindi campioneremo da questa memoria per ottenere un piccolo numero di transizioni casuali

08:14.390 --> 08:18.670
e quello su cui il modello andrà bene.

08:18.720 --> 08:21.210
Quindi ora abbiamo la nostra memoria perfetta.

08:21.210 --> 08:23.180
Ora prendiamo il nostro ottimizzatore.

08:23.430 --> 08:31.800
Quindi di nuovo noi creiamo una nuova variabile che chiamiamo ottimizzatore, in modo che l'ottimizzatore sia un'altra variabile del nostro

08:31.800 --> 08:35.320
futuro che deseleziona un oggetto autonomo che ottimizza.

08:35.520 --> 08:44.130
E ora, se torniamo indietro, possiamo vedere che abbiamo importato Upton torturato che è una torcia modulare che contiene tutti gli

08:44.160 --> 08:47.080
strumenti per eseguire la griglia al centro.

08:47.130 --> 08:54.260
e gli abbiamo dato la scorciatoia Upton e quindi qui quello che faremo è prendere il modello

08:54.270 --> 09:00.900
da lui che è la torcia che è lui e da questo modulo prenderemo uno dei ottimizzatori.

09:00.900 --> 09:03.060
Quindi ovviamente contiene alcuni ottimizzatori

09:03.180 --> 09:05.670
Quindi come puoi vedere sono tutti elencati qui.

09:05.880 --> 09:10.630
Molti di questi sono eccellenti, ad esempio l'armatura Propp è un ottimo ottimizzatore.

09:10.640 --> 09:16.170
Ad esempio, è altamente raccomandato per un record di reti neurali o apprendimento profondo non supervisionato.

09:16.230 --> 09:22.140
Ma l'altro che è eccellente e che sceglierà è l'ottimizzatore atom.

09:22.500 --> 09:26.400
Questo è quello che vedrai che con questo si otterrà una buona auto a guida autonoma.

09:26.580 --> 09:32.000
Ma di nuovo sei il benvenuto a provare altri che puoi provare con il prop di armi ma per il

09:32.000 --> 09:32.810
metallo scegliamo Adam.

09:32.850 --> 09:34.290
Quindi sto premendo enter.

09:34.560 --> 09:37.240
E infatti noterai che qui c'è la capitale.

09:37.260 --> 09:40.430
Questo perché stiamo creando un oggetto della classe Atom.

09:40.430 --> 09:44.990
Questa è una classe ma l'oggetto sarà un atom optimizer stesso.

09:45.060 --> 09:50.970
Ma dal momento che questa è una classe, abbiamo bisogno di mettere alcuni argomenti gli argomenti della classe Atom

09:51.060 --> 09:55.270
e gli argomenti sono tutti i parametri che possono personalizzare il tuo e ottimizzatore.

09:55.380 --> 10:00.330
Quindi, ad esempio, in genere è il tasso di apprendimento il decadimento o altri parametri.

10:00.510 --> 10:05.690
E oltre a prendere tutti i parametri di Ormeau, specificheremo un tasso di apprendimento.

10:05.970 --> 10:08.650
Quindi è l'inizio dei parametri del nostro modello.

10:08.670 --> 10:12.830
Possiamo ottenerli con un modello di autodifesa.

10:12.870 --> 10:17.530
Quindi questo è il modello che abbiamo creato qui, un modello autodidatta della nostra stessa classe.

10:17.580 --> 10:24.780
Quindi modello autodidatta e quindi per accedere ai parametri del modello aggiungiamo un altro punto e quindi i

10:25.500 --> 10:28.170
parametri con alcune parentesi molto semplicemente.

10:28.170 --> 10:35.860
Quindi questo è solo per collegare l'addon optimizer alla nostra rete neurale, quella che abbiamo creato qui di nuovo,

10:35.880 --> 10:42.810
quindi come abbiamo appena detto aggiungeremo un tasso di apprendimento e l'argomento per questo è il nostro.

10:43.170 --> 10:50.540
non avviene troppo velocemente se otteniamo una velocità di apprendimento troppo grande di quella che l'IA AI apprenderà correttamente.

10:50.540 --> 10:53.910
E lo imposteremo su un valore tale che l'apprendimento

10:53.910 --> 10:58.890
Vogliamo dare tempo alla nostra intelligenza artificiale per esplorare imparare dai suoi errori.

10:58.890 --> 11:04.320
Sai quando lo puniamo quando commette degli errori come andare in un certo senso o avvicinarsi

11:04.320 --> 11:05.510
troppo al muro.

11:05.770 --> 11:08.780
Bene, vogliamo dare un po 'di tempo per imparare.

11:08.880 --> 11:12.030
Vogliamo un modo per la rete neurale di datare correttamente.

11:12.180 --> 11:21.010
E quindi un buon valore per il tasso di apprendimento con cui ho finito dopo aver provato molti di loro è 0. 2 o uno.

11:21.210 --> 11:24.540
Va bene e questo è tutto ciò di cui abbiamo bisogno per creare un ottimizzatore.

11:24.720 --> 11:28.320
Quindi in pratica stai creando un oggetto della classe Atom.

11:28.530 --> 11:29.050
Grande.

11:29.070 --> 11:35.980
E poi le ultime tre variabili di cui abbiamo bisogno sono le variabili che compongono i nostri eventi di transizione.

11:36.150 --> 11:40.130
Quindi questa è l'ultima data dell'ultima azione e l'ultima parola.

11:40.170 --> 11:45.280
E quindi questo è fondamentalmente ciò che creeremo ora e avremo solo bisogno di inizializzarli.

11:45.300 --> 11:50.130
Quindi iniziamo con l'ultima data dell'ultima data che chiameremo autodidatta.

11:50.400 --> 11:56.000
Ultimo stato di sottolineatura e quindi come inizializzarlo.

11:56.190 --> 12:03.840
che l'ultima data è un vettore di 5 dominazioni di un vettore che è codificato in uno stato dell'ambiente.

12:03.840 --> 12:04.700
Bene, ricorda

12:04.950 --> 12:10.800
E come promemoria queste cinque dimensioni sono i tre segnali dei

12:10.800 --> 12:15.180
tre sensori sinistra e destra, orientamento e direzione negativa.

12:15.210 --> 12:18.350
Quindi questo è un vettore e un senso intuitivo.

12:18.420 --> 12:21.060
Ma per la torcia deve essere più che un vettore.

12:21.210 --> 12:23.640
In realtà deve essere un tensore della torcia.

12:23.820 --> 12:29.970
Ma non solo ha bisogno di essere un sensore di torcia, ma ha anche bisogno di avere una dimensione in

12:29.970 --> 12:33.510
più che mi piace chiamare dimensione falsa che corrisponde al lotto.

12:33.630 --> 12:39.810
E questo perché gli ultimi otto saranno l'input della rete neurale, ma quando si lavora con me quando funziona

12:39.810 --> 12:46.220
in generale se è con un flusso più denso porta una torcia mentre i vettori di input non possono essere

12:46.290 --> 12:48.040
un vettore semplice di per sé.

12:48.210 --> 12:49.760
Deve essere in un lotto.

12:49.830 --> 12:57.660
La rete può accettare solo batch di osservazioni di input e quindi non solo creerà un tensore

12:57.870 --> 13:05.140
per i vettori di stato di input, ma creeremo anche questa dimensione falsa corrispondente al batch.

13:05.190 --> 13:11.490
Quindi, facciamolo e iniziamo inizializzando un tensore della torcia, così per fare questo non c'è niente di

13:11.490 --> 13:12.340
più semplice.

13:12.510 --> 13:21.810
Prendiamo la nostra libreria di torche, quindi puntiamo e poi useremo la classe tensoriale perché, come avrete intuito,

13:21.810 --> 13:27.950
questo creerà un oggetto della classe tensoriale che è un oggetto tensoriale.

13:28.120 --> 13:34.660
E in questo tensore dobbiamo mettere un argomento che specificherà la dimensione del tensore.

13:34.660 --> 13:38.720
Puoi immaginarlo come un array con un solo tipo.

13:38.890 --> 13:45.430
Ma in sostanza ciò che questo rappresenterà ora è naturalmente questo stato di input che puoi vedere ha un vettore e

13:46.180 --> 13:49.380
quindi specificare il numero di elementi che devono avere la distanza.

13:49.570 --> 13:55.180
Bene, dobbiamo ovviamente utilizzare le dimensioni di input perché la dimensione di input è esattamente il numero di dimensioni

13:55.510 --> 13:57.520
dei nostri vettori di stato di input.

13:57.520 --> 13:59.050
Ora dovrei dire tensori.

13:59.170 --> 14:05.650
E quindi ciò di cui abbiamo semplicemente bisogno di inserire nella nostra classe tensoriale per creare un oggetto tensoriale.

14:06.010 --> 14:07.260
Beh, questo è impreciso.

14:07.540 --> 14:10.230
E in seguito le dimensioni dell'input saranno quantificate.

14:11.350 --> 14:12.430
Va bene, va bene.

14:12.430 --> 14:13.670
Questa è la prima cosa che si fa.

14:13.720 --> 14:17.390
Abbiamo appena inizializzato il tensore come dovrebbe essere.

14:17.530 --> 14:23.080
danno che hai mettere nel gruppo sarà la prima volta che parlo di questo diciamo molto bene.

14:23.080 --> 14:30.070
Ma poi ricorda che dobbiamo fare un'altra cosa che dobbiamo creare quella dimensione falsa perché questo è ciò che la rete

14:30.070 --> 14:35.840
si aspetta per i suoi input e creare questo per l'esame che, tra l'altro, deve essere il motore

14:35.940 --> 14:37.800
della prima volta che conosci il

14:38.230 --> 14:46.050
Bene, per fare questo, abbiamo semplicemente bisogno di aggiungere quello e poi stringere e poi in alcune parentesi.

14:46.050 --> 14:49.580
Dobbiamo mettere l'indice di questa grande dimensione.

14:49.620 --> 14:55.790
E come ho appena detto questa dimensione fasulla deve essere la prima animazione dell'ultima data e, poiché indici

14:55.790 --> 15:02.460
e byte e zero avviati, dobbiamo inserire zero in modo che questo nuovo motore di paradigma stia diventando il motore

15:02.460 --> 15:03.570
di prima linea.

15:03.570 --> 15:09.360
Quindi abbiamo un motore per la prima volta corrispondente al lotto e quindi il diamante dovrebbe

15:09.360 --> 15:15.960
rispondere a quel sensore che conterrà i cinque elementi del tuo input, indicando i tre segnali di orientamento

15:15.990 --> 15:16.910
e meno orientamento.

15:17.370 --> 15:21.960
E poi andiamo abbiamo inizializzato correttamente i nostri stati di input.

15:21.960 --> 15:22.850
Perfezionare.

15:23.310 --> 15:30.840
E poi due variabili da percorrere e questo sarà molto più semplice perché la prossima variabile è

15:31.110 --> 15:31.850
l'ultima azione.

15:32.190 --> 15:36.340
Questo è un nuovo Roybal che stiamo creando per Object ultima azione.

15:36.510 --> 15:43.440
E ricorda che nel primo tutorial della sezione ti ho detto che le azioni saranno

15:43.440 --> 15:52.470
o 0 1 o 2 e quindi usando il vettore di rotazione dell'azione convertiremo questi indici di queste azioni negli

15:52.470 --> 15:58.010
angoli della rotazione che ricordo ai nostri 0 20 o meno 20.

15:58.050 --> 16:00.980
Possiamo davvero rinfrescare la nostra memoria con quello.

16:01.200 --> 16:03.170
Beh, è ​​esattamente qui.

16:03.170 --> 16:06.260
Azione alla rotazione se l'azione è zero.

16:06.390 --> 16:11.650
Bene, questo corrisponderà al primo indice di zero se l'azione è 1.

16:11.700 --> 16:17.310
avremo meno 20 gradi che sarà l'angolo di rotazione della nostra macchina quando giocheremo l'azione.

16:17.310 --> 16:23.490
Questo corrisponderà all'indice di uno di questi vettori di 20 gradi e se l'azione è quella

16:23.510 --> 16:24.200
Tutto ok.

16:24.380 --> 16:31.040
E quindi poiché l'azione sarà 0 1 o 2 Bene, l'azione è lì per un

16:31.040 --> 16:31.740
numero semplice.

16:31.850 --> 16:35.440
E quindi molto semplicemente possiamo inizializzarlo a zero.

16:35.660 --> 16:38.330
Non abbiamo bisogno di creare decine o sentire qualcos'altro.

16:38.360 --> 16:40.880
Abbiamo solo bisogno di inizializzarlo con zero.

16:41.420 --> 16:42.850
E infine.

16:43.010 --> 16:44.460
Bene, questa è l'ultima parola.

16:44.550 --> 16:48.840
È l'io che l'ultima parola.

16:48.860 --> 16:49.940
Eccoci.

16:49.940 --> 16:56.510
E ancora la parola è un numero float che ricordo è tra meno 1 e più 1.

16:56.510 --> 16:57.790
Quindi questo è di nuovo il numero.

16:57.860 --> 16:59.400
E per quanto riguarda l'azione.

16:59.510 --> 17:02.900
Inizializzeremo a zero e poi andiamo.

17:02.900 --> 17:06.330
Le congratulazioni sono in esso la funzione è pronta.

17:06.350 --> 17:08.930
Quindi ora siamo pronti per passare alle cose eccitanti.

17:08.930 --> 17:16.040
E in realtà la cosa più importante per l'intelligenza artificiale è decidere quale azione eseguire ogni volta

17:16.080 --> 17:23.240
e ogni tanty. Ed è esattamente quello che faremo nel prossimo tutorial creando il metodo di azione selezionato.

17:23.510 --> 17:27.310
Quindi facciamolo nel prossimo a fatica e fino a quel momento.