Apprendimento automatico e Reti Neurali - pagina 43

[MetaQuotes]

Come implementare la regressione logistica da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/03%20Logistic%20Regression

Come implementare la regressione logistica da zero con Python

Il video spiega come implementare la regressione logistica da zero con Python, utilizzando la funzione sigmoid per creare probabilità e l'entropia incrociata come funzione di errore. L'istruttore condivide istruzioni dettagliate per il calcolo di previsioni, gradienti e errori di aggiornamento attraverso le iterazioni. Dimostrano anche come caricare un set di dati sul cancro al seno e addestrare il classificatore di regressione logistica per prevedere se un tumore è maligno o benigno. Il video si conclude valutando l'accuratezza del modello utilizzando una funzione personalizzata. Nel complesso, l'implementazione ha successo e dimostra che l'algoritmo di regressione logistica funziona bene.

• 00:00:00 In questa sezione, il video discute la regressione logistica e come comporta la creazione di probabilità invece di valori specifici utilizzando la funzione sigmoide. Invece di utilizzare l'errore quadratico medio, la regressione logistica utilizza l'entropia incrociata per la sua funzione di errore. Per utilizzare la discesa del gradiente, è necessario calcolare il gradiente della funzione di errore in termini di peso e distorsione. Il tasso di apprendimento viene utilizzato per determinare la velocità con cui avvicinarsi alla direzione data dal gradiente. Durante il test, viene calcolata la probabilità e l'etichetta viene scelta in base alla probabilità più alta. L'implementazione della regressione logistica è simile alla regressione lineare, ma con l'inizializzazione di pesi e distorsioni pari a zero.
  
  
• 00:05:00 In questa sezione del video, l'istruttore spiega come implementare la regressione logistica con Python utilizzando una funzione sigmoide per prevedere i risultati. Il processo prevede il calcolo delle previsioni dal prodotto dei pesi e dei valori x più il bias, inserendole in una funzione sigmoidea per fornire i risultati e calcolando i gradienti. L'istruttore dimostra come calcolare il gradiente per il bias e gli aggiornamenti attraverso le iterazioni. La sezione include anche come eseguire l'inferenza con la regressione logistica ottenendo la probabilità e scegliendo l'etichetta in base ai valori delle previsioni.
  
  
• 00:10:00 In questa sezione, l'istruttore dimostra come implementare la regressione logistica da zero usando Python. Spiegano il processo passo dopo passo, mostrando come calcolare le probabilità e le etichette delle classi utilizzando la funzione sigmoidea e come regolare il tasso di apprendimento per ottenere risultati migliori. L'istruttore carica anche un set di dati sul cancro al seno da Scikit-learn e addestra il classificatore di regressione logistica per prevedere se un tumore è maligno o benigno in base alle caratteristiche del set di dati. Infine, valutano l'accuratezza dell'algoritmo e dimostrano come calcolarlo utilizzando una funzione personalizzata. Nel complesso, l'implementazione ha successo e mostra che l'algoritmo fatto in casa funziona abbastanza bene.

[MetaQuotes]

Come implementare gli alberi decisionali da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/04%20Decision%20Trees

Come implementare gli alberi decisionali da zero con Python

Il video fornisce una guida dettagliata sulla creazione di un albero decisionale da zero utilizzando Python. Il relatore spiega il concetto di alberi decisionali, come funzionano e come sono costruiti. Discutono i criteri di arresto, la funzione di crescita dell'albero, le funzioni di supporto "etichetta più comune", "guadagno di informazioni", "entropia" e "divisione", nonché la funzione di previsione. L'oratore dimostra anche come calcolare il guadagno di informazioni, l'entropia ponderata e l'accuratezza. Inoltre, testano il modello dell'albero decisionale e forniscono ai visualizzatori un collegamento al loro repository GitHub dove è disponibile il codice.

