Apprendimento automatico e Reti Neurali - pagina 16

[MetaQuotes]

Corso di Machine Learning per principianti (parti 5-10)

Corso di apprendimento automatico per principianti

Parte 5

• 04:00:00 In questa sezione del video, l'istruttore spiega la terminologia di base degli alberi decisionali, come nodi terminali o foglia e rami. Discutono anche della suddivisione dei dati e della potatura dei nodi, che è l'eliminazione di alcuni nodi nell'albero. L'istruttore sottolinea l'importanza di prendere appunti e comprendere la terminologia per una migliore comprensione degli alberi decisionali. Quindi passano a spiegare come appaiono i confini decisionali, o iperpiani, negli alberi decisionali e come sono costruiti per ogni risultato. L'istruttore traccia gli iperpiani in base alle due caratteristiche scelte per l'esempio e mostra come sono costruiti a seconda del risultato.
  
  
• 04:05:00 In questa sezione, l'istruttore spiega come vengono costruiti gli alberi decisionali utilizzando misure di selezione degli attributi come entropia, guadagno di informazioni e impurità gini. Queste misure aiutano a determinare quale caratteristica dovrebbe essere il nodo radice o come suddividere il set di dati. L'istruttore sottolinea l'importanza di scegliere la caratteristica giusta per evitare di finire con un cattivo modello. L'entropia è definita come una misura della casualità in cui maggiore è l'entropia, più difficile è ricavarne informazioni. L'istruttore fornisce esempi e proprietà dell'entropia per aiutare a comprendere il suo significato nella costruzione di alberi decisionali.
  
  
• 04:10:00 In questa sezione del video, l'istruttore spiega come calcolare l'entropia, che è una misura della casualità, utilizzando una formula che coinvolge la probabilità di ogni classe e il logaritmo della probabilità. L'istruttore utilizza l'esempio di un set di dati per giocare a golf e calcola l'entropia delle classi "sì" e "no" per dimostrare come funziona la formula. L'istruttore discute anche diverse proprietà dell'entropia, inclusi i classificatori binari con due classi, e l'importanza di ridurre al minimo l'entropia per migliorare l'accuratezza di un modello di apprendimento automatico.
  
  
• 04:15:00 In questa sezione, l'istruttore spiega il concetto di entropia, che è una misura della casualità di un attributo che determina se deve essere suddiviso per un albero decisionale. L'entropia viene calcolata in base al numero di valori univoci nei dati e l'obiettivo è ridurre al minimo l'entropia per ottenere migliori risultati dell'albero decisionale. L'istruttore fornisce esempi di diversi scenari e mostra come calcolare l'entropia per ciascuno per capire quando un attributo diventa un nodo foglia o necessita di un'ulteriore suddivisione. L'entropia massima è 1 e l'entropia minima è 0 e diversi algoritmi dell'albero decisionale seguono regole specifiche su quando considerare un attributo come una foglia o dividere ulteriormente in base al valore di entropia.
  
  
• 04:20:00 In questa sezione, il presentatore spiega il concetto di entropia come misura della casualità e il diagramma dell'entropia. Il valore di entropia più alto è uno e può essere calcolato utilizzando una certa equazione. Passando all'acquisizione di informazioni, il relatore la presenta come un'altra misura di selezione degli attributi e fornisce un esempio di set di dati utilizzato per spiegarla. Il set di dati è suddiviso in sottoinsiemi più piccoli in base al numero di etichette e l'entropia viene calcolata per ciascun sottoinsieme. Questa è una spiegazione preliminare dell'acquisizione di informazioni, che verrà esplorata ulteriormente nella sezione successiva.
  
  
• La sezione 04:25:00 spiega come calcolare il guadagno di informazioni negli alberi decisionali utilizzando l'entropia. Il processo prevede l'acquisizione dell'entropia dell'intera distribuzione dei dati e quindi l'acquisizione dell'entropia prima e dopo la suddivisione dei dati. La formula per l'acquisizione di informazioni comporta la sottrazione dell'entropia prima della scissione dall'entropia ponderata dopo la scissione. L'esempio utilizzato in questo video dimostra come l'entropia e l'entropia ponderata vengono calcolate per ogni divisione e quindi calcolate la media per ottenere l'entropia ponderata dell'intero set di dati. Infine, l'entropia prima della scissione viene sottratta dall'entropia dopo la scissione per determinare il guadagno di informazioni.
  
  
• 04:30:00 l'impurità di Gini è molto simile al calcolo dell'entropia, ma invece di usare i logaritmi, usa le probabilità al quadrato. Dopo aver diviso il set di dati in più categorie, si calcola l'impurità di Gini ponderata e quindi la si sottrae dall'impurità di Gini precedente per ottenere il guadagno di informazioni. Questo è un metodo popolare e comunemente usato nell'apprendimento automatico. È importante comprendere l'impurità di Gini, nonché l'entropia e il guadagno di informazioni durante la creazione di un modello di albero decisionale.
  
  
• 04:35:00 In questa sezione, l'istruttore spiega il concetto di impurità di Gini come un'altra misura di impurità in un albero decisionale. L'impurità di Gini è un segno dato per una data impurità di y uguale a 1 meno i uguale a 1 tutto intorno a k. L'istruttore spiega lo scenario dell'impurità di Gini con un esempio di avere un valore di categoria univoco di sì o no dove 0,5 è la probabilità del numero di sì e il numero di no è 0,5. L'impurità di guadagno di 0,5 è massima nell'impurità di Gini, che viene utilizzata principalmente come alternativa all'entropia poiché è più veloce, in quanto evita l'uso della funzione log nell'entropia. Infine, l'istruttore mostra il diagramma dell'entropia e dell'impurità di Gini e promette di dimostrare come utilizzare un classificatore ad albero decisionale per eseguire un'attività di regressione nella sezione successiva.
  
  
• 04:40:00 In questa sezione del video, l'istruttore spiega come calcolare l'entropia prima di suddividere i dati per determinare il guadagno di informazioni. Prendono l'entropia della distribuzione dei dati e calcolano il guadagno di informazioni rispetto alla variabile di prospettiva. Quindi dividono i dati in base a questa variabile e continuano a calcolare l'entropia ponderata e il guadagno di informazioni per le variabili di temperatura, umidità e vento. Alla fine, si scopre che il guadagno di informazioni in Outlook è il più alto, quindi viene scelto come nodo radice per l'albero decisionale.
  
  
• 04:45:00 albero decisionale e come può essere utilizzato sia per problemi di classificazione che di regressione. Nella classificazione, gli alberi decisionali sono costruiti sulla base del calcolo delle misure di impurità, come l'entropia e il coefficiente di Gini, per prendere decisioni in ogni nodo. L'obiettivo è rendere l'albero il più puro possibile o finché non raggiunge un punto in cui diventa puro. Nella regressione, gli alberi decisionali vengono costruiti prendendo la media del valore target in ogni punto di divisione finché non raggiunge un nodo foglia. L'overfitting può essere un problema negli alberi decisionali, quindi è importante fermare la crescita dell'albero a una certa profondità o potare alcuni rami per renderlo più robusto.
  
  
• 04:50:00 In questa sezione, l'istruttore spiega che è importante comprendere le misure di selezione degli attributi quando si lavora con gli alberi decisionali. Forniscono esempi e spiegano l'implementazione per la regressione dell'albero decisionale e il classificatore residenziale. L'istruttore sottolinea l'importanza dell'apprendimento dall'implementazione e spiega gli iperparametri come la profondità massima dell'albero, la suddivisione minima del campione, la foglia minima del campione e il controllo dello stato casuale. Mostrano anche un esempio di utilizzo dello strumento grafico per tracciare un albero decisionale.
  
  
• 04:55:00 In questa sezione, il video discute la regressione dell'albero decisionale e i suoi criteri per misurare la funzione, inclusi l'errore quadratico medio, l'errore assoluto medio e il veleno. Il video sottolinea l'importanza degli iperparametri, in particolare del passo massimo, nel controllo dell'overfitting. Vengono inoltre mostrati esempi di alberi decisionali e dei relativi metodi, come la trama, e il video sottolinea l'importanza di comprendere gli alberi decisionali come concetto cruciale nell'apprendimento automatico. La sezione successiva discute l'apprendimento dell'ensemble e le sue tre tecniche: bagging, boosting e stacking, che sono comunemente usate nelle competizioni Kaggle.

Parte 6

• 05:00:00 In questa sezione, l'istruttore discute il concetto di modelli ad alta varianza e bias elevato, in cui possono verificarsi overfitting e underfitting. L'obiettivo nell'apprendimento automatico è quello di avere un modello a bassa distorsione e bassa varianza per ottenere una precisione ottimale. L'istruttore fornisce esempi di apprendimento d'insieme, in cui più modelli vengono addestrati sui dati e le previsioni vengono prese da ciascun modello per essere votate e alla fine determinare la risposta o la previsione corretta. La maggior parte è spesso più accurata della risposta di un individuo nell'apprendimento d'insieme e l'istruttore spiega il concetto utilizzando esempi come domande a quiz e votazioni elettorali.
  
  
• 05:05:00 In questa sezione, l'istruttore fornisce una panoramica dell'apprendimento d'insieme e di come può essere utilizzato per problemi di classificazione e regressione. Nella classificazione, viene presa in considerazione la maggioranza dei voti, mentre nella regressione, la media o la mediana degli output dei modelli di base viene utilizzata per la previsione finale. Le tecniche utilizzate nell'apprendimento dell'ensemble includono bagging, boosting, stacking e cascading, e la maggior parte dei vincitori del concorso Kaggle utilizza una qualche forma di tecniche di apprendimento dell'ensemble. Inoltre, l'istruttore sottolinea che aziende come Amazon e Google utilizzano questi algoritmi, come XGBoost e random forest, nei propri prodotti.
  
  
• La sezione 05:10:00 discute le basi del bagging, una tecnica di apprendimento dell'insieme nota anche come aggregazione bootstrap. Il bagging comporta il campionamento casuale di sottoinsiemi di dati di addestramento e modelli di addestramento su ciascun sottoinsieme. L'idea è di ridurre l'overfitting e migliorare la precisione del modello utilizzando un insieme di più modelli. La sezione spiega come funziona il bagging, incluso come campionare i dati, addestrare sottoinsiemi di modelli e combinare le previsioni per una maggiore precisione.
  
  
• 05:15:00 In questa sezione, il relatore spiega il concetto di bagging, una tecnica per migliorare l'accuratezza dei modelli di machine learning. Il bagging comporta il campionamento dei dati con la sostituzione e quindi l'addestramento dei modelli su ciascun campione. I singoli modelli vengono quindi combinati per formare un modello aggregato che produce previsioni più accurate. Il relatore osserva che il bagging è una tecnica concettualmente semplice che non richiede matematica avanzata.
  
  
• 05:20:00 In questa sezione, il relatore discute il bagging, che aiuta a ridurre la varianza dei modelli di base ad alta varianza e bassa polarizzazione. Il bagging combina questi modelli per creare un modello più ampio, a bassa varianza e con bassa polarizzazione. Il campionamento delle righe viene utilizzato durante il campionamento dei dati, il che comporta il campionamento solo delle righe dalla grande distribuzione di dati. È importante notare che nel bagging viene utilizzato solo il campionamento per riga, a differenza della foresta casuale, che utilizza sia il campionamento per riga che quello per colonna. Il bagging è anche noto come aggregazione bootstrap, che implica il bootstrap e l'aggregazione dei modelli di base.
  
  
• 05:25:00 In questa sezione, l'istruttore ricapitola la tecnica del bagging, che è un modo per ridurre la varianza nei modelli ad alta varianza e bassa distorsione. Il bagging comporta l'acquisizione di sottoinsiemi di dati per l'addestramento e la combinazione della maggioranza dei voti per la classificazione. L'istruttore ritiene che un potente algoritmo per questo sia la foresta casuale, che è una combinazione di alberi decisionali, bagging e campionamento di colonne. Gli alberi decisionali prendono decisioni semplici e dividono i nodi, mentre il bagging comporta l'acquisizione di sottoinsiemi di dati per l'addestramento. Viene utilizzato anche il campionamento delle colonne o il bagging delle caratteristiche, prendendo sottoinsiemi delle colonne. L'istruttore afferma che le foreste casuali sono potenti e le principali aziende come Google, Quora e Amazon le usano.
  
  
• 05:30:00 In questa sezione, l'istruttore di machine learning spiega il concetto di bagging e random forest. Il bagging comporta il campionamento delle righe con la sostituzione e l'addestramento di un albero decisionale sul sottoinsieme, mentre la foresta casuale aggiunge il campionamento delle colonne al mix. Ciò significa che vengono campionate sia le righe che le colonne, il che crea maggiori possibilità di un modello con buone prestazioni grazie alla tecnica di apprendimento dell'insieme. L'istruttore menziona anche il concetto di punti out of bag (oob) che sono i punti lasciati fuori dopo il campionamento e possono essere utilizzati per la convalida incrociata. Infine, l'istruttore riassume le principali differenze tra bagging e random forest.
  
  
• 05:35:00 In questa sezione, il video discute le tecniche di bagging e random forest nell'apprendimento automatico. Il bagging comporta il campionamento delle righe, che porta a un modello più grande, riducendo la varianza. La foresta casuale è la stessa, ma con il campionamento delle colonne e gli alberi decisionali come modelli di base. La complessità del treno negli alberi decisionali è dell'ordine di n log m volte n volte d, mentre nelle foreste casuali è d volte k volte n. Il video discute anche di come le foreste casuali siano banalmente parallelizzate, rendendole facili da addestrare. Infine, viene introdotto il concetto di alberi estremamente randomizzati, che provano possibili valori per determinare la soglia negli alberi decisionali.
  
  
• 05:40:00 In questa sezione, il relatore discute il concetto di alberi estremamente randomizzati come alternativa al metodo computazionalmente costoso di provare ogni possibile valore in Random Forest. Campionando un sottoinsieme di colonne e righe, la varianza viene ridotta ma c'è una minore possibilità di ottenere buoni risultati rispetto a Random Forest. Il relatore menziona anche gli svantaggi dell'utilizzo di Random Forest su set di dati di grandi dimensioni a causa della sua complessità temporale, ma suggerisce di provarlo e ottimizzare gli iperparametri utilizzando la ricerca a griglia. Quindi introducono l'API scikit-learn per l'implementazione di Random Forest e menzionano un progetto per la messa a punto degli iperparametri.
  
  
• 05:45:00 In questa sezione, viene discusso il classificatore foresta casuale con i suoi parametri e attributi. Il primo parametro è n_estimators, ovvero il numero di alberi decisionali utilizzati. Vengono inoltre spiegati i criteri di selezione degli attributi e la profondità massima dell'albero insieme ad altri parametri come il campione minimo richiesto per la suddivisione e il numero massimo di caratteristiche. Viene anche menzionato l'uso dell'importanza delle caratteristiche per selezionare caratteristiche importanti per il modello. Viene anche discusso brevemente il regressore a foresta casuale con le sue somiglianze con il classificatore.
  
  
• 05:50:00 In questa sezione del video, l'istruttore discute le tecniche di ensemble, in particolare il Boosting. Il potenziamento è un'altra popolare tecnica di apprendimento dell'insieme e l'istruttore offre una panoramica di Gradient Boosting, Adaptive Boosting o AdaBoost ed Extreme Boosting o XGBoost. L'istruttore afferma inoltre che su GitHub è disponibile un set di problemi che gli spettatori possono provare e incoraggia gli spettatori a iscriversi al canale YouTube per supportare la creazione di più contenuti gratuiti.
  
  
• 05:55:00 In questa sezione, il video tratta gli argomenti del bagging e del potenziamento nell'apprendimento automatico. Il bagging viene utilizzato per ridurre la varianza elevata nei modelli eseguendo il campionamento di colonne e righe, seguito dall'aggregazione. Il potenziamento, d'altra parte, viene utilizzato per ridurre la distorsione nei modelli combinando in modo additivo studenti deboli in un modello forte. L'idea centrale dell'utilizzo del potenziamento è ridurre la distorsione in un modello altamente distorto. Il video fornisce un'intuizione di base del potenziamento utilizzando un esempio di dati di allenamento.

Parte 7

• 06:00:00 In questa sezione, il relatore spiega l'idea alla base del potenziamento e come funziona per ridurre al minimo gli errori. Il potenziamento è una tecnica di apprendimento supervisionato che prevede l'addestramento di un modello sui dati di addestramento (x e y) con un'etichetta per ogni esempio. Il modello viene quindi utilizzato per prevedere l'output per ciascun input e viene misurata la differenza tra il valore di verità previsto e il valore di base per calcolare la perdita. Il modello viene addestrato per ridurre l'errore residuo, concentrandosi sui dati classificati in modo errato o con MSE o MAE elevati. Il potenziamento implica l'adattamento di più modelli sugli errori residui, riducendo al minimo l'errore adattandosi ad esso per ogni esempio di addestramento. Il modello finale è la somma di tutti questi modelli, pesata per alfa.
  
  
• 06:05:00 In questa sezione viene spiegato il concetto di potenziamento, che è una tecnica per ridurre i bias nei modelli di machine learning. Il potenziamento converte gli studenti deboli in studenti forti adattando gli errori residui dei modelli precedenti, risultando in un modello a bassa distorsione e bassa varianza che funziona bene sul set di addestramento. Tuttavia, c'è il rischio di overfitting se il modello è troppo buono sul training set. Vengono discusse diverse tecniche di potenziamento, come il potenziamento del gradiente, il potenziamento adattivo e il potenziamento estremo. Inoltre, viene brevemente menzionata l'idea alla base del bagging, che è un'altra tecnica per migliorare le prestazioni del modello.
  
  
• 06:10:00 In questa sezione, l'istruttore spiega il concetto di gradient boosting, che è un algoritmo di boosting che converte studenti deboli in studenti forti. Il potenziamento del gradiente è un potente algoritmo utilizzato dalle grandi aziende tecnologiche e di produzione. È una funzione di costo differenziabile che consente di prendere derivati per migliorare l'errore in un set di addestramento. L'istruttore fornisce esempi reali di potenziamento del gradiente e discute le funzioni di costo differenziabili e la loro importanza nell'algoritmo. La discussione include l'uso di dati di addestramento e una funzione di costo nella discesa del gradiente, rendendolo uno strumento utile nell'apprendimento automatico.
  
  
• 06:15:00 In questa sezione, il relatore spiega l'algoritmo per addestrare un modello usando il boosting. L'algoritmo prevede l'inizializzazione del modello con un valore costante, il calcolo dei residui o pseudo-residui, l'assunzione della derivata parziale della funzione di costo rispetto al modello, l'adattamento degli studenti di base ai residui dei modelli precedenti e quindi l'iterazione di ciascun modello per calcolare gli pseudo-residui e adattare gli studenti di base. L'obiettivo è trovare il valore lambda che minimizza la funzione di costo e migliora l'accuratezza del modello.
  
  
• 06:20:00 In questa sezione, il relatore spiega il processo dell'algoritmo di potenziamento del gradiente, che inizia inizializzando il modello con una costante e quindi applicando un ciclo for per eliminare i residui per ogni esempio di addestramento. Il modello quindi adatta uno studente di base ai residui e calcola il moltiplicatore lambda m per ciascun modello. Per aggiornare il modello, il modello precedente viene adattato ai residui precedenti e il modello finale si ottiene sommando il modello precedente e il nuovo modello ottenuto dopo aver risolto il problema di ottimizzazione unidimensionale. L'oratore copre anche i concetti di regolarizzazione e restringimento e perché sono necessari per aumentare a causa dell'elevato pregiudizio.
  
  
• 06:25:00 In questa sezione, il video illustra come utilizzare il potenziamento per ridurre i bias elevati nei modelli di machine learning. Il potenziamento comporta l'adattamento dei residui del modello precedente durante ogni iterazione, il che può comportare un overfitting e un aumento della varianza. Per evitare questo problema, è possibile aggiungere regolarizzazione e restringimento utilizzando un parametro apprendibile chiamato v. Empiricamente, è stato riscontrato che un valore di v uguale a 0,1 comporta notevoli miglioramenti. Il video copre anche la complessità temporale degli alberi decisionali del gradient boosting e l'implementazione del gradient boosting tramite l'API scikit-learn.
  
  
• 06:30:00 In questa sezione, il relatore discute l'implementazione del Gradient Boosting Classifier utilizzando l'API Scikit-learn. Spiegano i diversi parametri coinvolti, come perdita, tasso di apprendimento, numero di stimatori e altro. Il tasso di apprendimento viene utilizzato per ridurre l'overvariance e prevenire l'overfitting. L'implementazione di Gradient Boosting Classifier è solo una riga di codice e la probabilità di previsione fornisce la probabilità che i dati siano veri per una determinata classe. Il relatore discute anche brevemente l'implementazione di Gradient Boosting Regressor e sottolinea l'importanza di imparare dalla documentazione.
  
  
• 06:35:00 In questa sezione del video "Machine Learning Course for Beginners", l'istruttore discute il classificatore AdaBoost e la sua implementazione utilizzando l'API Cython, nonché l'algoritmo Extreme Gradient Boosting (XGBoost). L'istruttore spiega che XGBoost è una versione avanzata di Gradient Boosting che aggiunge la randomizzazione attraverso il campionamento di righe e colonne, rendendolo un potente strumento per i problemi di apprendimento automatico. La sezione copre anche i diversi parametri utilizzati in XGBoost e il loro significato nella messa a punto del modello.
  
  
• 06:40:00 In questa sezione, il relatore parla dei diversi pacchetti per algoritmi di apprendimento automatico come Gradient Boosting Tree, GB Linear e DART. Discutono i diversi parametri che possono essere regolati, inclusa la matrice di valutazione e la regolarizzazione, e come influenzano il modello. L'oratore menziona anche XGBoost e mostra come viene utilizzato in Python. Sottolineano l'importanza di mettere a punto il modello e come può portare a una migliore precisione. Infine, il relatore introduce il concetto di impilamento e come può aiutare a migliorare la precisione dei modelli.
  
  
• 06:45:00 In questa sezione, l'istruttore introduce il concetto di accatastamento e come differisce dall'insacchettamento e dal potenziamento. Lo stacking implica prendere studenti di base diversi che sono altamente sintonizzati e hanno un buon compromesso tra bias e varianza e addestrarli su diversi sottoinsiemi di dati per creare modelli diversi. Questo è diverso dal bagging, che viene utilizzato per ridurre la varianza elevata utilizzando studenti di base con varianza elevata e bias basso, e dal boosting, in cui i modelli di base non sono necessariamente altamente sintonizzati. L'istruttore fornisce un esempio di impilamento con diversi modelli di base, come la regressione logistica, le macchine vettoriali di supporto e i vicini k-più vicini, che sono stati sottoposti a un'ampia messa a punto per produrre buoni modelli con un buon compromesso bias-varianza.
  
  
• 06:50:00 In questa sezione, il relatore spiega l'intuizione di base dietro lo stacking, che è un tipo di apprendimento d'insieme. Lo stacking comporta la divisione dei dati di addestramento in sottoinsiemi e l'addestramento di diversi classificatori su ciascun sottoinsieme. Questi studenti di base sono bravi a bilanciare pregiudizi e varianza. A differenza del bagging, che ha un'elevata varianza e una bassa distorsione, e del boosting, che ha un'elevata distorsione e una bassa varianza. Dopo aver ottenuto le previsioni da ciascun modello, un meta-classificatore viene addestrato sulle etichette delle classi previste o sulle loro probabilità. L'idea è di combinare le previsioni di questi modelli di ensemble per creare un classificatore più accurato e robusto.
  
  
• 06:55:00 In questa sezione, l'istruttore discute lo stacking, un metodo per combinare più modelli per creare un nuovo modello con prestazioni migliori. Il processo prevede l'addestramento di più modelli di base e l'utilizzo delle relative previsioni come funzionalità per addestrare un classificatore di secondo livello, che emette le previsioni finali. L'istruttore mostra un esempio di creazione di un modello di classificazione in pila utilizzando la regressione logistica, k-nearest neighbors, Gaussian naive Bayes e modelli di foresta casuale in Python utilizzando la libreria sklearn. Dimostrano anche come utilizzare il classificatore di impilamento dalla libreria mlx10.

Parte 8

• 07:00:00 In questa sezione, il relatore spiega come implementare un classificatore di stacking utilizzando diversi modelli come K vicini, foresta casuale e regressione logistica. Eseguono la creazione di un'istanza dell'oggetto e l'esecuzione di tre convalide incrociate per selezionare il modello migliore con la massima precisione. Il relatore dimostra anche come tracciare i limiti delle decisioni e utilizzare la ricerca sulla griglia per regolare il compromesso tra bias e varianza. Selezionando i parametri e le funzionalità migliori, il classificatore di stacking può fornire una previsione più accurata rispetto ai singoli modelli.
  
  
• 07:05:00 In questa sezione, l'istruttore riassume gli argomenti trattati nelle sezioni precedenti sull'apprendimento dell'ensemble, tra cui bagging, foreste casuali, boosting, alberi decisionali di boosting del gradiente, AdaBoost e XGBoost. L'istruttore fornisce anche una panoramica dell'impilamento e fornisce esempi dell'algoritmo in azione. La sezione si conclude con un promemoria per l'iscrizione al canale YouTube dell'istruttore e informazioni su un corso di machine learning, CS01, che copre argomenti oltre l'apprendimento d'insieme, tra cui reti neurali, GAN e reti neurali convoluzionali. Infine, l'istruttore prende in giro le prossime sezioni sull'apprendimento senza supervisione e sui progetti futuri.
  
  
• 07:10:00 In questa sezione, il relatore introduce il concetto di apprendimento non supervisionato, che implica solo l'accesso a punti dati senza etichette o un supervisore per guidare il processo di apprendimento. A differenza dell'apprendimento supervisionato, in cui l'output è noto, l'apprendimento non supervisionato implica la creazione di cluster di punti dati per comprenderli meglio. Come esempio motivante, l'oratore suggerisce di segmentare i clienti in un'azienda come Amazon in base alle somiglianze, anche se non ci sono etichette che indichino quale cliente appartiene a quale segmento. L'obiettivo dell'apprendimento non supervisionato è scoprire modelli e strutture nel set di dati.
  
  
• 07:15:00 In questa sezione, l'istruttore discute l'apprendimento non supervisionato e le sue applicazioni. Spiega che i data scientist possono utilizzare l'apprendimento senza supervisione per dividere i clienti in segmenti e fornire consigli per i prodotti in base alla loro attività sul sito web. Usa Amazon come esempio di un'azienda che utilizza l'apprendimento senza supervisione per la segmentazione dei clienti e i motori di raccomandazione. L'istruttore spiega anche che l'apprendimento senza supervisione può essere utilizzato per il raggruppamento in spazi ad alta dimensione, con oggetti simili vicini tra loro e oggetti dissimili lontani. Fornisce esempi di analisi delle sequenze in biologia e raggruppamento di cluster simili nel mondo degli affari come applicazioni dell'apprendimento non supervisionato. Nel complesso, l'istruttore fornisce una breve panoramica dell'apprendimento non supervisionato e delle sue potenziali applicazioni in vari settori.
  
  
• 07:20:00 In questa sezione, il relatore discute diverse applicazioni dell'apprendimento automatico, come il raggruppamento di cluster simili nei dati aziendali per il marketing mirato e l'utilizzo di motori di raccomandazione per suggerire prodotti in base all'attività dell'utente. Il relatore menziona anche la segmentazione dell'immagine per il rilevamento di oggetti, l'analisi del sentimento per determinare se un testo è positivo o negativo e il rilevamento di anomalie per trovare valori anomali in un modello. Queste varie applicazioni dimostrano la versatilità dell'apprendimento automatico in diversi campi.
  
  
• 07:25:00 In questa sezione, il relatore introduce l'argomento del clustering e i diversi tipi di algoritmi di clustering come quelli basati sul centro e basati sulla densità. L'attenzione si concentrerà sull'algoritmo di clustering k-means, che sarà esplorato in profondità. Il relatore incoraggia inoltre gli spettatori a lavorare su serie di problemi e progetti per ottenere una migliore comprensione dell'apprendimento automatico. Il relatore sottolinea l'importanza dell'apprendimento non supervisionato e mostra come il clustering può essere applicato in vari campi. Il clustering su un piano X e Y viene utilizzato per illustrare il concetto di clustering. Nel complesso, la sezione evidenzia i prossimi argomenti da trattare nel corso e incoraggia gli spettatori a continuare a imparare.
  
  
• 07:30:00 In questa sezione, il relatore spiega l'apprendimento e il clustering senza supervisione, che comporta la segmentazione dei dati in diversi cluster. Viene discussa la terminologia della distanza intra-cluster e inter-cluster, dove intra-cluster si riferisce alla distanza tra i punti dati all'interno di un cluster, mentre inter-cluster si riferisce alla distanza tra i cluster. L'obiettivo è avere una piccola distanza all'interno del cluster e una grande distanza tra i cluster, il che significa che i dati all'interno dei cluster dovrebbero essere simili e i dati tra i cluster dovrebbero essere dissimili. Questo è noto come l'obiettivo dell'ottimizzazione.
  
  
• 07:35:00 In questa sezione, apprendiamo le tecniche di valutazione per i modelli di clustering o di apprendimento non supervisionato. La prima tecnica introdotta è l'indice di Dunn, che rappresenta la distanza maggiore tra i cluster divisa per la distanza minima all'interno dei cluster. L'obiettivo è avere un alto indice Dunn, il che significa che la distanza tra i cluster dovrebbe essere grande, mentre la distanza all'interno dei cluster dovrebbe essere piccola. Questa tecnica ci consente di valutare la qualità del nostro modello di clustering.
  
  
• 07:40:00 In questa sezione, l'istruttore discute le tecniche di valutazione per i modelli di clustering. L'attenzione si concentra sull'indice Dunn, che è una matrice di valutazione utilizzata per determinare se l'intra-cluster è grande e l'inter-cluster è piccolo. L'istruttore fornisce la definizione di base dell'indice di Dunn, che prevede la valutazione delle distanze massime tra diversi punti dati all'interno e tra i cluster. Un'altra tecnica di valutazione discussa è l'indice di Davies-Bouldin, che è simile all'indice di Dunn, ma con più vincoli. L'istruttore fornisce anche una definizione di una riga di clustering, che raggruppa oggetti o elementi insieme in un modo specifico.
  
  
• 07:45:00 In questa sezione, il relatore spiega la definizione di base di clustering, che è il processo di organizzazione dei dati in gruppi basati su somiglianze e differenze. Esistono due casi di clustering: intra-cluster e inter-cluster, che misurano rispettivamente la distanza all'interno di un cluster e la differenza tra tutti i cluster. Il relatore discute quindi diversi tipi di clustering, incluso il clustering basato su partizioni, che divide i dati in due cluster, e il clustering gerarchico, che utilizza i dendrogrammi per visualizzare il processo di clustering. Il relatore entra più in dettaglio sul clustering agglomerativo e sul clustering divisivo all'interno del clustering gerarchico, fornendo un esempio di dendrogramma per illustrare il processo.
  
  
• 07:50:00 In questa sezione, l'istruttore copre diversi tipi di clustering, inclusi cluster basati su partizioni, gerarchici, ben separati, basati sul centro e basati sulla densità. L'istruttore spiega che il clustering consiste nel raggruppare oggetti simili in modo che gli oggetti all'interno di un cluster siano simili tra loro e gli oggetti tra i cluster siano diversi. L'istruttore spiega anche come valutare le prestazioni dei modelli di clustering utilizzando diversi indici, tra cui l'indice Dunn e l'indice Davis-Bouldin. La sezione successiva si concentrerà sul clustering k-mean, uno degli algoritmi basati sul centro.
  
  
• 07:55:00 In questa sezione, l'istruttore ricapitola le sottosezioni precedenti che trattavano le applicazioni di apprendimento non supervisionato, i tipi di clustering e l'intuizione e la definizione formale del clustering. L'attenzione si sposta quindi sull'algoritmo di clustering k-means, noto anche come algoritmo di Lloyd, e sulle sue varie caratteristiche come inizializzazione, centroidi, iperparametri, metriche di valutazione e limitazioni. L'istruttore fornisce una visualizzazione dell'algoritmo con due centroidi inizializzati in modo casuale e illustra la fase di assegnazione seguita dalla fase di media nella prima iterazione.

Parte 9

