Apprendimento automatico e Reti Neurali - pagina 20

[MetaQuotes]

Mega-R3. Giochi, Minimax, Alpha-Beta

Mega-R3. Giochi, Minimax, Alpha-Beta

Questo video copre vari argomenti relativi alla teoria dei giochi e all'algoritmo minimax, tra cui minimax regolare, aggiunte alfa-beta, potatura alfa-beta, valutazione statica, approfondimento progressivo e riordino dei nodi. L'istruttore fornisce spiegazioni e dimostrazioni di questi concetti utilizzando esempi e chiede al pubblico di partecipare alla determinazione dei valori in diversi nodi in un albero di gioco. Il video si conclude con una discussione sui potenziali difetti nelle funzioni euristiche e consigli per il prossimo quiz.

• 00:00:00 In questa sezione, il docente introduce il concetto di gioco e menziona che l'attenzione si concentrerà sulle diverse componenti dei giochi. Quindi procedono a spiegare il normale algoritmo minimax e come calcolare il valore minimax in un punto particolare di un albero di gioco. Utilizzando un albero di gioco di esempio, il docente guida il pubblico attraverso l'algoritmo e determina il valore minimax in vari nodi. Vengono anche menzionati brevemente il principio di Biancaneve e la clausola del nonno.
  
  
• 00:05:00 In questa sezione del video, il relatore spiega le aggiunte alfa e beta alla formula minimax nella teoria dei giochi. Paragona l'aggiunta di questi numeri alla Guerra Fredda, in cui ciascuna parte ha cercato di trovare il miglior risultato possibile mentre si preparava al peggio. Alpha e beta rappresentano i numeri che forniscono uno scenario sicuro o lo scenario peggiore per ciascuna parte. L'oratore suggerisce che la ricerca alfa-beta è più complicata di minimax e può essere una sfida per alcune persone. Tuttavia, afferma anche che padroneggiare la ricerca alfa-beta può aiutare a comprendere e risolvere i problemi minimax.
  
  
• 00:10:00 In questa sezione, il docente spiega il concetto di alfa e beta come opzioni nucleari per Maximizer e Minimizer, rispettivamente. L'impostazione di alfa come infinito negativo e beta come infinito positivo crea un failsafe che garantisce che sia il Maximizer che il Minimizer guarderanno ogni volta il primo percorso che vedono. Man mano che l'algoritmo procede, il valore di alfa e beta cambia a seconda del potenziale risultato del gioco. Quando beta diventa inferiore a alfa o alfa diventa inferiore a beta, l'algoritmo elimina il ramo, segnalando che uno dei giocatori non vuole più esplorare quel ramo. Il docente osserva inoltre che esistono diversi metodi per disegnare numeri alfa e beta in diversi nodi dell'albero del gioco.
  
  
• 00:15:00 In questa sezione, il relatore spiega il principio di Biancaneve utilizzato nell'algoritmo alfa-beta. Il principio prevede l'ereditarietà dei valori alfa e beta dai nodi padre, ma l'assunzione del valore migliore per se stessi quando si sale a un nodo padre. Sono stati discussi anche i valori predefiniti di alfa e beta, dove l'alfa è infinito negativo e il beta è infinito positivo. L'oratore mostra quindi un esempio di potatura alfa-beta e chiede al pubblico di determinare i valori alfa e beta in ciascun nodo nell'albero di ricerca. Viene inserita una domanda trabocchetto per sottolineare che l'algoritmo alpha-beta può evitare di cercare determinati nodi in base ai valori ereditati dai nodi padre.
  
  
• 00:20:00 In questa sezione, il relatore spiega il principio della potatura alfa-beta, che comporta il taglio di rami di un albero decisionale che probabilmente non porteranno a un risultato migliore. L'oratore fornisce un esempio che coinvolge le opzioni dell'attacco nucleare di un nemico e determina quali scelte potare in base al principio della potatura alfa-beta. Inoltre, l'oratore fornisce un test di sanità mentale per determinare se un ramo può essere potato o meno e la capacità del Maximizer di determinare se saltare un ramo o meno, a differenza del minimizzatore che inizia con l'infinito nel gioco dell'albero decisionale.
  
  
• 00:25:00 In questa sezione del video, l'oratore discute il processo di determinazione dei valori alfa e beta in un algoritmo minimax analizzando i valori in diversi nodi in un albero di gioco. L'oratore spiega che quando si incontra un nodo minimizzatore, il valore beta è impostato su infinito positivo e quando si incontra un nodo massimizzatore, il valore alfa è impostato su infinito negativo. L'oratore utilizza quindi valori specifici in un albero di gioco per dimostrare come funziona l'algoritmo e come i nodi vengono eliminati quando il valore alfa è maggiore o uguale al valore beta. Infine, il relatore discute l'ordine in cui i nodi vengono valutati in un albero di gioco utilizzando l'approfondimento progressivo.
  
  
• 00:30:00 In questa sezione, il relatore spiega il concetto di valutazione statica, che è essenzialmente la funzione responsabile dell'assegnazione di valori numerici ai nodi foglia. Il valutatore statico assegna questi valori alla parte inferiore delle foglie e l'ordine di valutazione si riferisce esclusivamente alle foglie. L'oratore spiega anche il principio di Biancaneve, per cui ogni nodo inizia prendendo il valore dello stesso tipo dal suo nonno (alfa o beta). Il massimizzatore non ha il controllo su quale percorso prendere; è il minimizzatore che seleziona il percorso da seguire. Il concetto di valutazione statica è fondamentale per la tecnica di potatura alfa-beta poiché aiuta a determinare se eliminare o meno un particolare percorso. In sostanza, la valutazione statica contribuisce all'efficienza dell'algoritmo, consentendo la potatura alfa-beta per risparmiare più tempo eliminando alcune valutazioni statiche.
  
  
• 00:35:00 In questa sezione, il relatore spiega il concetto di valutazioni statiche, utilizzate per valutare la posizione della scacchiera in giochi come gli scacchi. La valutazione richiede molto tempo e richiede un'attenta analisi dello stato del gioco. I nodi foglia dell'albero di ricerca sono chiamati statici perché sono ipotesi euristiche del valore basate sull'analisi dello stato del gioco. Il relatore introduce anche il concetto di approfondimento progressivo su un albero profondo solo due livelli e chiede come l'albero possa essere riordinato per consentire ad alfa-beta di potare il più possibile.
  
  
• 00:40:00 In questa sezione, l'istruttore spiega come utilizzare l'algoritmo minimax per ottimizzare il processo di ricerca del nodo migliore riordinando i rami in base al potenziale vincitore, poiché è più facile scartare rapidamente tutti quelli sbagliati quando l'eventuale vincitore viene scelto per primo. L'istruttore illustra questo concetto assegnando un valore binario a ciascun nodo foglia e utilizza i valori per calcolare il vincitore finale per ciascun sottoalbero, trovando così la mossa ottimale. La combinazione di questo approccio con l'approfondimento progressivo ridurrebbe significativamente il numero di nodi che devono essere valutati.
  
  
• 00:45:00 In questa sezione, il docente discute l'approfondimento progressivo e la possibilità di riordinare i nodi per migliorare la potatura alfa-beta. Mentre l'approfondimento progressivo può essere una perdita di tempo per alberi piccoli e non ramificati, è essenziale per alberi più grandi e complessi. Tuttavia, il concetto di riordino dei nodi basato sui risultati di approfondimento progressivo dipende dall'accuratezza della funzione euristica. Il docente sottolinea che nessuna funzione euristica è perfetta e una funzione euristica imperfetta potrebbe portare a risultati peggiori durante il riordino dei nodi. Infine, il docente spiega come è possibile eseguire la memorizzazione nella cache dei valori euristici per funzioni euristiche coerenti, ad esempio nei casi in cui lo stesso valore euristico sarà sempre associato a un particolare stato di gioco, indipendentemente da come è stato raggiunto lo stato.
  
  
• 00:50:00 In questa sezione del video, l'istruttore discute il potenziale svantaggio dell'utilizzo di un'euristica che fornisce sempre la mossa peggiore invece della mossa migliore. Sebbene possa aiutare a ridurre al minimo i rischi, potrebbe anche comportare la peggiore potatura possibile, portando a una mancanza di successo garantito. L'istruttore afferma che il prossimo quiz sarà interessante e comporterà varie sfide. Tuttavia, consiglia agli studenti di non stressarsi troppo e di godersi il fine settimana.

[MetaQuotes]

Mega-R4. Reti neurali

Mega-R4. Reti neurali

Il video copre vari aspetti delle reti neurali, comprese le loro rappresentazioni, confusione su input e output, funzioni sigmoidee e prestazionali, pesi e distorsioni, retropropagazione, modifica delle funzioni sigmoidee e prestazionali, pesi soglia, visualizzazione e potenziale delle reti neurali. L'istruttore spiega varie formule necessarie per il quiz e come calcolare e regolare i delta in modo ricorsivo. Discute anche i tipi di reti neurali necessarie per risolvere problemi semplici e menziona una recente applicazione nel mondo reale delle reti neurali in una competizione di gioco presso l'Università del Maryland. Infine, afferma che mentre le reti neurali sono cadute in disgrazia a causa dei loro limiti e complessità nella ricerca, sono ancora utili per i quiz.