• 00:00:00 In questa sezione, apprendiamo gli alberi decisionali, come funzionano e come sono costruiti. Gli alberi decisionali sono costruiti per rappresentare un set di dati, con ogni punto dati suddiviso in nodi foglia che rappresentano "sì" o "no". I nodi tra i nodi foglia sono chiamati rami e sono divisi in base a caratteristiche come caratteristiche che mostrano se il punto dati si trova nel quartiere est o ovest. Il guadagno di informazioni viene calcolato come l'entropia del genitore e la media ponderata dell'entropia dei figli e il modello dell'albero decisionale viene addestrato in base ai guadagni di informazioni più significativi. Infine, discutiamo i criteri di arresto, che vengono utilizzati per decidere quando interrompere la costruzione dell'albero decisionale.
  
  
• 00:05:00 In questa sezione, il relatore discute i modi per interrompere un albero decisionale prima di analizzare tutti i possibili nodi foglia, inclusa l'impostazione di una profondità massima o di un numero minimo di campioni per un nodo. Il relatore presenta quindi due classi che verranno utilizzate per l'implementazione dell'albero decisionale: una classe Node e una classe DecisionTree. La classe Node include informazioni sulla caratteristica con cui è stato diviso il nodo e sul valore del nodo. La classe DecisionTree include metodi per adattare l'albero con valori x e y, prevedere nuovi dati e impostare criteri di arresto come il numero minimo di campioni e la profondità massima. Nel complesso, l'oratore adotta un approccio graduale per delineare l'implementazione di un albero decisionale da zero in Python.
  
  
• 00:10:00 In questa sezione, il relatore discute l'implementazione della funzione grow tree, che è la funzione principale che costruisce l'albero decisionale in modo ricorsivo. La funzione accetta i valori x e y e controlla che il numero di feature non superi il numero di feature effettive. La funzione controlla prima i criteri di arresto e poi procede per trovare la suddivisione migliore, creare nodi figlio e chiamare nuovamente la funzione di crescita dell'albero. Se i criteri di arresto vengono soddisfatti, la funzione crea un nuovo nodo foglia e lo restituisce con il parametro value. L'oratore discute anche di una funzione di supporto chiamata "etichetta più comune", che utilizza la struttura dei dati del contatore e restituisce l'etichetta più comune nel set di dati.
  
  
• 00:15:00 In questa sezione, il video illustra come implementare alberi decisionali da zero con Python. L'istruttore dimostra come creare una funzione di supporto per trovare la soglia e la funzionalità migliori per creare una nuova suddivisione. Questa funzione utilizza numpy per selezionare in modo casuale un gruppo di funzionalità da considerare per la creazione di una nuova divisione. Una volta che la funzione helper trova la soglia tra tutte le possibili divisioni, calcola il guadagno di informazioni per determinare se è migliore del miglior guadagno calcolato finora. Infine, vengono restituiti l'indice e la soglia di suddivisione migliori.
  
  
• 00:20:00 In questa sezione del video, l'oratore crea una funzione di supporto chiamata "guadagno di informazioni" per calcolare il guadagno di informazioni e definisce un'altra funzione di supporto chiamata "entropia" per calcolare l'entropia del genitore in base ai valori passati Spiegano che l'entropia del genitore è calcolata come somma di px per log 2 di px, e usano un trucco numpy per contare le occorrenze di ogni valore e dividerlo per il numero totale di valori per ottenere la p di x . Successivamente, l'oratore crea un'altra funzione di supporto chiamata "split" per aiutare a trovare quali indici vanno a sinistra e quali a destra e dimostra come funziona numpy argwhere.
  
  
• 00:25:00 In questa sezione del video, il presentatore spiega come calcolare l'entropia ponderata dei figli di un albero decisionale utilizzando Python. Dopo aver ottenuto la lunghezza dei valori y e gli indici sinistro e destro, l'entropia dei bambini può essere calcolata utilizzando la formula della media ponderata. Ciò implica trovare il numero di campioni in ciascun nodo figlio diviso per il numero totale di campioni, moltiplicarlo per l'entropia di ciascun nodo e quindi sommare i risultati per ottenere l'entropia dei figli. Con queste informazioni, il guadagno di informazioni può quindi essere calcolato prendendo l'entropia genitore meno l'entropia figlio, che viene quindi ritrasmessa all'intero albero decisionale.
  
  
• 00:30:00 In questa sezione del video, il presentatore spiega come implementare la funzione di previsione per il classificatore dell'albero decisionale. La funzione helper traverse_tree viene qui utilizzata per attraversare ricorsivamente l'albero e restituire il valore del nodo foglia se viene raggiunto. Se il valore della caratteristica è minore o uguale alla soglia, il lato sinistro dell'albero viene passato per essere attraversato e il lato destro dell'albero viene passato per essere attraversato altrimenti. I valori vengono restituiti e quindi trasformati in un array numpy prima di essere emessi. Il classificatore dell'albero decisionale viene quindi testato con il set di dati sul cancro al seno e la funzione di previsione viene utilizzata per generare previsioni che vengono passate a una metrica di accuratezza.
  
  
• 00:35:00 In questa sezione, il relatore sta testando il modello dell'albero decisionale che ha creato da zero utilizzando Python. Per prima cosa calcolano l'accuratezza del modello utilizzando le previsioni ei dati del test. Trovano anche due errori nel codice: uno nell'inizializzazione del nodo e l'altro nella funzione traverse tree. Dopo aver corretto gli errori, eseguono nuovamente i dati del test e ottengono una precisione di 0,91. Quindi passano al modello diversi argomenti e ottengono una precisione leggermente migliore. Infine, il relatore invita gli spettatori a porre domande e fornisce un collegamento al loro repository GitHub dove è disponibile il codice.

[MetaQuotes]

Come implementare Random Forest da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/05%20Random%20Forests