• 08:00:00 In questa sezione, l'istruttore spiega in dettaglio l'algoritmo di clustering k-medie. L'algoritmo prevede l'inizializzazione di k centroidi, l'assegnazione di cluster, l'aggiornamento dei cluster eliminando la media e l'aggiornamento del centroide assegnando il punto dati più vicino. Questo processo viene ripetuto fino a quando i centroidi non cambiano, indicando che l'algoritmo è convergente. L'istruttore menziona anche che il clustering k-mean è anche chiamato algoritmo di Lloyd e comporta l'inizializzazione casuale dei centroidi.
  
  
• 08:05:00 In questa sezione, il relatore spiega i passaggi per l'algoritmo di clustering k-medie. Prima selezionano il numero di cluster (k), quindi assegnano ogni punto al cluster più vicino. Ricalcolano il centroide prendendo la media e spostandola, quindi ripetono il processo finché i centroidi non smettono di cambiare. L'obiettivo di ottimizzazione è minimizzare la funzione di costo, che può essere calcolata utilizzando la distanza euclidea tra punti dati e centroidi del cluster. La funzione di costo è nota anche come SSE (sum squared error) e l'obiettivo è ridurre al minimo la variabilità all'interno del cluster. Il relatore osserva che possono essere utilizzate anche altre metriche di distanza oltre a quella euclidea.
  
  
• 08:10:00 In questa sezione, l'istruttore spiega perché l'inizializzazione casuale dei centroidi nel clustering K-medie può causare problemi e introduce l'algoritmo K-medie++ come soluzione. K-means++ comporta la selezione di più centroidi e la scelta di quello che minimizza la somma degli errori al quadrato (SSE). L'istruttore introduce anche il metodo del gomito, che viene utilizzato per determinare il numero ottimale di centroidi sulla base di un grafico di SSE rispetto al numero di cluster. Si consiglia di utilizzare K-means++ e il metodo del gomito anziché l'inizializzazione casuale per ottenere migliori risultati di clustering nell'apprendimento automatico.
  
  
• 08:15:00 In questa sezione, l'istruttore spiega la tecnica di valutazione per k-medie, che comporta la minimizzazione dell'intra-cluster calcolando la distanza tra i punti all'interno del cluster utilizzando l'errore quadratico della somma. L'inizializzazione dei centroidi ha un impatto sull'algoritmo e la tecnica k-means ++ è un metodo consigliato per selezionare i centroidi in base a più esecuzioni con SSE basso. Il numero di cluster può essere determinato utilizzando il metodo del gomito, dove il valore k ottimale è il punto in cui il gomito gira. L'istruttore menziona anche alcune limitazioni del clustering k-means, come la sensibilità ai valori anomali, che possono essere risolti utilizzando tecniche basate sulla densità come DBSCAN o clustering gerarchico. La complessità temporale del clustering k-mean dipende dalla dimensione dell'input, dal numero di cluster e dalle dimensioni. Il docente consiglia il corso di padronanza DSA per cogliere meglio il concetto di complessità temporale.
  
  
• 08:20:00 cluster con p1 e p2, quindi aggiungiamo p4 a questo cluster. Successivamente, uniamo questo cluster in uno e infine aggiungiamo p3 al cluster per ottenere un cluster. Questo è un esempio di clustering gerarchico, che è una tecnica in cui i punti dati vengono raggruppati insieme in base alle loro somiglianze, formando una gerarchia di cluster. La sottosezione riguarderà anche il clustering agglomerativo e divisivo, nonché un calcolo manuale dell'algoritmo.
  
  
• 08:25:00 In questa sezione, l'oratore spiega il raggruppamento gerarchico e il processo di conversione di un gruppo di numeri in una gerarchia di gruppi. L'esempio fornito mostra come i cluster sono collegati tra loro in base alla somiglianza finché non rimane un solo cluster. L'oratore spiega quindi i due tipi di clustering gerarchico - clustering agglomerativo e divisivo, e fornisce un'intuizione dietro entrambi i metodi. Il clustering agglomerativo è un approccio dal basso verso l'alto in cui più cluster simili sono collegati tra loro, mentre il clustering divisivo è un approccio dall'alto verso il basso in cui i cluster sono divisi in cluster più piccoli in base alla somiglianza.
  
  
• 08:30:00 In questa sezione, l'oratore spiega l'intuizione di base alla base del clustering gerarchico che comporta la creazione di una gerarchia di numeri o cluster. Il clustering può essere eseguito con un approccio dall'alto verso il basso o dal basso verso l'alto, a seconda del tipo di clustering, agglomerativo o divisivo. Il clustering agglomerativo implica l'unione di diversi cluster in uno, mentre il clustering divisivo comporta la divisione di un cluster in singoli gruppi. L'oratore passa quindi a spiegare l'algoritmo per il clustering agglomerativo che comporta il calcolo di una matrice di prossimità e la ripetizione del processo di fusione dei cluster e l'aggiornamento della matrice fino a coprire tutti i cluster. Infine, il relatore fornisce un esempio di matrice approssimata con quattro punti per illustrare il concetto.
  
  
• 08:35:00 In questa sezione, il relatore spiega come creare una matrice di prossimità e un dendrogramma utilizzando un esempio di punti dati. La matrice di prossimità aiuta a misurare la somiglianza tra due punti o cluster, mentre il dendrogramma mostra la gerarchia dei cluster. Il relatore evidenzia i tre metodi utilizzati per misurare la somiglianza tra i cluster, vale a dire min, max e media di gruppo.
  
  
• 08:40:00 In questa sezione, l'istruttore discute due metodi per unire i cluster nel clustering gerarchico: minimo e massimo. L'approccio minimo comporta l'assunzione della somiglianza tra due cluster come distanza minima tra due punti qualsiasi nei cluster. I cluster con la distanza minore vengono uniti per primi e il processo continua finché tutti i punti non si trovano in un singolo cluster. L'approccio massimo è simile, ma prende la somiglianza tra due ammassi come distanza massima tra due punti qualsiasi negli ammassi. L'istruttore fornisce un esempio utilizzando una matrice di prossimità per illustrare questi concetti.
  
  
• 08:45:00 In questa sezione, l'istruttore spiega il concetto di misura di somiglianza intercluster media di gruppo, che è un altro tipo di misura di somiglianza tra cluster. Ne fornisce un'equazione e mostra un dendrogramma per spiegare come funziona. L'istruttore discute quindi gli svantaggi della misura della distanza minima, affermando che è sensibile ai valori anomali e suggerisce che gli studenti possono fare riferimento alle pagine di Wikipedia per una maggiore comprensione. Fornisce anche la complessità del tempo e dello spazio per il clustering agglomerativo, che è dell'ordine di n quadrato per lo spazio e dell'ordine di n log quadrato di n o dell'ordine di n cubo per la complessità temporale. Infine, conclude la sezione esortando gli studenti a esercitarsi con molti progetti per consolidare la loro comprensione dell'apprendimento automatico.
  
  
• 08:50:00 In questa sezione, il relatore discute la sezione progettuale del corso e introduce il modello di previsione dell'insufficienza cardiaca che verrà costruito. Il relatore spiega che il modello prevederà se una persona morirà in base a varie caratteristiche come età, sesso, pressione sanguigna, diabete e fumo. I dati per questo progetto sono disponibili a un link fornito e il relatore spiega che l'obiettivo aziendale di questo progetto è costruire un sistema di intelligenza artificiale sanitaria che aiuterà con la diagnosi precoce dei problemi di salute per salvare vite umane. Inoltre, il relatore menziona che nel corso verrà presentato anche un progetto di sistema di rilevamento dello spam. L'oratore importa le librerie necessarie, carica i dati e stampa la forma dei dati.
  
  
• 08:55:00 In questa sezione, apprendiamo le basi dell'esplorazione dei dati, come il controllo della forma dei dati e delle relative informazioni. Usando il metodo info(), possiamo vedere se ci sono valori nulli, il tipo di dati e l'utilizzo della memoria. Possiamo anche utilizzare il metodo describe() per ottenere informazioni sulla distribuzione statistica dei dati numerici. L'analisi esplorativa dei dati (EDA) è un passaggio essenziale nell'apprendimento automatico, in cui poniamo domande ai dati e troviamo risposte per aiutare a fornire soluzioni aziendali. Per questo problema di classificazione binaria, esamineremo la distribuzione delle classi, dove '1' significa che la persona è morta e '0' significa che la persona è viva.

Parte 10

• 09:00:00 In questa sezione del video, l'istruttore discute il problema dei dati sbilanciati nell'apprendimento automatico. Il frammento di codice mostra la distribuzione dei dati in cui ci sono 203 casi viventi e 96 casi deceduti, che è squilibrata. Dati sbilanciati significa che i dati non sono equamente distribuiti tra le classi e ciò può causare una distorsione del modello verso determinate classi. L'istruttore spiega che i dati sbilanciati sono un grosso problema nell'apprendimento automatico, in cui il modello potrebbe essere più incline a essere addestrato sulla classe maggioritaria e a prevedere quella classe più spesso.
  
  
• 09:05:00 In questa sezione, il relatore spiega il concetto di dati equilibrati e come i modelli funzionano meglio con essi in quanto sono più robusti e imparziali. Proseguono poi mostrando vari modi in cui i dati possono essere analizzati, come la distribuzione per età e il filtraggio dei dati in base a determinate condizioni. L'oratore mostra un codice Python per selezionare le righe in cui l'età è superiore a 50 e vedere se la persona è morta o meno. Usano grafici a torta per visualizzare i dati e rispondere a domande aziendali, ad esempio il numero totale di casi di morte è due volte inferiore rispetto ai casi viventi e che la maggior parte dell'età sale da 40 a 95 anni.
  
  
• 09:10:00 In questa sezione, l'istruttore esamina uno snippet di codice in Python in cui calcola il numero totale di casi dietetici e casi non dietetici. Scoprono che su un totale di 203 casi, la maggior parte dei casi sono casi dietetici, ma oltre 50 di loro hanno più di 50 anni e sono morti. L'istruttore prosegue quindi spiegando come possono rispondere a più domande sulla base di questi dati e rappresentare visivamente i dati per facilitarne la comprensione. Infine, l'istruttore controlla la correlazione tra le variabili e fornisce un grafico per spiegare cosa significa correlazione.
  
  
• 09:15:00 n questa sezione, l'istruttore spiega la correlazione e come varia da meno uno a più uno. Una variabile più vicina a meno uno significa che è molto simile, mentre un valore più vicino a zero significa che non c'è trasmissione lineare. La correlazione di Pearson è un modo per determinare se i dati sono lineari o meno, e più la correlazione è vicina a uno, più i dati sono correlati positivamente. L'istruttore parla della perfetta correlazione e di come le diagonali siano tutte una, il che significa che i quadrati sono in correlazione con ciascuna variabile stessa. Dopo aver discusso i dati e la comprensione, l'istruttore passa allo sviluppo del set di dati e a come suddividere i dati in set di addestramento e test per convalidare il modello funziona meglio. L'istruttore fornisce un esempio di ingegneria delle funzionalità, che consiste nell'aggiungere più funzionalità con variabili categoriali e nell'applicare trasformazioni ai dati per inserire funzionalità. Un termine di interazione aggiunge il prodotto di due caratteristiche e l'istruttore mostra come scorrere tutte le colonne e moltiplicare le due colonne insieme.
  
  
• 09:20:00 In questa sezione, il relatore discute il processo di creazione di un modello e ne valuta l'accuratezza, la precisione, il richiamo e la matrice di confusione. Il relatore utilizza un algoritmo chiamato algoritmo di ottimizzazione per restringere un set di dati con 10.000 punti dati e dieci funzionalità. Spiegano come funziona la discesa del gradiente stocastico e come può essere utilizzata per ridurre al minimo il tempo di calcolo. Inoltre, spiegano termini chiave come "vero positivo" e "classe positiva", che sono importanti per comprendere le prestazioni complessive del modello.
  
  
• 09:25:00 In questa sezione, il relatore spiega i concetti di vero positivo, falso positivo, vero negativo e falso negativo e come vengono utilizzati per creare una matrice di confusione, che mostra il numero di istanze correttamente classificate per positivo e classi negative in un modello. Il relatore discute anche di precisione e richiamo, che rispondono a diverse domande sull'accuratezza delle previsioni positive e sulle loro effettive occorrenze. Il relatore dimostra l'uso della regressione logistica e supporta i classificatori vettoriali con un'ampia messa a punto, nonché i classificatori dell'albero decisionale, utilizzando la ricerca randomizzata per l'ottimizzazione dei parametri. Vengono inoltre presentati i punteggi di addestramento e test per ciascun classificatore.
  
  
• 09:30:00 In questa sezione del video, l'istruttore spiega come costruire un sistema di rilevamento di spam e ham utilizzando un set di dati scaricato dal repository UCI. I dati sono in formato tabella e l'istruttore li legge e li separa in base a una scheda, con le intestazioni impostate su nessuna e le colonne etichettate come "etichetta" e "messaggi". L'obiettivo è classificare i messaggi come spam o non spam (ham) e l'istruttore illustra il processo di messa a punto di diversi modelli (come un classificatore foresta casuale e un classificatore XGBoost) per raggiungere questo obiettivo. L'istruttore sottolinea inoltre l'importanza della selezione delle funzionalità e mostra come salvare il modello XGBoost per un uso futuro. Nel complesso, questo è un progetto interessante che dimostra come l'apprendimento automatico può essere utilizzato per risolvere problemi del mondo reale.
  
  
• 09:35:00 In questa sezione del video, il presentatore passa attraverso il processo di esplorazione e analisi di un set di dati di messaggi di testo che sono stati scaricati da un repository UCI. L'obiettivo è creare un modello di machine learning in grado di distinguere tra messaggi spam e non spam. Il presentatore spiega che i dati di testo devono essere convertiti in numeri affinché il modello possa lavorare e dimostra come utilizzare un vettorizzatore di testo per questo. Quindi esplorano la distribuzione delle classi, osservando che il set di dati è sbilanciato con più messaggi non spam che messaggi spam. Infine, spiegano l'importanza di pulire i dati di testo, poiché piccole differenze di ortografia o maiuscole possono portare a classificazioni errate.
  
  
• 09:40:00 In questa sezione, l'istruttore spiega il processo di preelaborazione del testo, che comporta la conversione di tutto il testo in minuscolo, la sostituzione di alcuni caratteri come 0 e 3 con equivalenti di testo significativi e la rimozione di caratteri non necessari. L'istruttore suggerisce anche di esplorare la derivazione e la lemmatizzazione per una significativa riduzione delle parole nel testo. Viene fornito un esempio utilizzando lambda per applicare la preelaborazione del testo a ciascun messaggio, che viene quindi archiviato in una nuova colonna denominata "testo elaborato".
  
  
• 09:45:00 In questa sezione, l'oratore parla della pre-elaborazione del testo e dell'applicazione dello stemmer usando lo stemmer di Porter per ridurre l'inflessione nelle parole. L'oratore menziona anche l'ingegneria delle caratteristiche, in cui la mano è codificata a zero ed espansa a uno chiamando il metodo map. Il set di addestramento viene quindi convertito in incorporamenti di parole, che convertono le parole in numeri utilizzando tecniche come count vectorizer, tf-idf vectorizer e bag of words. Il testo viene convertito in una matrice sparsa con elementi memorizzati, che viene quindi utilizzata nell'algoritmo Naive Bayes per la classificazione. Infine, l'oratore fornisce un esempio di come testare un nuovo testo chiamando il vettore di conteggio e il modello per determinare se si tratta di spam o meno.
  
  
• 09:50:00 In questa sezione del video, il relatore mostra come costruire un sistema base di rilevamento di spam e ham utilizzando tecniche di elaborazione del linguaggio naturale (NLP), come la trasformazione del vettore di conteggio e la previsione di Naive Bayes. Il sistema prende i messaggi come input, li preelabora e prevede se sono spam o non spam. L'oratore sottolinea che questo è solo un esempio di come lavorare con i dati in PNL e che ci sono varie altre tecniche che possono essere utilizzate. Il relatore conclude il corso e si congratula con gli spettatori per averlo completato.

[MetaQuotes]

Apprendimento automatico per tutti – Corso completo

Apprendimento automatico per tutti – Corso completo

00:00:00 - 01:00:00 Questa parte del video illustra le basi dell'apprendimento automatico, compreso l'apprendimento supervisionato e non supervisionato. Copre anche i diversi modelli disponibili e come usarli. Infine, spiega come misurare le prestazioni di un modello di machine learning.

01:00:00 - 02:00:00 Questa parte spiega come utilizzare l'apprendimento automatico per prevedere i risultati degli eventi. Discute la regressione lineare, la regressione logistica e le macchine vettoriali di supporto. Spiega inoltre come utilizzare una ricerca a griglia per addestrare un modello di apprendimento automatico.

02:00:00 - 03:00:00 Questa parte copre le basi dell'apprendimento automatico, inclusa la regressione lineare e la retropropagazione. Spiega come normalizzare i dati e adattare un modello di regressione lineare utilizzando la libreria TensorFlow.

03:00:00 - 03:50:00 Questo video introduce i concetti di machine learning, compreso l'apprendimento supervisionato e non supervisionato. Dimostra come utilizzare una regressione lineare e una rete neurale per fare previsioni. Il relatore spiega anche come utilizzare l'apprendimento automatico per raggruppare i dati.

Parte 1

• 00:00:00 In questo video, Kylie Ying spiega i modelli di apprendimento supervisionato e non supervisionato, come funzionano e come programmarli su Google Colab.
  
  
• 00:05:00 Questo riepilogo di 1 paragrafo spiega l'apprendimento supervisionato, che è un tipo di apprendimento automatico in cui al computer viene fornito un insieme di input e viene chiesto di prevedere l'etichetta di un dato input.
  
  
• 00:10:00 L'apprendimento supervisionato è il processo di assegnazione di un'etichetta ai dati di input per addestrare un modello di apprendimento automatico. Il modello produrrà quindi una previsione per l'input specificato. L'apprendimento non supervisionato è il processo di utilizzo di dati non etichettati per conoscere i modelli nei dati. Nell'apprendimento per rinforzo, un agente viene addestrato in un ambiente interattivo basato su premi e sanzioni.
  
  
• 00:15:00 Questo video illustra l'apprendimento automatico, le sue varie applicazioni e i vari tipi di dati che può gestire. Copre anche l'apprendimento supervisionato e non supervisionato e la regressione.
  
  
• 00:20:00 In questo video, l'istruttore spiega come funziona l'apprendimento automatico e come utilizzarlo per prevedere i risultati in un set di dati. L'istruttore spiega anche come regolare l'accuratezza di un modello di machine learning dopo l'addestramento.
  
  
• 00:25:00 Questo video discute il concetto di perdita e come influisce sulle prestazioni di un modello di machine learning. La perdita è una misura di quanto è lontana una previsione da un modello di apprendimento automatico dall'etichetta effettiva fornita in un determinato set di dati. Sono disponibili varie funzioni di perdita, ognuna con i propri vantaggi e svantaggi. Infine, il video illustra come calcolare e verificare le prestazioni di un modello di machine learning.
  
  
• 00:30:00 Il video illustra come utilizzare l'apprendimento automatico per prevedere le etichette delle classi da un set di dati. Il set di dati include 10 funzionalità, ciascuna delle quali corrisponde a una classe. Gli istogrammi vengono utilizzati per confrontare visivamente le distribuzioni delle funzionalità tra le classi. Il video si conclude con una discussione su come i dati potrebbero essere migliorati.
  
  
• 00:35:00 In questo video, l'istruttore spiega come utilizzare le tecniche di apprendimento automatico per creare un set di addestramento, convalida e test. L'istruttore dimostra come ridimensionare un set di dati per rendere i valori più comparabili, quindi crea una funzione per trasformare i valori x. Infine, l'istruttore crea un array numpy 2d e chiama la funzione hstack per impilare gli array fianco a fianco.
  
  
• 00:40:00 In questo video, l'istruttore discute i diversi modelli di machine learning disponibili e come utilizzarli nel codice. Tra i modelli discussi ci sono k-vicini più vicini, la regressione lineare e una rete neurale.
  
  
• 00:45:00 In questo video, l'istruttore Alan Siegel esamina le basi dell'apprendimento automatico, incluso l'uso di una funzione di distanza e l'uso degli algoritmi del vicino più vicino. Spiega che, nella classificazione binaria, l'algoritmo del vicino più vicino utilizzerà un valore "k" per determinare quale punto è l'etichetta "più" o "meno". Mostra come questo può essere applicato a un set di dati di proprietà di auto e gravidanza, dimostrando come l'algoritmo del vicino più vicino può determinare quale punto è l'etichetta "più" o "meno" per un dato punto dati.
  
  
• 00:50:00 Questo video illustra come utilizzare l'apprendimento automatico per prevedere la posizione di un punto. Il video spiega come utilizzare un algoritmo k-nearest neighbors per trovare il punto più vicino. Il video spiega anche come utilizzare un rapporto di classificazione per determinare la classificazione del punto.
  
  
• 00:55:00 In questo video viene spiegato un modello di machine learning. Il modello ha un'accuratezza dell'82 percento, una precisione del 77 percento e un richiamo dell'89 percento. Il modello è descritto come ingenuo bayes, che è un semplice modello di apprendimento automatico.

Parte 2

• 01:00:00 La regola di Bayes è una formula matematica usata per calcolare la probabilità di eventi dato che altri eventi si sono già verificati. In questo esempio, la regola di Bayes viene utilizzata per calcolare la probabilità di una malattia dato un test positivo.
  
  
• 01:05:00 Questo video illustra le basi dell'apprendimento automatico, con particolare attenzione all'inferenza bayesiana. Il relatore dimostra come applicare l'inferenza bayesiana ai problemi di classificazione e discute le varie distribuzioni di probabilità coinvolte.
  
  
• 01:10:00 In questo video viene spiegata una regola per ingenui bayes, e viene mostrato che la probabilità di un particolare evento, dato un insieme di dati, è proporzionale alla somma delle probabilità dei singoli eventi.
  
  
• 01:15:00 Questo video spiega come utilizzare l'apprendimento automatico per prevedere gli esiti di eventi, ad esempio se pioverà o meno durante una partita di calcio o che giorno è. Il video passa quindi alla discussione della regressione logistica, che è una tecnica di apprendimento automatico più avanzata. Il video mostra come la linea di regressione può essere utilizzata per prevedere la probabilità di risultati diversi. Il video si conclude con una dimostrazione di come la regressione logistica può essere utilizzata per prevedere se uno studente supererà o meno un determinato test.
  
  
• 01:20:00 In questo video, l'istruttore spiega come utilizzare la regressione lineare per stimare la probabilità che un classificatore sia corretto. Per fare ciò, devono prima riscrivere l'equazione come p è uguale a mx più b. Questa equazione può assumere un intervallo da infinito negativo a infinito, ma deve rimanere tra zero e uno. Per risolvere p, rimuovono il logaritmo delle probabilità, che dà loro p su uno meno la probabilità.
  
  
• 01:25:00 In questo video, il relatore discute tre tipi di modelli di machine learning: regressione lineare, regressione logistica e macchine vettoriali di supporto. Il relatore dimostra come utilizzare ciascun modello e fornisce esempi di come ciascuno potrebbe essere utilizzato.
  
  
• 01:30:00 In questo video, l'istruttore spiega come funziona l'apprendimento automatico e i diversi tipi di algoritmi disponibili. Discute anche su come massimizzare i margini di una macchina vettoriale di supporto (SVM) utilizzando punti dati che si trovano sulle linee di margine.
  
  
• 01:35:00 In questo video, l'autore discute diversi modelli di apprendimento automatico, tra cui le macchine a vettori di supporto (SVM), le reti neurali e la regressione logistica. Mostra che le SVM sono le più accurate delle tre e che le reti neurali possono essere ancora più accurate delle SVM.
  
  
• 01:40:00 Nell'apprendimento automatico, un neurone è un'unità di rappresentazione di base in una rete neurale. Le caratteristiche di input di un neurone vengono moltiplicate per un peso e la somma di tutti questi input moltiplicati viene quindi immessa nel neurone. La funzione di attivazione del neurone altera lo stato lineare dei suoi input in base all'errore associato alle sue previsioni. L'algoritmo di discesa del gradiente viene utilizzato per seguire la pendenza della funzione quadratica verso un errore inferiore.
  
  
• 01:45:00 In questo video, l'istruttore spiega come funziona l'apprendimento automatico e come programmare una rete neurale utilizzando TensorFlow. Continua mostrando come creare una rete neurale sequenziale e come calcolare la perdita rispetto a un peso.
  
  
• 01:50:00 In questo video, il relatore mostra come utilizzare gli algoritmi di machine learning con TensorFlow. Innanzitutto, importano TensorFlow e creano un modello di rete neurale. Successivamente, impostano l'attivazione dei livelli e configurano le metriche di perdita e precisione. Infine, addestrano il modello utilizzando un addestramento di 100 epoche e una divisione di convalida di 32 epoche.
  
  
• 01:55:00 In questo video, l'autore spiega come addestrare un modello di machine learning utilizzando una griglia di ricerca. Discute anche dell'importanza degli iperparametri e di come impostarli.

Parte 3

• 02:00:00 Questo tutorial video mostra come utilizzare l'apprendimento automatico per la previsione e la classificazione. Il video copre le nozioni di base sull'addestramento di un modello di machine learning, la registrazione della cronologia del modello e il tracciato delle prestazioni del modello.
  
  
• 02:05:00 Questo video mostra come creare un modello a perdita minima per una rete neurale utilizzando una tecnica chiamata casting. Il modello funziona in modo simile a un modello che utilizza un SVM e il video mostra anche come creare un rapporto di classificazione utilizzando l'output della rete.
  
  
• 02:10:00 In questo video, l'autore spiega la regressione lineare e come calcolare il residuo. Il residuo è la distanza tra la previsione e il punto dati effettivo e viene utilizzato per determinare la linea di adattamento migliore per la linea di regressione.
  
  
• 02:15:00 Il video discute i concetti di linearità e indipendenza e mostra come questi presupposti possono essere violati nei set di dati non lineari. Passa quindi a discutere le ipotesi di normalità e omoschedasticità e come queste possono essere valutate utilizzando i grafici dei residui.
  
  
• 02:20:00 La misura dell'errore assoluto medio ci dice in media quanto le nostre previsioni sono lontane dai valori effettivi nel nostro set di addestramento.
  
  
• 02:25:00 L'errore quadratico medio (MSE) è una misura del rendimento di una previsione ed è strettamente correlato all'errore assoluto medio. L'RMSE viene calcolato prendendo la somma di tutti i quadrati dei residui e viene utilizzato per misurare il rendimento di una previsione rispetto al suo valore atteso.
  
  
• 02:30:00 Questo video corso di 1 ora copre le basi dell'apprendimento automatico, inclusa la regressione lineare. Il corso copre l'argomento dei residui e come usarli per determinare la migliore linea di adattamento per un set di dati.
  
  
• 02:35:00 Questo video introduce il concetto di machine learning e come utilizzare varie librerie e set di dati. Quindi prosegue spiegando come utilizzare un frame di dati per rappresentare i dati e come analizzare i dati.
  
  
• 02:40:00 Il video illustra come utilizzare l'apprendimento automatico per prevedere il numero di biciclette in diversi momenti della giornata. Mostra come creare un set di addestramento, convalida e test e come utilizzare la funzione numpy.split per dividere il frame di dati in diversi gruppi.
  
  
• 02:45:00 Il video illustra come utilizzare l'apprendimento automatico per risolvere i problemi. L'istruttore fornisce un esempio di utilizzo dell'apprendimento automatico per prevedere la temperatura e fornisce informazioni su come calcolare i coefficienti di regressione e valutare il modello.
  
  
• 02:50:00 In questo video, il creatore mostra come utilizzare l'apprendimento automatico per migliorare le prestazioni di un modello di regressione lineare su un nuovo set di dati.
  
  
• 02:55:00 In questo video, il presentatore spiega come costruire un modello di regressione lineare in Python utilizzando la libreria TensorFlow. Spiegano che è utile normalizzare i dati prima di addestrare il modello e quindi adattare il modello utilizzando la retropropagazione. Mostrano come tracciare la perdita del modello nel tempo e come il modello ha raggiunto un buon adattamento.

Parte 4

• 03:00:00 Questo video spiega i concetti di machine learning in un modo accessibile a tutti. L'istruttore dimostra come utilizzare una rete neurale per prevedere i valori da un set di dati e dimostra l'effetto della modifica di vari parametri.
  
  
• 03:05:00 Questo video copre le basi dell'apprendimento automatico, inclusa la storia della regressione lineare e come utilizzare una rete neurale. Il relatore mostra quindi come calcolare l'errore quadratico medio per una regressione lineare e una rete neurale e confronta i risultati.
  
  
• 03:10:00 In questo video, l'istruttore spiega come funziona l'apprendimento supervisionato e non supervisionato. Discute come una regressione lineare e una rete neurale possono essere utilizzate per fare previsioni.
  
  
• 03:15:00 In questo video, il presentatore spiega come utilizzare l'apprendimento automatico per dividere i dati in tre cluster. Quindi utilizzano queste informazioni per calcolare nuovi centroidi e creare nuovi cluster.
  
  
• 03:20:00 Questo video discute due tipi di apprendimento automatico: l'apprendimento non supervisionato, che cerca modelli nei dati, e l'apprendimento supervisionato, che utilizza un set di addestramento per imparare a prevedere i risultati futuri. Le tecniche di apprendimento senza supervisione includono la massimizzazione delle aspettative e l'analisi delle componenti principali, che riducono la dimensionalità trovando le componenti principali dei dati. Le tecniche di apprendimento supervisionato includono la regressione lineare e l'inferenza bayesiana.
  
  
• 03:25:00 L'apprendimento automatico è un campo di analisi dei dati che aiuta a fare previsioni su dati sconosciuti. In questo corso, l'istruttore spiega come utilizzare l'analisi dei componenti principali (PCA) per ridurre la dimensionalità di un set di dati. Ciò consente una più facile visualizzazione e discriminazione dei punti dati.
  
  
• 03:30:00 In questo video, il presentatore introduce il concetto di regressione lineare e la sua applicazione ai dati bidimensionali (2D). Successivamente, introducono il concetto di analisi dei componenti principali (PCA), che è una tecnica utilizzata per ridurre un set di dati alle sue dimensioni più rilevanti. Infine, discutono dell'uso dell'apprendimento non supervisionato nell'apprendimento automatico.
  
  
• 03:35:00 Questo video illustra come utilizzare l'apprendimento automatico per la classificazione utilizzando l'apprendimento non supervisionato. Il presentatore mostra come utilizzare i panda per importare i dati, quindi confronta i dati l'uno con l'altro per vedere i risultati. Concludono discutendo l'aspetto di alcuni dati e suggeriscono che il clustering potrebbe essere migliorato utilizzando un classificatore diverso.
  
  
• 03:40:00 Il video insegna come utilizzare gli algoritmi di machine learning per raggruppare i dati.
  
  
• 03:45:00 In questo video, un esperto di machine learning spiega come applicare varie tecniche di machine learning per risolvere problemi specifici. Il video copre anche l'analisi dei cluster e la PCA.
  
  
• 03:50:00 Questo video spiega il machine learning e le sue varie fasi, incluso l'apprendimento non supervisionato. Descrive anche come eseguire il clustering utilizzando k-means. Il video si conclude con una discussione sull'apprendimento supervisionato e le sue varie fasi, comprese la classificazione e la regressione.

[MetaQuotes]

Corso intensivo di TensorFlow 2.0

Corso intensivo di TensorFlow 2.0

Il video "TensorFlow 2.0 Crash Course" tratta le basi delle reti neurali e della loro architettura, con particolare attenzione alla classificazione delle immagini. L'istruttore utilizza un gioco del serpente e un set di dati di fashion mnist come esempi per addestrare la rete neurale attraverso il processo di regolazione di pesi e pregiudizi basati su funzioni di perdita. Il video mostra l'importanza della pre-elaborazione dei dati e dell'utilizzo di funzioni di attivazione, come sigmoid e ReLU, per creare modelli più complessi. Il relatore sottolinea inoltre l'importanza dei dati di test e training e dimostra come caricare e modificare i dati dell'immagine per il modello. Infine, il presentatore mostra come definire l'architettura di un modello in Keras, addestrarlo utilizzando metodi di compilazione e adattamento e fare previsioni su immagini specifiche utilizzando "model.predict".

La seconda parte del video tutorial copre vari aspetti della creazione di una rete neurale di base in grado di classificare gli articoli di moda e condurre analisi del sentiment sulle recensioni dei film. Iniziando con il caricamento e la preparazione dei dati per l'addestramento, l'esercitazione prosegue spiegando l'importanza della pre-elaborazione dei dati e della normalizzazione delle lunghezze delle sequenze di input. L'esercitazione copre quindi la creazione di un'architettura del modello adatta, incluso l'utilizzo di livelli diversi come l'incorporamento e i livelli densi. Infine, l'esercitazione spiega come ottimizzare gli iperparametri, convalidare il modello, salvare e caricare modelli e valutare le prestazioni del modello su dati esterni. Nel complesso, il tutorial fornisce una struttura essenziale su cui costruire una conoscenza più avanzata della rete neurale. Copre anche diversi argomenti relativi a TensorFlow 2.0, tra cui la codifica dei dati per il modello, l'esecuzione di un modello salvato per la previsione e l'installazione della versione GPU TensorFlow 2.0 su Ubuntu Linux. Nella sezione di codifica, il presentatore segue il processo di ritaglio e pulizia dei dati per garantire una corretta mappatura delle parole e la creazione di una funzione di ricerca per codificare i dati per la previsione. Dimostrano quindi l'importanza di preparare i dati di input nel formato corretto per il modello da elaborare, prima di passare a un tutorial sull'installazione della versione GPU TensorFlow 2.0 su un sistema Linux, consigliando al pubblico di essere paziente a causa delle dimensioni dei download coinvolti .