• 00:00:00 In questa sezione, Patrick introduce un nuovo modo di disegnare reti neurali per i problemi in 603. Mostra due diverse rappresentazioni della stessa rete neurale e spiega perché quella a destra è preferibile. Discute anche alcuni problemi che gli studenti incontrano comunemente quando lavorano con le reti neurali, come la confusione su input e output e la moltiplicazione implicita con i pesi. Patrick fornisce una guida alla conversione per gli studenti che lavorano con quiz precedenti e lavora attraverso le formule necessarie per il quiz. Infine, menziona la possibilità che la funzione sigmoidea venga cambiata in una funzione diversa e consiglia agli studenti di cambiarla in un plus se ciò accade.
  
  
• 00:05:00 In questa sezione, l'istruttore spiega la funzione sigmoidea, che è 1 fratto 1 più e alla meno x, e la sua importante proprietà, dove la derivata della sigmoide è essa stessa. Viene discussa anche la funzione di prestazione, che indica alle reti neurali quanto siano sbagliati i loro risultati. Hanno scelto che la loro funzione di preferenza sia 1/2 D, che è l'output desiderato meno l'output effettivo al quadrato, e la ragione di ciò è che la derivata della performance è negativa, rendendo più facile il calcolo. L'istruttore parla quindi della modifica della funzione sigmoidea in un'altra funzione e dell'analisi di ciò che accade alle funzioni di backpropagation, in particolare il nuovo calcolo del peso, che comporta la modifica dei pesi in modo incrementale verso il risultato desiderato.
  
  
• 00:10:00 In questa sezione, il relatore spiega i pesi e i pregiudizi utilizzati nelle reti neurali. I pesi sono rappresentati da nomi come "w1I" e "w2B", dove "I" e "B" sono i nodi della rete. Gli offset di polarizzazione sono sempre associati a -1 e il valore di alfa, che determina la dimensione dei gradini in salita, viene fornito nei quiz. Gli input ai nodi sono rappresentati da "I" e sono moltiplicati per delta, che è la variazione dell'output della rete neurale dovuta a una variazione di un peso specifico. I delta sono calcolati utilizzando derivate parziali per determinare quanto i pesi contribuiscono alla performance della rete.
  
  
• 00:15:00 In questa sezione, il relatore discute il processo di utilizzo delle derivate e della regola della catena per ottenere i pesi finali nell'ultimo livello delle reti neurali. Viene utilizzata la derivata della funzione sigmoidea e devono essere considerati anche i pesi nei livelli precedenti per calcolare i delta per i nuovi pesi. L'oratore propone una soluzione ricorsiva, che prevede la somma di tutti i figli di un dato nodo, che a sua volta influisce sull'output. Questo processo viene eseguito in modo ricorsivo fino a ottenere i delta per i pesi finali.
  
  
• 00:20:00 In questa sezione, l'istruttore spiega come la modifica della funzione sigmoidea e della funzione prestazionale può influire sulle equazioni utilizzate nella rete neurale. Spiega che se la funzione sigmoidea viene modificata, l'unica cosa che cambia è l'equazione Delta F, che viene sostituita dalla nuova derivata della funzione sigmoidea. Allo stesso modo, se la funzione di prestazione viene sostituita, è necessario regolare solo l'equazione Delta F. L'istruttore prosegue poi spiegando la differenza tra pesi soglia e pesi regolari in una rete neurale e come influiscono sulla funzione complessiva della rete.
  
  
• 00:25:00 In questa sezione, il relatore parla di come visualizzare le reti neurali e di come sia importante avere una rappresentazione che abbia senso per te per risolvere efficacemente i problemi. Spiega come funziona un nodo sommatore e che la sua derivata è solo una. Fornisce una formula per Delta F e Delta a e spiega il processo per la Parte B, che prevede il calcolo dell'output per una rete neurale e l'esecuzione di una propagazione all'indietro per trovare i nuovi pesi. Chiede agli studenti di porre domande per chiarire i loro dubbi poiché non potrà chiamare tutti per verificare se stanno seguendo.
  
  
• 00:30:00 In questa sezione, il video discute i nuovi pesi per la rete neurale e quale sarebbe l'output dopo un passaggio di backpropagation. I nuovi pesi sono stati calcolati utilizzando i vecchi pesi, la costante del tasso di apprendimento ei valori delta. Alla fine è stato determinato che l'output fosse 3. Il video solleva quindi la questione di cosa accadrebbe se la rete fosse addestrata ad apprendere i dati forniti e procede a spiegare come le reti neurali possono tracciare linee sui grafici per ciascuno dei nodi nella rete. Tuttavia, va notato che prevedere ciò che attirerà questa rete è un po' complicato.
  
  
• 00:35:00 In questa sezione della trascrizione, l'oratore discute di una rete neurale che si riduce a un solo nodo mentre si somma ogni volta e non prende mai una soglia, rendendola analogica invece che digitale. La forma semplificata della rete neurale contiene nodi rappresentati da cerchi in cui ogni cerchio ha un sigmoide. C'è un problema in cui ABCDEF deve essere abbinato da uno a sei usando ciascuno solo una volta. L'oratore spiega che ogni nodo sigmoideo può tracciare una linea nell'immagine, che può essere diagonale se riceve entrambi gli input o orizzontale/verticale se viene ricevuto un input. I nodi di livello secondario possono eseguire un'operazione logica booleana come e/o sui primi due. L'oratore procede quindi a identificare il problema più semplice, che è il problema 6 e conclude che esiste una mappatura uno a uno di ciascuna rete su un problema, che può risolvere tutti e sei i problemi insieme.
  
  
• 00:40:00 In questa sezione, il relatore discute quanto sia difficile creare una rete X o neurale perché è difficile distinguere tra i due input che devono essere alti in un singolo nodo. Tuttavia, ci sono molte possibilità e l'oratore suggerisce di utilizzare il nodo 3 e il nodo 4 per fornire valori e il nodo 5 per fornire una combinazione di soglia che risulta in uno XOR. L'oratore spiega anche che accoppiare due linee orizzontali come B è impossibile, ma poiché D deve disegnare una linea orizzontale e una linea verticale, devono usare B per creare due linee orizzontali.
  
  
• 00:45:00 In questa sezione, il relatore spiega lo scopo dell'esercizio di disegno per le reti neurali. Disegnando problemi semplici, le persone possono vedere i tipi di reti neurali che potrebbero essere necessarie per risolverli. Questo può aiutare le persone a evitare di progettare reti neurali troppo semplici o troppo complesse per un determinato problema. L'oratore fornisce anche un esempio di una recente applicazione nel mondo reale delle reti neurali in una competizione di gioco presso l'Università del Maryland.
  
  
• 00:50:00 In questa sezione del video, il relatore discute il potenziale delle reti neurali nell'apprendimento di diversi compiti e regole. Descrive un esperimento in cui una rete neurale è stata addestrata per apprendere qualsiasi cosa da una serie di dati casuali e, sebbene i risultati dell'esperimento non fossero chiari, altri partecipanti allo studio hanno tentato di trovare proprietà fondamentali delle regole attraverso test sperimentali. L'oratore prosegue spiegando che le reti neurali sono state utilizzate in molte aree di ricerca, tra cui la scienza cognitiva e l'intelligenza artificiale, tuttavia, sono cadute in disgrazia a causa dei loro limiti e complessità. Nonostante ciò, l'oratore afferma che creano reti semplici ai fini dei quiz, anche se chiarisce che qualsiasi rete neurale utilizzata oggi nella ricerca sarebbe troppo complicata per un quiz.

[MetaQuotes]

Mega-R5. Supporta le macchine vettoriali

Mega-R5. Supporta le macchine vettoriali

Il video spiega le Support Vector Machines (SVM), che determinano la linea di demarcazione o i limiti decisionali nei dati trovando i vettori di supporto che non sono gli stessi di qualsiasi altro punto dati. Include anche l'uso di funzioni del kernel che consentono al kernel di calcolare il prodotto scalare senza manipolare direttamente i vettori. Il professore chiarisce l'obiettivo di trovare gli Alpha che forniscono il miglior W per la strada più ampia e come W sia il confine decisionale per SVM. Gli studenti si informano sull'intuizione alla base di SVM e l'ottimizzazione basata su Alpha crea la strada più ampia per una migliore classificazione dei dati. SVM Kernel aiuta anche a ottimizzare il processo, rendendolo più efficiente.

• 00:00:00 In questa sezione, il relatore introduce le Support Vector Machines (SVM) e afferma che sono una delle cose più difficili da imparare durante il corso. Tuttavia, spiega che ora sono disponibili alcune scorciatoie che possono aiutare a risolvere alcuni problemi senza dover affrontare insiemi di equazioni vasti e complessi. Il problema in questione richiede di circondare i vettori di supporto, disegnare i bordi della strada, illustrare la linea tratteggiata al centro e fornire sia W che B. L'oratore spiega quindi le equazioni importanti nelle SVM e come trovare la linea tratteggiata utilizzando due coefficienti e un'equazione lineare, dove W1 e W2 sono due coefficienti e X1 e X2 sono due componenti del vettore X.
  
  
• 00:05:00 In questa sezione, il video discute l'equazione di una linea in coordinate cartesiane e come si correla all'equazione W punto X più B uguale a 0 nelle macchine vettoriali di supporto. Il video spiega che gli alfa vengono utilizzati per determinare il significato di ciascun punto ai fini della creazione del confine e che gli alfa positivi sono uguali agli alfa negativi. Il video fornisce anche equazioni da utilizzare quando si risolve per W e B e menziona che i vettori di supporto sono importanti per determinare la soluzione. Il presentatore chiarisce che i vettori di supporto sono vettori sulle linee di confine e l'obiettivo è circondarli.
  
  
• 00:10:00 In questa sezione, il relatore affronta la questione di cosa sia un vettore di supporto e chiarisce che in problemi più complessi, dove ci sono numerose dimensioni, i vettori sono usati per rappresentare i punti dati quando non possono essere rappresentati graficamente su due piano dimensionale. Il relatore spiega che i vettori di supporto sono i punti che legano l'iperpiano e si trovano cercando di avere lo spazio più ampio possibile tra i punti dati positivi e negativi. Inoltre, il relatore osserva che a volte il terzo vettore di supporto potrebbe non esistere e illustra il proprio punto con un esempio di una coppia di punti su un piano.
  
  
• 00:15:00 In questa sezione, l'oratore spiega come trovare W e B in una macchina vettoriale di supporto. Invece di utilizzare il vecchio metodo di inserire punti in un'equazione, l'oratore introduce una strategia economica convertendo l'equazione nella forma y = mx + b. Impostando y = x - 1, il relatore mostra come questo può essere utilizzato per trovare una nuova equazione y = -w1/w2 - b/w2. Usando questa forma, l'oratore mostra che ci sono infinite equazioni possibili e che w1/w2 è un multiplo scalare di -1 e B/w2 è un multiplo scalare di 1.
  
  
• 00:20:00 In questa sezione, l'oratore discute come determinare il valore di K per calcolare W1, W2 e B per una macchina vettoriale di supporto. La grandezza di W può essere calcolata utilizzando la radice quadrata della somma dei componenti al quadrato, che è uguale a radice 2 su 4. Poiché il rapporto di W1 e W2 è uguale a meno 1, quando è al quadrato, W1 al quadrato è uguale a W2 al quadrato. Pertanto, utilizzando questa formula, W1 è calcolato come negativo 1/4, e poiché W1 è negativo, W2 e B sono uguali a 1/4 positivo. L'oratore suggerisce anche che i valori alpha plus e alpha minus sono uguali sulla base di un'equazione.
  
  
• 00:25:00 In questa sezione, il relatore continua a lavorare attraverso esempi di Support Vector Machines. L'oratore osserva che nell'esempio numero due è stato aggiunto un segno meno in più. Proseguono spiegando come determinare il vettore di supporto dato questo nuovo segno negativo. Vengono mostrati i calcoli per determinare la distanza e la grandezza di W risulta essere radice 2 su 3. L'oratore nota che gli alfa richiedono più tempo per il calcolo in questo esempio a causa dell'aggiunta di nuovi punti, ma la risposta finale è raggiunta .
  
  
• 00:30:00 In questa sezione, l'attenzione si concentra sull'utilizzo di macchine vettoriali di supporto su un vettore unidimensionale, che rende una linea di base lineare inadatta alla classificazione dei dati. Per risolvere questo problema, viene utilizzata una funzione del kernel per portare i dati in una nuova dimensione. La funzione è tipicamente chiamata Phi e, quando applicata al vettore X, lo porta in questa nuova dimensione. In questa nuova dimensione si può tracciare una linea retta per classificare i dati. L'inventore degli SVM si è reso conto che non è necessario lavorare con la funzione Phi, anche se è un mostro terribile, poiché il kernel può essere utilizzato per calcolare il prodotto scalare tra due vettori nella nuova dimensione senza calcolare esplicitamente Phi.
  
  
• 00:35:00 In questa sezione, il relatore spiega come utilizzare una funzione del kernel per trovare il prodotto scalare di due vettori in uno spazio regolare, eliminando la necessità di utilizzare direttamente i vettori stessi. Inserendo i vettori X e Z nel kernel, la funzione risultante restituirà Phi di X punteggiato da Phi di Z, che sostituisce il prodotto scalare dei due vettori. L'oratore fornisce un esempio di una funzione del kernel e sfida il pubblico a trovare la funzione Phi corrispondente per risolvere il quiz. L'oratore osserva inoltre che, sebbene il calcolo degli alpha per gli SVM possa essere complicato, l'utilizzo della funzione kernel è una scorciatoia utile per eliminare la necessità della manipolazione diretta dei vettori.
  
  
• 00:40:00 In questa sezione, il relatore discute la rappresentazione grafica dei punti in una nuova dimensione utilizzando i loro valori di coseno e seno. Vengono visualizzati i più e i meno, nonché i rispettivi valori di coseno e seno. Ci sono tre punti nel secondo quadrante e tre punti nel terzo quadrante. L'oratore discute quindi la distinzione tra due negativi e come individuare i vettori di supporto, che risultano essere i punti negativo e positivo sulla bisettrice perpendicolare. I due punti negativi sono sulla stessa linea e sono cerchiati invece di trovarsi sui lati opposti della bisettrice.
  
  
• 00:45:00 In questa sezione, il professore spiega l'idea alla base dei vettori di supporto e il loro utilizzo in SVM. Chiarisce che un vettore di supporto non è uguale a qualsiasi altro punto dati e la linea di divisione o i confini creati da SVM sono determinati da questi vettori. Nei dati di test, la linea tratteggiata è il limite decisionale per SVM. L'algoritmo ottimizza gli Alpha controllando matematicamente la combinazione degli Alpha che danno la migliore W per la strada più larga. Gli studenti interrogano l'intuizione dietro SVM e il professore spiega che W è il confine decisionale e l'ottimizzazione basata su Alpha crea la strada più ampia per classificare i dati in un modo migliore. SVM Kerne aiuta anche a ottimizzare il processo di ottimizzazione, rendendolo più semplice ed efficiente.

[MetaQuotes]

Mega-R6. Potenziamento

Mega-R6. Potenziamento