Come implementare Random Forest da zero con Python

Questo video tutorial insegna come implementare Random Forests da zero con Python. Durante l'addestramento, viene selezionato un sottoinsieme casuale del set di dati e viene creato un albero decisionale con questo sottoinsieme. Questo processo viene ripetuto per il numero di alberi determinato prima di iniziare l'algoritmo. Durante l'inferenza, la previsione viene ottenuta da ogni albero e, se si tratta di classificazione, viene preso il voto di maggioranza dell'etichetta di classe. Il relatore dimostra come implementarlo creando un elenco che distribuisce gli alberi decisionali in esso e lo aggiunge a un array Numpy. L'accuratezza può essere calcolata utilizzando il numero di valori veri previsti correttamente diviso per il numero totale di valori veri. L'oratore parla anche del numero di alberi, della profondità massima e della suddivisione minima del campione che possono essere modificati per ottenere una maggiore precisione.

• 00:00:00 In questa sezione, apprendiamo le foreste casuali, che consistono in molti alberi decisionali diversi. Il processo prevede l'introduzione di una certa casualità nell'equazione durante la creazione di questi alberi. Durante l'addestramento, viene selezionato un sottoinsieme casuale del set di dati e viene creato un albero decisionale con questo sottoinsieme. Questo processo viene ripetuto per il numero di alberi determinato prima di iniziare l'algoritmo. Durante l'inferenza, la previsione è ottenuta da ciascun albero e, se si tratta di una classificazione, viene preso il voto di maggioranza dell'etichetta di classe. Se si tratta di regressione, viene calcolata la media di tutte le previsioni. L'implementazione utilizza la classe decision tree creata nella lezione precedente e viene inizializzata specificando il numero di alberi, la profondità massima, i campioni minimi per una suddivisione, il numero di caratteristiche e un array vuoto in cui contenere tutti gli alberi. La classe ha una funzione di adattamento e previsione e ciò che è necessario è passare i parametri richiesti come menzionato sopra.
  
  
• 00:05:00 In questa sezione, l'istruttore spiega come adattare un albero decisionale basato su un sottoinsieme di campioni e aggiungerlo all'elenco di alberi in un modello di foresta casuale. Viene creata una funzione di supporto "bootstrap_samples" per scegliere casualmente un numero specificato di campioni con sostituzione dal set di dati specificato. L'istruttore procede quindi a spiegare come prevedere utilizzando la foresta casuale per un input X, che comporta l'iterazione su tutti gli alberi nella foresta casuale e la restituzione di un elenco di previsioni, in cui ogni elenco interno contiene previsioni per lo stesso campione da alberi diversi. Infine, l'istruttore introduce la funzione "swap axis" da numpy per riorganizzare gli elenchi e una funzione di supporto "most_common" che utilizza la struttura dei dati del contatore dalla libreria delle raccolte per restituire l'etichetta di classificazione più comune.
  
  
• 00:10:00 In questa sezione, il relatore spiega il processo di implementazione di una foresta casuale da zero utilizzando Python. Menzionano una funzione di supporto che verrà utilizzata per la previsione e creano un elenco, diffondendo gli alberi decisionali in esso e quindi aggiungendolo a un array NumPy che verrà restituito per le previsioni. L'accuratezza viene calcolata utilizzando il numero di valori veri previsti correttamente diviso per il numero totale di valori veri. L'oratore menziona anche che il numero di alberi, la profondità massima e la suddivisione minima del campione possono essere manipolati per ottenere una maggiore precisione. Il relatore indirizza gli spettatori al codice sul loro repository GitHub e accoglie le domande nella sezione dei commenti. Infine, l'oratore consegna a Patrick la parte restante del tutorial.

[MetaQuotes]

Come implementare Naive Bayes da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/06%20NaiveBayes

Come implementare Naive Bayes da zero con Python

Questo tutorial video si concentra sull'implementazione di Naive Bayes da zero utilizzando Python. Il docente fornisce una panoramica del teorema di Bayes e dell'assunzione di indipendenza. Spiegano come calcolare la probabilità a priori e la probabilità condizionale di classe, necessarie per addestrare l'algoritmo. Il relatore introduce anche la distribuzione gaussiana come un modo per modellare le probabilità. Il video illustra i passaggi di addestramento e previsione per l'algoritmo con il codice. L'istruttore testa l'algoritmo su un set di dati giocattolo con due classi, ottenendo un'accuratezza del 96,5%. Nel complesso, questo tutorial è una risorsa utile per chi è interessato ad apprendere Naive Bayes e ad implementarlo in Python.