• 00:00:00 In questa sezione, l'istruttore introduce il concetto di reti neurali e come funzionano. Le reti neurali sono composte da strati interconnessi di neuroni, in modo simile a come funzionano i neuroni nel nostro cervello. Questi neuroni possono attivarsi o meno e le connessioni tra di loro determinano quando si attivano e quali altri neuroni possono causare l'attivazione. Una rete neurale funziona prendendo l'input da uno strato di neuroni e facendolo passare attraverso uno o più strati nascosti prima di produrre l'output dallo strato finale. L'architettura di una rete neurale può variare a seconda del tipo di problema che viene utilizzata per risolvere, ma un approccio comune consiste nell'utilizzare una rete neurale completamente connessa in cui ogni neurone in un livello è connesso a ogni neurone nel livello successivo. L'istruttore sottolinea l'importanza di comprendere la matematica dietro le reti neurali per essere in grado di crearne di complesse e di successo.
  
  
• 00:05:00 In questa sezione, l'istruttore spiega le basi delle reti neurali e come funzionano per risolvere un problema. Costruisce una semplice rete neurale utilizzando quattro input e un output addestrato per mantenere in vita un serpente in un gioco. L'input è se c'è un ostacolo davanti, a sinistra ea destra del serpente e la direzione di movimento consigliata che ha tre diversi valori: -1 per sinistra, 0 per dritto e 1 per destra. Quando viene fornito un input, la rete neurale fornisce come output uno 0 o un 1, che rappresenta se la direzione consigliata debba essere seguita o meno. È progettato per seguire la direzione consigliata se può mantenere in vita il serpente, altrimenti non lo seguirà.
  
  
• 00:10:00 In questa sezione, il relatore discute l'architettura delle reti neurali e il loro funzionamento. I livelli di input e output sono collegati tramite pesi e l'output viene determinato prendendo la somma ponderata dei valori moltiplicata per questi pesi, includendo anche un valore di bias. La rete viene quindi addestrata inserendo una grande quantità di dati e regolando le distorsioni e i pesi per produrre output accurati. Se l'output è corretto, non vengono apportate modifiche, ma se non è corretto, la rete regola i pesi e le distorsioni per migliorare la precisione.
  
  
• 00:15:00 In questa sezione, l'istruttore spiega il processo di addestramento di una rete neurale, in cui le informazioni vengono passate attraverso la rete in modo che possa regolare pesi e pregiudizi per ottenere risposte più corrette. La rete inizia con pesi e distorsioni casuali e li regola in modo iterativo fino a raggiungere un elevato livello di precisione. Vengono quindi introdotte le funzioni di attivazione, funzioni non lineari che aggiungono complessità alla rete. La funzione di attivazione sigmoidea, in particolare, è descritta come la mappatura di qualsiasi valore di input compreso tra uno negativo e uno, consentendo uscite entro un certo intervallo. Questo introduce più complessità e ricchezza nella rete.
  
  
• 00:20:00 In questa sezione, il relatore discute le funzioni di attivazione e il loro ruolo nelle reti neurali. Queste funzioni consentono una maggiore complessità nel modello abilitando funzioni non lineari, che sono migliori nell'approssimare i dati del mondo reale. Sigmoid è una delle funzioni di attivazione di base che trasforma l'output in un intervallo da 0 a 1. Una funzione utilizzata più di recente è l'unità lineare rettificata (ReLU), che imposta i valori negativi su 0 e rende i valori positivi più positivi, mantenendo così i dati punti all'interno di un intervallo compreso tra 0 e infinito positivo. Il relatore spiega anche che le funzioni di perdita sono fondamentali per comprendere come devono essere regolati pesi e distorsioni nei modelli. Calcolano l'errore tra l'output previsto e l'output effettivo, consentendo una messa a punto e una regolazione più efficienti.
  
  
• 00:25:00 In questa sezione, il relatore spiega il concetto di reti neurali e come i livelli nascosti possono essere utilizzati per creare modelli più complessi in grado di risolvere problemi difficili. Il video si concentra anche sull'importanza dei dati e su come devono essere pre-elaborati e inseriti nella forma corretta prima di essere inviati a un array. L'oratore sta lavorando al tutorial 2.0 di TensorFlow, ma aggiunge ulteriori informazioni che potrebbero creare confusione per chi è nuovo alle reti neurali. L'esercitazione utilizza il set di dati fashion mnist, che contiene immagini di capi di abbigliamento, come esempio per la classificazione delle immagini. Il video termina mostrando agli spettatori come installare TensorFlow 2.0 e matplotlib.
  
  
• 00:30:00 In questa sezione, il video copre i pacchetti necessari da installare come tensorflow, keras, numpy e matplotlib per la rappresentazione grafica e la visualizzazione delle immagini. Il video spiega anche la differenza tra i dati di test e quelli di addestramento, in cui circa il 90-80% dei dati viene passato alla rete per addestrarlo e i dati rimanenti vengono utilizzati per testare l'accuratezza e garantire che la rete non stia semplicemente memorizzando il dati. Il video utilizza Keras per suddividere il set di dati in dati di addestramento e test con etichette. Infine, il video fornisce informazioni sulla rappresentazione dell'etichetta, con ogni immagine con un'etichetta specifica assegnata tra 0 e 9.
  
  
• 00:35:00 In questa sezione, l'istruttore dimostra come caricare e modificare i dati dell'immagine per il modello TensorFlow 2.0. Crea un elenco per i nomi delle etichette, mostrando cosa rappresenta ciascun numero di etichetta. Quindi utilizza la libreria Matplotlib per visualizzare le immagini e spiega che si tratta di matrici di 28x28 pixel. I valori dei pixel sono divisi per 255 per ridurre la dimensione dei dati, facilitando l'utilizzo nel modello. I dati modificati, costituiti da valori decimali, vengono caricati nel modello, che prevederà la classe, ovvero il numero dell'etichetta, tra 0 e 9. L'istruttore conclude menzionando che dimostrerà l'impostazione, l'addestramento e il test del modello nel sezione successiva.
  
  
• 00:40:00 In questa sezione del Crash Course di TensorFlow 2.0, il relatore spiega l'architettura di una rete neurale per la classificazione delle immagini. L'input è un array di 28x28 pixel con valori in scala di grigi, appiattito in un elenco di 784 pixel da inserire nel livello di input della rete neurale. Il livello di output ha 10 neuroni, ognuno dei quali rappresenta una delle 10 classi (0-9). L'obiettivo è fare in modo che il neurone più attivato rappresenti la classe prevista. L'oratore copre anche i livelli nascosti, sottolineando che una rete a due livelli è possibile ma non ideale per attività di riconoscimento delle immagini più complesse.
  
  
• 00:45:00 In questa sezione del corso intensivo TensorFlow 2.0, l'istruttore spiega il concetto di livelli nascosti nelle reti neurali. Aggiungendo uno strato nascosto con 128 neuroni, la rete può analizzare l'immagine e identificare modelli che possono aiutare a riconoscere meglio l'immagine. La selezione di 128 neuroni è alquanto arbitraria e il numero di neuroni per uno strato nascosto dipende dall'applicazione. L'istruttore procede quindi alla definizione dell'architettura o dei livelli per il modello in Keras. L'architettura include uno strato di input appiattito, due strati densi o completamente connessi e uno strato di output con 10 neuroni e attivazione softmax per dare la probabilità che la rete riconosca una particolare classe.
  
  
• 00:50:00 In questa sezione, il video spiega il processo di impostazione dei parametri per un modello e di addestramento utilizzando i metodi "compila" e "adatta" in TensorFlow 2.0. Ciò include la definizione dell'ottimizzatore, della funzione di perdita e delle metriche da utilizzare nel modello compilato prima di impostare il numero di epoche per l'addestramento. Il video fornisce anche una semplice spiegazione di cosa sono le epoche e di come influenzano l'accuratezza del modello. Dopo aver eseguito il file, l'accuratezza del test del modello viene valutata e risulta essere 87, leggermente inferiore all'accuratezza dell'addestramento.
  
  
• 00:55:00 In questa sezione, il presentatore mostra come utilizzare il modello per fare previsioni su immagini specifiche. Spiega che è necessario utilizzare il metodo "model.predict" e passare un elenco o un array np che includa la forma di input delle immagini. Il metodo ti fornirà quindi un gruppo di previsioni, poiché si aspetta che tu passi in una serie di cose diverse e le predice tutte utilizzando il modello. L'output è una serie di elenchi diversi, ciascuno contenente le previsioni del modello per una particolare immagine. Il presentatore osserva che questa caratteristica a volte viene trascurata nei video tutorial, ma è importante capire come utilizzare praticamente il modello.

• 01:00:00 In questa sezione, il relatore mostra come interpretare e convalidare le previsioni di rete utilizzando la funzione np.argmax() che trova l'indice del numero più alto in un elenco. Prendono il valore di questa funzione e lo passano nei nomi delle classi per ottenere il nome effettivo della classe prevista. Il relatore procede all'impostazione di un ciclo for di base per visualizzare diverse immagini dalle immagini di prova e mostra la previsione corrispondente per ciascuna di esse. Mostrano come questo può essere utilizzato per convalidare che il modello sta prevedendo in modo accurato e che la previsione ha senso in relazione all'immagine di input visualizzata. Infine, l'oratore nota una soluzione rapida a un errore che ha riscontrato.
  
  
• 01:05:00 In questa sezione, il video tutorial mostra come creare un modello semplice in grado di classificare articoli di moda, come una camicia o una t-shirt, utilizzando TensorFlow 2.0. L'esercitazione illustra il processo di previsione per più immagini e come prevedere per un'immagine. Il modello si basa su un semplice problema di classificazione ed è progettato per fornire una panoramica delle reti neurali di base. Nei video futuri, il contenuto diventerà più avanzato e coprirà i problemi con dati reali. Sebbene i dati usati in questa esercitazione siano semplici, il caricamento e la pre-elaborazione di set di dati di grandi dimensioni possono essere impegnativi e saranno necessarie modifiche per renderli utilizzabili. Tuttavia, il tutorial fornisce una struttura facile da seguire, offrendo una solida base su cui costruire la conoscenza delle reti neurali.
  
  
• 01:10:00 In questa sezione, l'autore del tutorial spiega come caricare i dati e prepararli per l'addestramento suddividendoli in insiemi di addestramento e test. Introducono il concetto di parole con codifica intera e il modo in cui rappresentano le recensioni dei film. L'autore spiega quindi che questi numeri corrispondono a determinate parole e mostra come mappare questi numeri interi sulle rispettive parole. Dimostrano anche la creazione di un indice di parole che assegna un numero intero univoco a ciascuna parola nel set di dati. Infine, aggiungono chiavi speciali all'indice delle parole e spiegano come verranno utilizzate nelle parti successive del tutorial.
  
  
• 01:15:00 In questa sezione, il relatore spiega il processo di assegnazione dei valori per padding, inizio, sconosciuto e parole inutilizzate alle rispettive chiavi nel set di dati di addestramento e test. Aggiungono un tag pad per fare in modo che tutti i set di recensioni di film abbiano la stessa lunghezza aggiungendo parole di riempimento alla fine di un elenco per rendere l'intera recensione del film della stessa dimensione. Per creare un dizionario che consenta agli interi di puntare a una parola anziché viceversa, viene utilizzato l'elenco di indici di parole inverse per invertire i valori nelle chiavi per ottenere ciò. Infine, l'oratore spiega la funzione per decodificare i dati di addestramento e test in parole leggibili dall'uomo utilizzando una stringa vuota unita e un indice di parole inverso.
  
  
• 01:20:00 In questa sezione, il tutor spiega come normalizzare o impostare una lunghezza definita per tutte le recensioni utilizzando i tag di riempimento per identificare la lunghezza delle recensioni. Il tutor spiega che è impossibile determinare la lunghezza dei neuroni di input perché il set di dati può avere lunghezze diverse, quindi viene utilizzato un tag di riempimento per risolvere questa limitazione. Il tutor dimostra come utilizzare le funzioni di Tensorflow come la pre-elaborazione e la sequenza per riempire le sequenze a una lunghezza specifica o normalizzare tutte le sequenze a una lunghezza definita dall'utente. Infine, il tutor fornisce un riepilogo dell'intera sezione e mette in evidenza i diversi meccanismi utilizzati per caricare, codificare, decodificare e pre-elaborare i dati.
  
  
• 01:25:00 In questa sezione, l'istruttore video continua con la pre-elaborazione dei dati e li finalizza in modo che diventi una forma coerente che possa essere accettata dal modello. Dopo aver verificato la consistenza dei dati, il video passa alla definizione dell'architettura del modello. L'istruttore spiega l'uso di vari livelli come l'incorporamento, il raggruppamento medio globale 1D e i livelli densi con diverse funzioni di attivazione. Discutono anche di come l'output del modello sarà un singolo neurone con un valore compreso tra 0 e 1, indicando la probabilità che la revisione sia positiva o negativa. Il video termina discutendo l'importanza degli incorporamenti di parole e come aiutano a comprendere l'architettura del modello.
  
  
• 01:30:00 In questa sezione, il relatore discute il concetto di vettori di parole e come il livello di incorporamento può aiutare a raggruppare insieme parole con significati simili. Il livello di incorporamento genera vettori di parole, che sono essenzialmente coefficienti in uno spazio a 16 dimensioni, per ogni parola o termine codificato in numero intero nei dati di input. Inizialmente, il livello crea 10.000 vettori di parole per ogni termine e li raggruppa in modo casuale. Il livello quindi determina la somiglianza tra i vettori osservando l'angolo tra loro e cerca di raggruppare parole simili più vicine l'una all'altra. Questo processo aiuta il computer a comprendere il significato e il contesto delle parole, che è essenziale per classificare accuratamente le recensioni dei film come positive o negative.
  
  
• 01:35:00 In questa sezione, il video spiega come il livello di incorporamento in una rete neurale viene utilizzato per raggruppare parole simili in base al loro contesto, piuttosto che solo al loro contenuto. Osservando le parole attorno a una parola particolare, la rete neurale può determinare quali parole sono correlate tra loro e raggrupparle insieme nel livello di incorporamento. L'output di questo livello viene quindi ridimensionato utilizzando un livello di pooling medio globale, che inserisce i dati in una dimensione inferiore per semplificare il calcolo e l'addestramento della rete. Il video fornisce un diagramma di come la rete si occupa dopo che i dati di input sono passati attraverso il livello di incorporamento e i livelli successivi nella rete neurale.
  
  
• 01:40:00 In questa sezione, il video illustra la creazione di uno strato denso per il riconoscimento di schemi in una rete neurale utilizzata per l'analisi del sentimento. La rete neurale prende i vettori di parole che rappresentano parole diverse, ne calcola la media e li passa allo strato denso con 16 neuroni. Lo strato denso cerca modelli di parole e tenta di classificare recensioni positive o negative utilizzando la funzione sigmoide per produrre un valore compreso tra 0 e 1. Il modello viene quindi compilato con un ottimizzatore, una funzione di perdita e l'entropia incrociata binaria per calcolare la differenza tra valori previsti ed effettivi. I dati vengono suddivisi in set di validazione e training per misurare con precisione le prestazioni del modello sui nuovi dati durante il test.
  
  
• 01:45:00 In questa sezione, il relatore modifica i dati del test in dati di convalida, ovvero un sottoinsieme dei dati di addestramento che verranno utilizzati per convalidare il modello. Spiega che gli iperparametri sono importanti nell'apprendimento automatico e nelle reti neurali e che gli utenti devono mettere a punto i singoli parametri per ottenere risultati accurati. Spiega anche il concetto di dimensione del batch, che specifica quante recensioni di film verranno caricate contemporaneamente e lo imposta su 512. Infine, adatta il modello ai dati e lo valuta sui dati del test, che mostra un'accuratezza di 87%. Il relatore sottolinea l'importanza dei dati di convalida e spiega che a volte un modello può essere meno accurato sui nuovi dati.
  
  
• 01:50:00 In questa sezione del video, il relatore spiega come salvare e caricare i modelli in TensorFlow per evitare di dover ripetere il training del modello ogni volta che viene effettuata una previsione, il che può essere particolarmente scomodo per i modelli più grandi che possono richiedere giorni, settimane o addirittura mesi per allenarsi. Dopo aver aumentato la dimensione del vocabolario del modello, il relatore mostra come salvare il modello utilizzando la funzione "model.save()" e gli assegna un nome con estensione ".h5", che è l'estensione utilizzata per i modelli salvati in TensorFlow e Keras. Nei video futuri, il relatore prevede di discutere i modelli di checkpoint e il caricamento di modelli in batch con dati di dimensioni diverse.
  
  
• 01:55:00 In questa sezione, il relatore spiega come salvare e caricare un modello in TensorFlow 2.0. Il modello può essere salvato in dati binari, il che consente di risparmiare tempo quando si effettuano previsioni poiché il modello non deve essere riaddestrato ogni volta. Per caricare il modello, è necessario aggiungere una singola riga di codice con il nome del file. Il relatore mostra quindi come testare il modello su dati esterni aprendo un file di testo nel codice e pre-elaborando i dati in modo che possano essere inseriti nel modello. È importante notare che la dimensione del file di testo deve essere al massimo di 250 parole per corrispondere ai dati di addestramento. La pre-elaborazione include la rimozione di caratteri indesiderati come virgole e parentesi.

• 02:00:00 In questa sezione, il creatore del video discute il processo di codifica e riduzione dei dati a 250 parole in modo che possano essere utilizzati nel modello per la previsione. Simboli come punti, virgolette e parentesi devono essere rimossi per garantire una corretta mappatura delle parole. Viene creata una funzione per cercare le mappature per tutte le parole nei dati e restituire un elenco codificato. Una volta codificati i dati, il modello viene utilizzato per fare una previsione e vengono stampati il testo originale, la revisione codificata e la previsione. Infine, viene definita una funzione review_in_code per convertire i dati della stringa in un elenco codificato.
  
  
• 02:05:00 In questa sezione del video, il relatore esegue il modello salvato e riscontra un errore dovuto a un problema di codifica del codice. Dopo aver risolto il problema, il relatore mostra come tradurre la recensione in un formato che la rete possa comprendere utilizzando un vocabolario di 88.000 parole per assegnare gli indici corrispondenti a ciascuna parola della recensione. L'output risultante identifica accuratamente la revisione come positiva, evidenziando l'importanza di manipolare i dati di input per garantire che siano nella forma corretta per l'elaborazione da parte della rete. Il video passa quindi a un tutorial sull'installazione della versione GPU TensorFlow 2.0 su un sistema Ubuntu Linux, con istruzioni sull'installazione di CUDA e cuDNN per l'accelerazione GPU.
  
  
• 02:10:00 In questa sezione, il relatore guida gli spettatori attraverso il processo di installazione di TensorFlow 2.0 sul proprio computer utilizzando la versione GPU. Forniscono una guida dettagliata all'installazione dei pacchetti NVIDIA, inclusi i driver corretti e lo stesso framework TensorFlow 2.0. Il relatore osserva che, sebbene il processo sia relativamente semplice, potrebbe richiedere del tempo per essere completato a causa delle dimensioni dei download coinvolti. Consigliano inoltre agli spettatori che riscontrano problemi con l'utilizzo della GPU di disinstallare la versione CPU di TensorFlow e di consultare la sezione dei commenti per ulteriore assistenza.

[MetaQuotes]

Python TensorFlow per Machine Learning - Esercitazione sulla classificazione del testo della rete neurale

Python TensorFlow per Machine Learning - Esercitazione sulla classificazione del testo della rete neurale

In questo tutorial di YouTube, il relatore copre una serie di argomenti relativi a Python TensorFlow per l'apprendimento automatico e la classificazione del testo della rete neurale. Iniziano discutendo il processo di configurazione in Google Colab e l'importazione delle librerie necessarie, prima di concentrarsi sul set di dati di Wine Reviews e utilizzare Matplotlib per tracciare gli istogrammi delle varie funzionalità. L'esercitazione copre i concetti di machine learning, incluso l'apprendimento supervisionato, e la differenza tra dati qualitativi e quantitativi, nonché input e previsioni in scenari di classificazione come la classificazione binaria e multiclasse. Altri argomenti trattati includono funzioni di perdita, reti neurali, funzioni di attivazione, discesa del gradiente e retropropagazione, nonché l'implementazione di reti neurali all'interno di TensorFlow. Infine, il relatore implementa una rete neurale utilizzando TensorFlow per la classificazione del testo, dimostrando i vantaggi dell'utilizzo di pacchetti e librerie per aumentare l'efficienza.

La seconda parte del tutorial video copre vari aspetti dell'apprendimento automatico con TensorFlow in Python, concentrandosi in particolare sulla classificazione del testo della rete neurale. Il tutorial copre la suddivisione dei dati in set di addestramento e test, la creazione di un modello semplice con TensorFlow e Keras, il ridimensionamento e il bilanciamento di set di dati, l'utilizzo di reti neurali ricorrenti e l'utilizzo di TensorFlow Hub per la classificazione del testo. Il tutorial sottolinea l'importanza di valutare l'accuratezza del modello e l'uso di vari componenti della rete neurale, come funzioni di attivazione, livelli di abbandono e diversi tipi di celle. Il tutorial si conclude riassumendo i punti chiave, tra cui la creazione di reti neurali, l'utilizzo di TensorFlow per la classificazione del testo e l'utilizzo di dati numerici.

• 00:00:00 In questa sezione del video, Kylie Ying inizia mostrando agli spettatori come configurare un nuovo taccuino in Google Colab e importare le librerie necessarie come NumPy, Pandas, Matplotlib, TensorFlow e TensorFlow Hub. Dopo aver importato queste librerie, carica un set di dati chiamato "Wine Reviews" come file CSV e lo legge come Pandas DataFrame, selezionando le colonne che è interessata ad analizzare, come paese, descrizione, punti e prezzo. Decide di concentrarsi sull'analisi della relazione tra la descrizione e le colonne dei punti per vedere se è possibile addestrare un modello di rete neurale per classificare se una recensione del vino si trova all'estremità inferiore o superiore dello spettro dei punti.
  
  
• 00:05:00 In questa sezione del video, il relatore discute come rilasciare colonne in un dataframe panda e tracciare un istogramma utilizzando Matplotlib. Tracciano la colonna dei punti per vedere la distribuzione dei valori e decidono di classificare le recensioni come inferiori a 90 e superiori a 90. L'oratore fornisce anche una breve spiegazione dell'apprendimento automatico, inclusa la differenza tra intelligenza artificiale, apprendimento automatico e scienza dei dati, con l'apprendimento automatico è un sottoinsieme dell'intelligenza artificiale che si concentra sulla risoluzione di un problema specifico utilizzando i dati. I campi dell'intelligenza artificiale, dell'apprendimento automatico e della scienza dei dati si sovrappongono e possono utilizzare tecniche di apprendimento automatico per analizzare i dati e ricavarne approfondimenti.
  
  
• 00:10:00 In questa sezione, il relatore introduce tre diversi tipi di apprendimento automatico: apprendimento supervisionato, apprendimento non supervisionato e apprendimento per rinforzo. L'esercitazione si concentra sull'apprendimento supervisionato in cui l'input ha un'etichetta di output corrispondente e viene usato per addestrare i modelli per apprendere gli output. Il relatore spiega che il modello di apprendimento automatico apprende i modelli nei dati per elaborare la previsione e che l'elenco degli input è chiamato vettore di caratteristiche. Il relatore discute anche i due diversi tipi di input di dati qualitativi: numeri categorici e finiti di categorie o gruppi. L'esercitazione si concentra sull'uso di coppie di input e output con etichetta per fare previsioni future.
  
  
• 00:15:00 In questa sezione, il video introduce il concetto di caratteristiche qualitative e quantitative e come possono essere codificate in numeri per i computer. Le caratteristiche qualitative, come nazionalità o gruppi di età, sono quelle a cui non è associato un numero e possono essere codificate utilizzando la codifica one-hot. Le caratteristiche numeriche, come le dimensioni di una scrivania o la temperatura del fuoco, sono quantitative e possono essere continue o discrete. Il video distingue anche tra dati nominali, che non hanno un ordinamento intrinseco, e dati ordinali, che hanno un ordinamento intrinseco, e discute come diversi tipi di caratteristiche qualitative possono richiedere diverse tecniche di codifica.
  
  
• 00:20:00 In questa sezione, il relatore spiega i diversi tipi di input e previsioni nell'apprendimento supervisionato. Gli input possono essere continui o discreti, mentre le previsioni possono essere classificate come binarie o multiclasse. Per la classificazione binaria, il modello prevede se un input appartiene a una delle due categorie, mentre la classificazione multiclasse comporta la mappatura degli input a una delle diverse categorie. Inoltre, la regressione viene utilizzata per prevedere i valori continui. L'oratore poi prende in giro l'argomento dei modelli, ma non entra ancora nello specifico. Infine, il relatore accenna brevemente a come fare in modo che il modello impari e valuti le sue prestazioni.
  
  
• 00:25:00 In questa sezione, il relatore discute il set di dati che utilizzerà per un esempio reale e spiega la struttura dei dati. Il set di dati contiene informazioni sugli individui, comprese variabili quantitative come il numero di gravidanze, i livelli di glucosio e la pressione sanguigna, nonché una variabile di risultato che indica se hanno o meno il diabete. Ogni riga rappresenta un individuo diverso e ogni colonna rappresenta una caratteristica diversa che può essere inserita nel modello. Il vettore di caratteristiche è ciò che viene inserito nel modello, con l'obiettivo per quel vettore di caratteristiche che è l'output da prevedere. Il relatore prosegue spiegando che il set di dati è suddiviso in un set di dati di addestramento, un set di dati di convalida e un set di dati di test e che il set di dati di convalida viene utilizzato per verificare che il modello possa gestire dati invisibili prima che il modello sia testato sul set di dati di test.
  
  
• 00:30:00 In questa sezione, il relatore discute le funzioni di perdita e come quantificano la differenza tra i valori previsti ei valori effettivi negli scenari di regressione e classificazione binaria. Nella regressione, la funzione di perdita L1 trova la differenza tra i valori previsti e quelli effettivi, mentre la funzione di perdita L2 eleva al quadrato le differenze. Nella classificazione binaria, la perdita di entropia incrociata binaria trova la differenza tra le probabilità previste e quelle effettive di appartenenza a una particolare classe. Il relatore spiega anche l'accuratezza come misura delle prestazioni negli scenari di classificazione. Infine, il relatore introduce il concetto di modello e come si inserisce nel processo complessivo di apprendimento automatico.
  
  
• 00:35:00 In questa sezione, il relatore discute le reti neurali, affermando che sono popolari per la loro capacità di essere utilizzate per la classificazione e la regressione. Tuttavia, l'oratore menziona anche che le reti neurali sono a volte sovrautilizzate e il loro utilizzo per modelli semplici può non essere necessario. L'oratore discute di come le reti neurali siano una scatola nera e quindi a volte manchino di trasparenza. Spiegano la struttura di una rete neurale, compreso il modo in cui le caratteristiche vengono moltiplicate per pesi e aggiunte ai pregiudizi prima di essere passate attraverso una funzione di attivazione. Il relatore sottolinea l'importanza di utilizzare una funzione di attivazione non lineare per evitare che la rete neurale diventi una semplice regressione lineare.
  
  
• 00:40:00 In questa sezione, il video discute le funzioni di attivazione e il loro ruolo nelle reti neurali. Se una rete neurale utilizzasse semplicemente una funzione lineare, non servirebbe al suo scopo. Le funzioni di attivazione, come sigmoid, tange e relu, consentono a ciascun neurone di essere proiettato in uno spazio non lineare, che consente il processo di addestramento. Il video spiega poi il concetto di discesa del gradiente e propagazione all'indietro, che sono i motivi per cui le reti neurali funzionano. La discesa del gradiente misura la pendenza della funzione di perdita e la propagazione all'indietro regola i valori di peso per ridurre al minimo la perdita. Attraverso questo processo, viene impostato un nuovo valore di peso per ogni parametro, che è il vecchio peso più un po' di alfa.
  
  
• 00:45:00 In questa sezione, il video discute l'implementazione delle reti neurali nell'apprendimento automatico utilizzando librerie come TensorFlow che sono già state sviluppate e ottimizzate. La libreria TensorFlow è una libreria open source che aiuta a sviluppare e addestrare modelli di machine learning. La libreria comprende molti moduli, incluso Keras, che contiene moduli che aiutano gli utenti nella creazione e ottimizzazione di modelli, come diversi ottimizzatori. Il video spiega anche perché è vantaggioso utilizzare librerie consolidate piuttosto che codificare una rete neurale da zero.
  
  
• 00:50:00 In questa sezione, il presentatore mostra agli spettatori come implementare una rete neurale utilizzando TensorFlow per la classificazione del testo. Iniziano introducendo i vantaggi dell'utilizzo di pacchetti e librerie per migliorare l'efficienza, prima di passare alla creazione di un nuovo notebook in cui caricano un set di dati chiamato diabete.csv utilizzando la funzione read csv. Il set di dati proviene dal National Institute of Diabetes and Digestive and Kidney Diseases e include varie caratteristiche e dati demografici del paziente, nonché una classificazione se il paziente ha il diabete. Il relatore mostra quindi come visualizzare i dati tracciando gli istogrammi delle varie caratteristiche, indicizzati in base al fatto che il paziente abbia o meno il diabete, utilizzando un ciclo for nel Jupyter Notebook.
  
  
• 00:55:00 In questa sezione del video tutorial sull'utilizzo di Python TensorFlow per l'apprendimento automatico e la classificazione del testo della rete neurale, il relatore crea un nuovo frame di dati con risultati impostati su zero e un altro con risultati impostati su uno per differenziare i pazienti con diabete e quelli senza. Il passaggio successivo prevede la visualizzazione del numero di pazienti diabetici positivi e negativi, che appare inconcludente poiché non esiste un modello separabile tra i diversi valori. Ciò evidenzia l'importanza dell'apprendimento automatico nella previsione del diabete considerando tutte le caratteristiche insieme. Infine, il presentatore suddivide il frame di dati in valori x e y per un'ulteriore analisi.