Nel video "Mega-R6. Boosting", il relatore spiega il concetto di potenziamento nell'apprendimento automatico e dimostra il processo di selezione dei classificatori corretti per ridurre al minimo gli errori. Forniscono un esempio di identificazione dei vampiri in base a determinate qualità e discutono su come scegliere i classificatori più efficaci. I classificatori selezionati vengono utilizzati per creare un classificatore finale che viene applicato ai punti dati per determinare quanti sono classificati correttamente. Il relatore sottolinea inoltre che la scelta di quando interrompere il processo è importante e riconosce che il raggiungimento della completa accuratezza potrebbe non essere sempre fattibile.

• 00:00:00 In questa sezione, il relatore discute il concetto di potenziamento nell'apprendimento automatico, che coinvolge una serie di diversi classificatori. Il problema utilizzato come esempio riguarda l'identificazione dei vampiri in base a varie qualità come malvagità, emo, brillantezza e numero di interessi romantici. La chiave per il potenziamento è che per qualsiasi possibile classificatore, purché non sia una suddivisione 50/50 dei dati, può essere utilizzato in qualche modo per creare un classificatore superiore. Inoltre, il relatore osserva che in realtà ci sono più classificatori di quelli elencati, poiché molti di essi hanno versioni opposte che vengono ignorate per questo particolare problema.
  
  
• 00:05:00 In questa sezione, l'oratore spiega come una divisione 50/50 per il potenziamento sia inutile poiché è buona come lanciare una moneta. Tuttavia, in alcuni casi, un classificatore peggiore di 50/50 è comunque migliore di un classificatore 50/50. I round successivi di potenziamento richiedono la modifica dei pesi di ciascun punto dati e il classificatore che esegue il meglio sarà quello che ottiene il peso maggiore. Sebbene i classificatori che ottengono meno della metà del peso giusto di solito vadano bene, l'oratore consiglia di utilizzare i loro inversi per ottenere più della metà del peso giusto.
  
  
• 00:10:00 In questa sezione, l'oratore passa attraverso ogni classificatore e capisce quali punti di dati sono classificati erroneamente. Partendo dal presupposto che tutte le cose malvagie sono vampiri e tutte le cose non malvagie non sono vampiri, determinano di sbagliare angeli, Edward Cullen, Saya Otonashi e Lestat de Lioncourt quando il male è uguale a no. Una logica simile viene applicata ai personaggi emo e ai personaggi in trasformazione. Tuttavia, quando scintillante è uguale a sì, sbagliano uno, due, quattro, cinque, sei, sette e otto, e quando il numero di interessi romantici è maggiore di due, sbagliano Searcy ed Edward Cullen. Quando si tratta di un numero di interessi romantici superiore a quattro, nessun personaggio rientra in quella categoria, quindi nessuno viene classificato erroneamente.
  
  
• 00:15:00 In questa sezione del video, l'oratore discute la classificazione dei vampiri e quali classificatori potrebbero essere errati. L'oratore osserva che ci sono alcuni classificatori positivi che porteranno inevitabilmente a classificatori negativi errati. L'oratore quindi elenca diversi classificatori e afferma che nei loro sogni più sfrenati, le persone ne userebbero solo sei. L'oratore chiede input agli spettatori su quali classificatori ritengono utili e cerchia quelli che si ritiene valga la pena utilizzare. I classificatori considerati utili sono quelli che sbagliano solo alcuni, come i classificatori E e F.
  
  
• 00:20:00 In questa sezione, l'oratore spiega il processo di selezione dei sei punti dati corretti per il potenziamento in Mega-R6. Un punto chiave è che mentre ci sono molti diversi punti dati tra cui scegliere, alcuni sono decisamente migliori di altri. Ad esempio, il punto dati F è sempre peggiore di E, quindi non dovrebbe mai essere scelto. Il relatore osserva inoltre che quando si selezionano i sei punti dati, è importante scegliere quelli che non hanno un sottoinsieme rigoroso delle stesse risposte errate. Il processo di selezione dei sei punti dati richiede un'attenta considerazione del peso di ciascun punto dati per ridurre al minimo l'errore.
  
  
• 00:25:00 In questa sezione del video, il presentatore discute il processo di potenziamento e come selezionare i migliori classificatori per l'attività. Spiega come eliminare eventuali classificatori inutili e come scegliere quelli che riducono al minimo l'errore. Il relatore passa quindi a dimostrare il processo di potenziamento, iniziando con la ponderazione uguale di tutti e dieci i punti dati e selezionando il classificatore E come migliore. L'errore viene quindi calcolato a un quinto e il processo continua da lì.
  
  
• 00:30:00 In questa sezione del video, il presentatore spiega come rendere giuste tutte le decisioni prese da un classificatore. Questo processo comporta la modifica dei pesi di ciascuna decisione in modo che sia 1/2 per quelle corrette e 1/2 per quelle errate. Il relatore delinea un metodo per automatizzare questo processo, che prevede la riscrittura dei pesi in modo da rendere più facile sommarli e scegliere la decisione migliore. In questo esempio, viene scelta la decisione con il minor numero di errori.
  
  
• 00:35:00 In questa sezione, l'oratore discute il processo per determinare il miglior classificatore nel gioco di potenziamento Mega-R6. La trascrizione include calcoli che coinvolgono la somma dei numeri all'interno e all'esterno dei cerchi e il processo di modifica dei numeri nel cerchio per facilitare la determinazione del miglior classificatore. L'oratore afferma che è importante ignorare i round precedenti e considerare solo i pesi attuali quando si determina un classificatore. Il relatore spiega inoltre che i classificatori non possono essere utilizzati due volte di seguito e discute il motivo di questa caratteristica di progettazione. Il miglior classificatore è determinato come A perché ha avuto il minor numero di risposte sbagliate.
  
  
• 00:40:00 In questa sezione della trascrizione, il relatore spiega come calcolare il classificatore finale utilizzando il metodo del boosting. Il classificatore finale è una combinazione dei classificatori ponderati utilizzati per crearlo. L'oratore quindi applica il classificatore finale a dieci punti dati per determinare quanti sono classificati correttamente, utilizzando un semplice voto per determinare l'output. Un punto dati, Edward Cullen di Twilight, non è corretto perché due classificatori su tre non lo hanno classificato come un vampiro.
  
  
• 00:45:00 In questa sezione del video, l'oratore discute vari personaggi come malvagi, emo o un vampiro in base alle loro caratteristiche e interessi amorosi, e l'accuratezza di un algoritmo di potenziamento nel classificarli. La discussione porta a una domanda sull'utilizzo di più classificatori per rendere più rapido il processo di classificazione, che l'oratore spiega è corretto in una certa misura, ma richiede di passare attraverso un numero maggiore di classificatori. Il relatore sottolinea inoltre che il processo di convergenza per ottenere tutto corretto non è sempre facile e potrebbe richiedere la scelta di fermarsi dopo un certo numero di round.

[MetaQuotes]

Mega-R7. Quasi incidenti, Arch Learning

Mega-R7. Quasi incidenti, Arch Learning

Nel video viene introdotto il concetto di near miss learning, che prevede l'apprendimento di diversi tipi di sorgenti luminose e delle loro caratteristiche. L'approccio Arch Learning utilizza sei euristiche per perfezionare un modello, tra cui require link, forbid link, climb-tree, extend set, closed interval e drop link. Il video illustra varie tecniche utilizzate nell'apprendimento automatico, come l'estensione del set, l'arrampicata sull'albero, l'intervallo chiuso e il collegamento di rilascio. I relatori parlano anche di questioni relative alla fragilità e alla vulnerabilità del modello Arch Learning all'ordinamento, che porta a reazioni incoerenti a informazioni contraddittorie. Il video discute anche il concetto di generalizzazione per il Mega-R7 e come differisce dai modelli precedenti. Inoltre, vengono discussi i compromessi tra l'apprendimento irlandese e l'apprendimento reticolare in termini di capacità di esprimere sottoinsiemi di informazioni, nonché l'insegnamento del sistema utilizzando più modelli con diversi dettagli di implementazione.

• 00:00:00 In questa sezione viene introdotto il concetto di albero di apprendimento quasi mancato, che implica l'apprendimento di diversi tipi di sorgenti luminose e delle loro caratteristiche. Il modello di partenza è una lampadina a incandescenza con base piatta e paralume, alimentata dall'elettricità. L'approccio di arch learning prevede l'utilizzo di sei euristiche, tra cui require link, forbid link, climb-tree, extend set, closed interval e drop link. Require link rende necessaria una funzionalità precedentemente irrilevante e Forbid link vieta una funzionalità. Queste euristiche aiutano a perfezionare il modello rendendo necessarie o non necessarie determinate funzionalità e possono aiutare a identificare scenari quasi mancati.
  
  
• 00:05:00 In questa sezione, il relatore discute varie tecniche utilizzate nell'apprendimento automatico, tra cui extend set, climb tree, closed interval e drop link. La tecnica dell'insieme esteso comporta la creazione di un insieme di esempi positivi ma il divieto di alcuni elementi per risparmiare spazio. La tecnica dell'albero di salita si sposta sull'albero per creare un modello più generalizzato, mentre l'intervallo chiuso copre l'intero intervallo per renderlo accettabile. La tecnica drop link consente al sistema di essere parsimonioso eliminando un link se tutti gli elementi sono accettabili. Il relatore passa quindi all'uso di ciascuna tecnica e sottolinea l'importanza della conoscenza nell'apprendimento automatico per rendere il modello più accettabile per nuovi esempi e per accelerare il tempo del quiz.
  
  
• 00:10:00 In questa sezione, il video discute l'idea di un generalizzatore e come può essere esteso a esempi positivi o ingrandito per intervalli ravvicinati. Tuttavia, se c'è un esempio negativo, può complicare il sistema e potrebbe essere necessario adeguare l'implementazione. Il video fornisce quindi un esempio di una lampada e di come il modello può essere adattato utilizzando l'euristica del generalizzatore per generalizzare l'intervallo quando c'è un esempio positivo. Se c'è un esempio negativo, l'implementazione potrebbe dover utilizzare l'approccio drop-link per far funzionare il sistema in modo efficace.
  
  
• 00:15:00 In questa sezione del video, i relatori discutono alcune questioni relative al modello Arch Learning, che è un tipo di modello di apprendimento automatico sviluppato negli anni '60. Descrivono come il sistema sia fragile e particolarmente vulnerabile all'ordinamento, il che significa che l'ordine in cui i dati vengono presentati può avere un forte impatto sulla capacità di apprendimento del sistema. Inoltre, spiegano come il sistema possa essere incoerente e reagire male a informazioni contraddittorie. I relatori spiegano anche un tipo alternativo di apprendimento chiamato apprendimento a reticolo, che memorizza tutti gli esempi che ha visto e li confronta e li contrappone a nuovi esempi, consentendogli di identificare modelli e affinare la sua comprensione di un argomento.
  
  
• 00:20:00 In questa sezione, il video discute il concetto di arch learning, un sistema che intenzionalmente non ricorda le cose per cercare eleganza e semplicità. Questa sezione confronta l'idea con un bambino che non può parlarti di un blocco con cui ha giocato in precedenza poiché non memorizza e ricorda tutto ciò che ha vissuto. Tuttavia, gli umani sono buoni insegnanti e offrono esempi appropriati da cui una macchina può imparare. Il video parla anche di come generalizzare il colpo arrampicandosi sull'albero invece di impostare la misura in modo che sia più parsimoniosa, elegante e semplice. Infine, viene discusso un esempio di lampada fluorescente e l'euristica utilizzata per la generalizzazione è quella di arrampicarsi sull'albero da una base piatta a un supporto di base stesso.
  
  
• 00:25:00 In questa sezione, il relatore discute un nuovo modello per il Mega-R7 e come si differenzia dai precedenti. Esaminano alcuni esempi di quasi incidenti, che sono casi in cui il sistema incontra input simili ma non proprio uguali a quelli che ha visto prima. Il relatore spiega che questi quasi incidenti non richiedono alcuna modifica al modello e che è accettabile lasciarli così come sono. Inoltre, l'oratore pone una domanda sul fatto che un esempio negativo, come il fluorescente, sarebbe considerato un quasi incidente, a cui rispondono che non lo sarebbe perché il sistema è privo di memoria e non sa che il fluorescente era un esempio positivo .
  
  
• 00:30:00 In questa sezione, il relatore discute i compromessi nell'apprendimento irlandese e nell'apprendimento reticolare in termini di capacità di esprimere sottoinsiemi di informazioni. L'apprendimento irlandese, pur essendo privo di memoria, non può esprimere un sottoinsieme come accettabile senza vederne un esempio positivo, il che può portare a perdere una certa espressività. Tuttavia, questo problema viene risolto nell'apprendimento del reticolo, ma presenta una serie di problemi. Il relatore evidenzia anche come insegnare il sistema, come presentare più modelli che soddisfano il requisito di avere un supporto di base mentre si utilizzano diverse lampadine e fonti di elettricità. I dettagli di implementazione devono essere chiesti e chiariti, poiché la scelta di uno piuttosto che dell'altro potrebbe portare a risultati diversi.

