Prevedere i dati di borsa con Cassandra e TensorFlow

Prev. dati borsa con Cassandra e TensorFlow

Lo scenario che questo blog coprirà è una previsione in serie temporale di un prezzo specifico delle azioni. Il problema stesso è molto comune e ampiamente conosciuto. Detto questo, questa è una dimostrazione tecnologica e non è in alcun modo intesa come consulenza di mercato. Lo scopo della dimostrazione è mostrare come Astra e TensorFlow possano lavorare insieme per fare previsioni in serie temporale. Il primo passo è impostare il tuo database.

Ottenere dati di test

Ora che hai il database, le credenziali e il file bundle sulla tua macchina, assicurati di ottenere i dati necessari per eseguire questo tutorial. Questi dati sono open source e disponibili su molte piattaforme. Una delle quali è la piattaforma Kaggle, dove le persone hanno già fatto il lavoro di raccogliere questi dati tramite API.

Ecco il link a quei dati.

Un’altra fonte che può adattarsi a questo problema è il set di dati di Tesla, che è anche aperto su GitHub.

• ChatGPT arricchito da GenAI Una guida all’efficace ingegneria delle richieste
• Feature Store Summit 2023 Strategie pratiche per il deployment dei modelli di Machine Learning in ambienti di produzione
• Come diventare un data scientist negli Stati Uniti?

L’opzione più semplice, che consigliamo anche noi, è clonare il nostro repository Github (che comunque copriremo), dove abbiamo aggiunto anche dati di esempio per permetterti di iniziare subito con il codice.

Ora, passiamo subito al codice!

Codice per il tutorial

Il codice per questo tutorial può essere trovato sotto il link del nostro repository su GitHub. Se sei già familiare con Git e JupyterLabs, vai avanti e clona e riesegui i passaggi del notebook usando Git clone.

La readme sul repository dovrebbe anche avere tutti i dettagli necessari per iniziare con quel codice.

Utilizzando il repository

In questa sezione, ci assicuriamo di coprire alcuni dei passaggi che dovrai seguire per completare il tutorial e mettere in evidenza alcuni dei dettagli necessari.

Dopo aver clonato il codice, naviga nella directory del progetto e inizia installando le dipendenze (nota che se stai utilizzando il metodo di distribuzione di GitPod, questo avverrà automaticamente) utilizzando il seguente comando:

pip install -r requirements.txt

Nota che la versione di Python utilizzata in questo esempio è la 3.10.11, quindi assicurati di avere quella installata o assicurati di creare un ambiente virtuale utilizzando pyenv (quello che funziona meglio per te).

Installazione di Jupyter[Lab]

Ultimo ma non meno importante, prima di passare all’esecuzione del codice, assicurati di avere Jupyter installato sulla tua macchina. Puoi farlo eseguendo il comando sottostante.

pip install jupyterlab

Nota che qui stiamo installando JupyterLab, che è una versione più avanzata dei notebook Jupyter. Offre molte funzionalità oltre ai notebook tradizionali.

Una volta installato, digita jupyter-lab nel terminale. Dovrebbe aprire una finestra nel tuo browser elencando il contenuto della tua directory di lavoro. Se ti trovi nella directory clonata, dovresti vedere il notebook e dovresti essere in grado di seguire i passaggi.

Se non si avvia automaticamente, puoi accedere al server JupyterLabs facendo clic sui URL nel tuo terminale:

Ora che hai eseguito il comando Jupyter dalla tua directory di lavoro, dovresti vedere l’albero del progetto nel tuo browser e navigare nei file. Prima di tutto, assicuriamoci di configurare i segreti prima di iniziare a scrivere il codice, quindi assicurati di aprire il file local_secrets.py e compilare i dettagli forniti/estratti dal sito web di AstraDB dopo aver impostato i dettagli del database.

Ora possiamo passare al notebook. Iniziamo leggendo i dati e memorizzandoli in AstraDB.

Memorizzare i dati in AstraDB

Questo passaggio non fa altro che dimostrare il fatto che puoi utilizzare AstraDB per fornire dati ai tuoi modelli. AstraDB è, prima di tutto, un database potente e scalabile. I dati devono essere memorizzati da qualche parte e che tu sia già su Astra o Cassandra o che tu stia iniziando con gli strumenti, questo tutorial ti mostra quanto sia facile utilizzare Astra per il tuo backend.

È facile utilizzare il linguaggio CQL per creare una tabella e caricare i dati di esempio di questo tutorial al suo interno. La logica dovrebbe essere la seguente:

Una volta completato il passaggio precedente, leggiamo nuovamente i dati e assicuriamoci di ordinarli come un problema di previsione in serie temporale. Questo è un passaggio di gestione dei dati per assicurarsi che i dati siano ordinati per la serie.

Utilizza il codice qui sotto per leggere i dati per la tua serie temporale e prepararli per l’uso da parte di TensorFlow:

Analisi dei dati

Ora possiamo scrivere del codice per comprendere e analizzare i dati utilizzando dei grafici. Ad esempio, il grafico sottostante mostra i prezzi di apertura e chiusura del titolo (il prezzo all’apertura e alla chiusura del mercato) nel periodo di 4 anni tra il 2016 e il 2020.

Puoi trovare altri grafici nel notebook che descrivono altri fattori e analizzano le fluttuazioni dei prezzi nel tempo.