• 00:00:00 In questa sezione, il relatore discute la teoria alla base di Naive Bayes, un classificatore probabilistico che presuppone l'indipendenza tra le caratteristiche per prevedere le etichette delle classi. Spiegano il teorema di Bayes e l'assunzione di indipendenza, e come questo viene utilizzato per calcolare la probabilità a posteriori di ogni classe. L'oratore prosegue spiegando come calcolare la probabilità a priori e la probabilità condizionale di classe, entrambe necessarie per addestrare l'algoritmo. Introducono anche la distribuzione gaussiana come un modo per modellare le probabilità. Vengono riepilogati i passaggi di addestramento e previsione e viene illustrato il codice per implementare Naive Bayes. Il relatore fornisce una definizione per entrambi i metodi di adattamento e previsione e delinea i passaggi necessari per l'addestramento e la previsione in ciascuno.
  
  
• 00:05:00 In questa sezione del video, l'istruttore spiega come implementare Naive Bayes da zero utilizzando Python. Il codice presuppone che x e y siano già in formato numpy e d array. L'istruttore mostra come estrarre x usando x.shape e come ottenere il numero di classi univoche usando numpy.unique(). Il passaggio successivo consiste nel calcolare la media, la varianza e il precedente per ciascuna classe. Ciò può essere ottenuto inizializzando questi valori con zeri e quindi calcolandoli utilizzando le funzioni numpy. L'istruttore spiega quindi come calcolare la probabilità a posteriori per ogni classe utilizzando una funzione di supporto e una comprensione dell'elenco. Infine, l'istruttore mostra come restituire la previsione come un array numpy.
  
  
• 00:10:00 In questa sezione, il relatore discute l'implementazione dell'algoritmo Naive Bayes in Python. Eseguono le fasi di calcolo dei priori, quindi calcolo dei posteriori utilizzando una distribuzione gaussiana e creazione di una funzione di supporto per la densità di probabilità, seguita dalla previsione della classe con il posteriore più alto. Infine, testano l'algoritmo su un set di dati giocattolo di 1000 campioni e 10 caratteristiche con due classi, ottenendo un'accuratezza del 96,5%. L'oratore incoraggia un'ulteriore esplorazione del codice e attende con impazienza la prossima lezione.

[MetaQuotes]

Come implementare PCA (Principal Component Analysis) da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/07%20PCA

Come implementare PCA (Principal Component Analysis) da zero con Python

Il video spiega il processo di implementazione di Principal Component Analysis (PCA) da zero utilizzando Python e Numpy. PCA è una tecnica che riduce la dimensionalità di un set di dati conservando la maggior parte delle informazioni. L'istruttore segue i passaggi della creazione di una classe Python con metodi di adattamento e trasformazione per eseguire PCA su un set di dati. Il metodo fit calcola innanzitutto la media e la covarianza dei dati ed estrae gli autovettori e gli autovalori. Il metodo di trasformazione proietta quindi i dati sui componenti principali. Il relatore sottolinea l'importanza della sottrazione delle medie e dell'ordinamento degli autovettori nel processo. Infine, l'implementazione viene testata sul set di dati Iris, con conseguente riduzione della dimensionalità da quattro a due dimensioni.

• 00:00:00 In questa sezione, l'istruttore discute l'analisi dei componenti principali (PCA), un metodo di apprendimento non supervisionato che riduce la dimensionalità di un set di dati trasformandolo in un set dimensionale inferiore che contiene ancora la maggior parte delle informazioni del set più grande. L'istruttore spiega come PCA trova una trasformazione tale che le caratteristiche trasformate siano linearmente indipendenti, con la dimensionalità ridotta prendendo solo le dimensioni con la massima importanza. Le dimensioni appena trovate dovrebbero minimizzare l'errore di proiezione e i punti proiettati dovrebbero avere la massima diffusione, il che significa la massima varianza. L'istruttore illustra i passaggi per implementare PCA da zero utilizzando Python e Numpy. Questi passaggi includono la sottrazione della media da x, il calcolo della covarianza di x e x e l'ordinamento degli autovettori in base ai rispettivi autovalori in ordine decrescente.
  
  
• 00:05:00 In questa sezione, il relatore spiega l'implementazione dell'analisi delle componenti principali (PCA) utilizzando Python. Ciò comporta la creazione di una funzione 'init' che accetta il numero di componenti come input, un metodo 'fit' che sottrae la media, calcola la covarianza, ordina gli autovettori e memorizza i componenti principali. Il metodo "transform" applica quindi questa trasformazione ai nuovi dati. L'oratore percorre ogni fase del codice, evidenziando l'importanza della sottrazione dei mezzi e dell'ordinamento degli autovettori e, infine, dell'output dei componenti principali per la riduzione della dimensionalità.
  
  
• 00:10:00 In questa sezione, il relatore dimostra come implementare PCA (Principal Component Analysis) da zero in Python. Iniziano creando una classe con un metodo di adattamento e trasformazione. Il metodo di adattamento calcola innanzitutto la media dei dati e la centra attorno alla media. Quindi, calcola le covarianze dei dati ed estrae gli autovettori e gli autovalori. Il metodo di trasformazione proietta quindi i dati sui componenti principali con un prodotto scalare. Infine, il relatore verifica l'implementazione con il set di dati Iris e riduce con successo la dimensionalità dei dati da quattro a due dimensioni.