[MetaQuotes]

AlphaGo - Il film | Documentario pluripremiato completo

AlphaGo - Il film | Documentario pluripremiato completo

Un documentario sullo sviluppo del programma per computer AlphaGo, progettato per battere i giocatori umani al gioco del Go. Il film segue la vittoria del programma su un giocatore umano campione del mondo in una partita di cinque partite. Alcuni spettatori ritengono che la vittoria di AlphaGo possa annunciare la fine della razza umana così come la conosciamo, poiché le macchine diventano sempre più brave nell'esecuzione di compiti cognitivi.

• 00:00:00 Questo video parla di AlphaGo, un programma per computer che ha battuto un giocatore umano campione del mondo al gioco del Go. Il video descrive il significato della vittoria di AlphaGo e mostra le riprese del computer che gioca contro un giocatore umano. La società dietro AlphaGo, DeepMind, vuole invitare il più forte giocatore di Go del mondo, Demyster Harbis, a visitare i loro uffici a Londra per vedere il progetto in azione. Se sei interessato a partecipare, te ne sarebbero molto grati!
  
  
• 00:05:00 AlphaGo, un programma per computer sviluppato da DeepMind, sconfigge il giocatore professionista di Go Lee Sedol in una partita di cinque partite. Il documentario segue gli sforzi della squadra per sviluppare e allenare il programma e la partita stessa.
  
  
• 00:10:00 AlphaGo, un programma per computer sviluppato da Google, sconfigge il campione europeo di Go Lee Sedol in una partita di cinque partite. Il documentario segue lo sviluppo di AlphaGo e i preparativi per la partita. Nonostante lo scetticismo iniziale, il pubblico è in gran parte impressionato dalle prestazioni di AlphaGo, con alcuni che lo annunciano addirittura come un segno della fine del dominio umano nel campo dell'intelligenza artificiale.
  
  
• 00:15:00 AlphaGo, un programma per computer progettato per battere i campioni umani al gioco del Go, è stato sconfitto pubblicamente da un giocatore umano, Lee Sedol, in una partita tenutasi la scorsa settimana. Il video discute il significato della perdita, nonché gli sforzi in corso del team AlphaGo per migliorare il proprio sistema.
  
  
• 00:20:00 AlphaGo, un programma per computer che si dice sia "il miglior giocatore di Go al mondo", si scontra con un giocatore umano professionista in una partita di cinque partite. Fanway è un consulente del team e aiuta a migliorare la loro strategia.
  
  
• 00:25:00 Domani AlphaGo affronterà il giocatore professionista sudcoreano Lee Sedol in una partita storica. Il documentario segue la squadra mentre si prepara per la partita e discute le loro aspettative.
  
  
• 00:30:00 AlphaGo, un programma per computer che ha sconfitto un campione umano in un gioco da tavolo, è il soggetto di un documentario pluripremiato. Il documentario segue lo sviluppo del programma e il suo incontro di successo contro un avversario umano.
  
  
• 00:35:00 AlphaGo, un programma per computer sviluppato da Google, sconfigge un giocatore umano campione del mondo in una partita di cinque partite. Il successo del programma è una sorpresa per molti, così come la sua capacità di imparare dalla sua esperienza.
  
  
• 00:40:00 AlphaGo, un programma per computer sviluppato da DeepMind, ha sconfitto un giocatore professionista di Go in una partita di cinque partite. Il programma per computer è stato sviluppato dall'uomo ed è considerato una svolta nell'intelligenza artificiale, nella ricerca.
  
  
• 00:45:00 AlphaGo, un programma per computer progettato per sconfiggere un giocatore professionista umano in una partita di Go, ha sbalordito gli osservatori con la sua performance nella seconda partita della Google DeepMind Challenge. La rete politica, la rete del valore e la ricerca sull'albero dell'IA sono state tutte molto efficaci nel prevedere la mossa migliore per la situazione di gioco a portata di mano, portando alla vittoria di AlphaGo.
  
  
• 00:50:00 AlphaGo, un programma per computer sviluppato da Google, ha vinto una partita di campionato contro un giocatore umano di fama mondiale. Il documentario esamina la partita e il significato della vittoria di AlphaGo.
  
  
• 00:55:00 AlphaGo ha vinto due partite su tre contro un giocatore umano campione del mondo, ma la tristezza e il senso di smarrimento tra il pubblico è palpabile. AlphaGo è solo un programma per computer, ma i commentatori si riferiscono ad esso come se fosse un essere cosciente e si preoccupano delle implicazioni del suo potere crescente.

[MetaQuotes]

Deepmind AlphaZero - Padroneggiare i giochi senza conoscenza umana

Deepmind AlphaZero - Padroneggiare i giochi senza conoscenza umana

Il video esplora lo sviluppo dell'architettura di apprendimento per rinforzo profondo di DeepMind, AlphaZero, che utilizza una politica unificata e una rete di valore per avere successo in giochi con enormi spazi di stato senza alcun dato umano precedente. L'algoritmo di AlphaZero prevede l'addestramento di una rete neurale per prevedere l'azione scelta da un'intera ricerca sull'albero di Monte Carlo, distillando in modo iterativo la conoscenza per generare giocatori più forti nel tempo. L'algoritmo ha mostrato curve di apprendimento impressionanti, superando le versioni precedenti in poche ore di addestramento e mostrando una notevole scalabilità nonostante la valutazione di meno posizioni rispetto ai precedenti motori di ricerca. Il video discute anche della capacità di AlphaZero di combinare il meglio degli approcci umani e delle macchine, mostrando il potenziale per l'apprendimento per rinforzo generico.

• 00:00:00 In questa sezione del video, David parla di AlphaGo, la versione originale dell'architettura di apprendimento per rinforzo profondo di DeepMind che è stata in grado di sconfiggere un giocatore professionista umano e campione del mondo. AlphaGo utilizza due reti neurali convoluzionali: una rete di criteri, che consiglia le mosse da giocare in base a una distribuzione di probabilità, e una rete di valori, che prevede il vincitore del gioco. Le reti vengono addestrate attraverso l'apprendimento supervisionato e l'apprendimento per rinforzo su un set di dati umano e giochi giocati contro se stessi. Il successo di AlphaGo nel gioco del Go dimostra il potenziale degli approcci basati sull'apprendimento automatico e sull'intelligenza artificiale per avere successo nei giochi con enormi spazi di stato.
  
  
• 00:05:00 In questa sezione, il relatore discute la pipeline di formazione di AlphaGo e come utilizza la rete politica e la rete di valore per rendere la ricerca più trattabile data la vastità del bacino di ricerca nel gioco di Go. La policy network suggerisce mosse per ridurre l'ampiezza dell'albero di ricerca, mentre la value network prevede il vincitore del gioco da qualsiasi posizione per ridurre la profondità della ricerca. Ciò consente all'algoritmo di cercare in modo efficiente attraverso parti importanti dell'albero utilizzando la ricerca dell'albero Monte Carlo, che espande efficacemente un grande albero di ricerca in modo selettivo considerando solo le parti più rilevanti. Ciò ha portato allo sviluppo di AlphaGo Master, che è stato addestrato con reti più profonde e più iterazioni di apprendimento per rinforzo, vincendo 60 partite a zero contro i migliori giocatori umani del mondo.
  
  
• 00:10:00 In questa sezione, il relatore descrive lo sviluppo di AlphaGo Zero, che impara a giocare al gioco del Go senza alcun dato umano precedente, partendo invece da giochi completamente casuali e utilizzando solo le regole del gioco. AlphaGo Zero differisce dall'originale AlphaGo in quanto non utilizza funzionalità artigianali, unifica la rete di policy e la rete di valore, utilizza una ricerca più semplice senza implementazioni Monte Carlo casuali e ha un approccio più semplice per ridurre la complessità, che porta a una maggiore generalità, potenzialmente applicabile in qualsiasi dominio. L'algoritmo per AlphaGo Zero prevede l'esecuzione di una ricerca sull'albero Monte Carlo utilizzando la rete neurale corrente per ogni posizione e l'esecuzione della mossa suggerita, quindi l'addestramento di una nuova rete neurale dalle posizioni raggiunte nel gioco completato.
  
  
• 00:15:00 In questa sezione, il relatore spiega il processo dell'algoritmo AlphaGo Zero, che prevede l'addestramento di una rete neurale per prevedere direttamente l'azione che è stata scelta da un intero Monte Carlo Tree Search (MCTS) per distillare tutta la conoscenza nel suo comportamento diretto e addestrando una nuova rete di valori per prevedere il vincitore del gioco. La procedura viene ripetuta per generare ogni volta un giocatore più forte e generare dati di qualità superiore, portando a un gioco sempre più forte. AlphaGo Zero utilizza il miglioramento delle policy basato sulla ricerca incorporando la ricerca nella valutazione delle policy, che consente risultati di alta qualità e segnali di addestramento precisi per le reti neurali. La curva di apprendimento mostra che AlphaGo Zero ha superato le versioni precedenti in sole 72 ore e ha sconfitto i giocatori umani di 60 dopo 21 giorni.
  
  
• 00:20:00 In questa sezione, il relatore discute le varie versioni di AlphaGo che sono state sviluppate, a partire dalla versione originale che ha sconfitto il campione europeo per cinque partite a zero fino all'AlphaGo Zero, che è stato addestrato completamente con pesi casuali ed è stato circa 5.000 Elo, rendendola la versione più potente di AlphaGo. La nuova versione, AlphaZero, applica lo stesso algoritmo a tre diversi giochi: scacchi, shogi e go. Il gioco degli scacchi, in particolare, è stato un dominio altamente studiato nell'IA, con gli scacchi per computer che sono il dominio più studiato nella storia dell'intelligenza artificiale, culminando in sistemi altamente specializzati che attualmente sono indiscutibilmente migliori degli umani.
  
  
• 00:25:00 In questa sezione, l'oratore discute la complessità del gioco dello Shogi, che è più difficile da calcolare e ha uno spazio d'azione più ampio e interessante rispetto agli scacchi. Spiega che i più potenti programmi per computer per lo Shogi hanno raggiunto solo di recente il livello di campione del mondo umano, rendendolo un caso di studio interessante da perseguire per DeepMind. I motori all'avanguardia sia per gli scacchi che per lo shogi si basano sulla ricerca alfa-beta, che è stata potenziata da una funzione di valutazione artigianale messa a punto da grandi maestri umani nel corso di molti anni, nonché da un numero enorme di strumenti altamente ottimizzati estensioni di ricerca. L'oratore confronta quindi i componenti del miglior programma di scacchi Stockfish con AlphaZero, che letteralmente non ha nessuno degli stessi componenti, sostituendoli con idee di principio basate sul gioco personale, l'apprendimento per rinforzo e la ricerca Monte Carlo. L'oratore osserva che gli scacchi sono diversi da Go in quanto hanno una perfetta invarianza traslazionale, mancano di simmetria, hanno uno spazio di azione più interessante con azioni composte e contengono pareggi.
  
  
• 00:30:00 In questa sezione, il relatore discute le curve di apprendimento per i tre giochi: scacchi, shogi e go. AlphaZero ha superato il campione del mondo Stockfish nel gioco degli scacchi in sole quattro ore di allenamento da zero, utilizzando la stessa architettura di rete e le stesse impostazioni per tutti i giochi. AlphaZero ha sconfitto con facilità le versioni precedenti di AlphaGo Zero e l'attuale campione del mondo di Shogi dopo solo poche centinaia di migliaia di passi o 8 ore di allenamento. La scalabilità della ricerca sull'albero Monte Carlo di AlphaZero è stata confrontata con i motori di ricerca alfa-beta utilizzati nei programmi precedenti, incluso Stockfish, che valuta circa 70 milioni di posizioni al secondo, mentre AlphaZero valuta solo circa 80mila posizioni al secondo. Il relatore teorizza che il motivo per cui MCTS è così efficace, nonostante valuti ordini di grandezza in meno posizioni, quando combinato con approssimatori di funzioni profonde come le reti neurali è che aiuta a cancellare gli errori di approssimazione presenti nella ricerca, con conseguente miglioramento delle prestazioni e scalabilità. Infine, AlphaZero ha anche scoperto da sé la conoscenza degli scacchi umani individuando le 12 aperture umane più comuni nel gioco degli scacchi.
  
  
• 00:35:00 In questa sezione, il relatore discute l'uso di specifiche aperture di scacchi da parte di AlphaZero e come le ha giocate durante l'auto-gioco. AlphaZero ha trascorso una notevole quantità di tempo a suonare queste variazioni, ma alla fine ha iniziato a preferire aperture diverse, scartando alcune che venivano suonate più spesso. Il relatore menziona anche i progressi compiuti nell'utilizzo dei metodi di AlphaZero per l'apprendimento per rinforzo profondo per scopi generali, che può essere trasferito ad altri domini. Più un algoritmo è specializzato, meno può adattarsi ad altri domini. Mentre l'uso di uomo e macchina insieme è una prospettiva interessante, l'oratore sottolinea che AlphaZero gioca in modo più umano rispetto ai precedenti programmi di scacchi, indicando la sua capacità di combinare il meglio di entrambi i mondi.
  
  
• 00:40:00 In questa sezione, il relatore spiega che, sebbene in AlphaGo Zero abbiano incorporato solo le regole del gioco come conoscenza umana, ciò include la codifica e la decodifica di base delle azioni. Ad esempio, negli scacchi, usavano la rappresentazione spaziale per codificare il pezzo che veniva raccolto e il piano che veniva usato per posarlo. Escludono le mosse illegali dallo spazio azione. L'oratore spiega inoltre che non hanno incluso barre di errore nei loro esperimenti perché hanno condotto solo una corsa per partita. Tuttavia, hanno eseguito più esperimenti ei risultati sono molto riproducibili.