• 01:00:00 In questa sezione, il relatore spiega come suddividere i dati in set di addestramento e test utilizzando il modulo Scikit-learn. L'oratore importa il modulo, chiama la funzione train_test_split e passa le funzionalità di input e output. La dimensione del test è impostata al 20%, mentre la dimensione dell'addestramento è impostata al 60% del set di dati. I set temporanei vengono quindi utilizzati per creare set di convalida e test utilizzando una suddivisione 50/50. Infine, il relatore costruisce un modello semplice utilizzando TensorFlow e Keras, in particolare lo strato denso con 16 neuroni che sono densamente connessi allo strato precedente.
  
  
• 01:05:00 In questa sezione, il relatore spiega il processo di creazione di una rete neurale per la classificazione binaria utilizzando TensorFlow in Python. Aggiungono livelli e una funzione di attivazione chiamata sigmoid che associa l'input alle probabilità che qualcosa appartenga o meno a una singola classe. Il modello viene quindi compilato con un ottimizzatore chiamato "adam", una funzione di perdita chiamata "binary cross-entropy" e una metrica per la precisione. Prima di addestrare il modello, ne valutano le prestazioni sui dati di addestramento e convalida, che producono una bassa precisione. Infine, il relatore addestra il modello utilizzando la funzione "model.fit", passando i dati di addestramento e convalida, la dimensione del batch e il numero di epoche.
  
  
• 01:10:00 In questa sezione, il relatore discute la necessità di ridimensionare le funzionalità del set di dati per assicurarsi che si trovino su un intervallo più standardizzato. Il relatore spiega come importare il pacchetto necessario per ridimensionare le funzionalità utilizzando la pre-elaborazione sklearn e lo scalare standard. Dopo aver ridimensionato le funzionalità, il relatore controlla l'intervallo di valori e traccia il frame di dati trasformato per dimostrare che la maggior parte delle funzionalità si trova ora su una scala simile. Il ridimensionamento delle funzionalità aiuta a garantire che le funzionalità non influenzino il risultato della rete neurale a causa dei diversi intervalli.
  
  
• 01:15:00 In questa sezione, il video tutorial si concentra sulla normalizzazione e il bilanciamento del set di dati attraverso un processo chiamato oversampling casuale. Visualizzando i dati, l'istruttore dimostra come il set di dati per i pazienti diabetici e non diabetici sia fortemente sbilanciato, portando a una rete neurale che potrebbe non allenarsi bene. Utilizzando il random over sampler, più campioni casuali vengono aggiunti al set di dati, bilanciando le lunghezze delle due categorie. Ciò si ottiene importando un altro pacchetto chiamato Imbalance learn dot over sampling che include un Random Over Sampler. Il set di dati viene nuovamente suddiviso utilizzando la funzione fit_resample rendendo entrambi i risultati approssimativamente uguali a uno. Dopo aver rieseguito le celle, l'accuratezza del modello è più vicina al 50%, indicando che il bilanciamento del set di dati ha portato a prestazioni migliori del modello.
  
  
• 01:20:00 In questa sezione, il creatore valuta il modello di rete neurale su un set di dati di test e raggiunge un'accuratezza del 77,5%, dimostrando che il modello riesce a generalizzare a dati invisibili. Il tutorial passa quindi a discutere le reti neurali ricorrenti (RNN) e come sono utili per i dati che coinvolgono sequenze o serie. Gli RNN consentono la creazione di una memoria all'interno della rete neurale, consentendole di ricordare le informazioni dei passaggi temporali precedenti. Tuttavia, l'uso di RNN può portare a problemi come l'esplosione o la scomparsa dei gradienti durante la propagazione all'indietro.
  
  
• 01:25:00 In questa sezione, il relatore discute i problemi con i gradienti che si avvicinano sempre di più allo zero, il che impedisce l'aggiornamento e l'apprendimento dei modelli. Per combattere questo, ci sono diversi tipi di cellule o neuroni che possono essere utilizzati, come l'unità ricorrente recintata e l'unità di memoria a lungo termine. Il relatore passa quindi a un esempio di TensorFlow con classificazione del testo utilizzando recensioni di vini e dimostra come suddividere i dati in set di dati di addestramento, convalida e test. L'oratore utilizza la funzione split di numpy per mostrare un modo diverso di suddividere i dati e sottolinea l'importanza di essere flessibili quando si lavora con i set di dati.
  
  
• 01:30:00 In questa sezione, il tutorial video illustra come suddividere un set di dati in set di addestramento, convalida e test e come convertirli in un oggetto tf.data.Dataset in TensorFlow. L'istruttore utilizza una dimensione batch maggiore e tf.data.autotune a causa delle dimensioni elevate del set di dati e regola il codice della funzione per modificare la variabile di destinazione in "etichetta" poiché i dati sono già stati etichettati. Il tutorial spiega anche come funziona l'hub TensorFlow, utilizzato per la classificazione del testo in questo tutorial. Il video mostra come visualizzare i set di dati anche all'interno degli oggetti del set di dati TensorFlow.
  
  
• 01:35:00 In questa sezione, il tutorial video illustra come utilizzare TensorFlow Hub, un repository di modelli di machine learning preaddestrati, per facilitare la classificazione del testo. Il video spiega che i computer non capiscono il testo, quindi il testo deve essere trasformato in numeri che il computer può capire. Per fare questa trasformazione, il video utilizza nnlm, un incorporamento di testo basato su token addestrato sulle notizie di Google in inglese, e converte tutto il testo in un vettore di numeri. Il video mostra quindi come costruire un modello di rete neurale utilizzando TensorFlow Keras con uno strato denso, la funzione di attivazione ReLU e un output di classificazione binaria. Il video compila il modello e lo valuta sui dati di addestramento e validazione, mostrando una precisione di circa il 40%.
  
  
• 01:40:00 In questa sezione del video, il relatore addestra un modello di machine learning e osserva i risultati. La precisione dell'addestramento aumenta e la perdita diminuisce, a indicare che il modello è ben addestrato. Tuttavia, l'accuratezza della convalida raggiunge un plateau e addirittura diminuisce leggermente, indicando che il modello non si sta generalizzando bene e si sta adattando eccessivamente. Per risolvere questo problema, il relatore suggerisce di aggiungere livelli di abbandono, che selezionano casualmente alcuni nodi da "disattivare" durante ogni iterazione di addestramento. Ciò introduce più casualità e variabilità nel modello, aiutandolo a generalizzare meglio. Infine, il relatore ripete il livello hub e compila il modello.
  
  
• 01:45:00 In questa sezione, l'utente valuta la rete neurale creata e addestrata nella sezione precedente. La perdita sta diminuendo e la precisione sta aumentando, ma l'utente interrompe l'allenamento in anticipo dopo sole cinque epoche. Il modello viene valutato sui dati del test e l'accuratezza è di circa l'83%. L'utente mostra quindi come ricreare il modello utilizzando un LSTM e inizia creando un codificatore con un token massimo impostato su 2000. Il modello viene quindi definito utilizzando il codificatore e un livello di incorporamento con una dimensione di input impostata sulla lunghezza del vocabolario del codificatore e una dimensione di output impostata su 32. Infine, viene aggiunto un livello LSTM con 32 nodi.
  
  
• 01:50:00 In questa sezione del video, l'istruttore costruisce la rete neurale aggiungendo uno strato denso e uno strato di abbandono per evitare l'overfitting. La funzione di attivazione per l'output è sigmoid, mentre l'input richiede un tokenizer. L'accuratezza del modello risulta essere di circa 53 e la perdita di circa 0,7. Quindi, il modello viene addestrato valutando i dati di addestramento e convalida. Alla fine della formazione, l'accuratezza dei dati di test risulta essere 84. Il tutorial termina con l'istruttore che riassume il takeaway, che sta imparando come costruire una rete neurale feed-forward, utilizzare TensorFlow per la classificazione del testo e implementare numeri dati.

[MetaQuotes]

Corso completo TensorFlow 2.0 - Reti neurali Python per principianti Tutorial (parti 1-4)

Corso completo TensorFlow 2.0 - Reti neurali Python per principianti Tutorial

00:00:00 - 01:00:00 Questo video fornisce un'introduzione a TensorFlow 2.0, una libreria per la manipolazione dei dati e l'apprendimento automatico. L'istruttore spiega cos'è un tensore e come utilizzare i tensori per memorizzare calcoli parzialmente definiti. Dimostra anche come utilizzare le funzioni TF dot rank e TF dot reshape per controllare il numero di dimensioni in un tensore.

01:00:00 - 02:00:00 Il tutorial video spiega come utilizzare la regressione lineare per prevedere i valori in un set di dati. Il set di dati Titanic viene utilizzato come esempio. Il presentatore spiega come viene utilizzata la regressione lineare per prevedere i valori in un set di dati e come creare colonne di funzionalità in un set di dati utilizzando TensorFlow.

02:00:00 - 03:00:00 Questo tutorial video tratta le basi dell'utilizzo di Python per le reti neurali. Il video inizia con una descrizione di come una rete neurale è composta da strati di neuroni interconnessi. Il video illustra quindi come creare un generatore di numeri casuali e come addestrare una rete neurale. Infine, il video mostra come collegare neuroni e pesi, come passare le informazioni attraverso la rete e come calcolare il valore di output di un neurone.

03:00:00 - 04:00:00 Questo video spiega come utilizzare TensorFlow per creare una rete neurale convoluzionale per il riconoscimento delle immagini. Il video copre le basi delle reti neurali convoluzionali, incluso il modo in cui funzionano e come utilizzare modelli pre-addestrati.

04:00:00 - 05:00:00 Questo video spiega come utilizzare TensorFlow per addestrare un modello di machine learning in grado di prevedere la classe di un'immagine. Il video copre concetti di base come il deep learning e le reti neurali convoluzionali.

05:00:00 - 06:00:00 Questo video è una guida completa all'utilizzo di TensorFlow 2.0 per l'addestramento delle reti neurali. Copre le forme di input e output della rete neurale, come creare una funzione di perdita e come utilizzare il modello per prevedere una sequenza. Il video mostra anche come generare testo con TensorFlow.

06:00:00 - 06:50:00 Questo video tutorial introduce le basi di TensorFlow 2.0, una potente libreria di machine learning. Dopo aver introdotto TensorFlow e i suoi concetti chiave, il tutorial guida gli spettatori attraverso una serie di esercitazioni su diverse attività di machine learning come il deep learning e il reinforcement learning.

Parte 1

• 00:00:00 Questo video tutorial insegna ai principianti come utilizzare TensorFlow 2.0 per le reti neurali in Python. L'istruttore spiega le differenze tra intelligenza artificiale, reti neurali e apprendimento automatico e fornisce risorse per il corso, inclusi esercizi pratici ed esempi di codice.
  
  
• 00:05:00 L'apprendimento automatico è un sottocampo dell'intelligenza artificiale che consente ai computer di generare regole per se stessi, senza dover essere esplicitamente programmati.
  
  
• 00:10:00 Il video spiega le basi delle reti neurali e del deep learning e come funzionano questi sistemi trasformando i dati attraverso più livelli. Le reti neurali possono essere utilizzate per una varietà di attività, tra cui l'apprendimento automatico e l'intelligenza artificiale. Il video fornisce anche un set di dati di esempio dei voti degli studenti.
  
  
• 00:15:00 Questo video discute la differenza tra intelligenza artificiale, apprendimento automatico e reti neurali, quindi passa all'apprendimento supervisionato.
  
  
• 00:20:00 L'apprendimento automatico senza supervisione viene utilizzato quando non abbiamo dati di input. Viene utilizzato per individuare gruppi di punti dati simili.
  
  
• 00:25:00 Questo video fornisce una panoramica di tre diversi tipi di apprendimento automatico: apprendimento supervisionato, non supervisionato e per rinforzo. L'ultimo tipo, l'apprendimento per rinforzo, viene spiegato più dettagliatamente con un esempio di gioco in cui un agente di intelligenza artificiale (AI) cerca di raggiungere un obiettivo specifico.
  
  
• 00:30:00 In questo video viene fornita un'introduzione di base a TensorFlow, seguita da una discussione su come funziona la libreria a un livello inferiore. TensorFlow viene quindi discusso in modo più dettagliato, inclusi i due componenti principali: grafici e sessioni. Un grafico è una raccolta di calcoli parziali correlati tra loro e una sessione è un modo per eseguire una parte o l'intero grafico.
  
  
• 00:35:00 In questo video, l'istruttore introduce le basi di TensorFlow, incluso il concetto di grafici e sessioni. Quindi dimostra come utilizzare Google Collaboratory per creare ed eseguire blocchi di codice, nonché importare e utilizzare vari moduli. Infine, discute i vantaggi dell'utilizzo di TensorFlow su un computer con risorse limitate.
  
  
• 00:40:00 In questo video, l'istruttore dimostra come importare e utilizzare TensorFlow 2.0 con le reti neurali Python. TensorFlow è una libreria per la manipolazione dei dati e l'apprendimento automatico. TensorFlow 2.0 è una nuova versione della libreria che migliora le prestazioni. L'istruttore spiega anche cos'è un tensore e come generalizza vettori e matrici.
  
  
• 00:45:00 TensorFlow 2.0 introduce i tensori, che sono oggetti importanti che memorizzano calcoli parzialmente definiti. I tensori hanno un tipo di dati e una forma e ogni tensore ha un rango e un grado. Per determinare il rango di un tensore, utilizzare il metodo TF dot rank.
  
  
• 00:50:00 In questo video, l'autore introduce il concetto di forme tensoriali e spiega come possono essere utilizzate per identificare il numero di elementi in un tensore. Introduce anche il concetto di rango tensoriale e mostra come può essere utilizzato per controllare il numero di dimensioni in un tensore. Infine, dimostra come rimodellare un vettore di dati in una forma diversa utilizzando la funzione TF dot reshape.
  
  
• 00:55:00 Questo video insegna le basi dei tensori, inclusi i loro diversi tipi, come creare e valutare i tensori e come rimodellarli.

Parte 2

• 01:00:00 Questo video spiega l'idea di base della regressione lineare, che è un algoritmo di apprendimento automatico utilizzato per prevedere i valori futuri dai dati passati. La regressione lineare viene utilizzata quando i punti dati sono correlati in modo lineare.
  
  
• 01:05:00 In questo tutorial imparerai come utilizzare la regressione lineare per prevedere nuovi punti dati utilizzando una linea di best fit.
  
  
• 01:10:00 In questo video, il presentatore spiega come viene utilizzata la regressione lineare per prevedere i valori in un set di dati. Prima spiegano come funziona la regressione lineare in tre dimensioni e poi mostrano come codificarla in TensorFlow.
  
  
• 01:15:00 Il video introduce il set di dati del Titanic e spiega perché la regressione lineare è un buon algoritmo per prevedere chi sopravviverà sulla nave. Il set di dati viene caricato in panda ed Excel.
  
  
• 01:20:00 Questo video spiega come utilizzare un frame di dati per memorizzare i dati e come utilizzare l'operatore punto per cercare valori specifici all'interno del frame di dati.
  
  
• 01:25:00 In questo video, l'istruttore spiega le basi dei tensori e come vengono utilizzati nell'apprendimento automatico. Quindi mostra come creare un modello utilizzando un set di dati di addestramento e un set di dati di test.
  
  
• 01:30:00 In questo video, l'autore spiega come creare colonne di caratteristiche in un set di dati utilizzando TensorFlow. Queste colonne verranno utilizzate per addestrare uno stimatore lineare o un modello.
  
  
• 01:35:00 In questo video, l'istruttore spiega come creare colonne di caratteristiche e colonne numeriche in un modello TensorFlow e come addestrare il modello utilizzando i batch.
  
  
• 01:40:00 Il corso completo TF 2.0 spiega come creare una rete neurale utilizzando Python e come addestrare e valutare la rete. L'esercitazione video mostra come creare una funzione di input e come utilizzare la funzione per creare immagini del set di dati del panda.
  
  
• 01:45:00 Questo riepilogo di 1 paragrafo spiega come utilizzare un modello TensorFlow per fare previsioni su un set di dati. Innanzitutto, crei il modello utilizzando la sintassi dal modulo stimatore. Successivamente, si addestra il modello utilizzando un oggetto classificatore lineare. Infine, si valuta il modello e si stampa la precisione.
  
  
• 01:50:00 Questo video illustra come utilizzare TensorFlow per creare reti neurali per prevedere i risultati, incluso come scorrere le previsioni e accedere ai valori effettivi.
  
  
• 01:55:00 In questo tutorial, l'autore mostra come utilizzare TensorFlow per addestrare una rete neurale per prevedere le specie di fiori da un set di dati. L'autore spiega anche i diversi tipi di reti neurali e come utilizzare le funzioni di input per ottimizzarne le prestazioni.

Parte 3

• 02:00:00 In questo video, l'autore illustra il processo di creazione di una rete neurale in TensorFlow 2.0 e spiega i diversi modelli disponibili. Quindi mostrano come costruire la rete neurale e addestrarla utilizzando un classificatore dnn.
  
  
• 02:05:00 In questo video viene creata una funzione di addestramento e valutazione per una rete neurale. Un lambda viene utilizzato per definire la funzione in una riga. La funzione viene quindi utilizzata per addestrare la rete neurale. Viene visualizzata la precisione della rete neurale addestrata.
  
  
• 02:10:00 Il video mostra come utilizzare la funzione di previsione di TensorFlow per prevedere la classe di un fiore. L'utente inserisce prima le caratteristiche del fiore, come la lunghezza del sepalo, la lunghezza del petalo e la larghezza. Quindi, creano un dizionario predittivo e lo alimentano con le caratteristiche. TensorFlow prevede quindi la classe del fiore in base alle caratteristiche di input. Infine, l'utente stampa la previsione e la probabilità della previsione.
  
  
• 02:15:00 Questo video copre le basi delle reti neurali, inclusa la classificazione e il clustering.
  
  
• 02:20:00 Il video illustra come utilizzare le reti neurali Python per raggruppare i punti dati. Dopo aver etichettato tutti i punti dati, il video spiega come trovare il centro di massa più vicino tra tutti i cluster e come riassegnare i punti dati al cluster più vicino.
  
  
• 02:25:00 In questo video, l'istruttore tratta le basi delle reti neurali e dei modelli di Markov nascosti. Inizia discutendo i tipi di dati utilizzati nell'apprendimento automatico, come k-medie e regressione lineare. Quindi discute un modello meteorologico di base e come creare un modello Markov nascosto per prevedere il tempo in un dato giorno.
  
  
• 02:30:00 In questo video tutorial, il relatore introduce le basi di TensorFlow, incluso il suo utilizzo per le reti neurali. Prosegue quindi dimostrando come creare un modello meteorologico di base in TensorFlow, utilizzando due stati e due distribuzioni di probabilità. Il presentatore mostra quindi come utilizzare il modello per prevedere la temperatura per la settimana successiva.
  
  
• 02:35:00 Questo video mostra come utilizzare TensorFlow per creare una rete neurale per prevedere la temperatura media in ogni giorno di una data sequenza. Il video spiega come importare i moduli necessari e creare un modello. Il modello prevede correttamente la temperatura media nel primo giorno della sequenza, ma prevede la temperatura errata nei giorni successivi. Dopo aver risolto il problema, il video mostra come utilizzare un modulo TensorFlow diverso per prevedere con successo la temperatura media in ogni giorno della sequenza.
  
  
• 02:40:00 Questo video descrive come eseguire un modello in TensorFlow 2.0 utilizzando il comando Media. Questo è un comando utile per confrontare i valori attesi delle variabili in un modello.
  
  
• 02:45:00 In questo modulo, l'istruttore parlerà delle reti neurali e del loro funzionamento, oltre a spiegare come una rete neurale è composta da livelli. Discuterà anche di come un livello di input riceve i dati grezzi e di come una rete neurale sarebbe in grado di classificare tali dati.
  
  
• 02:50:00 Il "Corso completo TensorFlow 2.0 - Tutorial sulle reti neurali Python per principianti" fornisce una guida passo passo alla creazione di una rete neurale di base in Python. Il primo strato è un neurone di input, seguito da uno strato nascosto e quindi da uno strato di output. Il livello di output ha un neurone per ogni informazione di input e i neuroni nel livello nascosto sono collegati tra loro e al livello di output. Il livello nascosto è connesso al livello di input e al livello di output, che è chiamato rete neurale densamente connessa.
  
  
• 02:55:00 Questo video tutorial dimostra come utilizzare Python per le reti neurali, mostrando come creare un generatore di numeri casuali e addestrare una rete neurale. Il video spiega anche come collegare neuroni e pesi, come passare le informazioni attraverso la rete e come calcolare il valore di output di un neurone.

Parte 4

• 03:00:00 In questo video viene spiegata una rete neurale Python, con l'ausilio di una funzione di attivazione. Questa funzione schiaccia/quadra i numeri negativi e positivi, consentendo alla rete di identificare più facilmente tra i colori rosso e blu.
  
  
• 03:05:00 In questo video, l'autore spiega il concetto di funzione di attivazione e come influisce sull'output di una rete neurale. Spiega inoltre come utilizzare una funzione di attivazione per introdurre complessità nella rete. L'autore passa poi a discutere una funzione di perdita, che viene utilizzata per addestrare una rete neurale.
  
  
• 03:10:00 Questo video introduce il concetto di reti neurali e descrive le tre principali funzioni di perdita utilizzate nell'addestramento delle reti neurali: errore quadratico medio, errore assoluto medio e perdita di cerniera. Passa quindi a spiegare la discesa del gradiente, che è l'algoritmo utilizzato per ottimizzare le prestazioni della rete neurale.
  
  
• 03:15:00 Questo video tutorial introduce le basi di TensorFlow, incluso come creare e addestrare una rete neurale. Il video copre anche l'uso di un algoritmo di ottimizzazione della rete neurale e spiega come valutare le prestazioni di una rete neurale.
  
  
• 03:20:00 In questo video, l'istruttore mostra come utilizzare TensorFlow per addestrare una rete neurale in Python. Il set di dati utilizzato nella dimostrazione include immagini di diversi tipi di abbigliamento e l'istruttore mostra come utilizzare le funzioni di addestramento e test in TensorFlow per convalidare le previsioni della rete.
  
  
• 03:25:00 In questo video, l'istruttore descrive le basi di una rete neurale, inclusi gli strati e i nodi in una rete neurale, e la funzione di attivazione utilizzata per determinare il valore di output per un neurone. L'istruttore descrive anche come creare un modello in TensorFlow e come eseguire il modello.
  
  
• 03:30:00 In questo video tutorial di 1 ora, il creatore copre le basi di TensorFlow, inclusa l'architettura e la funzione di una rete neurale. Quindi mostrano come compilare e adattare una rete neurale e infine addestrarla su un set di addestramento. Viene spiegato l'overfitting e l'accuratezza del modello addestrato viene confrontata con quella di un set di test.
  
  
• 03:35:00 In questo video, l'istruttore spiega come le reti neurali possono sovradimensionarsi e come migliorare la generalizzazione modificando gli iperparametri. Quindi dimostra come fare previsioni sulle immagini di prova utilizzando l'oggetto previsto dalla rete neurale.
  
  
• 03:40:00 Questo video tutorial insegna come utilizzare TensorFlow per creare una rete neurale convoluzionale per la visione artificiale profonda. Il video illustra cos'è una rete neurale convoluzionale, come funziona e come utilizzare modelli pre-addestrati.
  
  
• 03:45:00 Il video spiega la differenza tra una rete neurale densa e una rete neurale convoluzionale e spiega che una rete neurale convoluzionale apprende schemi locali anziché schemi globali.
  
  
• 03:50:00 La rete neurale convoluzionale (CNN) è un algoritmo di apprendimento automatico utilizzato per analizzare e comprendere le immagini. La rete neurale convoluzionale è composta da un numero di livelli diversi che vengono utilizzati per analizzare e comprendere l'immagine. Il primo livello viene utilizzato per identificare la presenza di filtri specifici nell'immagine.
  
  
• 03:55:00 In questo video, l'istruttore spiega come trovare un filtro in un'immagine utilizzando il prodotto incrociato. Il filtro viene determinato in base a quanto sono simili i valori dei pixel tra l'immagine e il filtro.

[MetaQuotes]

Corso completo TensorFlow 2.0 - Reti neurali Python per principianti Tutorial (parti 5-7)

Corso completo TensorFlow 2.0 - Reti neurali Python per principianti Tutorial

Parte 5

• 04:00:00 Il video illustra come funzionano le reti neurali convoluzionali e come padding e stride aiutano a rendere la rete più facile da usare.
  
  
• 04:05:00 In questo video, l'istruttore spiega come le operazioni di pooling, come min e max, vengono utilizzate per ridurre la dimensionalità di una mappa delle caratteristiche. Quindi dimostra come ciò viene fatto mostrando come campionare i valori da una mappa delle caratteristiche e generare una mappa delle caratteristiche con dimensionalità ridotta. Successivamente, l'istruttore mostra come utilizzare un'operazione di raggruppamento due per due per ridurre della metà le dimensioni della mappa delle caratteristiche. Quindi dimostra come utilizzare un'operazione di max pooling per trovare caratteristiche in un'area. Quindi dimostra come utilizzare un'operazione di pooling medio per trovare caratteristiche in un'area. Infine, l'istruttore mostra come utilizzare Kerris per creare una rete neurale convoluzionale.
  
  
• 04:10:00 In questo video tutorial, l'istruttore dimostra come creare una rete neurale convoluzionale (CNN) utilizzando Python. Il primo livello della CNN è un livello di pooling massimo che riduce la dimensionalità dei dati di input. I due livelli successivi sono uno strato convoluzionale e uno strato di pool massimo. Il livello finale è un livello denso che classifica i dati di input.
  
  
• 04:15:00 Questo video spiega come l'aumento dei dati può essere utilizzato per migliorare le prestazioni di un modello di machine learning. L'aumento dei dati comporta la modifica di un'immagine per renderla più simile ai dati di addestramento, il che può migliorare la capacità di generalizzazione del modello.
  
  
• 04:20:00 Questo video mostra come utilizzare modelli preaddestrati in TensorFlow 2.0 per migliorare la precisione delle classificazioni.
  
  
• 04:25:00 In questo video, il presentatore spiega come utilizzare un modello TensorFlow preaddestrato per riconoscere le immagini di diversi animali. Innanzitutto, spiegano come caricare il modello in TensorFlow e ridimensionare le immagini alla stessa dimensione. Successivamente, mostrano come applicare il modello ai set di dati di addestramento e convalida. Infine, dimostrano come utilizzare il modello per riconoscere immagini di animali.
  
  
• 04:30:00 In questo video, l'istruttore dimostra come creare una rete neurale utilizzando TensorFlow 2.0 per l'addestramento su un set di dati di 1000 classi di cani e gatti. La rete viene pre-addestrata utilizzando un modello di base e quindi viene aggiunto un livello di previsione. L'istruttore mostra anche come congelare i parametri addestrabili di un livello in modo che la rete non venga riaddestrata quando la si utilizza per la previsione. Il modello viene quindi valutato e addestrato su un nuovo set di dati.
  
  
• 04:35:00 Questo video spiega come utilizzare TensorFlow per addestrare un modello in grado di prevedere la classe di un'immagine. Il video copre concetti di base come il deep learning e le reti neurali convoluzionali.
  
  
• 04:40:00 Questo video spiega come le reti neurali ricorrenti possono essere utilizzate per comprendere ed elaborare il linguaggio naturale. La prima sezione discute cos'è l'elaborazione del linguaggio naturale e in che modo le reti neurali ricorrenti differiscono dalle normali reti neurali. La seconda sezione illustra come convertire i dati testuali in dati numerici che possono essere utilizzati da una rete neurale ricorrente. La sezione finale illustra come utilizzare le reti neurali ricorrenti per eseguire l'analisi del sentiment e la generazione di testo con barra dei caratteri.
  
  
• 04:45:00 Il primo metodo di cui parleremo si chiama sacco di parole. Questo algoritmo esamina una frase e la converte in una rappresentazione numerica in cui ogni parola nella frase è codificata con un numero. Questo può essere utile per attività in cui la sola presenza di una parola è sufficiente per determinare il significato della frase. Tuttavia, quando si ha a che fare con input più complessi, questa tecnica può fallire.
  
  
• 04:50:00 Il video discute l'uso di un sacco di parole codificate per il testo, così come un paio di altri metodi di codifica. Un problema con questo approccio è che perde l'ordine delle parole, il che può rendere difficile per un modello di apprendimento automatico identificare correttamente il sentimento nel testo.
  
  
• 04:55:00 In questo video, l'istruttore spiega come funzionano gli incorporamenti di parole e come possono essere utilizzati per migliorare l'accuratezza delle previsioni di una rete neurale. L'istruttore introduce quindi le reti neurali ricorrenti, che sono un tipo di rete neurale particolarmente efficace nell'elaborazione di dati testuali.

Parte 6

• 05:00:00 Una rete neurale ricorrente è un tipo di rete neurale che elabora i dati in diverse fasi temporali e mantiene una memoria interna. Ciò consente alla rete di sviluppare gradualmente la comprensione di un testo o di un input.
  
  
• 05:05:00 Questo video spiega le basi di TensorFlow 2.0, che include una descrizione di un semplice livello di rete neurale ricorrente (RNN) e di un livello di memoria a lungo termine (LSTM). Il livello LSTM è progettato per aiutare il livello RNN a ricordare le frasi precedenti in una sequenza di testo, il che può diventare sempre più difficile con l'aumentare della lunghezza della sequenza.
  
  
• 05:10:00 Il corso completo TensorFlow 2.0 - Python Neural Networks for Beginners Tutorial copre le basi delle reti neurali, comprese le reti neurali ricorrenti, che vengono utilizzate per l'analisi del sentiment nelle recensioni dei film.
  
  
• 05:15:00 In questo video, il presentatore mostra come riempire una revisione del testo a una lunghezza specifica utilizzando Python e descrive come viene addestrato il modello. Menzionano anche che accelerano il processo di formazione utilizzando una GPU.
  
  
• 05:20:00 In questo video, l'autore fornisce un corso completo sull'insegnamento delle reti neurali Python per principianti. Il corso inizia con un'introduzione alle reti neurali, seguita da un tutorial su come addestrare una rete neurale utilizzando TensorFlow 2.0. Una volta addestrata la rete neurale, l'autore dimostra come fare previsioni su un set di dati di recensioni di film. I risultati mostrano che la rete neurale non è sufficientemente precisa e l'autore fornisce una funzione per codificare il testo in token affinché la rete neurale possa elaborarlo. L'autore fornisce anche una funzione di decodifica per riconvertire il testo in parole.
  
  
• 05:25:00 Questo riepilogo di 1 paragrafo spiega come la funzione di decodifica degli interi ha codificato il testo in una recensione di un film in Python. Questa funzione prende una sequenza di parole e le trasforma in numeri interi, quindi utilizza la funzione di testo ENCODE per codificare i numeri interi. Infine, il modello viene utilizzato per prevedere la recensione per un determinato testo. Si prevede che la prima revisione sia positiva al 72%, mentre la seconda revisione dovrebbe essere positiva al 23%.
  
  
• 05:30:00 In questo video finale del corso completo TensorFlow 2.0, viene creata una rete neurale ricorrente per generare un'opera teatrale basata su un testo di Shakespeare. Il file viene caricato e letto e viene calcolata la lunghezza del testo. I primi 250 caratteri vengono letti e analizzati per determinare lo schema di codifica. I caratteri vengono codificati come numeri interi e viene creato il vocabolario. L'indice di ogni carattere viene calcolato e memorizzato nel vocabolario.
  
  
• 05:35:00 In questo video, l'istruttore insegna come utilizzare TensorFlow per addestrare una rete neurale utilizzando un set di dati di testo. L'istruttore prima converte il set di dati di testo in numeri interi, quindi addestra la rete neurale utilizzando una sequenza di 101 esempi di addestramento per epoca.
  
  
• 05:40:00 Questo video spiega come creare un modello in TensorFlow 2.0 utilizzando la funzione integrata "costruisci modello". Il modello viene addestrato su un set di 64 esempi di addestramento e quindi salvato in modo che le previsioni possano essere effettuate su una sequenza di input.
  
  
• 05:45:00 L'autore descrive i passaggi necessari per addestrare una rete neurale utilizzando TensorFlow. Innanzitutto, l'autore descrive le forme di input e output della rete neurale. Successivamente, l'autore spiega come creare una funzione di perdita per ottimizzare la rete neurale. Infine, l'autore dimostra come utilizzare il modello per prevedere una sequenza di 100 campioni.
  
  
• 05:50:00 In questo video, TensorFlow viene spiegato in dettaglio, incluso il modo in cui funziona con le reti neurali ricorrenti. Il video spiega anche come creare una funzione di perdita per determinare le prestazioni di un modello.
  
  
• 05:55:00 Questo video introduce la libreria TensorFlow 2.0 per l'addestramento delle reti neurali e mostra come ricostruire un modello con una nuova dimensione batch pari a uno. Il video include anche una dimostrazione di come generare testo con TensorFlow.

Parte 7