[MetaQuotes]

Come implementare Perceptron da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/08%20Perceptron

Come implementare Perceptron da zero con Python

Il video tutorial spiega la teoria alla base dell'algoritmo Perceptron, che può apprendere solo modelli linearmente separabili per la classificazione binaria utilizzando una funzione di attivazione, pesi e input. Il relatore delinea quindi i passaggi necessari per implementare da zero il modello Perceptron in Python selezionando il tasso di apprendimento e il numero di iterazioni per l'algoritmo di ottimizzazione e definendo la funzione di attivazione come funzione del passo unitario. Dopo aver inizializzato i pesi e le distorsioni, il modello apprende dai dati di addestramento aggiornando i pesi e le distorsioni in base alla regola di aggiornamento di Perceptron. Infine, il relatore valuta l'accuratezza del modello prevedendo le etichette di classe per i dati del test e l'accuratezza risulta essere del 100%, indicando l'apprendimento riuscito del limite decisionale.

• 00:00:00 In questa sezione, il relatore spiega la teoria di base dietro l'algoritmo Perceptron e come si tratta di un algoritmo per l'apprendimento supervisionato di classificatori binari. Il Perceptron è un modello semplificato di un neurone biologico ed è anche conosciuto come il prototipo delle reti neurali. L'algoritmo Perceptron può apprendere solo modelli linearmente separabili e può essere visto come una singola unità di una rete neurale artificiale. Il presentatore spiega quindi la rappresentazione matematica del Perceptron, che include i pesi, l'input e la funzione di attivazione e le etichette delle classi del classificatore binario. Il video spiega quindi la regola di aggiornamento di Perceptron, che consente all'algoritmo di aggiornare i pesi e le distorsioni per spingerli verso la classe target positiva o negativa in caso di errata classificazione.
  
  
• 00:05:00 In questa sezione, il relatore delinea i passaggi per implementare da zero un modello di percettrone in Python. Iniziano selezionando il tasso di apprendimento e il numero di iterazioni per l'algoritmo di ottimizzazione. Successivamente, la funzione di attivazione viene memorizzata come funzione del passo unitario. I pesi e le distorsioni vengono inizializzati su nessuno all'inizio e il codice passa all'adattamento e alla previsione delle funzioni. Per la funzione di adattamento, il numero di campioni e il numero di caratteristiche vengono ottenuti dai dati di addestramento, quindi vengono inizializzati pesi e distorsioni. Le etichette di classe vengono regolate in modo da essere 1 o 0. Successivamente, viene eseguita l'ottimizzazione in cui viene calcolato l'output lineare per ciascun input. Infine, viene implementata la funzione di previsione in cui il modello lineare e la funzione di attivazione vengono utilizzati per calcolare l'output previsto per i dati di test.
  
  
• 00:10:00 In questa sezione, il presentatore spiega l'implementazione del perceptron da zero con Python. La regola di aggiornamento per perceptron è delta w = alfa per y meno y hat per x e il delta bias è alfa per y meno y hat. Il relatore utilizza quindi questa regola per aggiornare i pesi e il bias in base alle parti di aggiornamento. Dopo aver spiegato il metodo di adattamento, il relatore passa al metodo di previsione, in cui l'output lineare viene calcolato e quindi passato attraverso la funzione di attivazione per ottenere la previsione y. Infine, il relatore verifica questa implementazione utilizzando una funzione di supporto per l'accuratezza e i set di dati creano blob con 150 campioni e due funzionalità, creando un perceptron con velocità di apprendimento e numero di iterazioni, adattandolo ai dati di addestramento e prevedendo i dati di test. L'accuratezza risulta essere del 100%, indicando un apprendimento riuscito del limite decisionale.

[MetaQuotes]

Come implementare SVM (Support Vector Machine) da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/09%20SVM

Come implementare SVM (Support Vector Machine) da zero con Python

Le Support Vector Machines (SVM) mirano a trovare un limite decisionale lineare che massimizzi la separazione tra le classi, con il peso che viene appreso durante l'allenamento. La funzione di costo implica una perdita cardine che determina quanto siamo lontani dal lato corretto del confine decisionale, con un termine di regolarizzazione aggiunto al compromesso che minimizza la perdita e massimizza la distanza. I gradienti vengono calcolati, le regole di aggiornamento derivate e i pesi inizializzati, mentre la funzione di previsione è l'output della funzione lineare. Viene fornito il codice per implementare SVM da zero in Python utilizzando le librerie NumPy e Scikit-learn, inclusi il test e la suddivisione del treno di importazione, i set di dati e il tracciato del confine decisionale e dei due iperpiani che confermano l'implementazione accurata.