[MetaQuotes]

AlphaGo - Come l'IA ha dominato il gioco da tavolo più difficile della storia

AlphaGo - Come l'IA ha dominato il gioco da tavolo più difficile della storia

Il video esplora i dettagli tecnici di AlphaGo Zero, un sistema di intelligenza artificiale che è stato addestrato interamente attraverso l'auto-gioco e senza l'utilizzo di set di dati umani. Il sistema utilizzava un'architettura di rete residua e un approccio a due ricerche per prevedere il valore e le mosse forti. Il video evidenzia i miglioramenti apportati, inclusa la capacità di prevedere i risultati del gioco e la scoperta e l'allontanamento del sistema dalle mosse note in Go. Tuttavia, l'applicazione nel mondo reale del sistema è limitata dalla necessità di un simulatore perfetto, rendendo difficile l'applicazione dell'approccio ad altri campi.

• 00:00:00 In questa sezione vengono discussi i dettagli tecnici dei miglioramenti di AlphaGo Zero rispetto alle versioni precedenti. Il primo grande cambiamento è stato che AlphaGo Zero si allena interamente dal gioco autonomo e non utilizza set di dati di giocatori professionisti di Go umani. Inoltre, non utilizza nessuna delle funzionalità precedentemente create a mano per il gioco e impara invece interamente osservando lo stato del tabellone. L'architettura di rete è stata modificata in un'architettura completamente residua e, invece di avere una politica e una rete di valutazione separate, ora sono combinate in un'unica grande rete che fa entrambe le cose. Le implementazioni di Montecarlo sono state sostituite con un approccio più semplice basato su due ricerche che utilizza la singola rete per fare previsioni di valore e trovare mosse forti. Complessivamente, ciò ha portato a una rappresentazione del tabellone di 19 per 19 per 16 numeri binari, una rete residua e una rappresentazione del valore e un vettore di politica generati dal vettore delle caratteristiche.
  
  
• 00:05:00 In questa sezione, il video spiega come AlphaGo è stato addestrato a giocare buone mosse utilizzando un'architettura di rete che porta ad alte probabilità di buone mosse e basse probabilità di cattive mosse. La prima versione di AlphaGo è stata addestrata utilizzando l'apprendimento supervisionato su un set di dati di mosse Go professionali, seguito da una fase di perfezionamento utilizzando l'auto-gioco. Tuttavia, la nuova versione, AlphaGo Zero, non utilizza alcun set di dati e apprende interamente attraverso l'auto-gioco utilizzando una ricerca sull'albero Monte Carlo che stabilizza il processo di allenamento con il peso proprio. Esplodendo l'albero di ricerca e utilizzando la ricerca sull'albero Monte Carlo, il sistema può stimare quali mosse sono forti e quali no. Infine, il video evidenzia che il processo è specifico per giochi come Go, in cui si dispone di un simulatore perfetto, che rende impegnative le applicazioni del mondo reale di questo approccio.
  
  
• 00:10:00 In questa sezione, il relatore discute vari grafici che illustrano i miglioramenti apportati all'architettura di rete di AlphaGo. Un grafico mostra la capacità della rete AlphaGo Zero di prevedere l'esito di una partita in base all'attuale posizione sul tabellone, con un miglioramento significativo rispetto alle versioni precedenti. Il relatore osserva inoltre che il passaggio da una normale architettura convoluzionale a una rete residua ha comportato un notevole miglioramento. Inoltre, un grafico mostra come AlphaGo Zero ha scoperto e poi è passato da mosse ben note nel gioco del Go. Nel complesso, l'oratore è impressionato dai risultati del team di Google DeepMind e incoraggia gli spettatori a porre domande nella sezione dei commenti.

[MetaQuotes]

AlphaZero from Scratch – Tutorial sull'apprendimento automatico

AlphaZero from Scratch – Tutorial sull'apprendimento automatico

00:00:00 - 01:00:00 Il video "AlphaZero from Scratch – Machine Learning Tutorial" insegna agli utenti come costruire e addestrare l'algoritmo AlphaZero utilizzando Python e PyTorch per giocare a complessi giochi da tavolo a livelli sovrumani, con esempi forniti per Tic -tac-toe e Connect 4. Uno dei componenti chiave dell'algoritmo è la ricerca dell'albero Monte Carlo, che prevede la selezione dell'azione più promettente, l'espansione dell'albero e la simulazione del gioco, con i risultati retropropagati per l'allenamento. Il tutorial dimostra l'espansione dei nodi durante l'algoritmo di ricerca Monte Carlo, il processo di self-play e come addestrare il modello utilizzando funzioni di perdita che riducono al minimo la differenza tra la politica e la distribuzione MCTS, il valore e la ricompensa finale. Il video termina creando un gioco Tic-tac-toe e testandolo attraverso un ciclo while.

01:00:00 - 02:00:00 In questa sezione del tutorial sulla creazione di AlphaZero da zero, l'istruttore dimostra l'implementazione dell'algoritmo Monte Carlo Tree Search (MCTS) per il gioco Tic-tac-toe. L'algoritmo è implementato attraverso una nuova classe per MCTS che include un metodo di ricerca che definisce un ciclo di iterazioni ripetute per le fasi di selezione, espansione, simulazione e backpropagation. Il video copre anche l'implementazione dell'architettura della rete neurale AlphaZero, che include due teste, una per la politica e una per il valore, e utilizza una rete residua con connessioni skip. Il policy head utilizza una funzione softmax per indicare l'azione più promettente, mentre il value head fornisce una stima di quanto sia buono lo stato attuale. Il relatore discute anche l'implementazione del blocco iniziale e della spina dorsale per la classe ResNet e spiega come utilizzare il modello AlphaZero per ottenere una politica e un valore per un dato stato in Tic-Tac-Toe.

02:00:00 - 03:00:00 Il tutorial "AlphaZero from Scratch" dimostra la costruzione dell'algoritmo AlphaZero attraverso l'apprendimento automatico. Il presentatore copre un'ampia gamma di argomenti, dall'aggiornamento dell'algoritmo MCTS, all'auto-gioco e ai metodi di addestramento, a miglioramenti come l'aggiunta di temperatura alla distribuzione di probabilità, il decadimento del peso e il supporto della GPU nel modello e l'aggiunta di rumore al nodo principale. Il tutorial accompagna lo spettatore passo dopo passo attraverso l'implementazione di queste funzionalità, mostrando come codificare lo stato del nodo, ottenere policy e output di valore e modificare la policy utilizzando softmax, mosse valide e rumore casuale Dirichlet per aggiungere esplorazione garantendo al contempo le azioni promettenti non sono mancate.

03:00:00 - 04:05:00 In questo tutorial di YouTube sulla creazione di AlphaZero da zero utilizzando l'apprendimento automatico, l'istruttore copre vari argomenti come l'aggiunta dell'esplorazione alla politica con un fattore di rumore, incorporando il supporto di CPU e GPU per l'addestramento di modelli su giochi più complessi, aggiornamento del codice sorgente per creare un gioco Connect Four, aumento dell'efficienza dell'implementazione AlphaZero attraverso la parallelizzazione, creazione di due nuove classi in Python per giochi self-play, codifica degli stati per aumentare l'efficienza, implementazione dell'algoritmo Monte Carlo Tree Search per AlphaZero e addestrare un modello per Connect Four utilizzando fs0 parallelizzato. Il tutorial fornisce indicazioni dettagliate su ciascun argomento con particolare attenzione alla creazione di un'implementazione efficiente ed efficace di AlphaZero. Il presentatore dimostra come creare un ambiente Connect Four utilizzando il pacchetto di ambienti Kegel, quindi esegue e visualizza il gioco con due agenti che utilizzano l'algoritmo di ricerca MCTS basato su un modello AlphaZero addestrato. Il presentatore apporta anche piccole correzioni al codice e definisce il giocatore uno come l'agente che utilizza l'algoritmo MCTS per le previsioni basate sul modello addestrato. Il tutorial si conclude con il presentatore che fornisce un repository GitHub con notebook jupyter per ogni checkpoint e una cartella pesi con l'ultimo modello per Tic-tac-toe e Connect Four, esprimendo interesse a realizzare un video di follow-up su Mu Zero se ce n'è uno interesse in esso.

Parte 1