Passiamo ora alla costruzione del modello stesso.

Costruzione del modello

In questo esempio, utilizzeremo un modello LSTM (o Long Short Term Model), un modello di deep learning noto per la sua capacità di riconoscere i pattern nei dati, che funziona bene con il problema che stiamo dimostrando.

È anche importante notare che utilizzeremo Keras (un’API di deep learning per Python) come backend per il nostro esempio con TensorFlow. Il modello è composto da 2 strati LSTM: uno strato denso, uno strato di dropout e infine, un altro strato denso.

Un altro aspetto importante da notare è la normalizzazione e la scalatura dei dati.

Le prestazioni del modello sono molto sensibili alla scala e alla variazione dei valori effettivi dei dati; quindi, è cruciale normalizzare i dati e trasformarli in un intervallo o una distribuzione coerenti. Abbiamo utilizzato uno dei scalers più popolari nell’apprendimento automatico, il min-max scaler per la normalizzazione dei dati. Abbiamo anche implementato la suddivisione dei dati in set di allenamento e di test.

In questo caso, e per il bene della dimostrazione, abbiamo utilizzato il 95% dei dati per l’allenamento, il resto per il test.

Una volta completata la trasformazione e la configurazione dei dati e del modello, possiamo avviare la fase di fit, nota anche come fase di addestramento.

Utilizzo dei dati

Una volta addestrato il modello con i dati di allenamento, potrai utilizzarlo per effettuare una previsione delle serie temporali.

Eseguendo il seguente comando verranno generati i dati previsti:

predictions = model.predict(x_test)

Ma nota che poiché abbiamo scalato i nostri valori utilizzando il nostro minMaxScaler, le previsioni generate in questo punto sono tutte all’interno dell’intervallo di scalatura e per riportarli alla scala originale, dovremo invertire ciò che abbiamo fatto con TensorFlow; farlo è semplice come eseguire la seguente riga di codice.

predictions = scaler.inverse_transform(predictions)

Il grafico seguente mostra l’evoluzione dei dati di allenamento nel tempo, così come il confronto tra test e previsione generati dal nostro modello.

Notare i diversi colori nella parte destra del grafico. Il colore arancione è il sottoinsieme di test dei dati effettivi. La linea verde rappresenta il prezzo delle azioni previsto. In questo caso, la nostra previsione ha fatto un buon lavoro nel prevedere il calo del prezzo delle azioni. La linea delle previsioni è l’esito principale di qualsiasi previsione.

Nota che per questo problema di regressione, abbiamo utilizzato anche alcune metriche di valutazione del modello. MSE e RMSE sono state utilizzate a tal fine, di seguito è riportato il frammento di codice corrispondente alla loro implementazione:

# metriche di valutazione

mse = np.mean(((previsioni - y_test) ** 2))

rmse = np.sqrt(mse)

Archiviazione del modello

Passiamo ora all’archiviazione del modello. In questa sezione, interagiremo nuovamente con il nostro database AstraDB e, più specificamente, archivieremo il modello e le metriche di errore in una tabella. Abbiamo scelto una struttura semplice per questo scopo di visibilità.

Lo schema della tabella è il seguente:

I dati del modello stesso verranno archiviati come un blob; per fare ciò, dovremo prendere i dati del nostro modello, convertirli in JSON e quindi archiviarli nella nostra tabella. Il codice sottostante descrive come puoi farlo facilmente:

Ora che abbiamo archiviato i dati del nostro modello, possiamo scrivere della logica per recuperarli nuovamente per scopi diversi. Possiamo caricare il modello, servirlo ed eseguire delle previsioni in tempo reale oppure possiamo anche ricaricarlo ed eseguire il modello su dati in batch per eseguire delle previsioni in batch.

Lettura del modello

Ecco il codice che consente di leggere il modello. In base alle esigenze, è possibile eseguire uno qualsiasi degli approcci di previsione.

Possiamo anche dare un’occhiata al riepilogo del modello e assicurarci che corrisponda esattamente a ciò che abbiamo addestrato e archiviato in precedenza:

loaded_model.summary()

Dovresti vedere qualcosa del genere:

E sei arrivato alla fine di questo tutorial!

Mentre concludiamo questo blog, hai imparato come interagire con AstraDB e usarlo come fonte degli artefatti e dei dati del tuo modello.

Conclusioni

In questo blog, abbiamo esplorato la potente combinazione di TensorFlow e AstraDB. Durante il tutorial, abbiamo coperto passi essenziali come la configurazione dell’ambiente, l’installazione delle dipendenze necessarie e l’integrazione di TensorFlow con AstraDB. Abbiamo esplorato come eseguire attività comuni come l’ingestione dei dati, la pre-elaborazione e l’addestramento del modello utilizzando l’ampia libreria di funzioni di TensorFlow. Inoltre, abbiamo discusso come il design flessibile dello schema di AstraDB e le potenti capacità di interrogazione consentono il recupero e la manipolazione efficiente dei dati.

Combattendo TensorFlow e AstraDB, gli sviluppatori possono sbloccare un mondo di possibilità per la creazione di applicazioni avanzate di machine learning. Dall’analisi dei dati su larga scala alle previsioni in tempo reale, questa potente coppia ci permette di costruire sistemi intelligenti capaci di gestire enormi quantità di dati e fornire risultati accurati.