• 06:00:00 In questo video, TensorFlow 2.0 Complete Course - Python Neural Networks for Beginners Tutorial, l'utente spiega come generare una sequenza di testo utilizzando una rete neurale ricorrente. Il primo passaggio consiste nel reimpostare lo stato della rete e generare un elenco di previsioni. Quindi, l'utente addestra la rete su una sceneggiatura di un film di serie B e mostra i risultati.
  
  
• 06:05:00 Questo video tutorial copre le basi di TensorFlow 2.0, incluso come creare una semplice rete neurale in Python. Il video passa quindi alla discussione dell'apprendimento per rinforzo, che è una tecnica più complessa e avanzata. Il video si conclude con una discussione sulla terminologia e un riepilogo di cosa sia l'apprendimento per rinforzo.
  
  
• 06:10:00 L'apprendimento per rinforzo è un metodo per addestrare l'IA a svolgere compiti in un ambiente premiandoli per le azioni che portano a prestazioni migliori. L'obiettivo dell'apprendimento per rinforzo è massimizzare una ricompensa, che può essere qualsiasi cosa l'agente stia cercando di ottenere nell'ambiente. In questo corso, l'istruttore copre i concetti di stato, azione e ricompensa.
  
  
• 06:15:00 L'obiettivo dell'agente in questo esempio è massimizzare la sua ricompensa nell'ambiente imparando una cue table che prevede la ricompensa per diverse azioni in diversi stati.
  
  
• 06:20:00 TensorFlow è una libreria di machine learning che consente agli utenti di creare modelli in grado di apprendere dai dati. In questo video, l'istruttore spiega come funziona l'apprendimento Q e come viene utilizzato per ottimizzare il comportamento di un agente in un ambiente simulato. Continua spiegando come utilizzare la cue table per ottimizzare il comportamento dell'agente.
  
  
• 06:25:00 In questo video, impariamo a conoscere le reti neurali utilizzate in un tutorial per principianti per TensorFlow 2.0. La prima parte del video illustra le basi delle reti neurali e il loro funzionamento. Esploriamo quindi come creare un semplice agente che impari a navigare in un ambiente 3D utilizzando la cue table corrente o scegliendo casualmente un'azione. La seconda parte del video spiega le formule utilizzate per aggiornare la cue table dell'agente.
  
  
• 06:30:00 Il video "TensorFlow 2.0 Complete Course - Python Neural Networks for Beginners Tutorial" introduce il linguaggio di programmazione TensorFlow 2.0 e le relative strutture dati e algoritmi per le reti neurali, che sono un tipo di modello di machine learning. Il video mostra quindi come creare e addestrare un semplice modello di rete neurale utilizzando il software openAI gym.
  
  
• 06:35:00 Il corso completo TensorFlow 2.0 inizia con l'introduzione del modello attore-critico, utilizzato per addestrare una rete neurale. Mostra quindi come creare un ambiente lacustre ghiacciato utilizzando NumPy e TensorFlow. Il corso illustra come utilizzare l'apprendimento q per risolvere il problema di navigazione nell'ambiente.
  
  
• 06:40:00 Questo video fornisce un tutorial completo su come utilizzare TensorFlow 2.0 per creare una rete neurale per principianti. Innanzitutto, l'istruttore spiega la variabile epsilon e come influisce sulla possibilità che l'agente intraprenda un'azione casuale. Successivamente, l'istruttore dimostra come creare un elenco di ricompense e come aggiornare i valori q dell'agente utilizzando la formula di ricompensa. Infine, l'istruttore mostra come impostare lo stato attuale dell'agente e verificare se ha terminato di esplorare l'ambiente.
  
  
• 06:45:00 In questo modulo finale del "Corso completo TensorFlow 2.0 - Tutorial sulle reti neurali Python per principianti", l'istruttore spiega come utilizzare la cue table per regolare il valore epsilon per aumentare lentamente la ricompensa media man mano che l'agente si sposta un labirinto.
  
  
• 06:50:00 Questo video tutorial introduce le basi di TensorFlow, una potente libreria di machine learning. Dopo aver introdotto TensorFlow e i suoi concetti chiave, il tutorial guida gli spettatori attraverso una serie di tutorial su diverse attività di machine learning come il deep learning e il reinforcement learning.

[MetaQuotes]

Corso Keras con TensorFlow - Apprendimento approfondito di Python e reti neurali per tutorial per principianti

Corso Keras con TensorFlow - Apprendimento approfondito di Python e reti neurali per tutorial per principianti

Il corso Keras with TensorFlow si concentra sull'insegnamento agli utenti come utilizzare Keras, un'API di rete neurale scritta in Python e integrata con TensorFlow. Copre le basi dell'organizzazione e della pre-elaborazione dei dati, la costruzione e l'addestramento di reti neurali artificiali e l'importanza della normalizzazione dei dati e della creazione di set di convalida. Il corso fornisce anche risorse come file video e di testo e una guida su come configurare una GPU per una maggiore efficienza. Gli utenti imparano anche come salvare e caricare i modelli, comprese le opzioni per salvare tutto, solo l'architettura o solo i pesi. Il corso è adatto a chi ha competenze di programmazione di base e una certa esperienza con Python.

La seconda sezione del "Corso Keras con TensorFlow" copre una varietà di argomenti, a partire dal caricamento dei pesi in un nuovo modello Keras con la stessa architettura del modello originale. L'istruttore spiega quindi come preparare e preelaborare i dati delle immagini per addestrare una rete neurale convoluzionale per classificare le immagini come gatti o cani prima di passare alla costruzione e all'addestramento di un modello sequenziale di Keras per la prima CNN. La sezione include i dettagli per l'addestramento del modello utilizzando un generatore contenente i dati dell'etichetta per la convalida durante l'adattamento del modello e come tracciare una matrice di confusione per valutare le prestazioni del modello. Conclude dimostrando come mettere a punto un modello VGG 16 pre-addestrato per classificare le immagini di cani e gatti, regolarne la pre-elaborazione e anche addestrarlo.

Nella terza sezione l'istruttore introduce le MobileNet, un'alternativa più piccola e veloce a modelli più complessi. Dimostrano il download e l'utilizzo di MobileNet in un notebook Jupyter, l'organizzazione di un set di dati per le cifre della lingua dei segni e la messa a punto del modello per una nuova attività di classificazione. L'istruttore sottolinea l'importanza di indirizzare correttamente l'iteratore alla posizione del set di dati su disco, al numero di livelli da bloccare durante l'addestramento e all'ottimizzazione degli iperparametri per ridurre i problemi di overfitting. La sezione finale introduce l'aumento dei dati e il suo potenziale per ridurre l'overfitting e aumentare le dimensioni del set di dati e fornisce istruzioni sui diversi tipi di aumento (ad esempio, spostamento, capovolgimento, rotazione), salvataggio di immagini aumentate su disco e aggiunta di nuovo alla formazione impostato.

• 00:00:00 In questa sezione viene spiegato che il corso è incentrato sull'insegnamento dell'utilizzo di Keras, un'API di rete neurale scritta in Python e integrata con TensorFlow. Inizia con le basi dell'organizzazione e della pre-elaborazione dei dati e poi passa alla costruzione e all'addestramento di reti neurali artificiali. Il corso raccomanda alcune abilità di programmazione di base e una certa esperienza con Python, ma fornirà anche brevi introduzioni a ciascun concetto di deep learning prima di passare all'implementazione del codice. Il corso fornisce anche risorse video e di testo, inclusi i file di codice utilizzati nel corso, che vengono regolarmente testati e mantenuti, e l'accesso per il download a questi file è disponibile per i membri di Deep Lizard Hive Mind. Viene inoltre spiegato che Keras è stato sviluppato con l'obiettivo di consentire una rapida sperimentazione da parte dell'utente e, essendo integrato con TensorFlow, Keras è ora completamente integrato con l'API TensorFlow. Vengono fornite raccomandazioni per l'apprendimento di più API di rete neurale e per non attenersi a una per sempre per dimostrare l'esperienza e il confronto tra di esse, rendendo così il candidato più prezioso.
  
  
• 00:05:00 In questa sezione del corso Keras con TensorFlow, viene discussa la necessità di una GPU e si nota che non è richiesta per il corso. Tuttavia, se un utente desidera utilizzare una GPU, è disponibile una guida su come configurare la GPU per lavorare con TensorFlow. Si consiglia di seguire prima il corso con una CPU e quindi configurare la GPU per una maggiore efficienza e velocità. La sezione successiva discute come preparare ed elaborare i dati numerici per la rete neurale artificiale e i diversi formati per i dati previsti dal modello sequenziale in Keras. La funzione di adattamento prevede che i dati di input (x) siano in un array NumPy, un tensore TensorFlow, una mappatura dict, un set di dati TF o un generatore Keras. Anche i dati di destinazione (y) devono essere nello stesso formato di x.
  
  
• 00:10:00 In questa sezione, l'istruttore spiega che le tecniche di normalizzazione o standardizzazione dei dati possono inserire i dati in un formato che facilita l'apprendimento del modello di deep learning. L'istruttore utilizza un semplice set di dati numerici come esempio, in cui un farmaco sperimentale è stato testato su individui di età compresa tra 13 e 100 anni e circa il 95% dei pazienti che erano nella popolazione più anziana, 65 anni o più, ha manifestato effetti collaterali, mentre circa 95 % di pazienti di età inferiore a 65 anni non ha manifestato effetti collaterali. L'istruttore passa quindi attraverso un ciclo for che genera numeri interi casuali che imitano lo scenario della vita reale di pazienti che hanno sperimentato o non hanno avuto effetti collaterali, quindi aggiunge questi campioni e le etichette corrispondenti a due elenchi separati.
  
  
• 00:15:00 In questa sezione del video, l'istruttore riassume il processo di generazione e preparazione dei dati per una rete neurale utilizzando gli array NumPy nell'API Keras integrata in TensorFlow. Spiegano che l'elenco dei campioni contiene età e l'elenco delle etichette contiene zeri e uno che rappresentano effetti collaterali o nessun effetto collaterale, per corrispondere a ciascuna età. I dati vengono quindi elaborati e trasformati nel formato di matrice NumPy previsto dalla funzione fit e i dati vengono mescolati utilizzando la funzione shuffle per rimuovere qualsiasi ordine imposto dal processo di generazione dei dati. Inoltre, i dati vengono ridimensionati da una scala da 13 a 100, fino a una scala da zero a uno, e rimodellati affinché la funzione di trasformazione di adattamento accetti dati unidimensionali. Infine, l'istruttore dimostra come costruire una rete neurale artificiale su questi dati, utilizzando un modello sequenziale dall'API keras.
  
  
• 00:20:00 In questa sezione del video, il relatore spiega come creare un modello di rete neurale utilizzando l'API Keras integrata con TensorFlow. Il modello è un modello sequenziale e viene creato come istanza della classe Sequential. Il primo strato denso crea il primo strato nascosto e ha 16 unità con la funzione di attivazione ReLU. Il secondo strato denso crea il secondo strato nascosto e ha 32 unità con la funzione di attivazione ReLU. L'ultimo livello è il livello di output con due unità che rappresentano le due possibili classi di output. Il presentatore spiega che il livello di output è seguito dalla funzione Softmax, che fornisce le probabilità per ciascuna classe di output. Il relatore mostra quindi come utilizzare la funzione model.summary() per visualizzare un riepilogo visivo dell'architettura del modello.
  
  
• 00:25:00 In questa sezione impariamo come addestrare una rete neurale sui dati che sono stati creati ed elaborati nelle sezioni precedenti. Dopo aver creato il nostro modello, lo compiliamo con la perdita, l'ottimizzatore e le metriche appropriate. Quindi specifichiamo i dati di input, i dati di destinazione, la dimensione del batch e il numero di epoche per l'addestramento nella funzione di adattamento. Inizia l'addestramento e vediamo che entro 30 epoche, il nostro semplice modello raggiunge una precisione del 94% senza troppi sforzi. Questo è un ottimo esempio della facilità di iniziare con Keras.
  
  
• 00:30:00 In questa sezione viene spiegato il concetto di set di validazione nel contesto dell'addestramento dei modelli di apprendimento automatico e viene evidenziata l'importanza del suo utilizzo. La creazione di un set di convalida consente agli utenti di valutare quanto bene un modello si generalizza sui dati su cui non è stato addestrato. L'overfitting può essere evitato esaminando l'accuratezza dei risultati del set di convalida, che non dovrebbe essere significativamente inferiore a quella dei dati di addestramento. Vengono discussi due metodi per creare e utilizzare set di validazione con un modello sequenziale di Keras, con il secondo metodo che consente a Keras di creare il set di validazione per l'utente.
  
  
• 00:35:00 In questa sezione, il video illustra come creare un set di convalida dal set di addestramento utilizzando il parametro di suddivisione della convalida, che suddivide una percentuale specifica dei dati di addestramento in un set di convalida. Il video rileva che il set di convalida è completamente tenuto fuori dal set di addestramento e verrà creato al volo ogni volta che viene chiamata la funzione di adattamento. È inoltre importante mescolare i dati di addestramento prima di passarli all'adattamento per garantire che il set di convalida non sia solo l'ultimo X percento dei dati non mescolati. Il video spiega anche come utilizzare il set di convalida per verificare se il modello è overfitting o generalizza bene e discute il passaggio successivo dell'utilizzo di un set di test per l'inferenza.
  
  
• 00:40:00 In questa sezione, l'istruttore spiega il processo di inferenza nell'apprendimento profondo. L'inferenza è il processo di distribuzione di un modello addestrato sui set di dati del mondo reale per ottenere le previsioni su nuovi dati che il modello non ha mai visto prima. Per garantire che il modello possa generalizzare abbastanza bene da fare previsioni accurate su nuovi dati, l'istruttore suggerisce di utilizzare un set di test. Il set di test deve essere elaborato nello stesso formato dei dati di addestramento. L'autore dimostra come eseguire questa operazione mescolando i dati del test, ridimensionandoli in modo che siano compresi tra 0 e 1 e prevedendo i dati del test con un modello addestrato per ottenere la probabilità della classe a cui appartiene ciascun elemento nel set di test.
  
  
• 00:45:00 In questa sezione, esaminiamo l'utilizzo di una matrice di confusione per osservare visivamente quanto bene un modello di rete neurale predice sui dati di test. Importando i pacchetti necessari e creando una matrice di confusione utilizzando scikit-learn, possiamo confrontare le etichette vere del set di test con le etichette previste e quindi comprendere meglio l'accuratezza delle previsioni del nostro modello. Vediamo anche come tracciare la funzione della matrice di confusione e come determinati valori in essa contenuti vengono ottenuti, pre-elaborati e visualizzati. Un collegamento a una funzione utile per il corso Keras con TensorFlow è disponibile anche sul blog deep lizard.
  
  
• 00:50:00 In questa sezione, l'istruttore dimostra come tracciare una matrice di confusione per visualizzare l'accuratezza delle previsioni del modello. Il grafico mostra le etichette previste sull'asse x e le etichette vere sull'asse y. Le previsioni corrette sono mostrate in quadrati blu che vanno diagonalmente dall'alto a sinistra all'angolo in basso a destra del grafico. La matrice di confusione consente all'utente di visualizzare le prestazioni del modello e di identificare le classi che potrebbero richiedere miglioramenti. L'istruttore spiega che la matrice di confusione è un ottimo strumento da utilizzare per valutare le prestazioni di un modello e può aiutare a capire quali classi necessitano di ulteriore lavoro. Infine, l'istruttore mostra come salvare un modello sequenziale di Keras utilizzando la funzione `.save()`, che salva l'architettura, i pesi e la configurazione di addestramento del modello in un file h5.
  
  
• 00:55:00 In questa sezione, l'istruttore esamina i diversi modi per salvare e caricare un modello in Keras con TensorFlow. La prima e più completa opzione consiste nel salvare e caricare tutto ciò che riguarda il modello, inclusi l'architettura, i pesi e la configurazione dell'addestramento. La seconda opzione è salvare solo l'architettura del modello utilizzando la funzione "to JSON", che può essere utilizzata per creare un nuovo modello con la stessa architettura in un secondo momento. La terza opzione è salvare solo i pesi del modello utilizzando la funzione "salva pesi", che può essere caricata in un nuovo modello per aggiornarne i pesi, ma non salva nessun altro dettaglio sul modello. L'istruttore spiega anche che lo stesso processo può essere eseguito utilizzando stringhe YAML anziché stringhe JSON.

• 01:00:00 In questa sezione, il relatore discute il caricamento dei pesi in un nuovo modello Keras con la stessa architettura del modello originale. Spiega che la forma dei pesi caricati deve corrispondere alla forma dell'architettura del modello affinché la mappatura dei pesi funzioni. Il presentatore mostra quindi come caricare e popolare un nuovo modello con i pesi del modello originale utilizzando le funzioni "carica pesi" e "ottieni pesi" in Keras. La sezione passa quindi a un nuovo argomento, che sta preparando ed elaborando i dati delle immagini per addestrare una rete neurale convoluzionale per classificare le immagini come gatti o cani, utilizzando il set di dati della competizione Kaggle gatti contro cani. Il relatore spiega i passaggi manuali e programmatici necessari per preparare i dati per l'elaborazione.
  
  
• 01:05:00 In questa sezione, l'istruttore organizza i dati in tre sottoinsiemi: set di addestramento, convalida e test. Il set di dati utilizzato nel tutorial contiene 25.000 immagini di cani e gatti, ma per accelerare il processo di addestramento, vengono utilizzate solo 1.000 immagini per l'addestramento, 200 per la convalida e 100 per i test. I dati sono organizzati in diverse directory per ogni set e la struttura della directory viene verificata per assicurarsi che non esista già. Le immagini vengono selezionate in modo casuale in base ai nomi dei file, dove le immagini di gatto e cane hanno le parole "gatto" e "cane" nei rispettivi nomi di file. Infine, il percorso dei dati viene specificato per ogni set in modo che punti alla posizione corretta su disco.
  
  
• 01:10:00 In questa sezione, il video spiega come preparare i dati per un modello sequenziale Keras creando batch di dati utilizzando il generatore di dati immagine. I set di addestramento, convalida e test vengono definiti e ridimensionati a un'altezza e una larghezza specificate per uniformità. La funzione di pre-elaborazione, tf.keras.applications.VGG16.preprocess_input, viene applicata alle immagini prima che vengano passate alla rete. Il video avverte gli spettatori di non insistere sui dettagli tecnici della pre-elaborazione, come verrà spiegato nei prossimi episodi. Inoltre, il video specifica che shuffle è uguale a false per il set di test, spiegando che durante l'esecuzione dell'inferenza, le etichette non definite per il set di test sono necessarie per visualizzare i risultati della previsione in una matrice di confusione e i dati non devono essere mescolati per accedervi.
  
  
• 01:15:00 In questa sezione, l'istruttore dimostra come ottenere e organizzare i dati immagine per una rete neurale convoluzionale. I lotti dei treni, costituiti da dieci immagini e le etichette corrispondenti, vengono tracciati utilizzando una funzione di pre-elaborazione che distorce i dati dei colori RGB. Tuttavia, le immagini possono ancora essere distinte come un gatto o un cane con l'aiuto di un vettore codificato a caldo per le etichette. L'istruttore osserva che a volte le etichette corrispondenti per il set di test potrebbero non essere disponibili e indirizza gli spettatori al blog per indicazioni sulla gestione di tali casi. L'episodio si conclude con un'anteprima della sezione successiva in cui verrà costruita e addestrata una rete neurale convoluzionale sui dati delle immagini di cani e gatti.
  
  
• 01:20:00 In questa sezione del tutorial TensorFlow, viene utilizzato un modello sequenziale di Keras per la prima rete neurale convoluzionale (CNN). Il primo strato del modello è uno strato convoluzionale 2D con 32 filtri e una dimensione del kernel di 3x3 seguito dalla popolare funzione di attivazione ReLU con lo "stesso" riempimento per azzerare le immagini. La forma di input è specificata come 224x224x3 per le immagini in formato RGB. Il primo livello convoluzionale è quindi seguito da un livello di pooling massimo con una dimensione del pool di 2x2 e passi di 2. Viene aggiunto un altro livello convoluzionale 2D, simile al primo ma con 64 filtri invece di 32, seguito da un altro livello di pooling massimo. L'output appiattito del livello di max pooling viene quindi passato a un livello di output denso con due nodi corrispondenti rispettivamente a cat e dog. Il livello di output è seguito dalla funzione di attivazione softmax per fornire probabilità per ogni output corrispondente dal modello.
  
  
• 01:25:00 In questa sezione, l'istruttore discute come addestrare un modello utilizzando Keras con TensorFlow e come utilizzare un generatore contenente dati di etichetta per la convalida durante l'adattamento del modello. Il modello viene addestrato con la compilazione, quindi la funzione di adattamento viene definita utilizzando i set di addestramento e convalida e vengono impostate l'epoca e la verbosità. L'avviso che si verifica durante l'addestramento è un bug all'interno di TensorFlow e l'istruttore indica come ignorare questo avviso. I risultati mostrano che mentre l'accuratezza sul training set è del 100%, l'accuratezza della convalida è solo del 69%, indicando un overfitting. Il modello avrà bisogno di ulteriore attenzione per combattere il problema dell'overfitting se deve essere utilizzato in produzione. Il prossimo episodio esplorerà come il modello addestrato resiste all'inferenza nella previsione delle immagini nel set di test.
  
  
• 01:30:00 In questa sezione del video, l'istruttore spiega il processo di utilizzo di una funzione di tracciamento immagini per tracciare un batch di dati di test da batch di test e stampare le etichette corrispondenti per le immagini. L'istruttore sottolinea l'importanza di non mescolare il set di dati del test per garantire la corretta mappatura tra etichette e campioni. Successivamente, le previsioni vengono ottenute chiamando model.predict con i batch di test specificati come input. L'istruttore stampa le previsioni arrotondate e spiega come interpretarle. Menzionano anche l'uso di una matrice di confusione per visualizzare i risultati e la funzione della matrice di confusione di scikit-learn viene utilizzata con le vere etichette passate utilizzando le classi dei batch di prova.
  
  
• 01:35:00 In questa sezione, il video illustra come tracciare una matrice di confusione per valutare le prestazioni del modello nella classificazione di immagini di cani e gatti utilizzando l'API Keras di TensorFlow. La matrice di confusione viene tracciata utilizzando una funzione di scikit-learn e gli indici delle classi vengono regolati di conseguenza. La diagonale della matrice di confusione rappresenta le previsioni corrette e il modello sembra overfitting. La sezione successiva dimostrerà come mettere a punto un modello VGG 16 pre-addestrato per classificare le immagini di cani e gatti, che ha vinto il concorso ImageNet 2014. Il video spiega anche brevemente la funzione di pre-elaborazione VGG 16, che sottrae solo il valore RGB medio calcolato da ciascun pixel del training set dai dati dell'immagine.
  
  
• 01:40:00 In questa sezione, l'istruttore spiega la pre-elaborazione che è stata eseguita per il modello VGG-16 e come i nuovi dati devono essere elaborati nello stesso modo per corrispondere a come VGG-16 è stato originariamente addestrato. L'istruttore afferma che Keras ha funzioni integrate per modelli popolari come VGG-16, che dispone di una pre-elaborazione che corrisponde al modello corrispondente. L'istruttore spiega anche che il modello VGG-16 originariamente prevedeva 1000 diverse classi imageNet e l'obiettivo è modificare l'ultimo livello di output per prevedere solo due classi di output corrispondenti a gatto e cane. Infine, l'istruttore crea un nuovo modello sequenziale eseguendo il looping di ogni livello VGG-16 ed escludendo l'ultimo livello di output. Questo nuovo modello è per la messa a punto e ha solo due classi di output.
  
  
• 01:45:00 In questa sezione, vediamo come modificare e addestrare il modello VGG 16 ottimizzato su un set di dati di cani e gatti. L'ultimo livello nel modello, che prevede 1000 classi di output, è stato rimosso e viene aggiunto un nuovo livello denso che ha solo due classi di output per gatto e cane. Tutti i livelli precedenti sono stati impostati per non essere addestrabili, ad eccezione del livello di output contenente 8000 parametri addestrabili. Il modello viene compilato utilizzando l'entropia incrociata categoriale come perdita e l'accuratezza come metrica e viene addestrato utilizzando il metodo fit() passandogli il set di dati di addestramento e il set di convalida.
  
  
• 01:50:00 In questa sezione, l'istruttore discute i risultati dell'addestramento del modello VGG 16 su immagini di cani e gatti con una specificità sull'accuratezza dei set di addestramento e convalida. Il modello VGG 16 era già stato addestrato su immagini di cani e gatti dalla libreria della rete di immagini e l'addestramento che viene eseguito sul livello di output consiste nell'addestrare il modello per l'output solo di classi di cani o gatti. In sole cinque epoche, il modello VGG 16 ha avuto un'accuratezza di addestramento del 99%, mentre l'accuratezza della convalida era pari al 98%, indicando quanto bene questo modello si generalizza ai dati di cani e gatti nei set di convalida rispetto alla semplice rete neurale convoluzionale. Nel prossimo episodio, il modello VGG 16 perfezionato verrà utilizzato per l'inferenza per prevedere le immagini di cani e gatti nel set di test e, data l'accuratezza del set di convalida, dovremmo aspettarci di vedere buoni risultati anche nel set di test .
  
  
• 01:55:00 In questa sezione del video, l'istruttore discute l'uso di una matrice di confusione per valutare le prestazioni di un modello VGG16 messo a punto su un set di test invisibile. Viene esaminata la diagonale della matrice di confusione, che rivela che il modello ha raggiunto un tasso di accuratezza del 96%. Sebbene l'approccio di messa a punto adottato per il modello VGG16 sia stato minimo, l'istruttore spiega che i prossimi episodi copriranno metodi di messa a punto più precisi su altri modelli pre-addestrati, come MobileNet. Questi modelli più piccoli ea basso consumo sono più adatti per l'implementazione su dispositivi mobili grazie alle loro dimensioni e al numero di parametri notevolmente ridotti.

• 02:00:00 In questa sezione del video, l'istruttore introduce i MobileNet, un'alternativa più piccola e più veloce ai modelli più grandi come il VGG 16. Anche se i MobileNet non sono precisi come alcuni di questi modelli pesanti, la riduzione della precisione è relativamente piccola. L'istruttore illustra i passaggi per scaricare e lavorare con MobileNet in un notebook Jupyter, inclusa l'importazione dei pacchetti necessari, il download e l'assegnazione del modello MobileNet e la creazione di una funzione chiamata "prepare_image" per ridimensionare e formattare le immagini prima di passarle attraverso MobileNet modello per l'elaborazione. Nel complesso, l'obiettivo è comprendere i compromessi tra accuratezza e dimensioni/velocità quando si lavora con diversi modelli di deep learning e come utilizzarli in modo efficace.
  
  
• 02:05:00 In questa sezione, l'istruttore dimostra come utilizzare un modello MobileNet preaddestrato per prevedere le prime cinque classi possibili di determinate immagini. Per prima cosa visualizzano un'immagine di una lucertola e la passano attraverso una funzione di pre-elaborazione prima di passarla alla funzione di previsione di MobileNet. MobileNet prevede le prime tre classi con alte probabilità, con il camaleonte americano che è il più probabile. Ripetono lo stesso processo con l'immagine di una tazza di caffè e il modello prevede che si tratti di un espresso con una probabilità del 99%. Infine, passano un'immagine fragola al modello e ottengono le previsioni per le migliori classi possibili.
  
  
• 02:10:00 In questa sezione del video, il presentatore mostra i risultati delle previsioni del modello di rete mobile per un campione casuale di immagini, che include una fragola e altri frutti. Il presentatore afferma che sebbene ci sia stata una piccola riduzione della precisione per il modello, non è evidente quando si eseguono test come quelli mostrati nel video. Il passaggio successivo consiste nel mettere a punto il modello di rete mobile per un set di dati personalizzato costituito da cifre della lingua dei segni. Il relatore mostra come organizzare il set di dati su disco e spostarlo nella directory di lavoro prima di elaborarlo a livello di codice in un Jupyter Notebook.
  
  
• 02:15:00 In questa sezione, l'istruttore spiega come organizzare i dati immagine in directory train, valid e test utilizzando uno script Python. Il primo passaggio consiste nel controllare il numero di campioni in ciascuna classe, che varia da 204 a 208. Quindi, utilizzando un ciclo for, lo script sposta ogni directory di classe nella directory train e crea directory separate per set validi e test per ciascuna classe . Infine, lo script campiona immagini casuali da ciascuna classe nella directory train, le sposta nella directory valida, campiona più immagini e le sposta nella directory test. Dopo aver eseguito lo script, i dati vengono organizzati in directory separate per ciascun set e il numero di immagini in ciascuna classe può essere verificato controllando le directory corrispondenti.
  
  
• 02:20:00 In questa sezione del video, il relatore discute la struttura organizzativa del set di dati con cui lavorerà, che è simile al set di dati di cani e gatti utilizzato in precedenza nel corso ma ora contiene 10 classi invece di due. Quindi dimostrano come preelaborare i dati definendo le directory di addestramento, convalida e test e creando iteratori di directory utilizzando il generatore di dati immagine. La funzione di pre-elaborazione utilizzata è la funzione di pre-elaborazione della rete mobile, che ridimensiona i dati dell'immagine in modo che siano su una scala da meno uno a uno. Vengono definite anche le impostazioni dell'iteratore, come la dimensione dell'immagine di destinazione e la dimensione del batch. L'oratore sottolinea l'importanza di puntare correttamente l'iteratore alla posizione del set di dati su disco, poiché un puntamento errato potrebbe comportare la ricerca di zero immagini.
  
  
• 02:25:00 In questa sezione del corso Keras con TensorFlow, l'istruttore spiega come mettere a punto il modello MobileNet preaddestrato per una nuova attività di classificazione. Il primo passo è scaricare il modello MobileNet ed esaminarne i layer utilizzando la funzione "model.summary()". Quindi selezionano i livelli fino al sesto all'ultimo livello e creano un nuovo livello di output denso con 10 unità. Questo è seguito dalla creazione di un nuovo modello funzionale che passa tutti i livelli precedenti fino al sesto all'ultimo livello e la rete mobile al livello di output. Il nuovo modello viene creato e il passaggio successivo consiste nel congelare tutti i layer tranne gli ultimi 23 per l'addestramento. L'istruttore osserva che il numero di livelli da congelare richiede una sperimentazione personale e può variare a seconda dell'attività.
  
  
• 02:30:00 In questa sezione, l'istruttore perfeziona il modello MobileNet originale, addestrando solo gli ultimi 23 livelli e sostituendo il livello di output con uno che ha 10 classi invece di 1.000. Il modello viene compilato e addestrato utilizzando l'ottimizzatore Adam con un tasso di apprendimento di 0,0001 e una funzione di perdita di entropia incrociata categoriale. Dopo l'addestramento per 30 epoche, il modello raggiunge un'accuratezza del 100% sul set di addestramento e un'accuratezza del 92% sull'insieme di convalida. Sebbene vi sia un certo overfitting, con un'accuratezza di convalida inferiore all'accuratezza dell'addestramento, l'istruttore suggerisce che l'esecuzione di più epoche o l'ottimizzazione degli iperparametri può aiutare a ridurre il problema dell'overfitting.
  
  
• 02:35:00 In questa sezione del video, l'istruttore mostra come utilizzare un modello ottimizzato sul set di test e tracciare le previsioni in una matrice di confusione. La matrice di confusione indica che il modello ha funzionato bene con previsioni per lo più corrette sul set di test. Il modello ha un'accuratezza del 90% sul set di test, che è previsto data l'accuratezza del set di convalida. L'istruttore sottolinea che la serie su MobileNet ha fornito informazioni su come mettere a punto i modelli per set di dati personalizzati e utilizzare l'apprendimento del trasferimento. Il prossimo episodio dimostrerà come utilizzare l'aumento dei dati sulle immagini utilizzando l'API Keras di TensorFlow.
  
  
• 02:40:00 In questa sezione viene evidenziata l'importanza dell'aumento dei dati per il deep learning, soprattutto quando non ci sono dati sufficienti per addestrare il modello. L'aumento dei dati può aiutare a ridurre l'overfitting e ad aumentare le dimensioni del training set. Viene quindi introdotto il codice per aumentare i dati dell'immagine utilizzando Keras, in cui viene creato un generatore di dati dell'immagine e vengono specificati vari parametri di aumento, come l'intervallo di rotazione, l'intervallo di spostamento della larghezza e l'intervallo di zoom. Viene scelta un'immagine casuale da una directory di cani e viene chiamata la funzione di flusso per generare un batch di immagini aumentate da questa singola immagine. Le immagini aumentate risultanti vengono quindi tracciate utilizzando una funzione di immagini di trama predefinita.
  
  
• 02:45:00 In questa sezione, l'istruttore discute l'aumento dei dati, che è un metodo per aumentare artificialmente le dimensioni di un set di dati creando variazioni dei dati esistenti. Osservando diverse immagini, l'istruttore identifica i tipi di aumento dei dati che sono stati eseguiti su di loro, come lo spostamento, il capovolgimento e la rotazione, e spiega come questa tecnica può essere utile per far crescere un set di dati. Aumentando la varietà del set di dati, un modello può diventare più robusto e migliore nella classificazione dei dati. L'istruttore fornisce anche una breve istruzione per salvare queste immagini aumentate su disco e aggiungerle nuovamente al training set.

[MetaQuotes]

Scikit-learn Crash Course - Libreria di Machine Learning per Python

Scikit-learn Crash Course - Libreria di Machine Learning per Python

Il video "Scikit-learn Crash Course" offre una panoramica sull'utilizzo della libreria Scikit-learn per l'apprendimento automatico in Python. Il video copre la preparazione dei dati, la creazione e l'adattamento del modello, l'ottimizzazione degli iperparametri tramite la ricerca della griglia e la valutazione del modello. Viene sottolineata l'importanza della pre-elaborazione e dei trasformatori nel migliorare le prestazioni del modello, con esempi di scaler standard e trasformatore quantile. Il video discute anche dell'importanza della valutazione del modello e della scelta della metrica giusta per il problema, nonché della gestione di set di dati sbilanciati e categorie sconosciute nella codifica one-hot. Il relatore sottolinea la comprensione del set di dati e dei potenziali pregiudizi nelle previsioni del modello e fornisce un esempio di rilevamento delle frodi con carta di credito.