• 00:00:00 In questa sezione, il tutorial introduce il concetto di AlphaZero, un algoritmo AI che utilizza tecniche di apprendimento automatico per imparare a giocare a complessi giochi da tavolo a livelli sovrumani. L'algoritmo è stato inizialmente sviluppato da DeepMind e può ottenere risultati impressionanti in giochi come Go e persino inventare nuovi algoritmi in matematica. Il tutorial insegnerà agli utenti come costruire AlphaZero da zero usando Python e PyTorch e addestrarlo e valutarlo su giochi come Tic-tac-toe e Connect 4. L'algoritmo ha due componenti, self-play e training, e utilizza una rete neurale per produrre una politica e un valore in base allo stato di input. Ripetendo questo ciclo, l'algoritmo può ottimizzarsi per giocare meglio degli umani.
  
  
• 00:05:00 In questa sezione, il video spiega la ricerca dell'albero di Monte Carlo, un algoritmo di ricerca utilizzato per il self-play e l'algoritmo generale. Prende uno stato, in questo caso una posizione di blocco, e trova l'azione più promettente costruendo un albero nel futuro. Ogni nodo memorizza uno stato e un conteggio totale delle vincite ottenute giocando in quella direzione nel futuro, nonché il conteggio totale delle visite. Il rapporto vincente dei figli di ciascun nodo viene utilizzato per determinare l'azione più promettente e questa informazione può essere utilizzata in un gioco reale come il tris. I dati per i nodi vengono generati camminando lungo l'albero nella fase di selezione fino a raggiungere un nodo foglia che può essere ulteriormente espanso.
  
  
• 00:10:00 In questa sezione, il relatore discute le diverse fasi coinvolte nel Monte Carlo Tree Search (MCTS) per il gioco. La fase di selezione prevede la scelta di un nodo figlio che abbia una formula UCB più alta e che sia stato visitato relativamente poche volte. La fase di espansione prevede la creazione di un nuovo nodo e l'aggiunta all'albero, mentre la fase di simulazione prevede il gioco in modo casuale fino al raggiungimento di un nodo terminale. Nella fase di backpropagation, i risultati ottenuti dalla fase di simulazione vengono propagati all'indietro sull'albero, aggiornando il conteggio delle vincite e delle visite per ciascun nodo.
  
  
• 00:15:00 In questa sezione del video, l'istruttore passa attraverso un esempio del processo Monte Carlo Tree Search (MCTS), a partire dalla fase di selezione in cui l'algoritmo percorre l'albero per scegliere il nodo successivo. Quindi procedono alla fase di espansione in cui viene creato un nuovo nodo, seguita dalla fase di simulazione in cui vengono intraprese azioni casuali per raggiungere un nodo terminale. L'algoritmo controlla quindi se la partita è stata vinta, persa o se una regola è stata violata. Poiché il gioco è stato vinto, viene eseguita la propagazione all'indietro, aggiornando il conteggio delle vincite e delle visite per i nodi attraversati durante il processo MCTS. Il processo viene reiterato con una nuova fase di selezione, e fase di espansione, con un nuovo nodo creato e la fase di simulazione eseguita ancora una volta.
  
  
• 00:20:00 In questa sezione, il tutorial passa attraverso il processo di simulazione e propagazione all'indietro nell'algoritmo MCTS utilizzando AlphaZero. L'esempio presentato in questo tutorial mostra una perdita durante la fase di simulazione. Durante la propagazione all'indietro, viene aumentato solo il conteggio delle visite e il numero totale di vittorie rimane lo stesso poiché l'IA ha perso la partita durante la simulazione. Il tutorial passa quindi a spiegare i processi di selezione ed espansione di MCTS utilizzando AlphaZero. Il tutorial mostra come calcolare il punteggio UCB per ogni bambino e come selezionare il bambino con il punteggio più alto. Il processo si ripete quindi con l'AI che calcola la formula UCB per ciascun nodo fino a raggiungere un nodo foglia, dove avviene l'espansione.
  
  
• 00:25:00 In questa sezione del tutorial, l'attenzione è rivolta a come cambia la tecnica di ricerca Monte Carlo quando viene adattata all'algoritmo General AlphaZero. Ci sono due modifiche critiche che vengono apportate all'algoritmo. In primo luogo, la polizza ottenuta dal modello viene incorporata nella fase di selezione aggiornando la formula UCB con le informazioni sulla polizza. In secondo luogo, viene eliminata la fase di simulazione e il valore ottenuto dalla rete neurale viene utilizzato per la retropropagazione, insieme alla politica per la fase di selezione. Con questi cambiamenti, la tecnica di ricerca Monte Carlo può migliorare significativamente quando c'è un modello che capisce come giocare.
  
  
• 00:30:00 In questa sezione del video "AlphaZero from Scratch – Machine Learning Tutorial", il presentatore apporta una piccola modifica per espandere le direzioni possibili durante la fase di espansione, quindi è possibile creare tutti i possibili nodi anziché solo uno nuovo nodo. Quindi passano attraverso le iterazioni su una lavagna per mostrare come viene adattata la ricerca multicolore. Durante la fase di espansione, vengono creati nuovi nodi chiamando la rete neurale per ottenere policy e valore e aggiungendo ai nodi il numero di vittorie, il conteggio delle visite e le informazioni sulla policy. Quindi, nella fase di backpropagation, il valore viene propagato all'indietro. Il presentatore menziona la formula UCB e osserva che la probabilità di vincita non può essere calcolata per i nodi con un conteggio delle visite pari a zero, che deve essere affrontato per evitare un errore di divisione per zero.
  
  
• 00:35:00 In questa sezione del tutorial, il relatore spiega il processo di espansione dei nodi durante l'algoritmo di ricerca Monte Carlo. L'algoritmo viene utilizzato per determinare la mossa migliore per un dato stato in un gioco. L'oratore illustra un esempio di come i nodi vengono espansi e di come vengono calcolati la politica e il valore per ciascun nodo figlio. Viene anche spiegato il processo di retropropagazione del valore del nuovo nodo figlio al nodo radice. Il tutorial procede quindi a spiegare il processo di self-play, in cui un algoritmo gioca contro se stesso, iniziando con uno stato vuoto e utilizzando la ricerca Monte Carlo per determinare la mossa migliore in base alla distribuzione del numero di visite dei bambini di il nodo radice.
  
  
• 00:40:00 In questa sezione, vediamo come addestrare il modello utilizzando Monte Carlo Tree Search (MCTS). L'obiettivo è memorizzare tutte le informazioni ottenute durante il gioco, inclusa la distribuzione MCTS e la ricompensa per ogni stato. La ricompensa dipende dall'esito finale del gioco per il giocatore in quello stato. Una volta raccolti i dati, li utilizziamo per addestrare il modello utilizzando una funzione di perdita che minimizza la differenza tra la politica e la distribuzione MCTS e il valore V e la ricompensa finale Z. Lo facciamo utilizzando la backpropagation per aggiornare i pesi del modello Teta. Nel complesso, questo processo aiuta il modello a comprendere meglio come giocare e a ottimizzarsi.
  
  
• 00:45:00 In questa sezione, il tutorial video sulla creazione di AlphaZero da zero utilizzando l'apprendimento automatico inizia creando un Jupyter Notebook e costruendo un semplice gioco di tris con un conteggio di righe e colonne, nonché una dimensione dell'azione . Il tutorial scrive quindi i metodi per ottenere lo stato iniziale, lo stato successivo dopo che è stata intrapresa un'azione e le mosse legali. L'input dell'azione è codificato in un formato riga e colonna da utilizzare in un array NumPy. Il codice è scritto per essere flessibile per risolvere diversi ambienti o giochi da tavolo, con piani per espandersi a Connect Four.
  
  
• 00:50:00 In questa sezione, lo YouTuber sta scrivendo un metodo che controllerà se un giocatore ha vinto o meno dopo la sua mossa. Iniziano ottenendo la riga e la colonna della mossa e quindi determinando il giocatore che ha effettuato quella mossa. Quindi, controllano tutti i modi possibili per vincere il gioco del tris, che sono tre di fila, tre di colonna e due diagonali, utilizzando i metodi np.sum e np.diac. Inoltre, controllano il pareggio calcolando la somma delle mosse valide e controllando se è zero. Infine, creano un nuovo metodo chiamato get value e lo terminano che restituisce il valore e true se il gioco è terminato.
  
  
• 00:55:00 In questa sezione, l'autore scrive un gioco Tic-tac-toe e un metodo avversario per cambiare giocatore. Testano il gioco eseguendolo e usano un ciclo while. Nel ciclo, vengono stampati lo stato e le mosse valide e all'utente viene richiesto di inserire la propria mossa. Il gioco controlla se l'azione è valida e se il gioco è stato terminato. Se il gioco continua, il giocatore viene capovolto. Se il valore è uguale a uno, il giocatore vince e se c'è stato un pareggio, verrà stampato.

Parte 2

• 01:00:00 In questa sezione del tutorial sulla creazione di AlphaZero da zero utilizzando l'apprendimento automatico, l'istruttore inizia scegliendo il tris come gioco da utilizzare a scopo dimostrativo. Viene creata una nuova classe per la ricerca multicolore (MCTS), che viene inizializzata con il gioco e gli iperparametri come argomenti. All'interno di questa classe, viene definito un metodo di ricerca con un ciclo per iterazioni ripetute delle fasi di selezione, espansione, simulazione e backpropagation, restituendo infine la distribuzione del conteggio delle visite dei figli del nodo radice. Quindi, viene definita una classe per un nodo con attributi come stato del gioco, genitore, azione intrapresa, figli e conteggio delle visite. Il nodo radice viene inoltre definito con il gioco, gli iperparametri, lo stato iniziale e Nessuno per i segnaposto padre e azione intrapresa.
  
  
• 01:05:00 In questa sezione, il video illustra il processo di selezione dei nodi nell'albero durante il gioco nell'algoritmo AlphaZero. Viene definito il metodo per determinare se un nodo è completamente espanso, utilizzando le informazioni sul numero di spostamenti espandibili e se il nodo non è terminato. Durante la fase di selezione, l'algoritmo seleziona verso il basso mentre il nodo è completamente espanso. Per la selezione, l'algoritmo esegue un ciclo su tutti i figli del nodo, calcola il punteggio UCB per ogni figlio e quindi sceglie il figlio con il punteggio UCB più alto. Il punteggio UCB viene calcolato utilizzando il valore Q, una costante C per l'esplorazione o lo sfruttamento e una funzione logaritmica. Il valore Q è definito come la somma delle visite del bambino divisa per il conteggio delle visite, con gli aggiustamenti apportati per garantire che il valore Q rientri in un intervallo compreso tra 0 e 1.
  
  
• 01:10:00 In questa sezione, il video tutorial copre il processo di selezione di AlphaZero. Il codice seleziona un bambino che ha un valore molto negativo o basso, poiché scegliere questo metterà l'avversario in una brutta situazione. Il valore Q del figlio viene quindi invertito per dare al genitore un valore Q che è quasi 1. In questo modo, l'albero viene elaborato in modo tale che il bambino si trovi in una posizione sbagliata. Il video ripercorre i passaggi per implementare queste modifiche nel codice e spiega l'importanza di verificare se il nodo infine selezionato è un nodo terminale o meno. Inoltre, viene aggiunto un nuovo metodo per tenere conto della prospettiva del gioco nell'attributo get value.
  
  
• 01:15:00 In questa sezione del tutorial sulla creazione di AlphaZero da zero utilizzando l'apprendimento automatico, l'istruttore spiega come verificare se un nodo è terminale, propagarsi all'indietro ed eseguire l'espansione e la simulazione. Campionando uno spostamento espandibile tra quelli definiti, viene creato un nuovo stato per un elemento figlio e un nuovo nodo viene aggiunto all'elenco di elementi figlio per riferimento successivo all'interno del metodo select. L'istruttore discute anche l'idea di capovolgere lo stato per cambiare i giocatori piuttosto che definire esplicitamente i giocatori, semplificando la logica per i giochi a un giocatore e assicurando che il codice sia valido.
  
  
• 01:20:00 In questa sezione, l'oratore sta creando un nodo figlio per il gioco Tic-Tac-Toe e spiegando il metodo di cambiamento della prospettiva. Impostano il giocatore come -1 per l'avversario e usano la moltiplicazione per capovolgere la prospettiva. Dopo aver creato il nodo figlio, lo aggiungono all'elenco dei figli e lo restituiscono. Quindi, il relatore passa alla discussione del processo di simulazione, in cui utilizza i rollout per eseguire azioni casuali fino a raggiungere un nodo terminale e ottenere il valore. Usano il valore ottenuto per propagare all'indietro i nodi in cui il giocatore del nodo ha vinto per essere più promettente.
  
  
• 01:25:00 In questa sezione del video, il presentatore continua a costruire l'algoritmo Monte Carlo Tree Search (MCTS) per il programma di gioco AlphaZero. Mostrano come utilizzare lo stato grezzo corrente per scegliere un'azione, ottenere lo stato successivo e verificare se quello stato è terminale. Il presentatore scrive un'istruzione if per distinguere tra il giocatore uno o il giocatore due che riceve un valore positivo quando il gioco viene vinto da loro, quindi procede a scrivere il metodo di propagazione all'indietro per aggiornare il valore e il conteggio delle visite per ciascun nodo. Infine, il presentatore crea una variabile che calcola la probabilità delle azioni più promettenti, action_props.
  
  
• 01:30:00 In questa sezione, il video tutorial mostra come implementare un algoritmo autonomo di Monte Carlo Tree Search (MCTS) per il gioco Tic-tac-toe. Il tutorial mostra come eseguire il loop su tutti i bambini e scrivere oggetti di scena per ogni bambino. Il conteggio delle visite di ogni bambino viene utilizzato per trasformarle in probabilità. La somma delle probabilità viene quindi divisa per 1 per convertirle in probabilità. Viene quindi creato l'oggetto MCTS e la radice quadrata di 2 viene utilizzata per il valore C nella formula UCB. Lo script viene testato rispetto al gioco e l'algoritmo viene testato con lo stato neutrale. L'albero MCTS viene quindi utilizzato, insieme alla funzione best child, per restituire il child che è stato visitato più volte.
  
  
• 01:35:00 In questa sezione viene discussa l'architettura della rete neurale per l'algoritmo AlphaZero. Lo stato fornito come input alla rete neurale è una posizione sulla scheda codificata in tre diversi piani per il giocatore positivo, il giocatore negativo e i campi vuoti. Questa codifica consente di riconoscere i modelli e capire come giocare. L'architettura della rete neurale utilizzata è una rete residua con connessioni skip per archiviare il valore X iniziale e fornire l'output come somma dell'output dai blocchi convoluzionali e del valore X iniziale. Il modello è diviso in due parti, la testa della politica e la testa del valore, e per il caso del tris, ci sono nove neuroni nella testa della politica, uno per ogni azione potenziale.
  
  
• 01:40:00 In questa sezione, il relatore spiega da zero l'architettura della rete neurale AlphaZero. La rete ha due "teste", una per la politica e una per il valore. Il responsabile della politica ha nove neuroni e l'output viene applicato con una funzione soft-max per trasformarlo in una distribuzione di probabilità che indica quanto sia promettente una determinata azione. La testa del valore ha un solo neurone e utilizza la funzione di attivazione 10h per schiacciare tutti i valori potenziali nell'intervallo da uno negativo a uno positivo, fornendo una stima di quanto sia buono lo stato attuale. Il codice è costruito all'interno di un notebook Jupyter utilizzando il framework di deep learning PyTorch. Il modello include un blocco iniziale e una spina dorsale di blocchi residui convoluzionali e ogni blocco contiene uno strato convoluzionale seguito da due livelli di normalizzazione batch e una funzione di attivazione ReLU.
  
  
• 01:45:00 In questa sezione, il relatore discute la creazione del blocco iniziale per il modello AlphaZero, che prevede la creazione di un blocco 2D conf, un blocco norma batch e un blocco valore. Hanno anche impostato una spina dorsale per il modello utilizzando una serie di blocchi di riposo e hanno creato una classe per i blocchi di riposo. I blocchi rimanenti sono costituiti da un blocco conf, un blocco batch norm e un altro blocco conf, che vengono utilizzati per aggiornare l'input utilizzando connessioni saltate. Il metodo forward è definito per alimentare l'input attraverso i blocchi conf e aggiungere l'output risultante al residuo.
  
  
• 01:50:00 In questa sezione, l'oratore esamina da zero il codice per creare una rete residua (ResNet) per l'algoritmo AlphaZero. Mostrano come creare la spina dorsale di ResNet eseguendo il looping sui blocchi residui per il numero specificato di livelli nascosti. Quindi creano il criterio head e il valore head utilizzando nn.sequential e definendo i livelli nella sequenza. Infine, il relatore mostra come definire il metodo forward per la classe ResNet passando l'input attraverso il blocco iniziale, eseguendo il looping sui blocchi residui e restituendo la somma alla fine.
  
  
• 01:55:00 In questa sezione, il relatore spiega come utilizzare il modello AlphaZero per ottenere una politica e un valore per un dato stato in Tic-Tac-Toe. Scrive il codice per ottenere la politica e il valore passando uno stato tensoriale attraverso il modello, quindi appiattisce la politica e ottiene l'elemento valore. Spiega anche l'importanza di codificare lo stato nel formato corretto e di aggiungere una dimensione batch al tensore.