• 00:00:00 In questa sezione, il video discute di Support Vector Machines (SVM), che mira a trovare un limite di decisione lineare o iperpiano che fornisca la massima separazione tra le classi. L'iperpiano dovrebbe avere il margine maggiore dai punti o vettori di supporto più vicini, con il peso (w) che è ciò che deve essere appreso durante l'addestramento. Viene definita una funzione di perdita, che comporta una perdita cardine che determina quanto siamo lontani dal lato corretto del confine decisionale. Un termine di regolarizzazione viene aggiunto alla funzione di costo per bilanciare tra la minimizzazione della perdita e la massimizzazione della distanza da entrambi i lati, con un parametro Lambda che controlla l'importanza di dette parti nella funzione di costo.
  
  
• 00:05:00 In questa sezione viene discusso il processo di ricerca dei pesi e del bias per SVM. Viene spiegato il calcolo dei gradienti e le regole di aggiornamento sono derivate dal gradiente. Viene inoltre dimostrata l'inizializzazione dei pesi. Le etichette di classe vengono aggiornate per avere valori di -1 o 1 e le regole di aggiornamento vengono applicate per il numero specificato di iterazioni. La funzione di previsione è semplicemente l'output della funzione lineare che otteniamo dai pesi appresi. Confrontando l'output con zero, possiamo decidere la classe del dato campione di test. Il codice per SVM è scritto in Python utilizzando le librerie NumPy e Scikit-learn.
  
  
• 00:10:00 In questa sezione, il relatore spiega come scrivere un codice Python per implementare SVM da zero. Il metodo è costituito da due parti, i metodi fit e predict. Il metodo di adattamento è il nostro addestramento, che calcola i pesi dai dati forniti mentre il metodo di previsione utilizza i pesi per prevedere l'output approssimando i dati forniti. Il presentatore spiega inoltre gli aggiornamenti del codice in base a diversi gradienti, che dipendono dalla condizione. La condizione y per W per x meno B dovrebbe essere maggiore o uguale a uno, che usiamo con numpy dot per verificare. Il codice fa seguito all'importazione di train test, split e set di dati da sklearn e matplotlib e crea un set di dati di esempio con due BLOB di set di dati con due funzionalità, quindi garantisce che le classi siano -1 e più uno, suddivise in set di addestramento e test, ed eseguire svm per prevedere l'accuratezza. Il relatore delinea anche il codice per tracciare il confine decisionale ei due iperpiani a più uno e meno uno, il che conferma un'implementazione accurata.

[MetaQuotes]

Come implementare K-Means da zero con Python

Codice: https://github.com/AssemblyAI-Examples/Machine-Learning-From-Scratch/tree/main/10%20KMeans

Come implementare K-Means da zero con Python

Questo video mostra come implementare da zero l'algoritmo di clustering K-Means con Python. K-Means è un algoritmo di apprendimento non supervisionato per raggruppare i dati senza etichetta in k diversi cluster aggiornando le medie o i centroidi in modo iterativo fino a quando non ci sono ulteriori modifiche. Il video illustra l'inizializzazione dei cluster vuoti e l'impostazione dei parametri per il numero di cluster e iterazioni, l'aggiornamento delle etichette e dei centroidi dei cluster e l'interruzione del ciclo di ottimizzazione una volta che non ci sono modifiche. Il relatore spiega anche l'importanza di misurare la distanza euclidea per calcolare i centroidi più vicini e fornisce una funzione di tracciamento pre-scritta da Matplotlib per visualizzare il processo di clustering.

