Trading algoritmico con Python - pagina 22
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Machine Learning con BigQuery sulla piattaforma cloud di Google
Machine Learning con BigQuery sulla piattaforma cloud di Google
Il video illustra i contenuti di un corso incentrato sull'utilizzo di BigQuery per il machine learning. BigQuery è un data warehouse aziendale inizialmente utilizzato internamente a Google e successivamente diventato un servizio cloud. È altamente scalabile e senza server, in grado di accogliere petabyte di dati e fornire risultati di query rapidi. L'istruzione del corso si basa su casi di studio del mondo reale, guidando gli studenti attraverso il processo di creazione di modelli di apprendimento automatico dall'approvvigionamento dei dati alla creazione del modello. Durante il corso, gli studenti utilizzano BigQuery per costruire i propri modelli, richiedendo loro di configurare un account Google Cloud Platform (GCP) specifico per BigQuery.
Il video spiega i principi guida di Google per il ridimensionamento delle risorse hardware, sottolineando la decisione di ridimensionare anziché aumentare. Google riconosce che l'hardware può guastarsi in qualsiasi momento, quindi i progetti dovrebbero tenere conto di potenziali guasti. Inoltre, Google utilizza hardware di base, che è conveniente e consente la flessibilità del fornitore. La scalabilità orizzontale è preferibile rispetto alla scalabilità verticale a causa dell'elevato costo dell'hardware. Google ha sviluppato tecnologie come GFS, MapReduce e Bigtable, che hanno portato a un'architettura hardware scalabile. Colossus ha sostituito GFS e funge da sottosistema distribuito sottostante per le tecnologie di Google, tra cui BigQuery.
Il docente fornisce una panoramica della soluzione di database di Google, Spanner, che è distribuita a livello globale e si affida a Colossus per la gestione delle transazioni distribuite. Il video mostra anche il processo di registrazione e gestione degli account di fatturazione all'interno di Google Cloud Platform. Gli utenti possono creare un account GCP visitando il sito Web della piattaforma, accettando i termini e fornendo le informazioni necessarie. Ai nuovi utenti viene concesso un credito di $ 300 da utilizzare su GCP, che può essere monitorato attraverso la sezione relativa alla fatturazione. Il docente consiglia di impostare avvisi di budget per ricevere notifiche al raggiungimento di determinati obiettivi di fatturazione.
La creazione e lo scopo di BigQuery sono discussi in dettaglio. La crescita esponenziale dei dati di Google ha reso necessario lo sviluppo di BigQuery, che consente query interattive su set di dati di grandi dimensioni. BigQuery è in grado di gestire le query indipendentemente dal fatto che coinvolgano 50 righe o 50 miliardi di righe. Il suo dialetto SQL non standard facilita una breve curva di apprendimento e può parallelizzare l'esecuzione SQL su migliaia di macchine. Sebbene BigQuery memorizzi i dati strutturati, differisce dai database relazionali in quanto supporta i tipi di record nidificati all'interno delle tabelle, consentendo l'archiviazione di strutture nidificate.
Viene spiegata l'architettura di BigQuery, evidenziando il suo approccio alla parallelizzazione. A differenza della maggior parte dei sistemi di database relazionali che eseguono una query per core, BigQuery è progettato per eseguire una singola query su migliaia di core, migliorando notevolmente le prestazioni rispetto agli approcci tradizionali. Il motore Dremel abilita il pipelining delle query, consentendo ad altre query di utilizzare i core disponibili mentre alcune sono in attesa di I/O. BigQuery utilizza un approccio multi-tenancy, consentendo a più clienti di eseguire query contemporaneamente sullo stesso hardware senza influire su altre posizioni. L'interfaccia di BigQuery comprende tre riquadri principali, tra cui la cronologia delle query, le query salvate, la cronologia dei processi e le sezioni delle risorse per organizzare l'accesso a tabelle e viste.
Il video fornisce una spiegazione dettagliata delle schermate e dei pannelli all'interno di Google Cloud Console specifici per BigQuery. Il menu di navigazione mostra le risorse BigQuery, come set di dati e tabelle, mentre la sezione dell'area di lavoro SQL consente agli utenti di creare query, lavorare con le tabelle e visualizzare la cronologia dei loro lavori. Il pannello Explorer elenca i progetti correnti e le relative risorse, mentre il pannello Dettagli fornisce informazioni sulle risorse selezionate e consente modifiche agli schemi delle tabelle, esportazioni di dati e altre funzioni. Viene chiarito che BigQuery non è adatto per le applicazioni OLTP a causa della sua mancanza di supporto per piccoli aggiornamenti frequenti a livello di riga. Pur non essendo un database NoSQL, BigQuery utilizza un dialetto di SQL ed è più simile a un database OLAP, offrendo vantaggi e idoneità simili per molti casi d'uso OLAP.
La definizione di BigQuery di Google viene ulteriormente discussa, sottolineando il suo cloud completamente gestito, altamente scalabile, economico e veloce.
Ecco altri punti discussi nel video:
Formato di archiviazione di BigQuery: BigQuery utilizza un formato di archiviazione a colonne, ottimizzato per le prestazioni delle query. Memorizza i dati in modo compresso e colonnare, consentendo un'elaborazione efficiente di colonne specifiche in una query senza accedere a dati non necessari. Questo formato è particolarmente vantaggioso per i carichi di lavoro analitici che comportano aggregazioni e filtri.
Importazione dei dati: BigQuery supporta vari metodi di importazione dei dati. Può caricare direttamente i dati da fonti come Google Cloud Storage, Fogli Google e Google Cloud Bigtable. Offre inoltre integrazioni con altri strumenti di elaborazione dati, come Dataflow e Dataprep, per le operazioni ETL (Extract, Transform, Load).
Partizionamento e clustering dei dati: per ottimizzare le prestazioni delle query, BigQuery offre funzionalità come il partizionamento e il clustering. Il partizionamento implica la divisione di set di dati di grandi dimensioni in parti più piccole e gestibili in base a una colonna scelta (ad esempio, data). Il clustering organizza ulteriormente i dati all'interno di ciascuna partizione, in base a una o più colonne, per migliorare le prestazioni delle query riducendo la quantità di dati analizzati.
Controlli di accesso ai dati e sicurezza: BigQuery offre solidi controlli di accesso per gestire la sicurezza dei dati. Si integra con Google Cloud Identity and Access Management (IAM), consentendo agli utenti di definire autorizzazioni di accesso granulari a livello di progetto, set di dati e tabella. BigQuery supporta anche la crittografia dei dati inattivi e in transito, garantendo la protezione dei dati sensibili.
Determinazione del prezzo dei dati e ottimizzazione dei costi: il video illustra brevemente il modello di determinazione dei prezzi di BigQuery. Funziona su base pay-as-you-go, addebitando agli utenti in base alla quantità di dati elaborati dalle query. BigQuery offre funzionalità come la memorizzazione nella cache delle query, che possono ridurre i costi evitando l'elaborazione ridondante dei dati. È importante ottimizzare le query ed evitare la scansione dei dati non necessaria per ridurre al minimo i costi.
Machine learning con BigQuery: il corso copre l'utilizzo di BigQuery per le attività di machine learning. BigQuery si integra con i servizi di machine learning di Google Cloud, come AutoML e TensorFlow, consentendo agli utenti di sfruttare la potenza di BigQuery per la preparazione dei dati e l'ingegnerizzazione delle funzionalità prima di addestrare i modelli di machine learning.
Casi d'uso ed esempi: il docente menziona vari casi d'uso del mondo reale in cui BigQuery eccelle, come l'analisi di grandi volumi di dati di log, la conduzione di ricerche di mercato, l'esecuzione della segmentazione dei clienti e l'esecuzione di query analitiche complesse su enormi set di dati.
Nel complesso, il video offre una panoramica delle capacità, dell'architettura e delle funzionalità principali di BigQuery, evidenziando la sua idoneità per l'analisi dei dati su larga scala e le attività di machine learning. Sottolinea i vantaggi dell'utilizzo di una soluzione basata su cloud completamente gestita e altamente scalabile come BigQuery per gestire in modo efficiente grandi quantità di dati.
Visualizzazione dei dati con matplotlib in 1 ora
Visualizzazione dei dati con matplotlib in 1 ora
In questo video, l'istruttore introduce l'importanza della visualizzazione dei dati nell'apprendimento automatico e spiega come può aiutare a dare un senso a grandi quantità di dati raccolti. Le due principali librerie Python per la visualizzazione dei dati, Matplotlib e Seaborn, sono trattate nel corso.
L'istruttore afferma che il corso è progettato principalmente per ingegneri dell'apprendimento automatico, ingegneri dei dati e scienziati dei dati che desiderano imparare Python. Per illustrare l'utilizzo di Matplotlib, viene fornito un semplice esempio di tracciamento di una curva. La filosofia di Matplotlib ruota attorno allo sfruttamento del linguaggio esistente, Python, che è diventato lo standard per la creazione di modelli di apprendimento automatico e la gestione dei dati. Combinando Matplotlib con altri pacchetti Python, gli utenti possono sfruttare i numerosi pacchetti disponibili per varie attività.
Il video sottolinea l'importanza di utilizzare il pacchetto NumPy insieme a Matplotlib per il calcolo scientifico. Sebbene Matplotlib possa funzionare senza NumPy, l'utilizzo di NumPy può far risparmiare molto tempo e fatica. NumPy fornisce un potente oggetto array multidimensionale e funzioni per manipolarlo. Un esempio è mostrato nel video, dove una curva con 100 punti viene generata utilizzando NumPy per calcolare le coordinate x e y. Questo approccio si rivela molto più veloce rispetto all'esecuzione dell'operazione utilizzando Python puro. Inoltre, il video copre la tracciatura di due curve sullo stesso grafico per il confronto, la tracciatura dei dati da un file estraendo e organizzando i dati utilizzando il codice Python e la tracciatura dei punti anziché degli elementi in modo lineare.
Il tutorial approfondisce la creazione di diversi tipi di grafici a barre utilizzando la libreria Matplotlib. Viene introdotta la funzione dedicata per la creazione di grafici a barre, "bar", che prende la coordinata x per ogni barra e l'altezza di ogni barra come parametri di input. Regolando i parametri opzionali, gli utenti possono creare vari effetti e persino generare barre orizzontali utilizzando la funzione "barh". Il tutorial copre anche il tracciamento di più grafici a barre sullo stesso grafico e la creazione di barre in pila utilizzando un parametro speciale nella funzione "barra". Inoltre, il video accenna brevemente alla creazione di grafici a torta utilizzando la funzione "torta".
Varie funzioni utilizzate nella visualizzazione dei dati con Matplotlib sono spiegate nel tutorial. La prima funzione trattata sono gli istogrammi, che sono rappresentazioni grafiche delle distribuzioni di probabilità. Vengono discussi la funzione "hist" ei suoi parametri, che consentono agli utenti di tracciare facilmente i dati come istogrammi. La seconda funzione trattata sono i box plot, che facilitano il confronto delle distribuzioni di valore. Il video spiega i componenti di un box plot, inclusi quartili, mediana, media e quantità statistiche di un set di dati, e dimostra come generarli utilizzando la funzione "boxplot". Infine, l'esercitazione copre la modifica dei grafici utilizzando colori e stili diversi, come la definizione dei colori utilizzando terzine, quartine o nomi di colori HTML, nonché l'impostazione del colore di un grafico della curva.
Il video continua spiegando come aggiungere colore a grafici a dispersione, grafici a barre e grafici a torta utilizzando il parametro "color". Questo parametro consente agli utenti di controllare i singoli colori dei punti o modificare il colore comune per tutti i punti. Il video tocca anche l'importazione di librerie come moduli, l'utilizzo di alias per semplificare la codifica e il chiarimento della rappresentazione delle variabili. Si sottolinea che quasi tutto in Matplotlib e Python coinvolge funzioni, come la funzione "pi" e la funzione "show".
Successivamente, l'esercitazione illustra le combinazioni di colori e i modelli di linea personalizzati durante la creazione di box plot, marcatori e forme di linea. Dimostra la creazione di marcatori personalizzati utilizzando forme predefinite e la definizione di marcatori personalizzati utilizzando simboli di testo matematici. Inoltre, spiega come modificare facilmente le impostazioni predefinite di Matplotlib utilizzando l'oggetto di configurazione centralizzato, consentendo agli utenti di adattare lo stile visivo, come avere uno sfondo nero e annotazioni bianche, a diversi contesti di utilizzo.
Il presentatore spiega come salvare un grafico in un file utilizzando la funzione "savefig" in Matplotlib. Riguardano anche l'aggiunta di annotazioni a un grafico, tra cui un titolo, etichette per gli assi x e y, un riquadro delimitato e frecce. Il video mostra il processo di aggiunta di queste annotazioni per migliorare la chiarezza visiva e la comprensione del grafico. Inoltre, mostra come controllare manualmente la spaziatura dei tick in Matplotlib per regolazioni precise. Il video evidenzia le varie funzioni disponibili in Matplotlib per annotare i grafici e renderli più autoesplicativi per i lettori.
Andando avanti, l'istruttore discute la visualizzazione dei dati con Matplotlib e introduce Seaborn, un'interfaccia di alto livello per Matplotlib. Seaborn fornisce parametri e funzionalità diversi rispetto a Matplotlib. L'istruttore mostra come creare visualizzazioni utilizzando il set di dati e le mappe dei colori integrati di Seaborn. Il video si conclude presentando esempi di creazione di un grafico fattoriale e utilizzo di mappe di colori per tracciare i dati. Attraverso questi esempi, gli spettatori ottengono informazioni sull'utilizzo di diverse funzioni e strumenti in Matplotlib e Seaborn per migliorare le proprie capacità di visualizzazione dei dati.
Il video spiega come ridimensionare i grafici utilizzando la funzione "set_context" di Seaborn. Questa funzione consente agli utenti di controllare gli elementi del grafico, come le dimensioni, in base al contesto in cui verrà visualizzato il grafico. Quindi chiarisce la distinzione tra i due tipi di funzioni di Seaborn: funzioni a livello di assi e funzioni a livello di figura. Le funzioni a livello di assi operano a livello di asse e restituiscono l'oggetto assi, mentre le funzioni a livello di figura creano grafici che includono assi organizzati in modo significativo. Infine, il video fornisce indicazioni sull'impostazione degli assi per un box plot utilizzando l'oggetto Matplotlib axis subplots.
Questo tutorial video completo copre una vasta gamma di argomenti relativi alla visualizzazione dei dati con Matplotlib e Seaborn. Inizia introducendo l'importanza della visualizzazione dei dati nell'apprendimento automatico e l'uso di Matplotlib come potente libreria. Dimostra come tracciare curve, creare grafici a barre, generare istogrammi e box plot e personalizzare colori, indicatori e stili di linea. Il tutorial copre anche il salvataggio di grafici, l'aggiunta di annotazioni e la manipolazione della spaziatura dei tick. Inoltre, introduce Seaborn come uno strumento di visualizzazione alternativo con il proprio set di caratteristiche e funzionalità. Seguendo questo tutorial, i visualizzatori possono migliorare le proprie capacità di visualizzazione dei dati e comunicare efficacemente i propri risultati utilizzando queste potenti librerie Python.
Esercitazione sul deep learning con Python, TensorFlow e Keras
Esercitazione sul deep learning con Python, TensorFlow e Keras
Saluti a tutti e benvenuti a un attesissimo aggiornamento su deep learning e Python con TensorFlow, oltre a un nuovo tutorial di Chaos. Sono passati più di due anni dall'ultima volta che ho coperto l'apprendimento profondo di base in Python e durante questo periodo ci sono stati progressi significativi. Entrare nel deep learning e lavorare con modelli di deep learning è diventato molto più semplice e accessibile.
Se sei interessato ad approfondire il codice TensorFlow di livello inferiore e i dettagli intricati, puoi comunque fare riferimento al video precedente. Tuttavia, se stai mirando a iniziare con il deep learning, non è più necessario farlo perché ora disponiamo di API di alto livello intuitive come Chaos che si trovano sopra TensorFlow. Queste API rendono il deep learning incredibilmente semplice, consentendo a chiunque, anche senza una precedente conoscenza del deep learning, di seguirlo.
In questo tutorial, faremo una rapida panoramica delle reti neurali. Per iniziare, comprendiamo i componenti principali di una rete neurale. L'obiettivo principale di qualsiasi modello di apprendimento automatico, comprese le reti neurali, è mappare gli input agli output. Ad esempio, dati gli input X1, X2 e X3, miriamo a determinare se l'output corrisponde a un cane oa un gatto. In questo caso, lo strato di output è costituito da due neuroni che rappresentano la possibilità di essere un cane o un gatto.
Per ottenere questa mappatura, possiamo utilizzare un singolo strato nascosto, in cui ogni input, X1, X2 e X3, è connesso ai neuroni nello strato nascosto. A ciascuna di queste connessioni è associato un peso univoco. Tuttavia, se ci limitiamo a un singolo livello nascosto, le relazioni tra gli input e l'output sarebbero lineari. Per catturare le relazioni non lineari, che sono comuni nei problemi complessi, abbiamo bisogno di due o più strati nascosti. Una rete neurale con due o più livelli nascosti viene spesso definita rete neurale profonda.
Aggiungiamo un altro livello nascosto, collegandolo completamente al livello precedente. Ogni connessione tra gli strati ha il suo peso unico. In definitiva, l'output viene derivato dal livello finale, in cui ogni connessione al livello di output possiede un peso univoco. A livello di singolo neurone, il neurone riceve input, che potrebbero essere i valori del livello di input (X1, X2, X3) o input da altri neuroni. Questi input vengono sommati, considerando i pesi associati. Inoltre, viene applicata una funzione di attivazione per simulare o meno l'attivazione del neurone. Le funzioni di attivazione comuni includono la funzione gradino o la funzione sigmoide, che restituisce valori compresi tra 0 e 1. Nella nostra rete neurale, il livello di output utilizza una funzione di attivazione sigmoidea, assegnando probabilità a ciascuna classe (cane o gatto). La funzione Arg max viene quindi utilizzata per determinare la classe prevista in base alla probabilità più alta.
Ora che abbiamo una conoscenza di base delle reti neurali, procediamo a crearne una utilizzando TensorFlow. Innanzitutto, assicurati di aver installato TensorFlow eseguendo il comando "pip install --upgrade tensorflow". Puoi importare TensorFlow come "tf" e verificare la versione corrente utilizzando "tf.version". Per questo tutorial, si consiglia Python 3.6 o versioni successive, anche se TensorFlow dovrebbe supportare Python 3.7 e versioni successive in futuro.
Successivamente, importeremo un set di dati con cui lavorare. Utilizzeremo il set di dati MNIST, che consiste in immagini 28x28 di cifre scritte a mano che vanno da 0 a 9. Queste immagini verranno inserite nella rete neurale e la rete predirà la cifra corrispondente. Suddivideremo il set di dati in variabili di addestramento e test: X_train, Y_train, X_test e Y_test.
Per garantire prestazioni migliori, normalizzeremo i dati. I valori dei pixel delle immagini attualmente vanno da 0 a 255, quindi li ridimensioneremo tra 0 e 1 utilizzando la funzione TF.keras.utils.normalize.
Per creare il modello, utilizzeremo l'API Chaos di alto livello, che semplifica il processo di creazione e addestramento delle reti neurali in TensorFlow. Chaos fornisce un modello sequenziale chiamato Sequential che ci consente di impilare i livelli uno dopo l'altro.
Ecco un esempio di come creare un modello di rete neurale utilizzando Chaos:
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
Nel codice sopra, importiamo i moduli necessari da TensorFlow e Chaos. Creiamo un modello sequenziale e vi aggiungiamo strati usando il metodo add. Il primo livello è un livello Appiattisci che converte l'input 2D (immagini 28x28) in un array 1D. Aggiungiamo quindi uno strato denso con 128 neuroni e attivazione ReLU. Infine, aggiungiamo uno strato di output con 10 neuroni (corrispondenti alle 10 cifre) e attivazione softmax.
Dopo aver definito il modello, lo compiliamo utilizzando il metodo compile. Specifichiamo l'ottimizzatore (in questo caso, 'adam'), la funzione di perdita ('sparse_categorical_crossentropy' per la classificazione multiclasse) e le metriche da valutare durante l'addestramento.
Ora che abbiamo definito e compilato il nostro modello, possiamo procedere ad addestrarlo sul set di dati MNIST. Useremo il metodo fit per addestrare il modello.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
Nel codice sopra, passiamo i dati di addestramento (X_train e Y_train) al metodo di adattamento insieme al numero di epoche per cui eseguire l'addestramento. Forniamo anche i dati di convalida (X_test e Y_test) per valutare le prestazioni del modello su dati invisibili durante l'addestramento.
Dopo aver addestrato il modello, possiamo fare previsioni usando il metodo predict:
# Make predictions predictions = model.predict(X_test)
Nel codice sopra, passiamo i dati del test (X_test) al metodo predict, che restituisce le probabilità previste per ogni classe.
Questa è una breve panoramica della creazione e dell'addestramento di una rete neurale utilizzando Chaos in TensorFlow. Puoi esplorare ulteriormente diversi livelli, funzioni di attivazione, ottimizzatori e altri parametri per personalizzare il tuo modello.
tecniche e concetti aggiuntivi relativi alla costruzione e all'addestramento di reti neurali.
Tecniche di regolarizzazione:
Dropout: il dropout è una tecnica di regolarizzazione utilizzata per prevenire l'overfitting. Imposta casualmente una frazione di unità di input su 0 a ogni aggiornamento durante l'addestramento, il che aiuta a evitare che il modello faccia troppo affidamento su un particolare set di funzionalità.
Regolarizzazione L1 e L2: la regolarizzazione L1 e L2 sono tecniche utilizzate per aggiungere una penalità alla funzione di perdita per evitare grandi pesi nella rete. La regolarizzazione L1 aggiunge il valore assoluto dei pesi alla funzione di perdita, incoraggiando la scarsità, mentre la regolarizzazione L2 aggiunge i pesi al quadrato alla funzione di perdita, incoraggiando piccoli pesi.
Funzioni avanzate di attivazione:
Leaky ReLU: Leaky ReLU è una funzione di attivazione che risolve il problema della "ReLU morente" consentendo una piccola pendenza per gli input negativi. Introduce una piccola pendenza negativa quando l'input è negativo, che aiuta a prevenire la morte dei neuroni durante l'allenamento.
Unità lineare esponenziale (ELU): ELU è una funzione di attivazione che uniforma l'uscita per ingressi negativi, consentendo all'attivazione di assumere valori negativi. È stato dimostrato che aiuta a migliorare l'apprendimento delle reti neurali e a ridurre la propensione verso valori positivi.
Swish: Swish è una funzione di attivazione che esegue un'interpolazione uniforme tra le funzioni lineari e sigmoidee. È stato dimostrato che in alcuni casi fornisce risultati migliori rispetto ad altre funzioni di attivazione come ReLU e sigmoid.
Transfer Learning: Transfer Learning è una tecnica che sfrutta modelli preaddestrati per risolvere nuove attività o migliorare le prestazioni di un modello su un'attività correlata. Invece di addestrare un modello da zero, puoi utilizzare un modello pre-addestrato come punto di partenza e perfezionarlo sulla tua specifica attività o set di dati. Ciò è particolarmente utile quando si dispone di dati limitati per l'attività specifica.
Ottimizzazione degli iperparametri: gli iperparametri sono parametri che non vengono appresi dal modello ma influiscono sul processo di apprendimento, ad esempio la velocità di apprendimento, le dimensioni del batch, il numero di livelli e così via. L'ottimizzazione di questi iperparametri può influire in modo significativo sulle prestazioni del modello. Tecniche come la ricerca su griglia, la ricerca casuale e l'ottimizzazione bayesiana possono essere utilizzate per cercare sistematicamente lo spazio degli iperparametri e trovare la migliore combinazione.
Valutazione del modello: la valutazione delle prestazioni di un modello è fondamentale per valutarne l'efficacia. Le metriche di valutazione comuni per le attività di classificazione includono accuratezza, precisione, richiamo, punteggio F1 e area sotto la curva caratteristica operativa del ricevitore (ROC AUC). È importante scegliere le metriche appropriate in base al problema in questione e alla natura dei dati.
Gestione di set di dati sbilanciati: i set di dati sbilanciati si verificano quando la distribuzione delle classi non è uguale, il che può portare a modelli distorti. Tecniche come il sovracampionamento della classe di minoranza, il sottocampionamento della classe di maggioranza o l'utilizzo di una combinazione di entrambi possono aiutare a risolvere questo problema. Inoltre, l'utilizzo di metriche di valutazione come precisione, richiamo e punteggio F1 può fornire una migliore comprensione delle prestazioni del modello su set di dati sbilanciati.
Ricorda, la creazione e l'addestramento di reti neurali è un processo iterativo. Implica sperimentazione, messa a punto e miglioramento continuo per ottenere i risultati desiderati.
Caricare i propri dati - Fondamenti di Deep Learning con Python, TensorFlow e Keras p.2
Caricare i propri dati - Fondamenti di Deep Learning con Python, TensorFlow e Keras p.2
Benvenuti a tutti nella seconda parte del nostro tutorial di deep learning su Python TensorFlow in Karros. In questo tutorial, ci concentreremo sul caricamento di un set di dati esterno. Nello specifico, utilizzeremo il set di dati di cani e gatti di Microsoft, originariamente una sfida di Kaggle. L'obiettivo è addestrare una rete neurale per identificare se un'immagine contiene un gatto o un cane.
Per iniziare, scarica il set di dati di cani e gatti da Microsoft. Dopo aver scaricato ed estratto il set di dati, dovresti vedere due directory: "cat" e "dog". Queste directory contengono rispettivamente immagini di cani e gatti. Ogni directory dovrebbe avere un numero considerevole di campioni, circa 12.500, fornendo ampi esempi per addestrare il nostro modello.
Ora passiamo alla parte di codifica. Dobbiamo importare diverse librerie: numpy come np, matplotlib.pyplot come plt e OpenCV come cv2. Se non hai queste librerie installate, puoi usare pip per installarle.
Successivamente, definiremo la directory dei dati in cui si trova il nostro set di dati. È possibile specificare il percorso del set di dati di conseguenza. Definiremo anche le categorie come "cane" e "gatto" in modo che corrispondano alle directory nel nostro set di dati.
Esamineremo ogni categoria e le immagini corrispondenti utilizzando la libreria del sistema operativo. Per ogni immagine, la convertiremo in scala di grigi utilizzando la libreria cv2. Abbiamo scelto la scala di grigi perché riteniamo che il colore non sia cruciale per distinguere tra cani e gatti in questo compito specifico.
Per visualizzare le immagini, useremo matplotlib.pyplot. Mostreremo un'immagine di esempio utilizzando plt.imshow e la mappa dei colori in scala di grigi. Questo passaggio ci consente di verificare che le immagini siano caricate correttamente.
Dopo aver verificato le immagini, procederemo a ridimensionarle in una forma uniforme. Dobbiamo decidere una dimensione target, ad esempio 50x50 pixel, per garantire la coerenza. Ridimensioneremo le immagini utilizzando la funzione cv2.resize e memorizzeremo gli array di immagini ridimensionate.
Ora creeremo il set di dati di addestramento. Inizializziamo un elenco vuoto chiamato "training_data" e definiamo una funzione chiamata "create_training_data". All'interno di questa funzione, iteriamo attraverso le immagini e assegniamo etichette numeriche (0 per cani, 1 per gatti) utilizzando l'indice della categoria nell'elenco "categorie".
Per ogni immagine, la ridimensioniamo alla dimensione target scelta. Aggiungiamo l'array dell'immagine ridimensionata e la sua etichetta corrispondente all'elenco training_data. Gestiamo anche eventuali eccezioni relative a immagini danneggiate nel set di dati.
Dopo aver creato il set di dati di addestramento, dovremmo controllare il bilanciamento dei dati. In un compito di classificazione binaria come questo, è essenziale avere un numero uguale di campioni per ogni classe (50% cani e 50% gatti). Dati sbilanciati possono portare a previsioni del modello distorte. Se i tuoi dati sono sbilanciati, puoi utilizzare i pesi delle classi durante l'addestramento per mitigare questo problema.
Per garantire la casualità e impedire al modello di apprendere l'ordine delle immagini, mescoliamo i dati di addestramento utilizzando la funzione random.shuffle.
Ora che i nostri dati sono mescolati, possiamo comprimerli in variabili per caratteristiche (X) ed etichette (Y). Inizializziamo elenchi vuoti per X e Y e iteriamo attraverso i dati di addestramento, aggiungendo le caratteristiche e le etichette ai rispettivi elenchi. Infine, convertiamo X in un array NumPy e lo rimodelliamo usando np.array e la forma di ciascuna caratteristica.
A questo punto, abbiamo preparato i nostri dati per addestrare la rete neurale. Ora siamo pronti per procedere con ulteriori passaggi, come suddividere i dati in set di addestramento e convalida, creare il modello e addestrarlo utilizzando TensorFlow.
Negativo 1 è un segnaposto che calcola automaticamente la dimensione in base alla lunghezza dell'array e alla forma di ogni elemento. Quindi, in questo caso, stiamo rimodellando l'array X in modo che abbia una forma di (-1, image_size, image_size). Ciò garantisce che i dati siano nel formato corretto per essere inseriti nella rete neurale.
Successivamente, dobbiamo normalizzare i valori dei pixel delle immagini. Attualmente, i valori dei pixel vanno da 0 a 255, che rappresentano l'intensità della scala di grigi. Le reti neurali generalmente funzionano meglio quando i dati di input sono normalizzati, il che significa che i valori vengono ridimensionati su un intervallo più piccolo. Possiamo ottenere ciò dividendo i valori dei pixel per 255.0, che li scalerà tra 0 e 1.0. Questo può essere fatto usando il seguente codice:
x = x / 255.0
Reti neurali convoluzionali - Fondamenti di Deep Learning con Python, TensorFlow e Keras p.3
Reti neurali convoluzionali - Fondamenti di Deep Learning con Python, TensorFlow e Keras p.3
Ciao a tutti e benvenuti alla terza parte della nostra serie di tutorial Deep Learning con Python, TensorFlow e Keras. In questo video, ci concentreremo sulle reti neurali convoluzionali (CNN) e su come applicarle per classificare i cani rispetto ai gatti utilizzando il set di dati che abbiamo creato nel video precedente.
Prima di addentrarci nelle CNN, esaminiamo rapidamente come funzionano e perché sono utili per i dati delle immagini. Le CNN comportano diversi passaggi: convoluzione, raggruppamento e poi ancora convoluzione e raggruppamento. L'idea principale alla base della convoluzione è estrarre caratteristiche utili da un'immagine. Usiamo una finestra convoluzionale, tipicamente rappresentata come una matrice (ad esempio, 3x3), per eseguire la scansione dell'immagine e semplificare le informazioni all'interno della finestra a un singolo valore. La finestra quindi si sposta e ripete questo processo più volte. Anche il passo, che determina quanto si muove la finestra, può essere regolato.
Con Keras, possiamo specificare la dimensione della finestra e la maggior parte degli altri dettagli vengono curati automaticamente. Se vuoi approfondire le complessità del deep learning, ti consiglio di dare un'occhiata alla serie di tutorial "Practical Machine Learning", in cui i meccanismi interni sono spiegati in modo più dettagliato, in particolare per il codice TensorFlow non elaborato.
L'output del livello convoluzionale è un insieme di caratteristiche estratte dall'immagine. Queste funzionalità vengono quindi in genere passate attraverso un livello di pooling, con il tipo più comune di pooling massimo. Il pool massimo seleziona il valore massimo all'interno di una finestra e lo sposta ripetutamente, riducendo efficacemente il campionamento dei dati.
L'idea di livello superiore alla base delle CNN è che estraggono gradualmente caratteristiche più complesse dall'immagine man mano che si approfondisce la rete. Gli strati iniziali potrebbero identificare bordi e linee, mentre gli strati più profondi potrebbero riconoscere forme più complesse come cerchi o quadrati. Alla fine, la rete può imparare a identificare oggetti o modelli specifici.
Per implementare una CNN, dobbiamo importare le librerie necessarie. Importiamo TensorFlow e i moduli Keras che useremo, come Sequential, Dense, Dropout, Activation, Conv2D e MaxPooling2D. Importiamo anche pickle per caricare il nostro set di dati.
Prima di inserire i dati nella rete neurale, dovremmo prendere in considerazione la possibilità di normalizzarla. Nel nostro caso, possiamo ridimensionare i dati dei pixel dividendoli per 255, dato che i valori dei pixel vanno da 0 a 255. In alternativa, possiamo usare la funzione normalize di caos.utils per scenari di normalizzazione più complessi.
Successivamente, iniziamo a costruire il nostro modello utilizzando l'API sequenziale. Aggiungiamo un livello Conv2D con 64 unità e una dimensione della finestra 3x3. Il input_shape è impostato dinamicamente utilizzando X.shape. Quindi aggiungiamo uno strato di attivazione utilizzando la funzione di attivazione lineare rettificata (ReLU). Successivamente, aggiungiamo un livello di pooling massimo con una dimensione della finestra 2x2.
Ripetiamo questo processo aggiungendo un altro layer Conv2D e un corrispondente layer di max pooling. A questo punto, abbiamo una rete neurale convoluzionale 2D.
Per passare le feature estratte a un layer completamente connesso, dobbiamo appiattire i dati. Aggiungiamo un livello Appiattisci prima di aggiungere un livello Dense finale con 64 nodi. Infine, aggiungiamo un livello di output con un singolo nodo e specifichiamo la funzione di attivazione, che può essere categorica o binaria.
Compiliamo il modello specificando la funzione di perdita (entropia incrociata categoriale o binaria), l'ottimizzatore (ad esempio, Adam) e le metriche per valutare le prestazioni del modello (ad esempio, l'accuratezza).
Per addestrare il modello, utilizziamo il metodo fit, passando i dati di input X e le etichette Y. Possiamo anche specificare la dimensione del batch (ad esempio, 32).
Useremo il seguente codice per addestrare il modello:
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Questo codice addestrerà il modello utilizzando i dati di input X e le etichette corrispondenti Y. Impostiamo la dimensione del batch su 32, il che significa che il modello elaborerà 32 campioni alla volta durante l'addestramento. Il parametro validation_split è impostato su 0.1, il che significa che il 10% dei dati verrà utilizzato per la convalida durante l'addestramento del modello.
Una volta addestrato il modello, possiamo valutarne le prestazioni utilizzando i dati di test. Possiamo usare il seguente codice per valutare il modello:
model.evaluate(X_test, Y_test)
Qui, X_test e Y_test rappresentano rispettivamente i dati e le etichette del test. Questo codice restituirà il valore di perdita e l'accuratezza del modello sui dati del test.
Dopo aver valutato il modello, possiamo usarlo per fare previsioni su dati nuovi e invisibili. Possiamo utilizzare la funzione predict() per ottenere le etichette previste per i nuovi dati. Ecco un esempio:
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
Questo è tutto! Ora hai addestrato un modello di rete neurale convoluzionale per classificare cani e gatti e lo hai utilizzato per fare previsioni su nuovi dati. Ricordarsi di salvare il modello addestrato per un utilizzo futuro, se necessario.
Analisi dei modelli con TensorBoard - Deep Learning con Python, TensorFlow e Keras p.4
Analisi dei modelli con TensorBoard - Deep Learning con Python, TensorFlow e Keras p.4
Benvenuti a tutti alla parte 4 della serie di tutorial "Deep Learning with Python: TensorFlow and Keras". In questo video e nel prossimo parleremo di come analizzare e ottimizzare i nostri modelli utilizzando TensorBoard. TensorBoard è un potente strumento che ci consente di visualizzare l'addestramento dei nostri modelli nel tempo. Il suo scopo principale è aiutarci a comprendere vari aspetti delle prestazioni del nostro modello, come l'accuratezza, l'accuratezza della convalida, la perdita e la perdita della convalida. Inoltre, ci sono funzionalità più avanzate in TensorBoard che potremmo esplorare in futuri tutorial.
Prima di immergerci in TensorBoard, affrontiamo un piccolo dettaglio. Sebbene non sia fondamentale per questo tutorial, voglio sottolineare che anche i modelli piccoli tendono a consumare una quantità significativa di memoria della GPU. Se prevedi di eseguire più modelli contemporaneamente, puoi specificare una frazione della memoria GPU che ogni modello deve utilizzare. In questo modo, è possibile evitare potenziali problemi quando si eseguono più modelli o si incontrano vincoli di memoria. Ad esempio, in genere imposto il modello in modo che utilizzi un terzo della memoria della GPU. Questo approccio si è rivelato utile quando si eseguono più modelli contemporaneamente, come nella serie "Python Plays GTA" che coinvolge il rilevamento di oggetti e la guida autonoma. È solo un consiglio utile che può farti risparmiare tempo e mal di testa.
Ora, procediamo con l'argomento principale. La prima cosa che voglio affrontare è l'aggiunta di una funzione di attivazione dopo lo strato denso. È stata una svista da parte mia non includerlo inizialmente. L'aggiunta di una funzione di attivazione è essenziale perché senza di essa lo strato denso diventa una funzione di attivazione lineare, che non è adatta ai nostri scopi. Vogliamo evitare la regressione e garantire che il nostro modello funzioni in modo ottimale. Quindi, risolviamo rapidamente il problema inserendo la funzione di attivazione prima dello strato denso.
Con questa correzione, dovremmo osservare un significativo miglioramento della precisione. Mentre il modello viene addestrato, prendiamoci un momento per esplorare la documentazione di TensorFlow e conoscere i vari callback di Keras disponibili. Nel nostro caso, utilizzeremo il callback TensorBoard per interfacciarci con TensorBoard. Tuttavia, vale la pena notare che esistono altri callback utili, come l'arresto anticipato basato su parametri specifici, la pianificazione della velocità di apprendimento e il checkpoint del modello. Il checkpoint del modello è particolarmente utile quando si desidera salvare il modello a intervalli specifici, come la migliore perdita o l'accuratezza della convalida. Per ora, concentriamoci sulla richiamata di TensorBoard, ma in un video futuro potrei toccare brevemente altre richiamate.
Per utilizzare il callback di TensorBoard, dobbiamo importarlo dal modulo di callback Keras di TensorFlow. Aggiungi la seguente riga di codice per importare TensorBoard:
from tensorflow.keras.callbacks import TensorBoard
Ora che abbiamo importato il modulo necessario, eseguiamo alcune pulizie. È sempre consigliabile assegnare al modello un nome significativo, soprattutto quando si lavora con più modelli. In questo caso, possiamo nominare il nostro modello come "cats_vs_dogs_CNN_64x2". Inoltre, aggiungiamo un timestamp al nome per garantire l'univocità. L'inclusione del timestamp è utile quando si riaddestra un modello o si evita qualsiasi confusione con le versioni del modello. Quindi, all'inizio del nostro codice, definiamo il nome del modello e il timestamp come segue:
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
Inoltre, la tensor board ci consente di analizzare e ottimizzare i nostri modelli fornendo visualizzazioni del processo di addestramento. Si concentra principalmente su metriche quali accuratezza, accuratezza della convalida, perdita e perdita della convalida. Queste metriche ci aiutano a capire le prestazioni del nostro modello nel tempo e a identificare le aree di miglioramento. Mentre l'accuratezza e la perdita sono comunemente monitorate, la scheda tensor offre funzionalità più avanzate che potremmo esplorare in futuro.
Per iniziare a utilizzare la scheda tensore, dobbiamo prima fare una piccola aggiunta al nostro codice. Sebbene non sia cruciale per questo tutorial, vale la pena menzionarlo. Aggiungendo poche righe di codice, possiamo allocare una frazione specifica di memoria GPU per il nostro modello. Ciò è vantaggioso quando si eseguono più modelli contemporaneamente o quando si riscontrano problemi con la VRAM. Ci consente di controllare l'allocazione della GPU ed evitare potenziali arresti anomali o overflow della memoria. Nel nostro caso, allochiamo un terzo della GPU per il modello. Ciò garantisce un'esecuzione regolare e previene eventuali conflitti quando si lavora con altri modelli o progetti.
Andando avanti, concentriamoci sull'implementazione della scheda tensore. Innanzitutto, dobbiamo importare le dipendenze necessarie. Importiamo il modulo "tensorboard" dal pacchetto "tensorflow.keras.callbacks". Questo modulo fornisce la funzionalità di richiamata per la scheda tensore.
Successivamente, vogliamo assegnare un nome significativo al nostro modello. Assegnare a ciascun modello un nome distinto è essenziale quando si lavora con più modelli. Ci aiuta a tenere traccia degli esperimenti ed evitare qualsiasi confusione. In questo caso, chiamiamo il nostro modello "cat's_first_dog_CNN_64x2_good_enough". Inoltre, aggiungiamo un timestamp al nome utilizzando il valore dell'ora corrente. Ciò garantisce l'unicità e impedisce qualsiasi sovrascrittura accidentale dei modelli.
Dopo aver dato un nome al nostro modello, possiamo definire l'oggetto callback della tensor board. Creiamo un'istanza della classe "TensorBoard" e la assegniamo alla variabile "tensorboard". Passiamo il percorso della directory di log al costruttore. La directory dei log è dove la scheda tensor memorizzerà i log e i dati relativi al nostro modello. Utilizziamo la formattazione della stringa per includere il nome del modello nel percorso della directory del registro.
Una volta che abbiamo l'oggetto callback pronto, possiamo incorporarlo nel nostro processo di addestramento del modello. Nel metodo "fit" del nostro modello, passiamo l'oggetto callback al parametro "callbacks" come un elenco. In questo caso, abbiamo solo un callback, che è il callback della scheda tensor. Tuttavia, vale la pena notare che è possibile includere più richiamate nell'elenco, se necessario.
Con il callback integrato, ora possiamo addestrare il nostro modello. Impostiamo il numero di epoche su 10 per questo esempio. Tuttavia, sentiti libero di regolare il numero di epoche in base alle tue esigenze. Man mano che il modello viene addestrato, la scheda tensore inizierà a generare registri e visualizzazioni in base alle metriche specificate.
Per visualizzare la scheda tensore in azione, dobbiamo aprire la finestra di comando o il terminale e navigare nella directory contenente i file di registro. Una volta nella directory corretta, eseguiamo il comando tensor board digitando "tensorboard --logdir logs" nel prompt dei comandi. Questo comando avvia il server della scheda tensore e fornisce un URL locale in cui è possibile accedere all'interfaccia della scheda tensore.
Dopo aver avviato la scheda tensor, possiamo aprire un browser Web e inserire l'URL fornito dal prompt dei comandi. Questo mostrerà l'interfaccia della scheda tensore, dove possiamo visualizzare l'avanzamento dell'addestramento del nostro modello. L'interfaccia mostra vari grafici, tra cui l'accuratezza nel campione, la perdita nel campione, l'accuratezza fuori dal campione e la perdita fuori dal campione. Analizziamo queste metriche per monitorare le prestazioni del modello e prendere decisioni informate in merito alla sua ottimizzazione.
Osservando i grafici, possiamo identificare modelli e tendenze nel comportamento del modello. Ad esempio, se la perdita di convalida inizia ad aumentare mentre l'accuratezza della convalida rimane costante o diminuisce, indica overfitting. D'altra parte, se sia l'accuratezza della convalida che la perdita migliorano nel tempo, suggerisce che il modello sta imparando in modo efficace.
La scheda Tensor fornisce una potente piattaforma per l'analisi e l'ottimizzazione dei modelli. Le sue visualizzazioni offrono preziose informazioni sul processo di formazione e facilitano il processo decisionale. Sfruttando la tensor board, possiamo semplificare il processo di sviluppo del modello e ottenere risultati migliori.
Nella parte successiva di questa serie di tutorial, approfondiremo le funzionalità avanzate della scheda tensoriale, inclusi istogrammi, distribuzioni e incorporamenti. Queste funzionalità forniscono ulteriore granularità e ci consentono di ottenere una comprensione più completa dei nostri modelli. Resta sintonizzato per il prossimo video, in cui esploreremo queste entusiasmanti funzionalità.
Questo è tutto per questo tutorial. Grazie per aver guardato e ci vediamo nel prossimo video!
Ottimizzazione con TensorBoard - Deep Learning con Python, TensorFlow e Keras p.5
Ottimizzazione con TensorBoard - Deep Learning con Python, TensorFlow e Keras p.5
Salve a tutti e benvenuti alla quinta parte della serie di tutorial Deep Learning con Python TensorBoard e Keras. In questo tutorial, ci concentreremo su TensorBoard e su come possiamo usarlo per ottimizzare i modelli visualizzando diversi tentativi di modello. Immergiamoci dentro!
Innanzitutto, analizziamo il modello e identifichiamo gli aspetti che possiamo modificare per migliorarne le prestazioni. Sebbene il nostro modello attuale abbia raggiunto una precisione di circa il 79%, riteniamo di poter fare di meglio. Alcune potenziali aree di ottimizzazione includono l'ottimizzatore, il tasso di apprendimento, il numero di strati densi, le unità per strato, le unità di attivazione, le dimensioni del kernel, il passo, il tasso di decadimento e altro ancora. Con numerose opzioni da esplorare, potremmo finire per testare migliaia di modelli. Quindi, da dove iniziamo?
Per semplificare le cose, iniziamo con le modifiche più semplici. Ci concentreremo sulla regolazione del numero di strati, nodi per strato e se includere o meno uno strato denso alla fine. Per il numero di strati densi, considereremo zero, uno o due. Per quanto riguarda le dimensioni dei livelli, utilizzeremo i valori 32, 64 e 128. Questi valori sono solo convenzioni e puoi sceglierne di diversi in base alle tue preferenze.
Ora, implementiamo queste modifiche nel nostro codice. Definiremo alcune variabili per le scelte che vogliamo fare, come il numero di livelli densi e le dimensioni dei livelli. Esamineremo queste variabili per creare diverse combinazioni di modelli. Inoltre, creeremo un nome per ogni modello che ne rifletta la configurazione.
Una volta che abbiamo le configurazioni del modello, possiamo procedere ad applicarle nel nostro codice. Aggiorneremo la struttura del modello di conseguenza, considerando la forma di input, i livelli convoluzionali, i livelli densi e il livello di output. Ci assicureremo inoltre che le dimensioni del livello siano opportunamente regolate.
Con tutte le modifiche apportate, è il momento di eseguire il codice. Tuttavia, poiché l'addestramento di numerosi modelli può richiedere molto tempo, ho già eseguito il codice e salvato i risultati. Procediamo ad analizzare i risultati utilizzando TensorBoard.
Carichiamo i log di TensorBoard e osserviamo le diverse combinazioni di modelli. I modelli sono organizzati in base alle loro prestazioni, in particolare alla perdita di convalida. Ci concentriamo sui modelli con le migliori prestazioni e notiamo le loro configurazioni.
Dai risultati risulta evidente che i modelli con tre strati convoluzionali e zero strati densi si comportano costantemente bene. Il numero specifico di nodi per strato sembra meno significativo. Tuttavia, vale la pena notare che strati densi più grandi, come 512 o 256 nodi, potrebbero produrre risultati ancora migliori. Per verificarlo, puoi testare diverse dimensioni di strati densi.
Per riassumere, abbiamo iniziato esplorando varie configurazioni del modello utilizzando TensorBoard. Abbiamo scoperto che i modelli con tre strati convoluzionali e senza strati densi hanno funzionato costantemente bene. Abbiamo anche identificato che il numero di nodi per strato potrebbe essere ulteriormente ottimizzato. Testando diverse dimensioni di strati densi, possiamo potenzialmente migliorare ulteriormente la precisione del modello.
Tieni presente che questo è solo un punto di partenza e ci sono molti altri aspetti che puoi modificare per ottimizzare i tuoi modelli. TensorBoard fornisce uno strumento prezioso per visualizzare e analizzare queste variazioni del modello, aiutandoti a prendere decisioni informate per il miglioramento del modello.
Come usare il tuo modello addestrato - Nozioni di base sul Deep Learning con Python, TensorFlow e Keras p.6
Come usare il tuo modello addestrato - Nozioni di base sul Deep Learning con Python, TensorFlow e Keras p.6
Ciao a tutti e benvenuti alla Parte 6 della serie di tutorial Deep Learning in Python con TensorFlow e Keras!
In questo video, discuteremo di come utilizzare il nostro modello addestrato per fare previsioni su nuove immagini. Molte persone lo hanno chiesto, poiché hanno addestrato e testato con successo i loro set di dati, ma non sono sicuri di come utilizzare il modello per la previsione su immagini esterne. Quindi, tuffiamoci dentro!
Innanzitutto, dobbiamo importare le librerie necessarie. Importeremo cv2 per l'elaborazione delle immagini e tensorflow come TF per lavorare con il nostro modello. Avremo anche bisogno dell'elenco delle categorie, che contiene le etichette di classe "cane" e "gatto" che abbiamo usato durante l'addestramento.
Successivamente, definiremo una funzione chiamata prepare che accetta un percorso di file come parametro. Questa funzione gestirà i passaggi di pre-elaborazione richiesti per l'immagine di input. Ridimensioneremo l'immagine a una dimensione specifica e la convertiremo in scala di grigi. L'immagine verrà quindi restituita come un array numpy rimodellato.
Successivamente, caricheremo il nostro modello addestrato utilizzando la funzione TF.keras.models.load_model(). In precedenza, abbiamo salvato il nostro modello come "modello CNN 64 per 3", quindi lo caricheremo utilizzando lo stesso nome.
Ora siamo pronti a fare previsioni. Definiremo una variabile chiamata forecast e le assegneremo il risultato della chiamata a model.predict() sulla nostra immagine preparata. È importante notare che il metodo predict() prevede un elenco come input, anche se stiamo prevedendo su una singola immagine. Quindi, dobbiamo passare l'immagine preparata come un elenco.
Una volta ottenuto il risultato della previsione, possiamo stamparlo. Tuttavia, la previsione è attualmente sotto forma di un elenco nidificato. Per renderlo più leggibile, possiamo convertire il valore di previsione in un numero intero e usarlo come indice per recuperare l'etichetta di classe corrispondente dall'elenco delle categorie.
Infine, possiamo stampare l'etichetta della classe prevista, che indica se l'immagine è classificata come cane o gatto.
In questo tutorial, abbiamo utilizzato due immagini esterne per testare il nostro modello: una di un cane con un cono della vergogna e un'altra di una creatura sconosciuta. Queste immagini non facevano parte del nostro set di dati di addestramento, assicurando che stiamo facendo previsioni su dati invisibili.
Per provarlo con le tue immagini di cani e gatti, segui i passaggi descritti nel codice. Tieni presente che la precisione può variare, ma in media dovrebbe essere intorno all'80%.
È tutto per ora! Voglio ringraziare i nostri recenti sponsor: Michael, Nick, Rodrigo e Papasan E. Il vostro supporto è molto apprezzato. Se hai domande, commenti o suggerimenti per futuri tutorial, lasciali qui sotto. Sono anche aperto a idee per l'utilizzo di reti neurali ricorrenti, quindi se hai in mente un set di dati semplice, fammelo sapere.
Ci vediamo nel prossimo tutorial, dove esploreremo le reti neurali ricorrenti. Fino ad allora, buona programmazione!
Reti neurali ricorrenti (RNN) - Deep Learning con Python, TensorFlow e Keras p.7
Reti neurali ricorrenti (RNN) - Deep Learning con Python, TensorFlow e Keras p.7
Salve a tutti e benvenuti alla parte 7 della serie di tutorial Deep Learning con Python TensorFlow in Chaos. In questa parte, ci concentreremo sulla rete neurale ricorrente (RNN). Lo scopo di un RNN è catturare il significato e l'importanza dell'ordine dei dati. Ciò è particolarmente rilevante nei dati delle serie temporali, in cui i dati sono organizzati temporalmente, e nell'elaborazione del linguaggio naturale, in cui l'ordine delle parole in una frase ha un significato.
Per illustrare il concetto, consideriamo l'esempio di una frase: "Alcune persone hanno creato una rete neurale". Quando questa frase viene elaborata da una rete neurale profonda, che in genere tokenizza i dati suddividendoli in singole parole, la rete potrebbe non riuscire a catturare il significato corretto. Ad esempio, la frase "Una rete neurale ha creato alcune persone" ha un significato completamente diverso. Ciò sottolinea l'importanza dell'ordine delle parole nel determinare il significato di una frase.
Ora, approfondiamo il funzionamento di una rete neurale ricorrente. L'elemento costitutivo di base di un RNN è la cella ricorrente, che viene spesso implementata utilizzando una cella di memoria a lungo termine (LSTM). Sebbene esistano altre opzioni come l'unità ricorrente gated (GRU), la cella LSTM è comunemente usata. In un RNN, ogni cella accetta dati sequenziali come input e output al livello successivo o alla cella successiva nel livello ricorrente.
L'output di una cella può essere indirizzato in diversi modi. Può andare al livello successivo o alla cella successiva in modo unidirezionale o bidirezionale. In questo tutorial, ci concentreremo su un RNN unidirezionale di base. Per illustrare questo, immagina una casella verde che rappresenta una cella ricorrente. I dati della cella precedente entrano nella cella corrente, che esegue operazioni come dimenticare informazioni irrilevanti dal nodo precedente, incorporare nuovi dati di input e decidere quali informazioni inviare al livello o nodo successivo.
Per visualizzare meglio questo processo, consideriamo una cella specifica nel livello. La casella verde rappresenta la cella corrente. I dati fluiscono dalla cella precedente, vanno a capo ed entrano nella cella LSTM. All'interno della cella, ci sono operazioni per dimenticare le informazioni dal nodo precedente, incorporare nuovi dati di input e determinare l'output da passare al livello o nodo successivo. Queste operazioni consentono collettivamente alla cella LSTM di conservare informazioni importanti e di trasmetterle a livelli o nodi successivi.
L'implementazione di un RNN può essere complessa, soprattutto quando si tratta di valori scalari. Se sei interessato a una spiegazione dettagliata di come funzionano le celle LSTM, ti consiglio di consultare una guida completa che le spieghi in modo approfondito. Ho incluso un collegamento a questa guida nella versione testuale del tutorial come riferimento.
Passiamo ora alla costruzione di una rete neurale ricorrente di base. In questo tutorial, inizieremo con un semplice esempio utilizzando il set di dati M-NIST. Nel prossimo tutorial lavoreremo con dati di serie temporali più realistici, concentrandoci in particolare sui prezzi delle criptovalute.
Per iniziare, importiamo le librerie necessarie. Importeremo TensorFlow come tf, il modello Sequential da tensorflow.keras.models, il layer Dense da tensorflow.keras.layers, così come le celle Dropout e LSTM. Si noti che se si utilizza la versione GPU di TensorFlow, esiste anche una cella LSTM ottimizzata chiamata cella KU DNN LSTM. Tuttavia, per questo tutorial, ci atterremo alla normale cella LSTM. Se utilizzi la versione CPU di TensorFlow, il calcolo potrebbe richiedere molto tempo.
Successivamente, dobbiamo caricare il set di dati. Per questo esempio, utilizzeremo il set di dati M-NIST. Possiamo caricarlo facilmente usando la funzione tf.keras.datasets.mnist.load_data(), che restituisce i dati di addestramento e test. Decomprimiamo i dati in variabili: X_train, Y_train, X_test e Y_test.
Per prima cosa, normalizziamo i dati di input dividendo ogni valore di pixel per 255. In questo modo i valori dei pixel verranno ridimensionati in un intervallo compreso tra 0 e 1, adatto per l'addestramento della rete neurale. Possiamo raggiungere questo obiettivo dividendo sia i dati di addestramento che quelli di test per 255.
X_train = X_train / 255.0 X_test = X_test / 255.0
Successivamente, dobbiamo convertire le etichette target in vettori codificati one-hot. Nel set di dati M-NIST, le etichette sono numeri interi compresi tra 0 e 9, che rappresentano le cifre. La codifica one-hot converte ogni etichetta in un vettore binario di lunghezza 10, dove l'indice corrispondente alla cifra è impostato su 1 e tutti gli altri indici sono impostati su 0. Possiamo utilizzare la funzione to_categorical da tensorflow.keras.utils per eseguire una -codifica a caldo.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Ora definiamo l'architettura della nostra rete neurale ricorrente. Useremo il modello sequenziale da tensorflow.keras.models e vi aggiungeremo dei livelli.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Ora, compiliamo il modello specificando la funzione di perdita, l'ottimizzatore e la metrica di valutazione.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Infine, addestriamo il modello utilizzando i dati di addestramento e valutiamolo sui dati di test.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
Questo è tutto! Ora hai creato una rete neurale ricorrente utilizzando celle LSTM per il set di dati M-NIST. Puoi sperimentare diverse architetture, iperparametri e set di dati per esplorare ulteriormente le capacità degli RNN.
Introduzione all'RNN per la previsione delle criptovalute - Deep Learning con Python, TensorFlow e Keras p.8
Introduzione all'RNN per la previsione delle criptovalute - Deep Learning con Python, TensorFlow e Keras p.8
Ciao a tutti e benvenuti a un altro video tutorial di deep learning con Python. In questo video e in quelli successivi, parleremo di come applicare una rete neurale ricorrente (RNN) a un esempio più realistico di utilizzo di dati sequenziali. Nello specifico, lavoreremo con un set di dati di serie temporali costituito da prezzi e volumi per le criptovalute.
Prima di entrare nei dettagli, voglio chiarire che è possibile applicare gli stessi concetti ad altri tipi di dati sequenziali, come i prezzi delle azioni o i dati dei sensori. Quindi, anche se non sei interessato alla finanza, puoi comunque seguire e comprendere i concetti.
L'obiettivo di questo tutorial è utilizzare una rete neurale ricorrente per prevedere il prezzo futuro di una criptovaluta in base al prezzo e al volume passati. Ci concentreremo su quattro principali criptovalute: Bitcoin, Litecoin, Ethereum e Bitcoin Cash. L'idea è di prendere gli ultimi 60 minuti di dati di prezzo e volume per ciascuna di queste criptovalute e usarli come input per prevedere il prezzo di Litecoin, ad esempio, tre minuti nel futuro.
Questo tipo di problema di previsione può essere applicato anche ad altri domini, come la previsione dei guasti del server o del traffico del sito Web in base all'ora e ai dati di utilizzo. L'obiettivo finale è prevedere una classificazione (ad esempio, se il prezzo aumenterà o diminuirà) o eseguire una regressione (ad esempio, prevedere il prezzo effettivo o la variazione percentuale).
Lavorare con dati sequenziali presenta sfide uniche. In primo luogo, dobbiamo preelaborare i dati e convertirli in sequenze che la rete neurale ricorrente può gestire. Inoltre, dobbiamo bilanciare e normalizzare i dati, considerando che i prezzi e i volumi delle diverse criptovalute possono avere scale diverse. Il ridimensionamento dei dati è più complesso che in altri domini, come i dati delle immagini, dove dividiamo semplicemente per 255.
Inoltre, valutare le prestazioni del modello utilizzando dati fuori campione è una sfida diversa quando si lavora con dati sequenziali. Ci sono diversi aspetti che dobbiamo coprire, tra cui la preparazione dei dati, la normalizzazione e la valutazione.
Per iniziare, ti ho fornito un set di dati da scaricare. Puoi trovare il link per il download nella descrizione del tutorial. Una volta estratto il file zip scaricato, troverai quattro file, ciascuno corrispondente ai dati di prezzo e volume di una criptovaluta.
Useremo la libreria pandas in Python per leggere e manipolare il set di dati. Se non hai installato pandas, puoi farlo eseguendo il comando pip install pandas nel tuo terminale o prompt dei comandi.
Successivamente, leggeremo il set di dati utilizzando i panda ed esamineremo i dati. Ci concentreremo sulle colonne del prezzo e del volume di "chiusura" per ogni criptovaluta. Per unire i dati da file diversi, imposteremo la colonna "time" come indice per ogni dataframe. Quindi, uniremo i dataframe in base al loro indice condiviso.
Una volta che abbiamo il dataframe unito, dobbiamo definire alcuni parametri. Questi includono la lunghezza della sequenza (il numero di periodi passati da considerare), il periodo futuro (il numero di periodi nel futuro da prevedere) e il rapporto da prevedere (la criptovaluta che vogliamo prevedere).
Nel nostro caso, ci concentreremo sulla previsione del prezzo futuro di Litecoin (LTC) sulla base degli ultimi 60 minuti di dati e prediremo tre minuti nel futuro. Definiremo anche una regola di classificazione, in cui classifichiamo la previsione come aumento o diminuzione del prezzo in base ai prezzi attuali e futuri.
Una volta completati questi passaggi iniziali, siamo ora pronti per preelaborare i dati, creare sequenze e addestrare la rete neurale ricorrente. Tratteremo questi argomenti nei prossimi video, quindi rimanete sintonizzati.
Se vuoi continuare, assicurati di scaricare il set di dati e configurare le librerie richieste. Puoi trovare il codice completo e le istruzioni nella versione testuale del tutorial, disponibile nella descrizione.
Abbiamo molto da coprire, quindi lo classificheremo come 1, che indica un aumento del prezzo. Altrimenti, se il prezzo futuro è inferiore al prezzo attuale, lo classificheremo come 0, indicando un calo del prezzo. Questa è una semplice regola che utilizziamo per la classificazione, ma puoi sperimentare regole diverse o persino utilizzare la regressione per prevedere l'effettiva variazione di prezzo.
Ora, creiamo la colonna di destinazione nel nostro DataFrame principale. Useremo la funzione di spostamento da panda per spostare i valori della colonna "LTCUSD_close" entro il periodo futuro. Questo ci darà i prezzi futuri che confronteremo con i prezzi attuali per determinare la classificazione. Assegneremo il risultato a una nuova colonna chiamata "target".
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
Successivamente, creiamo le sequenze di input. Itereremo il DataFrame e creeremo sequenze di lunghezza sequence_length, costituite dai prezzi e dai volumi precedenti di Bitcoin, Litecoin, Ethereum e Bitcoin Cash. Memorizzeremo queste sequenze in un elenco chiamato "sequenze".
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Infine, convertiremo le sequenze e gli obiettivi in array numpy per una manipolazione e un addestramento più semplici.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Tieni presente che il codice qui fornito è un'implementazione parziale e si concentra sulle fasi di pre-elaborazione dei dati. Sarà necessario sviluppare ulteriormente l'architettura del modello, addestrare il modello e valutarne le prestazioni. Inoltre, potrebbe essere necessario regolare gli iperparametri e sperimentare tecniche diverse per migliorare la precisione del modello.
Ricordarsi di importare le librerie necessarie, gestire i dati mancanti, preelaborare le funzionalità (normalizzazione, ridimensionamento e così via) e suddividere i dati in set di addestramento e test prima di addestrare il modello.
Spero che questo ti aiuti a capire il processo di lavoro con dati sequenziali e l'applicazione di reti neurali ricorrenti per prevedere i prezzi futuri. Buona fortuna con il tuo progetto di deep learning!