Parte 3

• 02:00:00 In questa sezione, il relatore mostra come convertire un tensore della politica in un float utilizzando il metodo dell'elemento punto e quindi applica la funzione softmax per scegliere le azioni con la probabilità più alta. L'oratore quindi visualizza la distribuzione delle politiche utilizzando Matplotlib per mostrare dove giocare. Successivamente, l'oratore imposta un seme per Torch per garantire la riproducibilità e aggiorna l'algoritmo MCTS fornendo un input del modello ResNet per prevedere un valore e una politica basata sullo stato del nodo foglia. La parte di simulazione viene rimossa e il valore ottenuto dal modello viene utilizzato per la retropropagazione.
  
  
• 02:05:00 In questa sezione del video, il presentatore mostra come codificare lo stato del nodo di un gioco tris e trasformarlo in un tensore usando torch.tensor per darlo come input al modello. La politica, che consiste in logit, deve essere trasformata in una distribuzione di probabilità utilizzando torch.softmax. Il presentatore spiega anche come mascherare le mosse illegali utilizzando la policy e le mosse valide, e come ridimensionare le policy in modo che rappresentino delle percentuali. Il valore viene estratto dal valore head chiamando value.item(). Inoltre, il presentatore mostra come utilizzare la policy per l'espansione e il valore per la backpropagation nel caso in cui il nodo sia un nodo foglia.
  
  
• 02:10:00 In questa sezione del video tutorial sulla creazione di AlphaZero da zero utilizzando il machine learning, il relatore spiega come aggiornare i metodi di espansione e formula UCB. Il metodo di espansione viene aggiornato per espandersi immediatamente in tutte le direzioni possibili e per memorizzare la probabilità all'interno dell'oggetto nodo per un uso successivo nella formula UCB durante la selezione. La nuova formula UCB utilizza una formula diversa rispetto alla ricerca multicolore standard e il relatore dimostra come rimuovere math.log e aggiungerne uno al conteggio delle visite del bambino. Questi aggiornamenti consentono l'uso del metodo UCB su un bambino che non è stato visitato prima.
  
  
• 02:15:00 In questa sezione, l'istruttore aggiorna l'MCTS con una politica sui diritti dei bambini per la selezione delle mosse e la testa eseguendo un gioco. Quindi passano alla creazione dell'algoritmo AlphaZero principale definendo una classe AlphaZero che include un modello, un ottimizzatore, un gioco e altri argomenti. Definiscono inoltre i metodi di auto-gioco e di addestramento e creano un ciclo che itera attraverso più cicli di riproduzione, raccolta di dati, addestramento del modello e test di nuovo. L'istruttore crea anche una classe di memoria per archiviare i dati di allenamento e i loop su ogni gioco di auto-gioco nel ciclo di allenamento.
  
  
• 02:20:00 In questa sezione del video tutorial, il presentatore passa attraverso il codice per il self-play e il ciclo di allenamento per AlphaZero. Descrivono come estendere i nuovi dati ottenuti dal metodo di riproduzione automatica nell'elenco di memoria e come modificare la modalità del modello in modalità di valutazione per evitare manopole batch durante la riproduzione. Il ciclo di addestramento è anche dettagliato su come chiamare il metodo train e memorizzare i pesi del modello. Infine, viene spiegato il metodo di riproduzione automatica, inclusa la definizione di una nuova memoria, la creazione di uno stato iniziale e il looping del gameplay, verificando anche gli stati terminali e restituendo i dati alla memoria in formato Tuple.
  
  
• 02:25:00 In questa sezione, il video tutorial spiega come memorizzare lo stato neutrale, gli oggetti di scena e le informazioni sui giocatori in memoria per utilizzarli in seguito per raccogliere dati di allenamento. Il tutorial mostra come campionare un'azione dagli oggetti di scena usando la funzione random.choice di NumPy e quindi giocare in base a questa azione. Il video spiega anche come verificare se lo stato è terminato o meno e, in tal caso, come restituire il risultato finale per ogni istanza in cui un giocatore ha giocato. Infine, l'esercitazione mostra come aggiungere lo stato neutro, gli oggetti di scena e il risultato alla variabile di memoria e come recuperare questi dati in un secondo momento per l'addestramento.
  
  
• 02:30:00 In questa sezione del tutorial "AlphaZero from Scratch", il codice viene aggiornato per renderlo più generale modificando i valori negativi in valori percepiti dall'avversario per partite diverse. La visualizzazione dei loop è migliorata utilizzando il pacchetto tqdm e i percorsi di avanzamento. L'implementazione di AlphaZero viene testata creando un'istanza della classe con un modello resnet, un ottimizzatore Adam e argomenti specifici. Il gioco Tic-Tac-Toe viene utilizzato come esempio con 4 blocchi di riposo e una dimensione nascosta di 64. Vengono impostati la costante di esplorazione, il numero di ricerche, le iterazioni, i giochi di auto-gioco e le epoche e il modello viene salvato per un uso futuro .
  
  
• 02:35:00 In questa sezione del tutorial, il metodo di addestramento viene implementato all'interno dell'implementazione di AlphaZero rimescolando i dati di addestramento ed eseguendo il looping su tutta la memoria in batch per campionare un batch di diversi campioni per l'addestramento. Gli stati, le prop MCTS e le ricompense finali vengono ottenute dall'esempio chiamando il metodo zip per trasporre l'elenco di tuple in elenchi di matrici MP. Questi vengono quindi modificati in array NP e gli obiettivi di valore vengono rimodellati in modo che ogni valore si trovi nel proprio sottoarray per un migliore confronto con l'output del modello.
  
  
• 02:40:00 In questa sezione del tutorial, il creatore del video spiega come trasformare lo stato, gli obiettivi della politica e gli obiettivi del valore in tensori, utilizzando torch.float32, per ottenere la politica e il valore dal modello permettendogli di prevedere lo stato. Proseguono definendo la perdita di polizza e la perdita di valore, che utilizzano per calcolare la somma di entrambe le perdite al fine di ridurre al minimo la perdita complessiva attraverso la propagazione all'indietro. Quindi dimostrano il processo di addestramento utilizzando una dimensione batch predefinita di 64, con barre di avanzamento che mostrano le iterazioni del processo di addestramento. Dopo aver addestrato il modello per 3 iterazioni, caricano il modello statico per testare ciò che la rete neurale ha appreso sul gioco.
  
  
• 02:45:00 In questa sezione del video tutorial, il presentatore dimostra come utilizzare il modello di rete neurale per giocare e testare la sua capacità di prevedere dove fare le mosse. Eseguendo una simulazione nella ricerca MCTS, il modello è in grado di fornire una distribuzione di dove giocare e una previsione del valore per lo stato dato. Il presentatore aggiunge anche il supporto GPU all'algoritmo per renderlo più veloce durante l'addestramento e il test. Il presentatore mostra come dichiarare il dispositivo e passarlo al modello come argomento per utilizzare una GPU Nvidia, se disponibile. Inoltre, il modello viene spostato sul dispositivo durante l'auto-gioco e l'allenamento per ottimizzare la velocità.
  
  
• 02:50:00 In questa sezione, il relatore discute diverse modifiche che possono essere aggiunte ad AlphaZero per migliorarne le prestazioni. Innanzitutto, aggiungono al modello il decadimento del peso e il supporto della GPU. Successivamente, introducono il concetto di temperatura, che consente una distribuzione più flessibile delle probabilità durante il campionamento delle azioni. Una temperatura più alta porta a una maggiore esplorazione, mentre una temperatura più bassa porta a un maggiore sfruttamento. Infine, l'oratore suggerisce di aggiungere rumore alla politica iniziale data al nodo radice durante la ricerca Monte Carlo. Queste modifiche possono migliorare significativamente i risultati dell'algoritmo AlphaZero.
  
  
• 02:55:00 In questa sezione del tutorial sulla creazione di AlphaZero da zero attraverso l'apprendimento automatico, l'attenzione si concentra sull'aggiunta di rumore al nodo principale per incorporare la casualità ed esplorare di più, garantendo al contempo che non venga persa alcuna azione promettente. Ciò si ottiene ottenendo prima una policy e un valore chiamando save.model e utilizzando torch.tensor e il dispositivo del modello per lo stato. La politica viene quindi ottimizzata utilizzando softmax e moltiplicata con mosse valide per mascherare le mosse illegali. Il rumore casuale di Dirichlet viene aggiunto alla politica moltiplicando la vecchia politica con un coefficiente inferiore a uno e aggiungendo questo coefficiente con un altro coefficiente moltiplicato per il rumore casuale. In questo modo, la politica viene modificata per consentire una maggiore esplorazione, specialmente all'inizio, quando il modello non sa molto del gioco.

Parte 4