La seconda parte del video copre diversi argomenti, tra cui la ricerca sulla griglia, le metriche, le pipeline, l'ottimizzazione delle soglie, la modellazione delle serie temporali e la gestione dei valori anomali. L'istruttore esplora l'uso di metriche definite dall'utente e l'importanza di bilanciare precisione e richiamo nella creazione del modello. Inoltre, il classificatore di voto viene presentato come un meta-stimatore che aumenta la flessibilità e l'espressività del modello. Il video si conclude introducendo lo strumento Human Learn, che aiuta a costruire e confrontare sistemi basati su regole che possono essere combinati con algoritmi di machine learning. Inoltre, viene esplorato lo strumento FunctionClassifier, che consente agli utenti di creare una logica personalizzata come modello di classificatore e aggiungere comportamenti come il rilevamento dei valori anomali. Nel complesso, il video offre una panoramica completa di Scikit-learn e della sua API flessibile, sottolineando l'importanza di comprendere le metriche rilevanti per la creazione e la personalizzazione del modello.

• 00:00:00 I dati y. X contiene le caratteristiche o le variabili di input, mentre Y contiene la variabile di destinazione o di output che vogliamo prevedere. Abbiamo suddiviso i dati in un set di addestramento e un set di test per valutare le prestazioni del modello. Successivamente, dobbiamo preelaborare i dati. Una delle tecniche di pre-elaborazione più importanti è il ridimensionamento, che implica la normalizzazione dei valori delle caratteristiche in modo che rientrino tutte in un intervallo simile. Questo aiuta il modello ad apprendere in modo più efficace. Infine, scegliamo un modello e lo addestriamo sul training set. Una volta addestrato il modello, ne valutiamo le prestazioni sul set di test e facciamo previsioni sui nuovi dati. Nelle prossime sezioni approfondiremo gli argomenti della preelaborazione, della valutazione del modello e dei metastimatori.
  
  
• 00:05:00 In questa sezione, il relatore spiega come suddividere i dati in set x e y per i modelli di machine learning. Il set x rappresenta i dati utilizzati per fare previsioni, mentre il set y contiene la previsione di interesse. Utilizzando la libreria scikit-learn, gli utenti possono caricare set di dati di benchmark per scopi didattici. Il relatore spiega anche il processo in due fasi di creazione e adattamento di un modello per apprendere dai dati al fine di fare previsioni. Il modello k-nearest neighbor viene utilizzato come esempio, ma viene mostrato anche il modello di regressione lineare per illustrare come modelli diversi possono ancora avere la stessa API all'interno di scikit-learn.
  
  
• 00:10:00 In questa sezione, il video Crash Course di Scikit-learn spiega come funziona il modello K-nearest neighbor in un semplice set di dati che presenta i piedi quadrati di una casa e la sua vicinanza alle scuole. Il modello fa previsioni basate sui 5 vicini più vicini, ma la sfida può sorgere quando si utilizzano distanze con scale diverse, il che significa che un asse può avere un effetto molto maggiore sulle previsioni rispetto a un altro. Ciò richiede di ripensare a cosa sia un modello di apprendimento automatico e suggerisce che è necessaria una preelaborazione prima che i dati vengano forniti al modello del vicino più vicino K, in modo che il ridimensionamento venga eseguito prima che vengano fatte le previsioni e che tutto all'interno del pre- la scatola di lavorazione fa parte del modello.
  
  
• 00:15:00 In questa sezione, il video esplora il concetto di pipeline in Scikit-learn, che consente il concatenamento delle fasi di elaborazione e la chiamata di dot fit e dot predict per l'intera pipeline quando addestrata. Utilizzando una pipeline, è possibile gestire automaticamente le fasi di pre-elaborazione, come il ridimensionamento e la normalizzazione, per apprendere dai dati per garantire un sistema robusto. Tuttavia, questo approccio introduce un problema in cui il modello può memorizzare i dati originali. Il video mostra come il grafico suggerisca erroneamente una previsione perfetta, ma il modello può farlo solo perché consente di memorizzare il punto dati originale, impedendo un confronto equo e una prevedibilità affidabile sui nuovi dati.
  
  
• 00:20:00 In questa sezione, l'istruttore spiega il metodo per valutare le prestazioni di un modello utilizzando un set di dati di test separato per evitare di giudicare il modello sullo stesso set di dati su cui è stato addestrato. Suggerisce di dividere il set di dati in segmenti e di utilizzarne uno per l'addestramento e gli altri per i test. Inoltre, introduce l'oggetto cv di ricerca della griglia di Scikit-learn, che consente la convalida incrociata automatizzata per determinare i migliori iperparametri da utilizzare nel modello. Questo oggetto può essere utilizzato con la pipeline creata in precedenza per ottimizzare il modello e migliorarne le capacità predittive.
  
  
• 00:25:00 In questa sezione, l'istruttore esamina vari parametri del modello KNearestNeighbors e dimostra come utilizzare l'oggetto GridSearch per trovare il miglior set di iperparametri. L'oggetto GridSearch eseguirà automaticamente la convalida incrociata e terrà traccia dei risultati, semplificando l'analisi e la scelta della configurazione migliore. Tuttavia, l'istruttore sottolinea che mentre l'utilizzo dell'API e dei blocchi predefiniti appropriati è importante quando si lavora con scikit-learn, è altrettanto importante comprendere e analizzare il set di dati utilizzato. L'istruttore mostra come accedere e visualizzare la descrizione di un set di dati e sottolinea l'importanza di dedicare del tempo alla comprensione delle variabili nel set di dati prima di costruire un modello.
  
  
• 00:30:00 In questa sezione, il relatore discute le potenziali insidie dell'applicazione cieca dei modelli di apprendimento automatico senza comprendere appieno i dati utilizzati per l'addestramento e la previsione. Anche variabili apparentemente innocue, come la proporzione di una certa razza in una città, possono portare ad algoritmi distorti e persino razzisti. Il relatore sottolinea l'importanza di esaminare e testare a fondo il modello prima di distribuirlo in produzione. L'uso della griglia di ricerca e di altri metodi può fornire garanzie statistiche, ma può anche creare un falso senso di ottimismo e causare punti ciechi. È responsabilità dell'utente informarsi sui dati utilizzati e considerare meccanismi etici e di feedback, nonché scenari di riserva per quando le cose vanno male nella produzione.
  
  
• 00:35:00 In questa sezione viene evidenziata l'importanza della trasformazione dei dati nella creazione di modelli. Il video discute l'uso dei trasformatori e il loro significato nel migliorare le prestazioni del modello. Lo scaler standard di Scikit-Learn viene utilizzato per ridimensionare un set di dati e, sebbene le sue prestazioni siano buone, il video mostra come potrebbe essere migliorato utilizzando altri metodi di ridimensionamento. L'approccio prevede la sottrazione della media dal set di dati e la divisione per la deviazione standard. Sebbene l'approccio ridimensioni i dati, lascia valori anomali, che potrebbero influire su alcuni algoritmi. Il video sottolinea ulteriormente l'importanza della pre-elaborazione per ottenere i risultati del modello desiderati.
  
  
• 00:40:00 In questa sezione del video, il relatore discute il concetto di normalizzazione e come utilizzarlo efficacemente calcolando i quantili invece dei valori medi. Utilizzando i quantili, l'effetto dei valori anomali sui dati viene ridotto e il processo diventa più robusto. Il relatore dimostra come implementare il trasformatore quantile come fase di pre-elaborazione, sostituendo lo scaler standard, per ottenere risultati migliori nei modelli di machine learning. Il profondo effetto del trasformatore sui dati di output è mostrato attraverso una funzione di output del grafico che addestra un modello k-nearest neighbor e produce previsioni sia per lo scaler standard che per il trasformatore quantile.
  
  
• 00:45:00 In questa sezione del video, il relatore spiega come la pre-elaborazione può influenzare drasticamente la classificazione dei set di dati. Nel primo esempio, l'oratore utilizza il Quantile Transformer che rende il modello più stabile e più adatto a gestire i valori anomali nel lungo periodo. Il secondo esempio mostra come l'aggiunta di nuove funzionalità può migliorare le prestazioni del modello. Generando caratteristiche non lineari come x1 moltiplicato per x2 e x1 elevato a 2 e x2 elevato a 2 tramite funzioni polinomiali, il modello di regressione logistica è stato in grado di produrre una classificazione quasi perfetta. Infine, viene introdotto One Hot Encoder come tecnica per trasformare testo o categorie in dati numerici utili per prevedere classi di rischio basso, medio o alto.
  
  
• 00:50:00 In questa sezione, il video illustra come gestire le categorie sconosciute quando si utilizza la codifica one-hot con la libreria Scikit-learn. Il presentatore spiega che se al codificatore viene chiesto di trasformare dati che non ha visto prima, si verificherà un errore di valore. Tuttavia, questo può essere modificato impostando il parametro "handle_unknown" su "ignore". Il video introduce anche un sito Web chiamato "DrawData.xyz", che consente agli utenti di creare i propri set di dati per esercitarsi nella pre-elaborazione e nelle pipeline. Il relatore sottolinea che le fasi di pre-elaborazione sono cruciali perché possono avere un forte impatto sull'esito del modello. Infine, il video spiega i vantaggi dell'utilizzo di una griglia di ricerca per confrontare più modelli e scegliere quello migliore per la previsione, utilizzando come esempio un set di dati sulle frodi con carta di credito.
  
  
• 00:55:00 In questa sezione, il video spiega l'importanza di scegliere la metrica giusta e come la gestisce Scikit-learn. Il video utilizza un set di dati di funzionalità anonime e importi delle transazioni per dimostrare come Scikit-learn può essere utilizzato per prevedere con precisione i casi di frode. Tuttavia, poiché il set di dati è sbilanciato con più casi di frode rispetto a casi non di frode, il modello non riesce a convergere con il numero predefinito di iterazioni. Pertanto, il numero massimo di iterazioni viene aumentato e il parametro del peso della classe viene regolato per raddoppiare il peso dei casi di frode per migliorare il rilevamento delle frodi del modello. Il video introduce anche GridSearchCV per trovare il miglior valore per il parametro del peso della classe.

• 01:00:00 In questa sezione, l'istruttore spiega come utilizzare la ricerca su griglia per trovare i migliori parametri del modello per la regressione logistica in scikit-learn. Definendo una griglia di valori dei parametri, l'istruttore mostra come scorrere questi iperparametri e testarli utilizzando la convalida incrociata. L'oggetto griglia restituisce un dizionario di risultati, inclusi il peso e i punteggi della classe. Il modello di regressione logistica ha un metodo associato chiamato punteggio, che viene utilizzato per determinare il modello migliore. L'istruttore introduce quindi due metriche dal modulo di metriche scikit-learn, precisione e punteggio di richiamo, e spiega come includerle nella ricerca della griglia utilizzando un dizionario di punteggio.
  
  
• 01:05:00 In questa sezione, il relatore aggiunge i punteggi di precisione del test e di richiamo del test e imposta un flag che consentirà l'aggiunta dei punteggi del treno ai risultati della convalida incrociata. Quindi aumentano il numero di convalide incrociate e sostituiscono l'intervallo di quattro con uno spazio lineare intorpidito, impostando un valore più alto per indicare all'algoritmo di concentrarsi sui casi di frode. Creano alcuni grafici che riassumono i risultati, osservando che concentrarsi sul richiamo o sulla precisione si traduce in un risultato completamente diverso. Decidono quindi di creare la loro metrica, la precisione minima di richiamo, che calcola il minimo tra precisione e richiamo e lo aggiunge alla ricerca della griglia. Lo fanno per bilanciare le due metriche e hanno un modello che bilancia i punteggi di richiamo e precisione.
  
  
• 01:10:00 , stiamo usando la funzione make_scorer nella griglia di ricerca con la nostra metrica personalizzata, min_precision_recall, che accetta y_true e y_pred come input. Tuttavia, la funzione make_scorer richiede uno stimatore, un set di dati X, y true e una qualche forma di peso del campione, quindi trasforma la nostra funzione metrica in un oggetto scorer predittivo che può essere utilizzato nella ricerca sulla griglia. Il peso del campione è una funzionalità aggiuntiva che può essere trasmessa ai modelli di apprendimento automatico e ci consente di affermare che una determinata riga è più importante di un'altra. Invece di usare la funzione make_scorer, possiamo passare direttamente lo stimatore e calcolare i valori y previsti con la funzione predict.
  
  
• 01:15:00 In questa sezione, il relatore discute l'uso del peso campione nel rilevamento delle frodi e mostra come può essere aggiunto a una funzione per la stabilità numerica. Dimostrano anche l'effetto dell'aggiunta del peso del campione sul modello algoritmico. Il relatore propone quindi di utilizzare un algoritmo di rilevamento anomalo per rilevare le frodi e mostra come adattare le metriche per questo approccio. Sostituiscono la regressione logistica con un algoritmo della foresta di isolamento e dimostrano come ciò influisce sui punteggi di precisione e richiamo. Infine, l'oratore scrive la sua variante delle funzioni metriche per trasformare la previsione anomala in previsioni di etichetta di frode.
  
  
• 01:20:00 In questa sezione, il narratore discute la flessibilità dell'API di Scikit-learn e la possibilità di utilizzare algoritmi di rilevamento anomali come se fossero classificatori passando etichette y in metriche personalizzate. Questo può essere utile per giudicare se un modello anomalo sarebbe utile in un problema di classificazione. Tuttavia, il narratore avverte che è importante preoccuparsi della qualità delle etichette in quanto ciò può avere un impatto significativo sulle metriche del modello. Inoltre, il narratore sottolinea alcune impostazioni di personalizzazione per le metriche come specificare se maggiore è migliore e la necessità di una misura di probabilità per alcune metriche. Infine, il narratore menziona la capacità di Scikit-learn di lavorare con i metamodelli.
  
  
• 01:25:00 In questa sezione, l'istruttore spiega come funzionano le pipeline di scikit-learn e i limiti dell'utilizzo delle sole pipeline di scikit-learn per i modelli di machine learning. L'istruttore suggerisce di utilizzare i meta-estimatori come un modo per aggirare i limiti delle pipeline per aggiungere ulteriori passaggi e strumenti di post-elaborazione a un modello. L'istruttore fornisce un esempio di un meta-stimatore, il classificatore di voto e come può essere utilizzato per bilanciare diversi modelli per un set di dati assegnando pesi a ciascun stimatore.
  
  
• 01:30:00 In questa sezione, l'istruttore dimostra l'uso di un classificatore di voto con scikit-learn, che può combinare diversi modelli che funzionano in modi diversi per produrre previsioni più accurate. Inoltre, questo modello può essere utilizzato come input da altri stimatori, aumentando così la flessibilità e l'espressività. L'istruttore introduce anche l'idea di regolare il valore di soglia in un modello di regressione logistica per bilanciare la precisione per il richiamo o viceversa utilizzando il meta-modello di soglia. Ciò è dimostrato da un esempio di come utilizzare il modello thresholder in una ricerca a griglia. Utilizzando queste tecniche fornite da scikit-learn, è possibile regolare i parametri del modello e ottenere prestazioni migliori.
  
  
• 01:35:00 In questa sezione, l'oratore parla dell'utilizzo di una ricerca su griglia per regolare la soglia di un classificatore binario. Mostrano che le curve di precisione e richiamo cambiano al variare della soglia, ma l'accuratezza rimane relativamente costante. L'oratore spiega che questo tipo di fase di post-elaborazione è meglio implementato come meta-modello che accetta un altro modello come input. Il relatore mostra quindi un esempio di costruzione di un meta-modello con le classi Pipeline e Group( byRegressor) di Scikit-learn per raggruppare i dati per dieta e quindi utilizzare un modello di regressione lineare diverso per ciascun gruppo. Spiegano che questo tipo di raggruppamento può essere utile per situazioni in cui l'effetto di una variabile categorica potrebbe non essere semplicemente uno spostamento costante.
  
  
• 01:40:00 In questa sezione, il video spiega un'attività di serie temporali e mostra come modellarla utilizzando un predittore raggruppato e un regressore fittizio. Rileva che la previsione è buona per la metà dell'anno, ma risulta inferiore negli ultimi anni e superiore nel passato. Per migliorare il modello, il video suggerisce di concentrarsi sui dati più recenti e dimenticare i dati passati. Introduce il concetto di pesi campione, che consente all'utente di specificare quanto pesare un particolare punto dati. Il video mostra quindi come aggiungere decadimento al modello, il che rende i punti dati recenti più importanti di quelli vecchi. In questo modo, il modello diventa più espressivo e si comporta meglio sui dati recenti ignorando la storia lontana. Tuttavia, questo trucco può portare a una situazione in cui i dati di addestramento hanno prestazioni peggiori rispetto ai dati di test.
  
  
• 01:45:00 In questa sezione, il relatore introduce uno strumento chiamato Human Learn, un progetto open source progettato per offrire strumenti compatibili con scikit-learn che aiutano a costruire e confrontare sistemi basati su regole. Il relatore spiega che, in passato, era più comune utilizzare esperti umani per elaborare regole aziendali e sistemi per la classificazione dei dati piuttosto che algoritmi di apprendimento automatico. Tuttavia, i modelli di machine learning non sono perfetti e possono presentare comportamenti problematici o inefficaci. L'obiettivo di Human Learn è quello di costruire sistemi basati su regole che possano essere facilmente confrontati con i modelli di apprendimento automatico e combinati con essi. Il relatore dimostra come costruire un sistema basato su regole utilizzando il set di dati Titanic e spiega come Human Learn può semplificare l'integrazione di questi sistemi nel flusso di lavoro quotidiano.
  
  
• 01:50:00 In questa sezione del video, il relatore introduce lo strumento FunctionClassifier in scikit-learn che prende una funzione definita dall'utente e la trasforma in un classificatore compatibile con scikit-learn. Lo strumento consente anche l'ottimizzazione della ricerca della griglia di qualsiasi parametro definito nella funzione dell'utente. Il relatore dimostra come utilizzare lo strumento FunctionClassifier per condurre una ricerca sulla griglia su un parametro di soglia con un set di dati relativo al disastro del Titanic. La flessibilità dello strumento consente agli utenti di creare qualsiasi funzione Python con logica personalizzata come modello di classificatore e aggiungere comportamenti come il rilevamento dei valori anomali.
  
  
• 01:55:00 In questa sezione, l'istruttore spiega come gestire gli outlier nei modelli di machine learning preesistenti. Aggiungendo una logica davanti al modello, è possibile identificare un valore anomalo e assegnargli un'etichetta diversa. Il pacchetto consente di costruire sistemi basati su regole utilizzando modelli di apprendimento automatico preesistenti, trovando un equilibrio tra intelligenza naturale e intelligenza artificiale. L'istruttore utilizza il pacchetto scikit-lego e la funzione load penguins per illustrare la previsione efficiente della specie di un pinguino in base alle sue proprietà. La funzione utilizza un grafico interattivo e l'istruttore disegna poligoni attorno ai punti dati che richiedono la classificazione. L'algoritmo point-in-poly viene quindi utilizzato per classificare i punti dati. Un classificatore interattivo consente la definizione di un modello compatibile con scikit-learn dal blob json. Quindi, i set di dati x e y possono essere generati da un frame di dati e il modello può essere utilizzato come qualsiasi modello di cycler.

• 02:00:00 In questa sezione, il relatore sottolinea le proprietà e i vantaggi dei modelli di machine learning disegnati. Utilizzando una funzionalità del grafico in Matplotlib, dimostra come i modelli disegnati prevedono le classificazioni per nuovi esempi e gestiscono i dati mancanti in modo efficace. Inoltre, il relatore mostra come lo stesso disegno può essere utilizzato come sistema di rilevamento dei valori anomali controllando se i punti sono al di fuori dei poligoni. Dimostra anche come la meccanica del disegno può essere utilizzata per assegnare etichette ai punti dati, anche quando le etichette non sono prontamente disponibili, rendendola un'utile fase di pre-elaborazione.
  
  
• 02:05:00 In questa sezione, il relatore discute l'API Interactive Charts, che è relativamente sperimentale e può fungere da trasformatore scikit-learn o in una pipeline panda per aggiungere due nuove colonne con conteggi riguardanti l'aspetto del punto dati in un poligono. Il relatore consiglia di utilizzare algoritmi di apprendimento automatico insieme alle regole aziendali per creare sistemi basati su regole. Inoltre, il relatore suggerisce diverse risorse come freeCodeCamp, il canale YouTube di pi data e la pagina della documentazione di scikit-learn per saperne di più sull'apprendimento automatico e su scikit-learn.

[MetaQuotes]

PyTorch per Deep Learning e Machine Learning – Corso completo (parti 1-4)

PyTorch per Deep Learning e Machine Learning - Corso completo

Parte 1

• 00:00:00 In questa sezione del video, l'istruttore, Daniel Bourke, introduce gli spettatori al corso PyTorch e stabilisce le aspettative per il video tutorial per principianti. Il focus del corso sarà sull'implementazione dei concetti di machine learning in PyTorch, un framework basato su Python, in cui i visualizzatori impareranno scrivendo codice. Bourke afferma che il corso tratterà argomenti importanti come l'apprendimento del trasferimento, la distribuzione del modello e il monitoraggio degli esperimenti, e se gli spettatori vogliono saperne di più su PyTorch, sono disponibili risorse aggiuntive su learn pytorch.io. Infine, Bourke definisce l'apprendimento automatico come il processo di trasformare i dati in numeri e trovare modelli utilizzando algoritmi e matematica, e spiega che l'obiettivo del corso è scrivere codice, ma gli spettatori possono trovare risorse extra se vogliono approfondire la matematica. dietro il codice.
  
  
• 00:05:00 In questa sezione viene spiegata la differenza tra la programmazione tradizionale e l'apprendimento automatico. La programmazione tradizionale prevede la scrittura di regole per un'attività, mentre gli algoritmi di apprendimento automatico calcolano le regole in base ai dati di input e output. Il motivo per utilizzare l'apprendimento automatico rispetto alla programmazione tradizionale è per problemi complessi in cui diventa ingombrante scrivere manualmente tutte le regole. L'apprendimento automatico può essere utilizzato per qualsiasi cosa purché possa essere convertito in numeri, ma la regola numero uno dell'apprendimento automatico di Google è provare prima a creare un semplice sistema basato su regole prima di passare all'apprendimento automatico.
  
  
• 00:10:00 In questa sezione, l'istruttore discute a cosa serve il deep learning ea cosa non serve. Il deep learning è utile per affrontare problemi che richiedono lunghi elenchi di regole, gestire ambienti in continua evoluzione e scoprire informazioni all'interno di grandi set di dati. Tuttavia, il deep learning non è l'ideale per attività che richiedono spiegabilità poiché i modelli appresi da un modello di deep learning sono in genere non interpretabili dagli esseri umani. Inoltre, se un semplice sistema basato su regole può risolvere il problema in questione, potrebbe essere meglio utilizzarlo invece del deep learning.
  
  
• 00:15:00 In questa sezione del corso completo su PyTorch per deep learning e machine learning, l'istruttore mette a confronto machine learning e deep learning. Le tecniche tradizionali di apprendimento automatico, come le macchine potenziate con gradiente come xg boost, sono le migliori per i dati strutturati in righe e colonne. Per i dati non strutturati, come il linguaggio naturale o le immagini, il deep learning è generalmente una scelta migliore. I modelli di deep learning sono probabilistici, nel senso che scommettono sul risultato, mentre i sistemi basati su regole producono risultati prevedibili. Inoltre, i modelli di deep learning richiedono una grande quantità di dati per produrre ottimi risultati, ma esistono tecniche per ottenere buoni risultati con meno dati.
  
  
• 00:20:00 In questa sezione, l'istruttore spiega la differenza tra dati strutturati e non strutturati e gli algoritmi utilizzati per ciascun tipo di machine learning e deep learning. I dati strutturati funzionano bene con algoritmi superficiali come foreste casuali e macchine potenziate dal gradiente, mentre i dati non strutturati richiedono reti neurali. L'istruttore approfondisce quindi i tipi di reti neurali come reti neurali completamente connesse, reti neurali convoluzionali, reti neurali ricorrenti e trasformatori. L'istruttore consiglia che una volta appresi gli elementi costitutivi fondamentali per le reti neurali, gli altri stili di reti neurali diventano più facili da comprendere. La sezione si conclude con l'istruttore che incoraggia lo spettatore a ricercare e formare la propria definizione di reti neurali prima del video successivo.
  
  
• 00:25:00 In questa sezione del corso PyTorch, l'istruttore fornisce una panoramica delle reti neurali e della loro anatomia. Le reti neurali sono costituite da un livello di input, in cui i dati di input vengono trasformati in numeri, più livelli nascosti, che manipolano e apprendono i modelli nei dati, e un livello di output, che emette le rappresentazioni apprese. Il numero di nodi negli strati nascosti può essere personalizzato e la rete neurale apprende autonomamente le rappresentazioni, chiamate anche caratteristiche o pesi. Diversi tipi di reti neurali possono essere utilizzati per diversi problemi, come CNN per immagini e trasformatori per l'elaborazione del linguaggio naturale. Una volta che la rete neurale emette le sue rappresentazioni, queste possono essere convertite in un formato comprensibile dall'uomo. Anche l'anatomia di una rete neurale può essere personalizzata, con un numero di strati che va da pochi a oltre un centinaio.
  
  
• 00:30:00 In questa sezione viene spiegata l'anatomia di una rete neurale. Le reti neurali sono costituite da uno strato di input, uno o più strati nascosti, ciascuno con molti neuroni o unità nascoste, e uno strato di output. Modelli e set di dati vengono trasformati in dati numerici attraverso l'uso di funzioni lineari e non lineari. I modelli vengono disegnati utilizzando una combinazione di funzioni lineari e non lineari per produrre un risultato desiderato. Vengono discussi diversi paradigmi di apprendimento, tra cui l'apprendimento supervisionato, in cui i dati e le etichette vengono utilizzati insieme, e l'apprendimento non supervisionato, in cui vengono utilizzati solo i dati. Gli algoritmi di apprendimento auto-supervisionato utilizzano i dati per trovare modelli, mentre l'apprendimento di trasferimento implica l'utilizzo di modelli che sono già stati appresi in un modello diverso.
  
  
• 00:35:00 In questa sezione, l'istruttore discute i diversi paradigmi dell'apprendimento automatico, in particolare l'apprendimento supervisionato, l'apprendimento di trasferimento e l'apprendimento per rinforzo. Anche se in questo corso l'attenzione si concentrerà sull'apprendimento supervisionato e sul trasferimento dell'apprendimento, l'istruttore incoraggia gli studenti a esplorare l'apprendimento per rinforzo con i propri tempi. Inoltre, l'istruttore fornisce esempi di come viene utilizzato il deep learning, come sistemi di raccomandazione, traduzione, riconoscimento vocale e visione artificiale. Viene sottolineata la versatilità dell'apprendimento automatico, in quanto tutto ciò che può essere convertito in numeri e programmato per trovare modelli può essere utilizzato negli algoritmi di apprendimento automatico.
  
  
• 00:40:00 In questa sezione del video, l'istruttore discute le potenziali applicazioni del deep learning, come il rilevamento di oggetti utilizzando la visione artificiale per catturare incidenti mordi e fuggi per identificare l'auto del colpevole. L'istruttore spiega il concetto di elaborazione del linguaggio naturale e come viene utilizzato nel rilevamento dello spam. Il video passa quindi a coprire le basi di PyTorch, il framework di deep learning di ricerca più popolare che consente un deep learning veloce in Python, l'accesso a modelli predefiniti e prestazioni della GPU accelerate. Il sito Web PyTorch è identificato come una risorsa necessaria per il corso.
  
  
• 00:45:00 In questa sezione, l'istruttore parla di PyTorch, che secondo lui è il framework di ricerca sul deep learning più popolare. Cita Papers with Code, che tiene traccia dei documenti di machine learning che hanno codice, per dimostrare la popolarità di PyTorch, mostrando che il 58% dei 65.000 documenti che il sito ha tracciato sono implementati con PyTorch. Inoltre, fornisce vari motivi per la popolarità di PyTorch, incluso il suo utilizzo da parte di aziende come Facebook/Meta, Tesla, Microsoft e OpenAI, nonché la sua capacità di standardizzare le metodologie di ricerca. L'istruttore sottolinea anche il tweet di Francois Chale, che elogia PyTorch come uno strumento che chiunque può utilizzare per risolvere problemi senza richiedere investimenti significativi o un team di ingegneri. Nel complesso, l'istruttore conclude che PyTorch è uno dei preferiti dalla ricerca con un ecosistema diversificato e un alto tasso di adozione tra i pesi massimi del settore.
  
  
• 00:50:00 In questa sezione del corso PyTorch per Deep Learning e Machine Learning, l'istruttore discute le varie applicazioni di PyTorch, come in agricoltura e piattaforme di social media come Facebook e Microsoft. Inoltre, spiega come PyTorch consente agli utenti di eseguire codice di apprendimento automatico su GPU, che sono altamente efficienti nell'eseguire calcoli numerici, specialmente nell'elaborazione parallela. PyTorch sfrutta CUDA per consentire l'esecuzione del codice di machine learning su GPU NVIDIA e, sebbene siano disponibili TPU, le GPU tendono ad essere più popolari durante l'esecuzione del codice PyTorch. Inoltre, lascia la domanda "Cos'è un tensore?" al pubblico per la ricerca, con la sezione seguente per approfondire l'argomento.
  
  
• 00:55:00 In questa sezione, l'istruttore spiega che i tensori sono l'elemento fondamentale di PyTorch e potrebbero essere qualsiasi cosa rappresenti numeri. I dati di input sono codificati numericamente per trasformarli in un tensore, che potrebbe essere un'immagine o un milione di immagini. Il tensore o i tensori di input vengono quindi passati a una rete neurale che lo manipola attraverso operazioni matematiche e genera un altro tensore, che viene quindi riconvertito in un formato comprensibile dall'uomo. Viene sottolineato il motivo dell'utilizzo di PyTorch e della ricerca di risposte alle domande online, nonché un'introduzione ad argomenti specifici che verranno trattati nel corso.

Parte 2