• 00:00:00 In questa sezione, il relatore spiega il metodo di apprendimento non supervisionato k-medie, che prevede il raggruppamento di un set di dati in k cluster diversi e l'aggiornamento delle medie o dei centroidi durante un processo di ottimizzazione iterativo fino a quando non ci sono più modifiche. Il processo di aggiornamento delle etichette e dei centri dei cluster viene ripetuto e la formula dei centroidi più vicini viene utilizzata per calcolare la distanza euclidea tra due vettori di caratteristiche. L'oratore mostra quindi un esempio di ricerca di tre cluster in dati senza etichetta e mostra come implementare k-mean da zero in Python, inclusa l'inizializzazione di cluster vuoti e l'impostazione dei parametri per il numero di cluster e iterazioni. Il video si conclude con un riepilogo dell'algoritmo k-mean e della sua implementazione in Python.
  
  
• 00:05:00 In questa sezione, il relatore discute l'implementazione di K-Means da zero usando Python. Iniziano inizializzando le variabili necessarie, come elenchi vuoti per ogni cluster e centroide, e quindi definendo una funzione di previsione piuttosto che un metodo di adattamento. Spiegano che K-Means è una tecnica di apprendimento senza supervisione per dati senza etichetta. Il ciclo di ottimizzazione comporta l'assegnazione di campioni ai centroidi prima di calcolare nuovi centroidi dai cluster. L'oratore osserva che le funzioni di supporto sono necessarie per creare e ottenere centroidi e cluster. Concludono menzionando che è possibile interrompere il ciclo prima delle iterazioni massime se non ci sono più modifiche.
  
  
• 00:10:00 In questa sezione, il relatore spiega l'implementazione delle funzioni di supporto per aggiornare le etichette dei cluster e assegnare campioni ai centroidi più vicini. La funzione per aggiornare le etichette del cluster scorre ogni cluster e assegna l'indice del cluster all'etichetta di ogni indice campione. L'oratore mostra anche l'inizializzazione di elenchi vuoti per ciascun cluster per assegnare gli indici e quindi scorrere ciascun campione per assegnarlo al centroide più vicino. Infine, il discorso delinea i passaggi per tracciare i centroidi e i cluster e controlla se il codice deve fornire i passaggi per tracciare.
  
  
• 00:15:00 In questa sezione, il relatore spiega come implementare l'algoritmo di clustering K-Means da zero con Python. L'algoritmo accetta come input un set di dati e un numero specificato di cluster, quindi assegna ciascun punto al centroide più vicino. Il relatore introduce funzioni di supporto per trovare il baricentro più vicino e calcolare la distanza euclidea tra due punti. Un'altra funzione di supporto viene utilizzata per calcolare la media di ciascun cluster, che viene quindi assegnata al centroide. Infine, l'algoritmo controlla se la distanza tra il vecchio e il nuovo centroide per ogni cluster è zero per determinare se l'algoritmo ha convergenza.
  
  
• 00:20:00 In questa sezione, il relatore spiega come implementare il clustering K-Means da zero usando Python e numpy. Discutono dell'importanza di misurare la distanza euclidea e di come calcolare i nuovi centroidi e le etichette dei cluster. Forniscono anche una funzione di tracciamento pre-scritta che utilizza la libreria matplotlib per visualizzare il processo di clustering passo dopo passo. Infine, dimostrano l'implementazione su un set di dati di esempio utilizzando la funzione make_blobs di sklearn per creare tre cluster, mostrando come l'algoritmo K-Means raggruppa correttamente i punti dati in cluster separati. Il relatore incoraggia gli spettatori a controllare il codice completo su Github e a guardare il resto del corso per spiegazioni più approfondite sui concetti di machine learning.

[MetaQuotes]

Introduzione all'API OpenAI ChatGPT (GPT-3.5) in Python | Tutorial per principianti

Introduzione all'API OpenAI ChatGPT (GPT-3.5) in Python | Tutorial per principianti

Il video tutorial spiega come utilizzare l'API OpenAI ChatGPT (GPT-3.5) in Python per principianti. Il presentatore introduce il modello GPT 3.5 Turbo come alternativa più economica a DaVinci, che è un modello di composizione in grado di generare sia linguaggio naturale che codice e non ha token o limiti totali. Il tutorial mostra quindi come registrarsi per un account OpenAI, ottenere una chiave API e utilizzare la funzione chat_gpt-completion per mantenere un registro delle conversazioni con gli input dell'utente e del sistema. Il video spiega anche come recuperare le risposte, aggiungere domande di follow-up e modificare il codice per mantenere la conversazione ininterrotta.

• 00:00:00 In questa sezione del video, il relatore presenta il modello GPT 3.5 Turbo di OpenAI, che è un'alternativa più economica al modello DaVinci. Il modello GPT 3.5 Turbo è un modello di composizione in grado di comprendere e generare sia il linguaggio naturale che il codice e costa 0,002 centesimi per mille token. A differenza dei modelli GPT 3.0, non esiste un limite di token per il modello GPT 3.5 Turbo e non ha un limite totale. Il video prosegue quindi dimostrando come iniziare a utilizzare l'API OpenAI GPT in Python, incluso come registrarsi per un account OpenAI e ottenere una chiave API.
  
  
• 00:05:00 In questa sezione, il creatore del tutorial spiega come utilizzare l'API OpenAI ChatGPT (GPT-3.5) in Python. Questa API funziona in modo diverso dai normali modelli GPT 3.0 perché è più conversazionale. L'API utilizza una funzione chiamata chat_gpt-completion che fa riferimento alla libreria OpenAI e al modello di completamento della chat. Il registro delle conversazioni viene passato a questa funzione per continuare ad aggiungere record di conversazioni. I ruoli utente e di sistema vengono utilizzati per determinare se l'input proviene da un utente o dal sistema stesso. L'opzione di risposta viene stampata e la parte più importante della risposta è il tasto Scelta.
  
  
• 00:10:00 In questa sezione, il tutorial illustra come utilizzare l'API OpenAI ChatGPT (GPT-3.5) in Python. Il tutorial spiega che, a differenza dei normali modelli GPT 3.0, il modello ChatGPT può restituire solo un messaggio o una risposta alla volta. Il tutorial procede quindi dimostrando come recuperare la riga e il contenuto da una risposta, come comporre una conversazione con l'API ChatGPT e come recuperare e visualizzare la cronologia della composizione. L'esercitazione illustra anche come aggiungere domande di follow-up alla composizione e recuperare informazioni aggiuntive dall'API in base alla domanda di follow-up.
  
  
• 00:15:00 In questa sezione, l'oratore discute una modifica del codice che può essere apportata per mantenere la composizione ChatGPT in esecuzione senza interruzioni. Le modifiche comportano l'avvio di una sessione con la riga di sistema, l'attivazione della composizione impostando il contenuto su "come posso aiutarti" e l'inserimento di un ciclo while per mantenere la conversazione in corso. L'utente inserisce domande o prompt nell'istruzione di input, che salva la stringa nella variabile del problema. La chiave del contenuto è impostata come messaggio e l'utente esegue la funzione di compensazione ChatGPT per inviare richieste e aggiungere il messaggio all'elenco di composizione. La conversazione può quindi essere continuata con domande di follow-up e tutte le conversazioni vengono salvate in un elenco a cui è possibile fare riferimento dall'API ChatGPT.