• 03:00:00 In questa sezione, l'esercitazione video si concentra sull'aggiunta dell'esplorazione al criterio utilizzando un fattore di rumore. Modificando la policy, il bot può dare la priorità alle azioni che non sono state selezionate spesso aumentando l'esplorazione. Il video illustra come regolare l'equazione per la politica e utilizzare il valore Alpha come input per la funzione dirichlet punto casuale NP punto, che cambia l'aspetto della distribuzione casuale in base al numero di diverse azioni nel gioco, quindi l'Alpha potrebbe cambiare a seconda dell'ambiente. Viene delineata anche la politica di espansione del nodo radice, assicurando che il nodo venga retropropagato (conteggio delle visite impostato su uno) al momento dell'espansione in modo che il precedente sia d'accordo con la selezione del figlio all'inizio della ricerca Monte Carlo.
  
  
• 03:05:00 In questa sezione del tutorial, l'istruttore aggiunge il supporto di CPU e GPU per l'addestramento di modelli su giochi più complessi come Connect Four. Definiscono un dispositivo utilizzando torch.device() e controllano se torch.cuda.is_available() per decidere se utilizzare una CPU o un dispositivo CUDA. Aggiungono anche il dispositivo allo stack di stato del tensore e al caricamento del file statico. L'istruttore addestra e testa il modello su Tic-Tac-Toe e mostra che il modello ha imparato a riconoscere le mosse illegali. Quindi definiscono il gioco di Connect Four con il conteggio delle righe, il conteggio delle colonne e la dimensione dell'azione.
  
  
• 03:10:00 In questa sezione, il video tutorial illustra l'aggiornamento del codice sorgente per creare un gioco Connect Four. Il gioco viene inizializzato con una matrice vuota e un punto salvato in una riga variabile di quattro per il numero di pietre necessarie per vincere. Il metodo get next state viene aggiornato per recuperare una riga guardando una data colonna e quindi trovando il campo vuoto più profondo in quella colonna per posizionare una pietra. Il metodo Get Valid Moves viene aggiornato per controllare la riga superiore per le mosse disponibili. Il metodo check for a win viene copiato dal gioco Tic Tac Toe con modifiche per controllare entrambe le diagonali e il metodo get next state viene aggiornato per utilizzare la variabile di azione anziché la variabile della colonna. Il codice aggiornato viene testato per assicurarsi che funzioni.
  
  
• 03:15:00 In questa sezione, l'oratore sostituisce Tic-tac-toe con il gioco Connect Four e imposta il numero di ricerche su 20 per convalidare. Anche la dimensione del modello viene modificata in 9 per il numero di blocchi di riposo e 128 per l'oscuramento nascosto per consentire al modello di apprendere meglio. L'efficienza della formazione viene quindi aumentata in modo che richieda meno tempo per ambienti complessi. Il modello viene quindi addestrato per un'iterazione, che richiede diverse ore. Il set di valutazione viene quindi utilizzato per verificare se il modello ha appreso o meno qualcosa.
  
  
• 03:20:00 In questa sezione del tutorial, l'obiettivo è aumentare l'efficienza dell'implementazione di AlphaZero attraverso la parallelizzazione. Il piano è parallelizzare il più possibile l'implementazione raggruppando gli stati per ottenere previsioni parallele per la politica e il valore. In questo modo, il numero di volte in cui il modello viene richiamato viene drasticamente ridotto, sfruttando appieno le capacità della GPU e aumentando la velocità. Il tutorial spiega come implementare la versione parallelizzata usando Python senza usare pacchetti come Ray, e una nuova classe chiamata "AlphaZeroParallel" e "MCTSParallel" viene creata copiando le classi originali.
  
  
• 03:25:00 In questa sezione, il relatore discute la creazione di due nuove classi in Python: `SPG` per memorizzare informazioni sui giochi self-play, e `ParallelMCD`, che implementa i metodi `save_play` e `search` usando la nuova classe `SPG`. La classe `SPG` memorizza lo stato iniziale del gioco, un elenco di memoria vuoto e le variabili `root` e `note` impostate su `None`. La classe `ParallelMCD` aggiorna anche il metodo `set_play` per creare un elenco di istanze `SPG` utilizzando il `game` e il numero di partite parallele come input. Il ciclo `while` quindi esegue il metodo `set_play` finché tutti i giochi self-play non sono terminati, il che consente un'efficiente parallelizzazione.
  
  
• 03:30:00 In questa sezione, l'oratore spiega come ottenere un elenco di tutti gli stati e trasformarli in un array numerico per aumentare l'efficienza. Mostrano anche come cambiare la prospettiva per tutti gli stati utilizzando una chiamata di funzione per moltiplicare i valori con uno negativo per il giocatore impostato su uno negativo. Successivamente, il relatore mostra come passare gli stati neutrali alla ricerca Monte Carlo, aggiornare il metodo di ricerca della ricerca Monte Carlo e ottenere criteri sul video utilizzando tutti gli stati batch. Infine, spiegano come scambiare l'ordine dello stato codificato in modo che funzioni con più stati e non solo uno quando si chiama il metodo di stato codificato get e come copiare questo processo nel gioco del tris.
  
  
• 03:35:00 questo loop in un array numpy e utilizza invece la vettorizzazione di numpy. Quindi possiamo applicare il modello a tutti gli stati nell'array numpy senza dover scorrere ciascuno di essi, il che consente di risparmiare molto tempo. Possiamo quindi rimodellare l'output nella sua forma originale e procedere con il resto della ricerca MCTS come al solito. Infine, aggiorniamo le statistiche per ogni gioco self-play e restituiamo il nodo principale per l'azione scelta. Ciò completa l'implementazione della ricerca MCTS con policy e rete di valore utilizzando l'algoritmo AlphaZero.
  
  
• 03:40:00 In questa sezione del video, l'istruttore apporta alcune modifiche al codice per memorizzare tutti i nodi espandibili invece delle classi SPG. Quindi, l'attenzione si sposta sullo scoprire quali giochi di gioco sicuro sono espandibili o meno creando un elenco per memorizzarli e ottenendo l'indice di mappatura per ogni gioco di gioco sicuro. L'istruttore controlla se ci sono giochi espandibili e se ci sono, gli stati vengono impilati e codificati in modo che la politica e il valore possano essere ottenuti in seguito.
  
  
• 03:45:00 In questa sezione del tutorial, l'istruttore spiega l'implementazione del codice per l'algoritmo Monte Carlo Tree Search per AlphaZero. Mostrano come utilizzare gli stati espandibili e non è necessario decomprimere, comprimere o aggiungere rumore, oltre a creare un indice per ottenere la politica e gli indici di mappatura per l'allocazione delle politiche nell'indice di gioco self-play. I nodi vengono espansi utilizzando la politica SPG, retropropagati utilizzando il valore del punto SPG e quindi vengono ottenuti oggetti di scena invece di utilizzare il metodo OSF Planet. L'istruttore copia il codice di parallelizzazione e apporta modifiche per lavorare con gli oggetti di scena invece del metodo OSF Planet come parte dell'implementazione dell'algoritmo Monte Carlo Tree Search per AlphaZero.
  
  
• 03:50:00 In questa sezione, il video tutorial si concentra sull'aggiornamento del codice per l'implementazione parallela della ricerca MCTS. L'istruttore sottolinea l'importanza di rimuovere dall'elenco i giochi self-play se sono terminali e di aggiornare lo stato chiamando `spg.state` invece di `SPG class`. Il codice viene anche modificato per aggiungere la memoria alla memoria regionale generale e capovolgere il giocatore dopo che il ciclo su tutti i giochi self-play è stato completato. L'obiettivo è creare un ciclo fluido che funzioni in modo efficiente e rimuova il cerchio dall'elenco dei giochi self-play al momento opportuno.
  
  
• 03:55:00 In questa sezione, il relatore discute l'addestramento di un modello per Connect Four utilizzando l'implementazione parallelizzata di fs0. Il modello viene addestrato per otto iterazioni e valuta i risultati utilizzando una scheda Connect Four. Il relatore osserva che il numero di ricerche è piuttosto ridotto rispetto ad altri algoritmi di ricerca utilizzati nella pratica, ma i risultati sono soddisfacenti. Giocano contro il modello e fanno alcune mosse, e il modello risponde di conseguenza. Nel complesso, l'addestramento ha richiesto alcune ore, ma il modello finale ha una buona comprensione di come giocare.

• 04:00:00 In questa sezione del tutorial, il presentatore mostra come creare un ambiente Connect Four utilizzando il pacchetto di ambienti Kegel e giocare con due agenti. Gli agenti utilizzano l'algoritmo di ricerca MCTS per fare previsioni basate su un modello AlphaZero addestrato. Il relatore apporta anche alcune correzioni minori al codice, come l'incorporazione dei props dell'azione della temperatura in fs03 e l'utilizzo di save.optimizer invece del normale ottimizzatore. Inoltre, il presentatore imposta la temperatura su zero per ottenere sempre l'arco massimo della politica e imposta il riflesso epsilon su uno per aggiungere un po' di casualità al gioco. Infine, il presentatore definisce il giocatore uno come un agente calcolato che utilizza l'algoritmo MCTS per fare previsioni basate sul modello addestrato.
  
  
• 04:05:00 In questa sezione di "AlphaZero from Scratch - Machine Learning Tutorial", il relatore modella il gioco e gli argomenti scrivendo codici per il giocatore 1 e il giocatore 2, che offre maggiore flessibilità per provare diversi giocatori. Quindi eseguono la cella e ottengono visualizzazioni dei modelli che giocano l'uno contro l'altro, il che ha portato a un pareggio poiché il modello può difendere tutti gli attacchi. Hanno anche dimostrato come modificare il codice di Tic-tac-toe cambiando il gioco e gli argomenti e aggiornando il percorso, che ha portato i modelli a giocare l'uno contro l'altro per pareggiare nuovamente. Il tutorial è stato completato e il relatore ha fornito un repository GitHub con notebook jupyter per ogni checkpoint e una cartella pesi con l'ultimo modello per Tic-tac-toe e Connect Four. L'oratore ha anche espresso il proprio interesse a fare un video di follow-up su Mu Zero se c'è qualche interesse in esso.

[MetaQuotes]

Panico di Google su ChatGPT [Le guerre AI sono iniziate]

Panico di Google su ChatGPT [Le guerre AI sono iniziate]

Il video illustra come Google si sta preparando per il potenziale dei chatbot che diventano più potenti e come ciò potrebbe influire sul loro modello di business. Si dice che Microsoft stia lavorando a un chatbot che consentirebbe agli utenti di comunicare con Bing in un modo più umano e questa funzione sarà utile per le ricerche in cui le immagini non esistono attualmente. Microsoft ha affermato di lavorare a stretto contatto con l'IA aperta, quindi questa funzione non genera immagini esplicite o inappropriate. Quindi, sembra che Bing stia subendo un'importante revisione con le funzionalità di chat GPT e Dali 2 integrate.

• 00:00:00 Google, nel 1998, affittava una casa accanto a un'altra casa. Il tavolo da ping pong era nell'altra casa.
  
  
• 00:05:00 Il video discute di come Google sia preoccupato per il potenziale dei chatbot che diventano più potenti e di come ciò potrebbe danneggiare il loro modello di business. Secondo quanto riferito, Google ha lavorato a un piano per combattere questo problema e i loro co-fondatori, Larry Page e Sergey Brin, sono stati invitati a un incontro per discutere la questione.
  
  
• 00:10:00 In questo video, Google viene visto in competizione con Microsoft, poiché quest'ultima sta investendo altri 10 miliardi di dollari nell'IA aperta. Tuttavia, questo potrebbe non essere nel migliore interesse del movimento dell'IA aperta, in quanto potrebbe portare alla morte dell'essere AI prima che abbia davvero la possibilità di iniziare. Si dice anche che Google stia lavorando a 20 progetti di intelligenza artificiale, alcuni dei quali sono simili alla chat GPT, il che ha portato Microsoft a investire 300 milioni nell'azienda. Non è chiaro come andrà a finire, ma sembra che Google sarà costretta a mettere da parte i problemi di sicurezza e scatenare i propri prodotti AI.
  
  
• 00:15:00 Il video parla delle voci secondo cui Microsoft sta lavorando a un chatbot che consentirebbe agli utenti di comunicare con Bing in un modo più umano. Menziona anche che questa funzione sarà utile per le ricerche in cui le immagini non esistono attualmente. Infine, il video parla di come questa integrazione consentirà agli utenti di digitare testo e generare immagini, il che sarà particolarmente vantaggioso per le ricerche in cui le immagini non esistono attualmente. Microsoft ha affermato di lavorare a stretto contatto con l'IA aperta, quindi questa funzione non genera immagini esplicite o inappropriate. Quindi, sembra che Bing stia subendo un'importante revisione con le funzionalità di chat GPT e Dali 2 integrate. Sicuramente attirerà l'attenzione di tutti quando verrà lanciato.