• 01:00:00 In questa sezione, l'istruttore evidenzia gli argomenti trattati nel corso PyTorch. Il corso inizia con le basi di PyTorch, concentrandosi sui tensori e sulle operazioni tensoriali, quindi passa alla pre-elaborazione dei dati, alla creazione e all'utilizzo di modelli di deep learning pre-addestrati, all'adattamento di un modello a un set di dati, all'esecuzione di previsioni e alla valutazione delle previsioni del modello. L'istruttore spiega il flusso di lavoro, inclusa la preparazione dei dati, la scelta di un modello pre-addestrato, la scelta di una funzione di perdita e di un ottimizzatore, la creazione di un ciclo di addestramento, l'adattamento del modello e il miglioramento del modello attraverso la sperimentazione. Infine, l'istruttore sottolinea l'importanza di programmare insieme, esplorare e sperimentare il codice collegando risorse extracurriculari per saperne di più sulla teoria alla base del codice.
  
  
• 01:05:00 In questa sezione, l'istruttore del corso PyTorch for Deep Learning & Machine Learning consiglia agli studenti di avvicinarsi al corso con la mente di uno scienziato e di uno chef. Sottolinea l'importanza della sperimentazione e della visualizzazione per comprendere i dati nel deep learning. Inoltre, l'istruttore incoraggia gli studenti a porre domande e svolgere gli esercizi forniti, nonché a condividere il proprio lavoro con gli altri per aiutare con il proprio apprendimento e quello degli altri. Infine, consiglia agli studenti di evitare di pensare troppo e di dire che non possono imparare, esortandoli a evitare che il loro cervello prenda fuoco. Infine, indirizza gli studenti alle risorse fondamentali richieste per il corso, incluso un repository GitHub con tutti i materiali richiesti.
  
  
• 01:10:00 In questa sezione, il relatore spiega le risorse disponibili per il corso e come utilizzarle in modo efficace. I materiali del corso, inclusi codice e notebook, sono disponibili su GitHub, mentre le domande e risposte del corso sono disponibili nella scheda Discussioni dello stesso repository. Inoltre, è disponibile un libro online su learnpytorch.io. Per le domande relative a PyTorch che non sono specifiche del corso, i forum e il sito web di PyTorch sono altamente raccomandati. Il relatore introduce quindi Google Colab, che sarà lo strumento principale utilizzato durante il corso, e incoraggia gli utenti a programmare accedendovi tramite colab.research.google.com.
  
  
• 01:15:00 In questa sezione, l'istruttore spiega come utilizzare Google Colab per creare un nuovo taccuino e scrivere codice PyTorch. Google Colab offre vantaggi come la possibilità di utilizzare l'accelerazione GPU o TPU per tempi di elaborazione più rapidi, oltre a PyTorch preinstallato e altri pacchetti di data science Python comuni. L'istruttore si collega a un notebook di risorse su learnpytorch.io e fornisce un repository GitHub in cui gli studenti possono porre domande relative al corso. L'istruttore afferma inoltre che mentre utilizzano la versione a pagamento di Google Colab, la versione gratuita è sufficiente per completare il corso.
  
  
• 01:20:00 In questa sezione, il video introduce come configurare PyTorch utilizzando Google Colab o facendo riferimento al documento di configurazione per la configurazione locale. La configurazione consigliata per completare il corso è PyTorch 1.10 e CUDA 11.3. Il video suggerisce anche di utilizzare un approccio a finestra divisa per seguire e creare un taccuino per esercitarsi. L'obiettivo principale del video è un'introduzione ai tensori, l'elemento costitutivo principale per il deep learning, che fornisce esempi di creazione di un tensore scalare riempito con il numero sette e come accedere alla documentazione di PyTorch per torch.tensor.
  
  
• 01:25:00 In questa sezione, l'istruttore spiega le basi dei tensori PyTorch, a partire dalla creazione di tensori utilizzando torch.dot.tensor. Incoraggia gli studenti a esaminare la documentazione di PyTorch per saperne di più sulla libreria. Andando avanti, l'istruttore spiega gli attributi di scalari, vettori e matrici. Chiarisce che uno scalare non ha dimensioni ed è solo un singolo numero, mentre un vettore ha una dimensione, solitamente rappresentata come grandezza e direzione. Una matrice è il passaggio successivo e ha due dimensioni rappresentate da due coppie di parentesi quadre. Spiega la differenza tra dimensione e forma e come trovare la forma di un vettore in termini di dimensioni.
  
  
• 01:30:00 In questa sezione, l'istruttore introduce i tensori in PyTorch e spiega che sono gli elementi costitutivi fondamentali delle reti neurali di deep learning. L'istruttore dimostra come creare tensori con dimensioni diverse, che vanno da uno scalare a una matrice a un tensore con tre coppie di parentesi quadre. L'istruttore spiega che il numero di dimensioni è indicato dal numero di coppie di parentesi quadre e la forma è determinata dal numero di elementi in ciascuna dimensione. Inoltre, l'istruttore osserva che sebbene scrivere i tensori a mano sia noioso, è importante capire come funzionano poiché PyTorch li utilizza ampiamente.
  
  
• 01:35:00 In questa sezione, l'istruttore discute l'importanza dei tensori casuali in PyTorch per il machine learning e il deep learning. Iniziare con tensori pieni di numeri casuali e poi adattarli per rappresentare meglio i dati è un concetto chiave nelle reti neurali. Per creare un tensore casuale in PyTorch, l'istruttore mostra come utilizzare la funzione torch.rand e spiega che "dimensione" e "forma" sono due versioni diverse della stessa cosa. Viene brevemente discussa anche la convenzione di denominazione per le variabili nel deep learning, come scalari e vettori in minuscolo e matrici e tensori in maiuscolo.
  
  
• 01:40:00 In questa sezione, l'istruttore dimostra come creare tensori casuali utilizzando PyTorch e spiega che vari tipi di dati, comprese le immagini, possono essere rappresentati in formato tensore. L'istruttore spiega che PyTorch semplifica il processo di creazione dei tensori e, in molti casi, gestisce il processo dietro le quinte. Dimostrano come creare un tensore casuale con una forma simile a quella di un tensore immagine e spiegano che le immagini sono comunemente rappresentate come tensori con canali di colore, altezza e larghezza. L'istruttore sottolinea che quasi tutti i tipi di dati possono essere rappresentati come tensori, rendendo PyTorch un potente strumento per applicazioni di deep learning e machine learning.
  
  
• 01:45:00 In questa sezione, l'istruttore introduce come creare tensori di zeri e uno e come creare un intervallo di tensori. Il tensore di tutti zeri è utile per creare una maschera tensore, che può azzerare determinate colonne di un tensore. Anche il tensore di tutti può essere utile in alcune situazioni. L'istruttore spiega come utilizzare torch.range, ma avverte che potrebbe essere deprecato in alcune versioni di PyTorch e suggerisce invece di utilizzare una funzione di intervallo.
  
  
• 01:50:00 In questa sezione viene spiegata la funzionalità PyTorch di creare tensori utilizzando un intervallo e altri aventi la stessa forma di un altro tensore. L'intervallo di tensori viene creato utilizzando torch.arange() dove è possibile definire start, stop e step. Allo stesso modo, torch.zeros_like() viene utilizzato per creare un tensore di zeri con la stessa forma del tensore di input. La sezione introduce quindi i tipi di dati tensoriali in PyTorch, specificando che il tipo predefinito è float 32, anche se non ne viene specificato nessuno.
  
  
• 01:55:00 In questa sezione, apprendiamo i parametri importanti durante la creazione di tensori in PyTorch, come il tipo di dati, il dispositivo e richiede grad. Scopriamo che il tipo di dati si riferisce al livello di precisione nel calcolo e comunemente interagisce con tensori in virgola mobile a 32 bit e in virgola mobile a 16 bit. La precisione singola è a 32 bit e la mezza precisione è a 16 bit, con 32 bit come tipo di tensore predefinito in PyTorch. La nota sui tipi di dati tensoriali è essenziale in quanto è uno dei tre errori significativi in cui potremmo incorrere durante l'utilizzo di PyTorch e deep learning. Gli altri due errori includono tensori che non hanno la forma giusta e non si trovano sul dispositivo giusto.

Parte 3

• 02:00:00 In questa sezione, l'istruttore discute l'importanza di mantenere la forma e il dispositivo corretti quando si lavora con i tensori in PyTorch. Se i tensori hanno forme diverse o si trovano su dispositivi diversi (CPU o GPU), possono verificarsi errori. Inoltre, l'istruttore spiega il ruolo del parametro "grad" nel tracciare i gradienti durante i calcoli numerici. La lezione include una sfida per gli spettatori per creare tensori di diversi tipi di dati e testare l'impatto della moltiplicazione di tensori di diversi tipi. L'istruttore avverte che mentre alcune operazioni potrebbero non causare errori, altre possono portare a problemi di tipo di dati, in particolare durante l'addestramento di reti neurali di grandi dimensioni.
  
  
• 02:05:00 In questa sezione del video, l'istruttore illustra come risolvere i problemi relativi alle operazioni dei tensori e garantire che i tensori abbiano il tipo e la forma di dati corretti per l'utilizzo nei modelli di machine learning. Dimostrano come controllare il tipo di dati, la forma e il dispositivo di un tensore utilizzando PyTorch, utilizzando i comandi tensor.Dtype, tensor.shape e tensor.device. L'istruttore osserva inoltre che PyTorch può generare errori se i tensori non sono nel tipo o nella forma di dati corretti e mostra come modificare il tipo di dati se necessario. Infine, confrontano i comandi di dimensione e forma e notano che sono intercambiabili, essendo uno una funzione e l'altro un attributo.
  
  
• 02:10:00 In questa sezione, l'istruttore esamina la manipolazione dei tensori in PyTorch, in particolare le operazioni sui tensori come addizione, sottrazione, moltiplicazione, divisione e moltiplicazione di matrici. Queste operazioni sono importanti per la creazione di reti neurali in quanto aiutano a risolvere i problemi più comuni con la creazione di modelli di deep learning. Inoltre, le reti neurali combinano queste funzioni in vari modi per analizzare e regolare i numeri di un tensore casuale per rappresentare un set di dati. L'istruttore dimostra come eseguire le operazioni tensoriali di base di addizione, moltiplicazione e moltiplicazione di matrici utilizzando esempi di codice PyTorch.
  
  
• 02:15:00 In questa sezione, l'istruttore copre le operazioni tensoriali utilizzando PyTorch e introduce il concetto di moltiplicazione di matrici. Dimostrano come eseguire moltiplicazioni, addizioni e sottrazioni in base agli elementi utilizzando gli operatori Python e le funzioni integrate di PyTorch. L'istruttore lancia una sfida agli spettatori per cercare e comprendere la moltiplicazione di matrici prima di immergersi in essa. Spiegano che ci sono due modi principali per eseguire la moltiplicazione nelle reti neurali, la moltiplicazione per elemento e per matrice, che viene anche definita prodotto scalare. L'istruttore fornisce esempi di entrambi i tipi di moltiplicazione utilizzando matrici e sottolinea che la moltiplicazione di matrici è una delle operazioni tensoriali più comuni nelle reti neurali.
  
  
• 02:20:00 In questa sezione, l'istruttore spiega la differenza tra moltiplicazione per elemento e prodotto scalare in PyTorch. Per dimostrare il concetto, l'istruttore passa attraverso un processo graduale di moltiplicazione di due matrici, evidenziando come ogni elemento viene moltiplicato e aggiunto per ottenere il risultato finale. Successivamente, l'istruttore mostra come eseguire la moltiplicazione degli elementi utilizzando un esempio rudimentale, seguito dalla moltiplicazione della matrice utilizzando la funzione del centro commerciale del tappetino della torcia. La sezione illustra anche come eseguire la moltiplicazione di matrici utilizzando un ciclo for e spiega la differenza di prestazioni tra i due metodi.
  
  
• 02:25:00 In questa sezione, il video spiega i vantaggi della vettorizzazione rispetto ai loop for in PyTorch, utilizzando l'esempio della moltiplicazione di matrici. Il metodo torch dot matmore ha dimostrato di essere 10 volte più veloce rispetto all'utilizzo di un ciclo for per piccoli tensori. Tuttavia, il video avverte che due regole principali devono essere soddisfatte per tensori più grandi al fine di evitare errori di forma nella moltiplicazione di matrici. La prima regola è che le dimensioni interne dei due tensori devono coincidere.
  
  
• 02:30:00 In questa sezione, l'istruttore spiega le regole della moltiplicazione di matrici e come evitare errori di forma comuni durante la moltiplicazione di tensori. La prima regola è che le dimensioni interne della matrice devono corrispondere. Per dimostrarlo, l'istruttore crea un tensore di dimensione 3x2 e tenta di moltiplicarlo per un altro tensore che non ha le stesse dimensioni interne, generando un errore. La seconda regola è che la matrice risultante ha la forma delle dimensioni esterne. L'istruttore fornisce esempi di moltiplicazione di matrici con diverse forme e dimensioni di tensori e come si traducono in diverse forme di matrici. L'istruttore incoraggia gli spettatori a utilizzare un sito Web per esercitarsi con la moltiplicazione di matrici come sfida prima del video successivo.
  
  
• 02:35:00 In questa sezione, l'istruttore discute gli errori di forma nelle reti neurali, che sono uno degli errori più comuni nel deep learning. Poiché le reti neurali sono composte da diverse operazioni di moltiplicazione di matrici, anche un leggero errore di forma del tensore può portare a un errore di forma. L'istruttore quindi crea due tensori, il tensore a e il tensore b, e cerca di eseguire una moltiplicazione di matrici tra di loro, portando a un errore di forma. Per correggere questo errore, l'istruttore introduce il concetto di trasposizione, che cambia gli assi o le dimensioni di un dato tensore, e dimostra come può essere utilizzato per regolare la forma dei tensori nel codice PyTorch.
  
  
• 02:40:00 In questa sezione, l'istruttore spiega il concetto di trasposizione dei tensori e la sua importanza nella moltiplicazione di matrici. La trasposizione riorganizza gli elementi di un tensore senza modificarne i dati sottostanti ed è indicata con "punto t". L'istruttore dimostra anche come funziona un'operazione di moltiplicazione di matrici quando il tensore b viene trasposto e sottolinea l'importanza di questa operazione nelle reti neurali e nel deep learning. Il processo di trasposizione dei tensori è illustrato visivamente e l'istruttore fornisce esempi di codice passo dopo passo per aiutare gli studenti a comprendere e praticare il concetto.
  
  
• 02:45:00 In questa sezione, l'istruttore spiega la moltiplicazione di matrici utilizzando PyTorch e un sito Web chiamato Matrix Multiplication. Ha creato due tensori, il tensore a e il tensore b, e ha dimostrato che la loro moltiplicazione produce un nuovo tensore con una forma di output specifica. Sfida gli spettatori a trasporre il tensore a invece del tensore b e vedere i risultati. Andando avanti, l'istruttore copre l'aggregazione tensoriale, mostrando come trovare il minimo, il massimo, la media e la somma di un tensore usando i metodi PyTorch. Spiega anche come l'aggregazione tensoriale aiuta a ridurre il numero di elementi in un tensore.
  
  
• 02:50:00 In questa sezione del tutorial su PyTorch, l'istruttore mostra come risolvere uno degli errori più comuni in PyTorch, ovvero il tipo di dati errato. Lo dimostra creando un tensore del tipo di dati long, che impedisce l'uso della funzione media della torcia. Spiega quindi come convertire il tensore in float 32, richiesto dalla funzione mean, utilizzando il metodo x.type(). Oltre a trovare il minimo, il massimo, la media e la somma del tensore, l'istruttore lancia anche una sfida per trovare il minimo e il massimo posizionali, che sarà trattato nel prossimo video.
  
  
• 02:55:00 In questa sezione è stato spiegato l'uso delle funzioni argmin e argmax in PyTorch per trovare il minimo e il massimo posizionale di un tensore. La funzione argmin restituisce la posizione nel tensore che ha il valore minimo, mentre la funzione argmax restituisce la posizione nel tensore che ha il valore massimo. Queste funzioni sono utili quando non è necessario definire i valori minimo o massimo di un tensore, ma solo la posizione di tali valori. Inoltre, sono stati introdotti i concetti di reshaping, stacking, squeezing e unsqueezing dei tensori, utili per gestire le discrepanze di forma nell'apprendimento automatico e nel deep learning.

Parte 4

• 03:00:00 In questa sezione, l'istruttore spiega i diversi metodi di manipolazione del tensore in PyTorch, come reshape, view, stacking, squeeze, unsqueeze e permute. Reshape cambia la forma di un tensore di input, view restituisce una vista di un tensore con una forma diversa, stacking combina più tensori insieme verticalmente o orizzontalmente, squeeze rimuove tutte le dimensioni che sono uguali a 1 e unsqueeze aggiunge una nuova dimensione con una dimensione di 1. Infine, permute scambia le dimensioni di un tensore. L'istruttore fornisce esempi di codice per dimostrare ciascuno di questi metodi e sottolinea quanto sia importante la manipolazione della forma del tensore nell'apprendimento automatico e nell'apprendimento profondo.
  
  
• 03:05:00 In questa sezione, il video tutorial esplora come rimodellare e visualizzare i tensori PyTorch. La risagoma richiede compatibilità con le dimensioni originali e può essere eseguita utilizzando le funzioni "risagoma" o "visualizza". È importante notare che 'view' condivide la stessa memoria con il tensore originale. Inoltre, la funzione 'stack' concatena i tensori lungo una nuova dimensione e la dimensione predefinita è zero. Si consiglia agli utenti di salvare il proprio lavoro frequentemente poiché potrebbero verificarsi errori durante l'utilizzo di Google CoLab o di qualsiasi altra forma di Jupyter Notebooks.
  
  
• 03:10:00 In questa sezione, l'istruttore introduce i concetti di squeeze e unsqueeze in PyTorch. Per esercitarsi nell'uso di questi metodi, lo spettatore è incoraggiato a consultare la documentazione e provarli. L'istruttore dimostra il metodo di compressione in cui le singole dimensioni vengono rimosse da un tensore target. Per visualizzare le modifiche apportate ai tensori durante queste operazioni, l'istruttore suggerisce di stampare ogni modifica e controllare la dimensione del tensore. Inoltre, l'istruttore sottolinea l'importanza di praticare questi concetti più volte per acquisire familiarità con essi.
  
  
• 03:15:00 In questa sezione, l'istruttore spiega il concetto di aggiunta e rimozione di dimensioni nei tensori PyTorch utilizzando i metodi "squeeze" e "unsqueeze". Dimostra gli effetti di questi metodi aggiungendo e rimuovendo dimensioni dai tensori e stampando le loro forme. L'istruttore introduce anche il metodo "permute", che riorganizza le dimensioni di un tensore bersaglio in un ordine specificato. Fornisce un esempio di come permute può essere utilizzato con le immagini e discute l'importanza di trasformare i dati in rappresentazioni numeriche nel deep learning.
  
  
• 03:20:00 In questa sezione, l'istruttore insegna come permutare un tensore riorganizzando le sue dimensioni usando il metodo permute() in PyTorch. L'esempio fornito è un tensore immagine in cui la dimensione del canale colore viene spostata al primo indice. L'istruttore spiega che un tensore permutato è solo una vista e condivide la stessa memoria del tensore originale, dimostrato aggiornando un valore nel tensore originale e vedendo lo stesso valore copiato nel tensore permutato. La sezione copre anche l'indicizzazione in PyTorch e come è simile all'indicizzazione con NumPy, un'altra popolare libreria di calcolo numerico.
  
  
• 03:25:00 In questa sezione, l'istruttore introduce come importare la torcia e mostra come creare un piccolo intervallo e rimodellarlo in modo compatibile. Il tutorial approfondisce quindi l'indicizzazione con i tensori e mostra come indicizzare sulla prima e sulla seconda dimensione. L'esercitazione rivela anche la funzionalità dell'utilizzo di un punto e virgola per selezionare tutta una dimensione di destinazione. La sezione si conclude con una sfida per riorganizzare il codice per ottenere il numero nove.
  
  
• 03:30:00 In questa sezione, l'istruttore dimostra come selezionare valori specifici da un tensore utilizzando PyTorch. Gli esempi comportano la selezione di elementi da diverse dimensioni del tensore specificando i valori di indice appropriati. L'istruttore quindi sfida gli spettatori a provare a indicizzare il tensore per restituire valori specifici. Nella sezione successiva, l'istruttore spiega come i tensori PyTorch interagiscono con la popolare libreria scientifica di calcolo numerico, NumPy. Poiché PyTorch lo richiede, è presente una funzionalità integrata per consentire una facile transizione tra gli array NumPy e i tensori PyTorch.
  
  
• 03:35:00 In questa sezione, il video illustra come convertire i dati dai tensori NumPy ai tensori PyTorch e viceversa. Per passare da NumPy a PyTorch, viene utilizzato il metodo torch.fromNumPy sull'array NumPy, ma va notato che il tipo di dati predefinito di PyTorch è float32 mentre il valore predefinito di NumPy è float64. Pertanto, potrebbe essere necessario specificare il tipo di dati durante la conversione. È anche importante notare che quando si modifica il valore dell'array NumPy originale, non cambia il valore del tensore PyTorch se è stato creato utilizzando il metodo fromNumPy. Per passare da PyTorch a NumPy, è possibile utilizzare il metodo torch.tensor.numpy().
  
  
• 03:40:00 In questa sezione, il video illustra come passare da PyTorch a NumPy e ai tipi di dati predefiniti di ciascuno. Il tipo di dati predefinito di PyTorch è float32, mentre il tipo di dati predefinito di NumPy è float64 e, se si modifica il tipo di dati in PyTorch, il tensore NumPy rifletterà il tipo di dati originale. Il video copre anche il concetto di riproducibilità nelle reti neurali e l'uso di semi casuali per ridurre la casualità negli esperimenti. Impostando un seme casuale, la casualità viene aromatizzata e il computer diventa più deterministico, consentendo risultati più riproducibili.
  
  
• 03:45:00 In questa sezione, l'istruttore introduce il concetto di casualità e riproducibilità in PyTorch. Vengono creati due tensori casuali utilizzando la funzione torch.rand e i loro valori vengono stampati e confrontati. L'istruttore spiega il concetto di seme casuale, che viene utilizzato per creare casualità riproducibile in PyTorch. Il valore seme casuale può essere impostato su un valore numerico a scelta, ad esempio 42, e quindi utilizzato in varie funzioni casuali per ottenere una casualità aromatizzata. È importante notare che se viene utilizzata la funzione torch.manual_seed, in genere funziona solo per un blocco di codice in un notebook.
  
  
• 03:50:00 In questa sezione del video viene sottolineata l'importanza della riproducibilità nell'apprendimento automatico e nel deep learning e viene spiegato il concetto di seme casuale. Il seme manuale è un modo per aromatizzare la casualità dei tensori casuali di PyTorch e renderli riproducibili. Il documento sulla riproducibilità di PyTorch è raccomandato come un'ottima risorsa per conoscere la riproducibilità. La sezione discute anche l'esecuzione di oggetti PyTorch su GPU per calcoli più veloci e come ottenere l'accesso alle GPU, incluso l'utilizzo di Google Colab per una GPU gratuita, Google Colab Pro per GPU più veloci e tempi di esecuzione più lunghi e Google Colab Pro Plus per vantaggi più avanzati.
  
  
• 03:55:00 In questa sezione, l'istruttore spiega diversi modi per accedere alle GPU per attività di deep learning e machine learning. Le opzioni sono utilizzare Google Colab, eseguire l'upgrade a Colab Pro, utilizzare la propria GPU o utilizzare servizi di cloud computing come GCP, AWS o Azure. L'istruttore consiglia di iniziare con Google Colab, che è facile e gratuito da usare. Tuttavia, se hai bisogno di più risorse o desideri eseguire esperimenti più grandi, potresti voler aggiornare o utilizzare la tua GPU o il cloud computing. L'istruttore mostra anche come ottenere una GPU in Google Colab modificando il tipo di runtime e verificando l'accesso alla GPU con PyTorch.

[MetaQuotes]

PyTorch per Deep Learning e Machine Learning – Corso completo (descrizione per le parti 5-9)

PyTorch per Deep Learning e Machine Learning - Corso completo

Parte 5

• 04:00:00 In questa sezione, l'istruttore spiega come verificare l'accesso alla GPU con PyTorch e configurare il codice agnostico del dispositivo. Utilizzando il comando "torch.cuda.is_available()", l'utente può verificare se PyTorch può accedere alla GPU. Inoltre, per eseguire PyTorch, la variabile del dispositivo deve essere impostata per utilizzare la GPU, se disponibile, o per impostazione predefinita la CPU. È anche importante impostare il codice agnostico del dispositivo, che consente a PyTorch di funzionare sulla CPU o sulla GPU, a seconda di ciò che è disponibile, impostando "args.device=torch.device('cuda' if torch.cuda.is_available() else 'cpu')" negli script Python. L'istruttore sottolinea che l'impostazione del codice indipendente dal dispositivo è una best practice quando si lavora con PyTorch poiché consente l'esecuzione del codice su dispositivi diversi.
  
  
• 04:05:00 In questa sezione, l'istruttore spiega come l'utilizzo delle GPU può portare a calcoli più veloci ed essere vantaggioso per i modelli di machine learning che funzionano con calcoli numerici come le operazioni tensoriali. Per utilizzare la GPU, è necessario trasferire su di essa tensori e modelli e PyTorch semplifica l'operazione con il metodo `to`. Il codice può essere reso indipendente dal dispositivo in modo che venga eseguito indipendentemente dal fatto che una GPU sia disponibile o meno. Allo stesso modo, i tensori possono anche essere riportati alla CPU se necessario, e il metodo `cpu()` può essere usato per questo. L'istruttore sottolinea che i problemi del dispositivo sono il terzo errore più comune in PyTorch e che è buona norma tenere presente il tipo di dispositivo su cui sono archiviati tensori e modelli.
  
  
• 04:10:00 In questa sezione, l'istruttore discute i fondamenti del lavoro con PyTorch sulla GPU. Spiega come passare da CPU a GPU e come evitare errori quando si utilizzano calcoli NumPy con tensori sulla GPU. Incoraggia inoltre gli studenti a mettere in pratica ciò che hanno appreso attraverso una serie di esercizi e curriculum extra disponibili su learn.pytorch.io. Gli esercizi si basano su ciò che è stato trattato nelle sezioni precedenti e gli studenti sono incoraggiati a utilizzare la documentazione di PyTorch per completarli. Infine, l'istruttore fornisce suggerimenti su come affrontare questi esercizi in Colab impostando due schermate e importando la torcia.
  
  
• 04:15:00 In questa sezione, l'istruttore discute gli esercizi e il curriculum extra nel corso PyTorch. Gli esercizi sono basati su codice e includono modelli per ognuno degli esercizi. Il curriculum extra è basato sulla lettura e l'istruttore consiglia di dedicare un'ora al tutorial di base di PyTorch, all'avvio rapido e alle sezioni sul tensore, oltre a guardare la sezione "Cos'è un tensore?" video. L'istruttore delinea anche il flusso di lavoro PyTorch, che include la preparazione dei dati e la loro trasformazione in tensori, la raccolta o la costruzione di un modello pre-addestrato, la selezione di una funzione di perdita e l'ottimizzazione, la creazione di un ciclo di addestramento, l'adattamento del modello, la valutazione del modello, la sperimentazione e migliorare, salvare e ricaricare il modello addestrato. L'istruttore incoraggia gli studenti a seguire il codice e la documentazione, cercare risorse, riprovare e porre domande nei forum PyTorch.
  
  
• 04:20:00 In questa sezione del video, l'istruttore inizia aprendo un nuovo taccuino in Colab e lo intitola "01 PyTorch Workflow". Spiega che si concentreranno sulla codifica insieme e sulla creazione di un flusso di lavoro end-to-end PyTorch, che prevede la preparazione e il caricamento dei dati, la creazione di un modello di apprendimento automatico in PyTorch, l'addestramento del modello, la valutazione del modello e il salvataggio/caricamento del modello. . L'istruttore menziona anche che utilizzeranno il modulo nn in PyTorch, che contiene tutti gli elementi costitutivi di PyTorch per le reti neurali.
  
  
• 04:25:00 In questa sezione, l'istruttore discute l'utilizzo di torch.nn in PyTorch esplorando gli elementi costitutivi di base per i grafici computazionali, utilizzati nelle reti neurali. La combinazione di questi elementi costitutivi consente ai data scientist e agli ingegneri dell'apprendimento automatico di creare vari tipi di reti neurali. L'istruttore sottolinea l'importanza del primo passaggio nel flusso di lavoro PyTorch, che consiste nella preparazione e nel caricamento dei dati in una rappresentazione numerica affinché il modello apprenda i modelli. Il tipo di rappresentazione numerica utilizzata per la codifica dei dati dipende dal tipo di dati. La seconda fase prevede la costruzione di una rete neurale per apprendere i modelli nella rappresentazione numerica e quindi l'utilizzo dei modelli appresi per attività specifiche come il riconoscimento delle immagini o la classificazione dello spam.
  
  
• 04:30:00 In questa sezione, l'istruttore introduce il gioco in due parti nell'apprendimento automatico, che prevede la conversione dei dati in rappresentazione numerica e la costruzione di un modello per trovare schemi in quella rappresentazione. L'istruttore crea quindi dati noti utilizzando la formula di regressione lineare per mostrare questo processo. Il peso e la deviazione della formula vengono utilizzati come parametri che un modello apprenderà esaminando diversi esempi. Il codice in Python viene utilizzato per creare un intervallo di numeri, assegnare un valore alla variabile X e creare una formula Y che equivale a peso per X più bias. Vengono visualizzati la lunghezza e il valore di X e Y e vengono visualizzati i primi dieci valori di X e Y.
  
  
• 04:35:00 In questa sezione, l'istruttore discute l'importanza di suddividere i dati in set di addestramento e test nell'apprendimento automatico. Usa l'analogia dei corsi universitari e degli esami per spiegare il concetto. Il set di formazione è simile a tutti i materiali del corso, il set di convalida è come un esame pratico e il set di test è l'esame finale. L'obiettivo è raggiungere la generalizzazione, in modo che il modello possa adattarsi a dati invisibili. L'istruttore sottolinea che la corretta suddivisione dei dati è fondamentale per creare un modello accurato.
  
  
• 04:40:00 In questa sezione del corso completo PyTorch, l'istruttore discute l'importanza della generalizzazione nei modelli di apprendimento automatico e i tre set di dati comunemente utilizzati nell'addestramento e nel test: set di addestramento, convalida e test. Spiega anche le suddivisioni percentuali comuni utilizzate per ciascuno di questi set, con il set di allenamento che di solito ha il 60-80% dei dati e il set di test ha il 10-20%. L'istruttore mostra quindi come creare un set di addestramento e test utilizzando un set di dati di esempio con valori X e Y utilizzando l'indicizzazione per selezionare il numero appropriato di campioni per ogni suddivisione. Infine, spiega che mentre esiste spesso un caso d'uso per un set di convalida in set di dati più complessi, i set di addestramento e test sono i più comunemente usati.
  
  
• 04:45:00 In questa sezione, l'istruttore sottolinea l'importanza di visualizzare i dati scrivendo una funzione chiamata "previsioni del grafico" che verrà utilizzata per confrontare i dati di addestramento e test. La funzione accetta X train, Y train, X test, Y test e previsioni come parametri e quindi traccia i dati di training in blu utilizzando un grafico a dispersione con la libreria matplotlib. I dati di test vengono quindi tracciati in verde utilizzando la stessa funzione di dispersione. La funzione controlla anche se ci sono previsioni e, in tal caso, le traccia utilizzando anche la funzione di dispersione. Visualizzando i dati, diventa più facile da capire e interpretare.
  
  
• 04:50:00 In questa sezione del video, l'istruttore discute il processo di addestramento e valutazione dei modelli di machine learning. Spiegano che l'obiettivo è addestrare il modello sui dati di addestramento per prevedere con precisione i valori dei dati di test. Lo dimostrano utilizzando un semplice set di dati lineare, con i dati di addestramento tracciati in blu e i dati di test in verde. L'istruttore introduce quindi il concetto di regressione lineare e pone le basi per la sezione successiva, in cui costruiranno un modello PyTorch per la regressione lineare. Forniscono inoltre alcuni suggerimenti per la risoluzione dei problemi relativi a Google Colab.
  
  
• 04:55:00 In questa sezione del video, impariamo come creare un modello di regressione lineare utilizzando PyTorch puro. L'istruttore spiega che PyTorch è costruito sopra il nn.module, che è come i mattoncini Lego dei modelli PyTorch. Quasi tutto in PyTorch eredita da nn.module e i moduli possono contenere altri moduli, il che semplifica la creazione di reti neurali complesse. L'istruttore ci guida quindi attraverso il processo di creazione di un costruttore con la funzione init, creando un parametro weights usando nn.parameter e impostandolo su parametri casuali usando torch.rand. L'istruttore spiega anche come impostare require_grad e dtype.

Parte 6