[MetaQuotes]

Iniziare con OpenAI GPT-4 API (ChatGPT Official API) in Python

Iniziare con OpenAI GPT-4 API (ChatGPT Official API) in Python

Il video illustra come utilizzare l'API OpenAI GPT-4 in Python utilizzando l'API ufficiale ChatGPT. Dopo aver generato una chiave API e aver installato il pacchetto OpenAI python, l'utente può utilizzare il modello GPT-4 creando una funzione e chiamando l'endpoint di OpenAI con l'ID del modello e i registri delle conversazioni. Il relatore mostra come aggiungere i registri delle conversazioni all'argomento del registro di composizione, creare uno strumento da riga di comando e utilizzare l'API ChatGPT per generare risposte. Gli spettatori sono incoraggiati a provare l'API e a iscriversi al canale per i video futuri.

• 00:00:00 In questa sezione, il video spiega come utilizzare l'API ufficiale di ChatGPT in Python. L'API si basa sul modello GPT-4 e sono disponibili quattro diverse versioni. Il normale modello GPT-4 può accettare fino a 8192 token, mentre il modello GPT-4 32k può accettare fino a 32768 token. Per utilizzare l'API, devi prima generare una chiave API registrandoti per un account su platform.openai.com. Quindi, devi installare il pacchetto OpenAI python e allegare la chiave API al modulo OpenAI. Infine, puoi utilizzare il modello GPT-4 in Python creando una funzione ed effettuando una chiamata API all'endpoint di OpenAI, passando l'ID del modello e un elenco di registri di conversazione al metodo.
  
  
• 00:05:00 In questa sezione, il relatore mostra come utilizzare l'API OpenAI GPT-4 in Python. Iniziano creando un elenco di conversazioni e spiegano come l'API può accedere all'elenco per fornire risposte. Per inviare una richiesta all'API, l'utente deve fornire un ID riga per identificare se la conversazione appartiene all'AI o all'utente e il contenuto della conversazione. L'oratore condivide un blocco di codice di esempio che aggiunge una conversazione all'elenco e mostra come chiamare l'API utilizzando la funzione di conversazione GPT della chat. Spiegano anche il formato della risposta, inclusi il timestamp e il costo della chiamata API, nonché come accedere alla risposta GPT-4 all'interno della chiave delle scelte.
  
  
• 00:10:00 In questa sezione, il relatore illustra come aggiungere un registro di conversazione all'argomento del registro di composizione utilizzando Python in un'API OpenAI GPT-4. Fanno riferimento al blocco della composizione che contiene i record più recenti e aggiungono il record della risposta dalla chiave delle scelte all'argomento del registro della composizione. L'output viene quindi testato eseguendo il blocco di codice e stampando l'elenco di composizione. Il relatore dimostra anche come creare uno strumento a riga di comando per consentire agli utenti di fornire input, che possono quindi essere aggiunti al registro di composizione in base allo scopo dell'utente. Nel complesso, questa sezione fornisce una guida utile per gli sviluppatori che desiderano utilizzare l'API OpenAI GPT-4 in Python.
  
  
• 00:15:00 In questa sezione, il relatore mostra come utilizzare l'API ChatGPT per generare risposte utilizzando Python. Codifica una funzione per raccogliere l'input dell'utente e inviarlo all'API, quindi stampare la risposta. Lo dimostra chiedendo all'API di raccontargli una barzelletta e mostra l'output, che include sia l'input dell'utente che la risposta dell'API. Il presentatore conclude incoraggiando gli spettatori a provare l'API ChatGPT e ad apprezzare e iscriversi al suo canale.