• 05:00:00 In questa sezione, l'istruttore spiega come creare un modello di regressione lineare utilizzando PyTorch. Iniziano creando una classe per il modello e inizializzandola con i parametri per i pesi e il bias, che vengono aggiunti automaticamente all'elenco dei parametri quando vengono assegnati a un attributo del modulo. Quindi creano un metodo forward per definire il calcolo nel modello, che si basa sulla formula di regressione lineare. L'obiettivo del modello è aggiornare i parametri casuali per rappresentare il modello dei dati di addestramento attraverso la discesa del gradiente, che è la premessa dell'apprendimento automatico.
  
  
• 05:05:00 In questa sezione, l'istruttore discute il processo di regolazione dei valori casuali per rappresentare meglio i valori desiderati di peso e distorsione nei dati, che si ottiene utilizzando due algoritmi principali: discesa del gradiente e retropropagazione. L'uso di "richiede grad uguale a vero" è spiegato come tenere traccia dei gradienti tramite calcoli eseguiti utilizzando il modello, spingendo l'algoritmo nella giusta direzione. L'importanza della programmazione orientata agli oggetti e il ruolo di PyTorch nell'implementazione di questi algoritmi sono sottolineati, con risorse aggiuntive suggerite per aiutare a ottenere l'intuizione per il codice. L'istruttore sottolinea anche il fatto che mentre il modello attuale si occupa di set di dati semplici con parametri noti, set di dati più complessi hanno spesso parametri definiti da moduli da nn per noi.
  
  
• 05:10:00 In questa sezione, l'istruttore spiega i principali aspetti della creazione del primo modello PyTorch. Ogni modello in PyTorch eredita da nn.modgable e dovrebbe sovrascrivere il metodo forward per definire il calcolo che sta avvenendo all'interno del modello. Inoltre, quando il modello apprende, aggiorna i suoi pesi e valori di polarizzazione tramite la discesa del gradiente e la propagazione all'indietro utilizzando il modulo torch.auto grad. L'istruttore consiglia di controllare due video collegati nella trascrizione per una completa comprensione di questo concetto. Inoltre, l'istruttore introduce alcuni elementi essenziali per la creazione di modelli PyTorch come il modulo torch.nn che contiene tutti gli elementi costitutivi necessari per le reti neurali.
  
  
• 05:15:00 In questa sezione, l'istruttore spiega i moduli fondamentali in PyTorch, inclusi torch.nn, torch.nn.module, torch.optim e torch.utils.dataset. torch.nn.module è la classe base per tutti i moduli della rete neurale e richiede la sovrascrittura del metodo forward, che definisce cosa accade nel calcolo forward. Torch.optim contiene algoritmi per ottimizzare i valori del modello, che inizia con valori casuali e si adatta per rappresentare meglio i valori ideali. L'istruttore menziona anche il cheat sheet di PyTorch come risorsa utile per un'ulteriore esplorazione della libreria.
  
  
• 05:20:00 In questa sezione, l'istruttore aggiunge colore e codice al flusso di lavoro PyTorch e tratta importanti moduli PyTorch utilizzati per creare set di dati, costruire e addestrare modelli, ottimizzare i parametri del modello, valutare il modello e migliorare attraverso la sperimentazione. L'istruttore mostra quindi come controllare il contenuto di un modello PyTorch creando un'istanza del modello di regressione lineare e utilizzando i parametri punto per vedere i valori del tensore. L'istruttore imposta anche un seme casuale per creare i parametri con valori coerenti.
  
  
• 05:25:00 , abbiamo appreso come i modelli di deep learning vengono inizializzati con valori casuali per pesi e parametri di bias. Abbiamo anche appreso l'importanza dell'utilizzo di valori seme casuali per la riproducibilità. La premessa fondamentale del deep learning è regolare questi valori casuali in modo che siano il più vicino possibile ai valori ideali attraverso la discesa del gradiente e la propagazione all'indietro, utilizzando i dati di addestramento. Nella sezione successiva, il video riguarderà la creazione di previsioni con i valori dei parametri casuali del modello.
  
  
• 05:30:00 di questa sezione, il video spiega il processo di test del potere predittivo di un modello PyTorch. Il metodo forward del modello prende i dati di input X e li passa attraverso il modello per fare previsioni. Il video mostra come testare il potere predittivo del modello inserendo X test, che consiste di 10 variabili, e osservando l'output del modello Y pred. Il video risolve anche un errore comune che può verificarsi durante la creazione di un modello PyTorch e ne fornisce una soluzione.
  
  
• 05:35:00 In questa sezione, vediamo le previsioni del modello eseguendo i dati di test utilizzando il metodo Ford definito in precedenza. Le previsioni sembrano essere incredibilmente lontane dalle previsioni ideali. Il codice introduce anche la modalità di inferenza della torcia, che è un gestore di contesto utilizzato per disabilitare il tracciamento del gradiente durante le previsioni, consentendo a PyTorch di tenere traccia di meno dati e fare previsioni più velocemente. Mentre torch no grad può fare qualcosa di simile, la modalità di inferenza presenta alcuni vantaggi rispetto a no grad, come spiegato nella documentazione di PyTorch e in un thread di Twitter fornito nel video. Pertanto, la modalità di inferenza è attualmente il modo preferito di fare inferenza.
  
  
• 05:40:00 di questa sezione, il video spiega l'importanza dell'utilizzo del gestore di contesto torch.inference_mode quando si effettuano previsioni in PyTorch, in quanto garantisce che il modello sia in modalità di inferenza anziché in modalità di addestramento. Il video evidenzia inoltre che l'inizializzazione di un modello con parametri casuali potrebbe comportare prestazioni scadenti e fornisce alcune opzioni per l'inizializzazione, come l'utilizzo di valori zero o il trasferimento di parametri da un altro modello. L'obiettivo principale del video, tuttavia, è l'addestramento di un modello passando da parametri sconosciuti a parametri noti utilizzando una funzione di perdita, che misura lo scarso rendimento delle previsioni del modello. Il video rileva che i termini "funzione di perdita", "funzione di costo" e "criterio" sono spesso usati in modo intercambiabile nell'apprendimento automatico.
  
  
• 05:45:00 In questa sezione, l'istruttore introduce il concetto di funzione di perdita, che viene utilizzata per misurare quanto sono sbagliate le previsioni di un modello rispetto ai risultati ideali. L'istruttore utilizza l'esempio della misurazione della distanza tra i punti rossi e verdi per spiegare come si può calcolare una funzione di perdita. Il video copre anche l'importanza di un ottimizzatore, che tiene conto della perdita di un modello e regola i suoi parametri, come i valori di peso e bias, per migliorare la funzione di perdita. La sezione si conclude spiegando che i principi di una funzione di perdita e di un ottimizzatore rimangono gli stessi sia che si tratti di modelli con due parametri o modelli con milioni di parametri, sia che si tratti di modelli di visione artificiale o modelli semplici come quelli che prevedono punti su una linea retta.
  
  
• 05:50:00 In questa sezione del corso PyTorch for Deep Learning & Machine Learning, l'istruttore spiega l'importanza di utilizzare un ottimizzatore per spingere i parametri di un modello verso valori che abbassano la funzione di perdita al fine di migliorare l'accuratezza del predizioni. PyTorch ha funzionalità integrate per l'implementazione di funzioni di perdita e ottimizzatori e l'istruttore si concentra sulla perdita L1, nota anche come errore assoluto medio, che misura la differenza assoluta tra i valori previsti e quelli effettivi. L'istruttore fornisce un grafico colorato per illustrare l'errore assoluto medio e mostra come implementare la funzione di perdita utilizzando il modulo NN di PyTorch. L'obiettivo per l'addestramento di un modello sarà minimizzare le distanze tra i valori previsti ed effettivi e, a sua volta, minimizzare il valore complessivo dell'errore assoluto medio.
  
  
• 05:55:00 In questa sezione, l'istruttore discute il ruolo dell'ottimizzatore nell'apprendimento automatico, che lavora in tandem con la funzione di perdita per regolare i parametri del modello, come il peso e il bias, per ridurre al minimo la perdita. PyTorch ha torch.optim, dove sono disponibili vari algoritmi di ottimizzazione, come Stochastic Gradient Descent (SGD) e Adam. Entrambi regolano in modo casuale i parametri del modello per ridurre al minimo le perdite, ma si tratta di scegliere quello più appropriato per un problema specifico. La maggior parte opta per SGD, che inizia con aggiustamenti casuali e poi continua ad aggiustarsi nella direzione che riduce al minimo le perdite fino a quando non è possibile apportare ulteriori aggiustamenti. L'ottimizzatore richiede due argomenti, parametri o quali parametri l'ottimizzatore dovrebbe ottimizzare e la velocità di apprendimento (LR), l'iperparametro più importante da impostare durante l'ottimizzazione.

Parte 7

• 06:00:00 In questa sezione, l'istruttore spiega cosa sono i parametri del modello e gli iperparametri e il loro ruolo nel processo di deep learning. I parametri del modello sono valori impostati dal modello mentre gli iperparametri sono valori impostati dal data scientist o dall'ingegnere di machine learning. La velocità di apprendimento è un iperparametro e il suo valore determina l'entità della modifica dei parametri durante l'ottimizzazione. Un basso tasso di apprendimento si traduce in piccoli cambiamenti, mentre un alto tasso di apprendimento si traduce in grandi cambiamenti. L'istruttore parla anche dell'importanza di scegliere la funzione di perdita e l'ottimizzatore appropriati per il problema specifico. Infine, l'istruttore passa a spiegare il processo di creazione di un ciclo di formazione in PyTorch.
  
  
• 06:05:00 In questa sezione, l'istruttore discute i passaggi necessari per creare un ciclo di addestramento e un ciclo di test in PyTorch. Il primo passaggio prevede il ciclo dei dati più volte per migliorare le previsioni e ridurre al minimo le perdite effettuando passaggi in avanti attraverso il modello. L'istruttore spiega che il passaggio in avanti è quando i dati si spostano attraverso le funzioni in avanti del modello e la perdita viene calcolata confrontando le previsioni del modello con le etichette di verità di base. L'istruttore introduce quindi l'ottimizzatore e spiega che il passaggio all'indietro calcola i gradienti di ciascun parametro rispetto alla perdita, consentendo all'ottimizzatore di regolare i parametri del modello per migliorare la perdita attraverso la discesa del gradiente. L'istruttore sottolinea che PyTorch implementa la propagazione all'indietro e la matematica della discesa del gradiente, rendendo più facile per coloro che hanno un background matematico limitato apprendere l'apprendimento automatico.
  
  
• 06:10:00 In questa sezione, l'istruttore introduce il concetto di discesa del gradiente, che viene utilizzato per ottimizzare i parametri del modello nell'apprendimento automatico. Usando l'esempio di una collina, l'istruttore spiega come il modello deve muoversi verso la direzione in cui il pendio è meno ripido per raggiungere il fondo della collina, che rappresenta una perdita zero. L'istruttore passa quindi alla scrittura del codice per l'esecuzione della discesa del gradiente, che prevede l'impostazione del numero di epoche e l'impostazione del modello in modalità di addestramento utilizzando il parametro "richiede grad uguale a vero". L'istruttore menziona anche che sono disponibili diverse modalità per i modelli pytorch e incoraggia gli spettatori a sperimentare impostazioni diverse.
  
  
• 06:15:00 In questa sezione del video, l'istruttore discute l'implementazione del passaggio in avanti per addestrare un modello PyTorch. Il passaggio in avanti implica il passaggio dei dati attraverso la funzione in avanti del modello per fare previsioni, che vengono quindi confrontate con i valori di addestramento effettivi utilizzando la funzione di perdita MAE. Viene inoltre introdotta la funzione optimizer.zero_grad(), che imposta tutti i gradienti su zero prima di calcolare la perdita all'indietro e aggiornare i parametri del modello utilizzando la discesa del gradiente. Questi passaggi sono fondamentali per comprendere come un modello apprende e saranno ulteriormente ottimizzati e resi funzionali nelle sezioni successive del corso.
  
  
• 06:20:00 In questa sezione, l'istruttore ripercorre i cinque passaggi principali di un ciclo di addestramento in PyTorch, che include il passaggio in avanti, il calcolo della perdita, l'azzeramento dei gradienti dell'ottimizzatore, l'esecuzione della propagazione all'indietro e l'avanzamento dell'ottimizzatore attraverso la discesa del gradiente . L'istruttore osserva che l'ordine di questi passaggi a volte può essere ambiguo, ma è importante mantenere il passaggio dell'ottimizzatore dopo la propagazione all'indietro. L'istruttore spiega anche perché i gradienti dell'ottimizzatore devono essere azzerati in ogni iterazione per evitare l'accumulo tra i loop. L'istruttore suggerisce di esercitarsi a scrivere un ciclo di allenamento per comprendere meglio questi passaggi e fornisce una canzone e risorse extra per un ulteriore apprendimento.
  
  
• 06:25:00 In questa sezione del video, il relatore riassume i passaggi di un ciclo di addestramento in PyTorch, che prevede il passaggio in avanti, il calcolo del valore di perdita, l'azzeramento dei gradienti di ottimizzazione e l'esecuzione della propagazione all'indietro sulla funzione di perdita. Il ciclo di addestramento aiuta il modello ad apprendere modelli sui dati di addestramento, mentre il ciclo di test valuta i modelli su dati non visti. Il relatore spiega anche perché azzeriamo i gradienti dell'ottimizzatore e introduce il concetto di propagazione all'indietro, che calcola il gradiente della funzione di perdita.
  
  
• 06:30:00 In questa sezione, l'istruttore spiega il concetto di gradienti e curve della funzione di perdita nel deep learning PyTorch. Impostando 'requires grad' come vero per i parametri, PyTorch è in grado di tracciare i gradienti di ogni parametro e creare una curva della funzione di perdita per tutti loro. L'obiettivo della propagazione all'indietro e della successiva discesa del gradiente è calcolare il punto più basso della curva, che rappresenta la perdita minima. L'istruttore spiega il concetto di gradienti nell'apprendimento automatico e come funziona la discesa del gradiente con i punti di passaggio. Ottimizzando la perdita zero grad all'indietro, ottimizzando il passo e richiede grad, PyTorch fa gran parte di questo lavoro dietro le quinte, tracciando automaticamente i gradienti e trovando il fondo della curva.
  
  
• 06:35:00 In questa sezione, l'istruttore discute l'ottimizzatore e il tasso di apprendimento. L'ottimizzatore prende i parametri del modello e crea curve per ciascun parametro utilizzando un meccanismo chiamato torcia autograd per il calcolo automatico del gradiente per avvicinarsi alla parte inferiore della curva. Il tasso di apprendimento decide quanto grande o piccolo l'ottimizzatore cambia i parametri ad ogni passo, con passi più piccoli presi man mano che ci avviciniamo alla convergenza. Inoltre, l'istruttore tocca i cinque passaggi coinvolti nell'addestramento di un modello, che include l'inizializzazione del modello, la definizione dell'ottimizzatore, la velocità di apprendimento, il calcolo del passaggio in avanti, la propagazione all'indietro e il passaggio dell'ottimizzatore. Infine, l'istruttore afferma che questo ciclo può essere trasformato in una funzione, che aiuta a evitare ripetizioni di codici.
  
  
• 06:40:00 In questa sezione del "PyTorch for Deep Learning & Machine Learning – Corso completo", l'istruttore sottolinea l'importanza di scrivere il ciclo di addestramento in PyTorch, poiché è il modo in cui il modello apprende schemi e dati. Il video fornisce anche risorse aggiuntive sulla retropropagazione e la discesa del gradiente per coloro che sono interessati al background matematico. L'istruttore spiega che la scelta della funzione di perdita e dell'ottimizzatore sarà specifica per ciascun problema e raccomanda la perdita MAE e la perdita L1 per i problemi di regressione e la perdita di entropia incrociata binaria per i problemi di classificazione. La sezione si conclude con una dimostrazione del ciclo di addestramento utilizzando un modello con solo due parametri e una sola epoca.
  
  
• 06:45:00 In questa sezione, l'istruttore continua ad addestrare il modello di machine learning utilizzando PyTorch e mostra come la funzione di perdita sta diminuendo man mano che i parametri del modello vengono aggiornati tramite la discesa del gradiente. L'istruttore sottolinea che un valore di perdita inferiore indica un migliore avanzamento del modello e che le piccole differenze nei valori dovute alla casualità nell'apprendimento automatico non dovrebbero essere preoccupanti. L'istruttore quindi sfida lo spettatore a eseguire il codice per 100 epoche e fare previsioni per vedere quanto in basso possono ottenere il valore di perdita. Infine, l'istruttore discute l'importanza dei test e anticipa il prossimo video sulla scrittura del codice di test.
  
  
• 06:50:00 In questa sezione, l'istruttore discute l'importanza della ricerca e dell'apprendimento di nuovi argomenti utilizzando risorse esterne come Google e la documentazione. Incoraggiano gli studenti a provare a eseguire il codice di addestramento per 100 epoche ed esaminare i valori e le previsioni di peso e bias. L'istruttore passa quindi a spiegare il codice di test e lo scopo della funzione model.eval(), che disattiva le impostazioni nel modello non necessarie per il test, come i livelli dropout e batch norm. Discutono anche dello scopo di torch.no_grad() e di come disattiva il tracciamento del gradiente durante il test poiché in quella fase non avviene alcun apprendimento. Infine, la sezione si conclude con la scrittura del forward pass per il modello in modalità test.
  
  
• 06:55:00 In questa sezione, il video insegna come creare previsioni di test e calcolare la perdita di test utilizzando il modello zero in PyTorch. Le previsioni del test vengono fatte sul set di dati del test, che il modello non ha mai visto prima, proprio come valutare la propria conoscenza su materiali che non hanno mai visto prima. Il video spiega l'importanza di non lasciare che il modello veda il set di dati del test prima di valutarlo per evitare di ottenere risultati scadenti. Il codice stampa la perdita e ciò che sta accadendo ogni 10 epoche mentre il modello si sta allenando per 100 epoche e la perdita diminuisce a ogni epoca. Il video discute anche il concetto di precisione del modello, che può essere stampato in seguito.

Parte 8

• 07:00:00 In questa sezione, l'istruttore esamina il video precedente, in cui ha addestrato un modello e fatto previsioni su un semplice set di dati. Quindi sfidano lo spettatore a trovare modi per migliorare la capacità del modello di allineare i punti rossi previsti con i punti verdi effettivi, possibilmente addestrando il modello più a lungo. L'istruttore quindi esegue nuovamente il codice per altre 100 epoche e mostra un miglioramento significativo nella perdita di test e nelle previsioni del modello. L'istruttore sottolinea che questo processo di addestramento e valutazione dei modelli è fondamentale per il deep learning con PyTorch e sarà utilizzato nel resto del corso. Discutono anche dell'importanza di tenere traccia dell'avanzamento del modello utilizzando un elenco vuoto per memorizzare valori utili.
  
  
• 07:05:00 In questa sezione, l'istruttore spiega perché è importante tenere traccia dei valori di perdita e come possiamo usarli per monitorare i progressi del nostro modello e migliorarlo negli esperimenti futuri. Il frammento di codice presentato aggiunge il conteggio dell'epoca, il valore di perdita corrente e il valore di perdita del test corrente a elenchi diversi in modo che possano essere tracciati in un secondo momento. L'istruttore mostra un grafico delle curve di perdita generate dalle liste e ne spiega il significato. Una curva di perdita ideale dovrebbe iniziare in alto e diminuire nel tempo, rappresentando un valore di perdita decrescente.
  
  
• 07:10:00 In questa sezione, l'istruttore spiega come convertire i valori di perdita da PyTorch a NumPy per tracciarli in Matplotlib. Mostra che è necessario convertirli in NumPy poiché Matplotlib funziona solo con NumPy. Spiega anche come tenere traccia delle curve di perdita di allenamento e perdita di test e afferma che se a un certo punto corrispondono strettamente, significa che il modello sta convergendo e la perdita si sta avvicinando il più possibile allo zero. L'istruttore segue quindi il ciclo di test e spiega che è necessario passare i dati del test attraverso il modello, calcolare il valore di perdita del test e stampare ciò che sta accadendo durante l'addestramento per tenere traccia dei valori di ciò che sta accadendo. Infine, suggerisce di inserire tutti questi passaggi in una funzione e fornisce un loop song di ottimizzazione PyTorch non ufficiale per ricordare i passaggi.
  
  
• 07:15:00 imparerai in questa sezione i tre metodi principali per salvare e caricare i modelli in PyTorch. Il primo metodo, torch.save, consente di salvare un oggetto PyTorch nel formato pickle di Python. Il secondo metodo, torch.load, consente di caricare un oggetto PyTorch salvato. E il terzo metodo, torch.nn.module.loadStateDict, consente di caricare il dizionario salvato di un modello o il dizionario di stato di salvataggio, che esploreremo nel video seguente. Questi metodi sono fondamentali per il salvataggio e il riutilizzo dei modelli, soprattutto quando si lavora con modelli più grandi o quando è necessario condividere i modelli con altri.
  
  
• 07:20:00 In questa sezione, l'istruttore spiega il concetto di dizionari di stato e la loro importanza in PyTorch. PyTorch memorizza i parametri importanti di un modello in un dizionario, chiamato dizionario di stato, che contiene lo stato del modello, inclusi i parametri apprendibili come pesi e distorsioni. L'istruttore mostra come salvare e caricare il modello PyTorch salvando il suo dizionario di stato usando i metodi torch.save e torch.load. Inoltre, l'istruttore fornisce un'ulteriore sfida all'utente per leggere e comprendere i pro ei contro del salvataggio dell'intero modello piuttosto che solo del dizionario di stato. Infine, l'istruttore condivide il codice PyTorch per salvare il modello e creare una cartella chiamata models.
  
  
• 07:25:00 In questa sezione del video, l'istruttore dimostra come salvare un modello PyTorch utilizzando il metodo consigliato per salvare lo stato dict. Al modello viene assegnato un nome e il percorso viene creato utilizzando la libreria pathlib. Una volta che il percorso è pronto, lo stato del modello dict viene salvato utilizzando la funzione torch.save(), dove il primo parametro è l'oggetto e il secondo è il percorso in cui il modello deve essere salvato. L'istruttore mostra come viene utilizzato il comando LS per verificare se il modello è salvato nella directory models. Il video fornisce anche una guida per scaricare il modello salvato su un computer locale o su Google Drive. Inoltre, l'istruttore incoraggia lo spettatore a mettersi alla prova leggendo in anticipo la documentazione e utilizzando la funzione torch.load() per apprendere come caricare un modello salvato.
  
  
• 07:30:00 In questa sezione, l'istruttore parla del caricamento di un modello PyTorch e di come utilizzare il metodo di caricamento dei punti della torcia. Il dizionario dei parametri della classe precedentemente salvato da un modello verrà caricato come un mazzo di stato e questa sezione mostra come creare una nuova istanza della classe del modello di regressione lineare e caricare il mazzo di stato salvato in esso. Il metodo load state deck del modulo torch nn consente di caricare il dizionario di stato direttamente nell'istanza del modello, mentre il metodo torch dot load accetta F e lo passa al percorso di salvataggio del modello in cui è stato salvato il precedente state deck.
  
  
• 07:35:00 In questa sezione, l'istruttore esamina il salvataggio e il caricamento di un modello in PyTorch. Testano il modello caricato effettuando nuove previsioni con i dati del test e confrontandole con le previsioni del modello originale utilizzando la funzione equivalente uguale a uguale. L'istruttore risolve i problemi dei modelli che non sono equivalenti creando una nuova serie di previsioni del modello e verificando nuovamente l'equivalenza. Coprono gli aspetti principali del salvataggio e del caricamento di un modello, ma suggeriscono di consultare i tutorial per ulteriori dettagli. L'istruttore prevede di mettere insieme tutti i passaggi trattati finora nei prossimi video.
  
  
• 07:40:00 In questa sezione del video, l'istruttore passa attraverso l'intero flusso di lavoro del deep learning utilizzando PyTorch, inclusa l'importazione di PyTorch, il salvataggio e il ricaricamento dei modelli e la creazione di codice indipendente dal dispositivo, che consente al codice di utilizzare la GPU se disponibile o la CPU per impostazione predefinita in caso contrario. L'istruttore incoraggia gli spettatori a mettere in pausa e provare a ricreare il codice da soli, offrendo anche indicazioni e suggerimenti utili. Il video spiega anche come creare set di dati fittizi e tracciare punti dati, che verranno utilizzati per costruire un modello che imparerà a prevedere i punti verdi dai punti blu.
  
  
• 07:45:00 In questa sezione, l'istruttore dimostra come creare dati utilizzando la formula di regressione lineare di y uguale a peso per caratteristiche più bias. Spiegano che i principi della costruzione di un modello per stimare questi valori rimangono gli stessi e procedono a creare le caratteristiche x e y, che verranno utilizzate per prevedere i valori di addestramento e test. Inoltre suddividono i dati in set di addestramento e test e tracciano i dati per visualizzare i modelli nei dati.
  
  
• 07:50:00 In questa sezione, l'istruttore introduce il concetto di costruzione di un modello lineare PyTorch per i dati fittizi lineari dati. Sottoclassano nn.module per creare un modello di regressione lineare e inizializzano i parametri utilizzando i livelli. Il layer nn.Linear accetta le feature come input e output e applica una trasformazione lineare ai dati in ingresso utilizzando la stessa formula del modello di regressione lineare. Le forme di input e output del modello dipendono dai dati e l'istruttore sottolinea che durante il corso verranno visualizzati diversi esempi di funzionalità di input e output.
  
  
• 07:55:00 In questa sezione, l'istruttore spiega come utilizzare il livello lineare in PyTorch come livello preesistente per creare un modello. Il livello lineare è una forma di regressione lineare y è uguale a x, una trasposizione più b, in caratteristiche, fuori caratteristiche. Sottoclassando nn.module, possiamo creare uno strato lineare e sovrascrivere il metodo forward per passare i dati attraverso lo strato lineare, che esegue il calcolo forward predefinito. Il potere di PyTorch's torch.nn è che crea i parametri per noi dietro le quinte e non dobbiamo inizializzarli manualmente. Inoltre, l'istruttore discute i diversi nomi per lo strato lineare, come trasformazione lineare, strato di sondaggio, strato completamente connesso, strato denso e flusso intensivo.

Parte 9

• 08:00:00 In questa sezione, l'istruttore discute i diversi livelli disponibili in torch.nn tra cui convoluzionale, pooling, padding, normalizzazione, ricorrente, trasformatore, lineare e dropout. Le implementazioni predefinite di questi livelli sono fornite da PyTorch per attività comuni di deep learning. La sezione passa quindi all'addestramento del modello lineare PyTorch creato in precedenza utilizzando le funzioni di perdita e di ottimizzazione. L'ottimizzatore ottimizzerà il peso del modello e i parametri di polarizzazione per ridurre al minimo la funzione di perdita, che misura l'errore del modello. L'istruttore imposta la funzione di perdita L1 e l'ottimizzatore SGD per questo compito.
  
  
• 08:05:00 In questa sezione del video, l'istruttore discute l'importanza di scegliere un tasso di apprendimento appropriato per l'ottimizzatore, poiché un passo troppo piccolo o troppo grande può avere un impatto negativo sulle prestazioni del modello. Vengono inoltre spiegati i passaggi coinvolti nella scrittura di un ciclo di addestramento, che include l'esecuzione di un passaggio in avanti, il calcolo del valore di perdita, l'azzeramento dell'ottimizzatore, l'esecuzione della propagazione all'indietro e la regolazione dei pesi e dei bias. Inoltre, l'istruttore suggerisce di utilizzare torch.manual_seed() per garantire risultati riproducibili e fornisce il codice per stampare la perdita di addestramento e la perdita di test ogni 10 epoche.
  
  
• 08:10:00 In questa sezione del corso PyTorch, l'istruttore spiega come scrivere codice agnostico del dispositivo per i dati, sottolineando che avere tutti i calcoli sullo stesso dispositivo è fondamentale per evitare errori. Il modello e i dati devono trovarsi sullo stesso dispositivo, che può essere CPU o CUDA. Inserendo i dati di addestramento e test sul dispositivo di destinazione utilizzando X train e Y train, viene creato un codice agnostico del dispositivo, che fornisce risultati più accurati durante l'addestramento del modello. Il docente spiega inoltre come valutare il modello utilizzando state decked, dimostrando che i parametri stimati sono prossimi al valore ideale. La sezione si conclude con una sfida per gli utenti a fare e valutare previsioni e tracciarle sui dati originali.
  
  
• 08:15:00 In questa sezione, l'istruttore discute l'importanza di trasformare il modello PyTorch in modalità di valutazione e fare previsioni sui dati di test che il modello non ha mai visto prima. Portano la funzione di previsione della trama per visualizzare le previsioni del modello, ma incontrano un errore di tipo quando provano a convertire il tensore del tipo di dispositivo CUDA in NumPy perché Matplotlib funziona con NumPy, non con PyTorch. Risolvono questo errore utilizzando la CPU tensor dot per copiare prima il tensore nella memoria host. L'istruttore incoraggia inoltre gli spettatori a salvare e caricare il loro modello addestrato utilizzando il modulo del percorso, che dimostrano creando una directory dei modelli e impostando il percorso del modello.
  
  
• 08:20:00 In questa sezione, l'istruttore spiega come salvare e caricare i modelli PyTorch utilizzando il modulo path lib di Python. Innanzitutto, viene creato un percorso di salvataggio del modello con l'estensione .PTH per PyTorch. Il dizionario di stato del modello viene quindi salvato utilizzando il metodo di salvataggio della torcia. L'istruttore osserva che la visualizzazione esplicita del mazzo di stato potrebbe non essere praticabile per i modelli con molti parametri. Per caricare il modello salvato, il dizionario dello stato salvato viene caricato in una nuova istanza del modello di regressione lineare V2 utilizzando il metodo load state decked e passando il percorso del file dell'oggetto PyTorch salvato. Viene discusso anche l'uso del layer lineare predefinito di PyTorch e la sua chiamata nel metodo forward.
  
  
• 08:25:00 In questa sezione, l'istruttore conclude verificando che il modello caricato abbia gli stessi parametri del modello salvato valutandolo utilizzando la modalità di inferenza della torcia. Quindi si congratulano con l'utente per aver completato il flusso di lavoro PyTorch dalla creazione di un modello, all'addestramento e al salvataggio per riutilizzarlo. L'istruttore sottolinea quindi che gli utenti possono trovare gli esercizi e il curriculum extra nella versione del libro dei materiali del corso su learnpytorch.io. Forniscono anche modelli di quaderni di esercizi numerati per sezione e possono essere trovati nel repository GitHub di deep learning di PyTorch sotto extra ed esercizi.
  
  
• 08:30:00 In questa sezione, l'istruttore fornisce informazioni su come completare gli esercizi del flusso di lavoro e trovare risorse aggiuntive per il corso PyTorch. Sottolinea l'importanza di provare gli esercizi da soli prima di esaminare qualsiasi soluzione di esempio. La sezione si conclude con un riepilogo del flusso di lavoro PyTorch coperto, che include la preparazione dei dati, la loro trasformazione in tensori, la costruzione o la selezione di un modello, la scelta di una funzione di perdita e di un ottimizzatore, l'addestramento del modello, l'esecuzione di previsioni e la valutazione del modello. La sezione successiva si concentra sulla classificazione della rete neurale con PyTorch, che è uno dei maggiori problemi nell'apprendimento automatico. L'istruttore fornisce risorse per ottenere assistenza durante il corso, inclusa la pagina delle discussioni su GitHub del corso e la documentazione di PyTorch. Spiega anche quali sono i problemi di classificazione e fornisce esempi come prevedere se un'e-mail è spam o meno.
  
  
• 08:35:00 In questa sezione del corso PyTorch, l'istruttore discute diversi tipi di problemi di classificazione nel deep learning. La classificazione binaria è quando ci sono solo due opzioni, come spam o non spam. La classificazione multiclasse è quando ci sono più di due opzioni, come classificare un'immagine come sushi, bistecca o pizza. La classificazione multi-etichetta è quando un esempio può avere più di un'etichetta, come l'assegnazione di tag a un articolo di Wikipedia. L'istruttore fornisce esempi del mondo reale e spiega i concetti in modo approfondito. Distingue anche tra classificazione binaria e multiclasse con esempi di classificazione di immagini di cani e gatti in un problema di classificazione binaria e classificazione di immagini di animali diversi in un problema di classificazione multiclasse.
  
  
• 08:40:00 In questa sezione, l'istruttore spiega l'architettura di un modello di classificazione di una rete neurale e le forme di input e output di un modello di classificazione. Sottolinea l'importanza degli input numerici per i modelli di apprendimento automatico e spiega come gli input numerici spesso si presentano in forme diverse a seconda dei dati. Discute anche il processo di creazione di dati personalizzati per l'adattamento e la previsione e copre i passaggi coinvolti nella modellazione per la classificazione della rete neurale. Inoltre, l'istruttore spiega come impostare una funzione di perdita e un ottimizzatore per un modello di classificazione, creare cicli di addestramento e valutazione, salvare e caricare modelli, sfruttare la non linearità e valutare i modelli di classificazione. Conclude fornendo un esempio di come rappresentare numericamente le foto del cibo e la sua previsione utilizzando un algoritmo di apprendimento automatico.
  
  
• 08:45:00 In questa sezione, l'istruttore del corso PyTorch for Deep Learning & Machine Learning fornisce dettagli sul processo di codifica numerica e sul formato di output. Gli input per l'algoritmo di apprendimento automatico sono immagini codificate numericamente, che hanno alcuni output associati nelle probabilità di previsione. L'istruttore nota che più la probabilità di previsione è vicina a uno, più il modello è sicuro del suo output. Questo output deriva dall'osservazione di più campioni ed è possibile regolare l'algoritmo e i dati per migliorare queste previsioni. Gli output codificati devono essere modificati in etichette comprensibili per l'uomo. Inoltre, l'istruttore discute la forma dei tensori, incluse le dimensioni del batch, i canali di colore e l'altezza/larghezza. Una dimensione batch di 32 è una pratica comune e la forma può variare a seconda del problema da risolvere.
  
  
• 08:50:00 In questa sezione, l'istruttore spiega l'architettura di un modello di classificazione, che è lo schema di cosa sia una rete neurale. La forma del livello di input è determinata dal numero di caratteristiche, che devono essere codificate come rappresentazione numerica, e il livello di output è spesso una probabilità di previsione per una determinata classe. Esistono iperparametri come il numero di livelli nascosti, i neuroni per livello nascosto e la forma del livello di output che devono essere decisi dall'utente. L'istruttore fornisce anche esempi di codice per la creazione di livelli e neuroni utilizzando PyTorch e osserva che le forme varieranno a seconda del problema da risolvere.
  
  
• 08:55:00 In questa sezione, l'istruttore discute i componenti di un problema di classificazione, tra cui l'attivazione del livello nascosto, l'attivazione dell'output, la funzione di perdita e l'ottimizzatore, e fornisce esempi di ciascuno. L'istruttore introduce quindi un problema di classificazione multiclasse e discute come l'architettura può essere costruita per avere più funzionalità di output. Infine, l'istruttore passa alla scrittura del codice utilizzando PyTorch su Google CoLab, ricordando al pubblico che tutto il codice verrà salvato su un repository GitHub. L'istruttore sottolinea inoltre l'importanza di iniziare qualsiasi problema di apprendimento automatico con i dati.