Serie storica - Guida rapida

Una serie temporale è una sequenza di osservazioni su un determinato periodo. Una serie temporale univariata è costituita dai valori presi da una singola variabile in istanze temporali periodiche in un periodo e una serie temporale multivariata è costituita dai valori presi da più variabili nelle stesse istanze temporali periodiche in un periodo. L'esempio più semplice di una serie temporale che tutti noi incontriamo giorno per giorno è il cambiamento di temperatura nel corso della giornata, della settimana, del mese o dell'anno.

L'analisi dei dati temporali è in grado di fornirci utili spunti su come una variabile cambia nel tempo, o su come dipende dal cambiamento dei valori di altre variabili. Questa relazione di una variabile sui suoi valori precedenti e / o altre variabili può essere analizzata per la previsione di serie temporali e ha numerose applicazioni nell'intelligenza artificiale.

Una conoscenza di base di qualsiasi linguaggio di programmazione è essenziale per un utente per lavorare o sviluppare problemi di apprendimento automatico. Di seguito viene fornito un elenco dei linguaggi di programmazione preferiti per chiunque desideri lavorare sull'apprendimento automatico:

Pitone

È un linguaggio di programmazione interpretato di alto livello, veloce e facile da codificare. Python può seguire paradigmi di programmazione procedurali o orientati agli oggetti. La presenza di una varietà di librerie rende più semplice l'implementazione di procedure complicate. In questo tutorial, codificheremo in Python e le librerie corrispondenti utili per la modellazione di serie temporali saranno discusse nei prossimi capitoli.

R

Simile a Python, R è un linguaggio multi-paradigma interpretato, che supporta il calcolo statistico e la grafica. La varietà di pacchetti semplifica l'implementazione della modellazione di machine learning in R.

Giava

È un linguaggio di programmazione orientato agli oggetti interpretato, ampiamente famoso per un'ampia gamma di disponibilità di pacchetti e sofisticate tecniche di visualizzazione dei dati.

C / C ++

Questi sono linguaggi compilati e due dei linguaggi di programmazione più vecchi. Questi linguaggi sono spesso preferiti per incorporare funzionalità ML nelle applicazioni già esistenti in quanto consentono di personalizzare facilmente l'implementazione degli algoritmi ML.

MATLAB

MATrix LABoratory è un linguaggio multi-paradigma che consente di lavorare con le matrici. Consente operazioni matematiche per problemi complessi. Viene utilizzato principalmente per operazioni numeriche, ma alcuni pacchetti consentono anche la simulazione grafica multi-dominio e la progettazione basata su modelli.

Altri linguaggi di programmazione preferiti per problemi di apprendimento automatico includono JavaScript, LISP, Prolog, SQL, Scala, Julia, SAS ecc.

Python ha una consolidata popolarità tra le persone che eseguono l'apprendimento automatico grazie alla sua struttura del codice facile da scrivere e di facile comprensione, nonché a un'ampia varietà di librerie open source. Alcune di queste librerie open source che useremo nei prossimi capitoli sono state introdotte di seguito.

NumPy

Numerical Python è una libreria utilizzata per il calcolo scientifico. Funziona su un oggetto array N-dimensionale e fornisce funzionalità matematiche di base come dimensione, forma, media, deviazione standard, minimo, massimo e alcune funzioni più complesse come le funzioni algebriche lineari e la trasformata di Fourier. Imparerai di più su questi mentre andiamo avanti in questo tutorial.

Panda

Questa libreria fornisce strutture dati altamente efficienti e di facile utilizzo come serie, dataframe e pannelli. Ha migliorato le funzionalità di Python dalla semplice raccolta e preparazione dei dati all'analisi dei dati. Le due librerie, Pandas e NumPy, rendono molto semplice qualsiasi operazione su dataset da piccoli a molto grandi. Per saperne di più su queste funzioni, segui questo tutorial.

SciPy

Science Python è una libreria utilizzata per il calcolo scientifico e tecnico. Fornisce funzionalità per l'ottimizzazione, l'elaborazione di segnali e immagini, l'integrazione, l'interpolazione e l'algebra lineare. Questa libreria è utile durante l'esecuzione del machine learning. Discuteremo queste funzionalità mentre andiamo avanti in questo tutorial.

Scikit Learn

Questa libreria è uno SciPy Toolkit ampiamente utilizzato per la modellazione statistica, l'apprendimento automatico e l'apprendimento profondo, poiché contiene vari modelli di regressione, classificazione e clustering personalizzabili. Funziona bene con Numpy, Pandas e altre librerie che lo rendono più facile da usare.

Statsmodels

Come Scikit Learn, questa libreria viene utilizzata per l'esplorazione dei dati statistici e la modellazione statistica. Funziona bene anche con altre librerie Python.

Matplotlib

Questa libreria viene utilizzata per la visualizzazione dei dati in vari formati come grafico a linee, grafico a barre, mappe termiche, grafici a dispersione, istogramma, ecc. Contiene tutte le funzionalità relative ai grafici richieste dalla stampa all'etichettatura. Discuteremo queste funzionalità mentre andiamo avanti in questo tutorial.

Queste librerie sono molto essenziali per iniziare con l'apprendimento automatico con qualsiasi tipo di dati.

Oltre a quelle discusse sopra, un'altra libreria particolarmente significativa per trattare le serie temporali è:

Appuntamento

Questa libreria, con i suoi due moduli - datetime e calendar, fornisce tutte le funzionalità datetime necessarie per leggere, formattare e manipolare il tempo.

Useremo queste librerie nei prossimi capitoli.

Time Series è una sequenza di osservazioni indicizzate in intervalli di tempo equidistanti. Pertanto, l'ordine e la continuità dovrebbero essere mantenuti in qualsiasi serie temporale.

Il set di dati che utilizzeremo è una serie temporale multi-variata con dati orari per circa un anno, per la qualità dell'aria in una città italiana significativamente inquinata. Il set di dati può essere scaricato dal link indicato di seguito -https://archive.ics.uci.edu/ml/datasets/air+quality.

È necessario assicurarsi che:

La serie temporale è equamente spaziata e
Non ci sono valori ridondanti o lacune in esso.

Nel caso in cui la serie temporale non sia continua, possiamo sovracampionarla o sottocampionarla.

Mostra df.head ()

In [122]:

import pandas

In [123]:

df = pandas.read_csv("AirQualityUCI.csv", sep = ";", decimal = ",")
df = df.iloc[ : , 0:14]

In [124]:

len(df)

Fuori [124]:

In [125]:

df.head()

Fuori [125]:

Per la preelaborazione delle serie temporali, ci assicuriamo che non ci siano valori NaN (NULL) nel set di dati; se ci sono, possiamo sostituirli con 0 o valori medi o precedenti o successivi. La sostituzione è una scelta preferita rispetto all'eliminazione in modo da mantenere la continuità delle serie temporali. Tuttavia, nel nostro set di dati gli ultimi pochi valori sembrano essere NULL e quindi la caduta non influirà sulla continuità.

Eliminazione di NaN (non un numero)

In [126]:

df.isna().sum()
Out[126]:
Date             114
Time             114
CO(GT)           114
PT08.S1(CO)      114
NMHC(GT)         114
C6H6(GT)         114
PT08.S2(NMHC)    114
NOx(GT)          114
PT08.S3(NOx)     114
NO2(GT)          114
PT08.S4(NO2)     114
PT08.S5(O3)      114
T                114
RH               114
dtype: int64

In [127]:

df = df[df['Date'].notnull()]

In [128]:

df.isna().sum()

Fuori [128]:

Date             0
Time             0
CO(GT)           0
PT08.S1(CO)      0
NMHC(GT)         0
C6H6(GT)         0
PT08.S2(NMHC)    0
NOx(GT)          0
PT08.S3(NOx)     0
NO2(GT)          0
PT08.S4(NO2)     0
PT08.S5(O3)      0
T                0
RH               0
dtype: int64

Le serie storiche vengono solitamente tracciate come grafici a linee rispetto al tempo. Per questo ora combineremo la colonna data e ora e la convertiremo in un oggetto datetime da stringhe. Ciò può essere eseguito utilizzando la libreria datetime.

Conversione in oggetto datetime

In [129]:

df['DateTime'] = (df.Date) + ' ' + (df.Time)
print (type(df.DateTime[0]))

<class 'str'>

In [130]:

import datetime

df.DateTime = df.DateTime.apply(lambda x: datetime.datetime.strptime(x, '%d/%m/%Y %H.%M.%S'))
print (type(df.DateTime[0]))

Vediamo come alcune variabili come la temperatura cambiano con il cambiamento nel tempo.

Mostra trame

In [131]:

df.index = df.DateTime

In [132]:

import matplotlib.pyplot as plt
plt.plot(df['T'])

Fuori [132]:

[<matplotlib.lines.Line2D at 0x1eaad67f780>]

In [208]:

plt.plot(df['C6H6(GT)'])

Fuori [208]:

[<matplotlib.lines.Line2D at 0x1eaaeedff28>]

I box-plot sono un altro tipo utile di grafici che consentono di condensare molte informazioni su un set di dati in un unico grafico. Mostra la media, il 25% e il 75% del quartile e i valori anomali di una o più variabili. Nel caso in cui il numero di valori anomali sia ridotto ed è molto distante dalla media, possiamo eliminare i valori anomali impostandoli sul valore medio o sul valore del quartile del 75%.

Mostra boxplots

In [134]:

plt.boxplot(df[['T','C6H6(GT)']].values)

Fuori [134]:

{'whiskers': [<matplotlib.lines.Line2D at 0x1eaac16de80>,
   <matplotlib.lines.Line2D at 0x1eaac16d908>,
   <matplotlib.lines.Line2D at 0x1eaac177a58>,
   <matplotlib.lines.Line2D at 0x1eaac177cf8>],
   'caps': [<matplotlib.lines.Line2D at 0x1eaac16d2b0>,
   <matplotlib.lines.Line2D at 0x1eaac16d588>,
   <matplotlib.lines.Line2D at 0x1eaac1a69e8>,
   <matplotlib.lines.Line2D at 0x1eaac1a64a8>],
   'boxes': [<matplotlib.lines.Line2D at 0x1eaac16dc50>,
   <matplotlib.lines.Line2D at 0x1eaac1779b0>],
   'medians': [<matplotlib.lines.Line2D at 0x1eaac16d4a8>,
   <matplotlib.lines.Line2D at 0x1eaac1a6c50>],
   'fliers': [<matplotlib.lines.Line2D at 0x1eaac177dd8>,
   <matplotlib.lines.Line2D at 0x1eaac1a6c18>],'means': []
}

introduzione

Una serie temporale ha 4 componenti come indicato di seguito:

Level - È il valore medio attorno al quale varia la serie.
Trend - È il comportamento crescente o decrescente di una variabile nel tempo.
Seasonality - È il comportamento ciclico delle serie temporali.
Noise - È l'errore nelle osservazioni aggiunte dovuto a fattori ambientali.

Tecniche di modellazione delle serie storiche

Per acquisire questi componenti, sono disponibili numerose tecniche di modellazione di serie storiche diffuse. Questa sezione fornisce una breve introduzione di ciascuna tecnica, tuttavia ne discuteremo in dettaglio nei prossimi capitoli:

Metodi naïve

Si tratta di semplici tecniche di stima, ad esempio al valore previsto viene assegnato il valore uguale alla media dei valori precedenti della variabile dipendente dal tempo o il valore effettivo precedente. Questi vengono utilizzati per il confronto con sofisticate tecniche di modellazione.

Regressione automatica

La regressione automatica prevede i valori dei periodi di tempo futuri in funzione dei valori dei periodi di tempo precedenti. Le previsioni di regressione automatica possono adattarsi ai dati meglio di quelle dei metodi naïve, ma potrebbero non essere in grado di spiegare la stagionalità.

Modello ARIMA

Una media mobile integrata auto-regressiva modella il valore di una variabile come una funzione lineare dei valori precedenti e degli errori residui nelle fasi temporali precedenti di una serie temporale stazionaria. Tuttavia, i dati del mondo reale possono essere non stazionari e avere una stagionalità, quindi sono stati sviluppati ARIMA stagionale e ARIMA frazionaria. ARIMA lavora su serie storiche univariate, per gestire più variabili è stato introdotto VARIMA.

Livellamento esponenziale

Modella il valore di una variabile come funzione lineare ponderata esponenziale dei valori precedenti. Questo modello statistico può gestire anche trend e stagionalità.

LSTM

Il modello LSTM (Long Short-Term Memory) è una rete neurale ricorrente utilizzata per le serie temporali per tenere conto delle dipendenze a lungo termine. Può essere addestrato con una grande quantità di dati per catturare le tendenze in serie temporali multi-variate.

Le suddette tecniche di modellazione vengono utilizzate per la regressione delle serie temporali. Nei prossimi capitoli, esploriamo ora tutti questi uno per uno.

introduzione

Qualsiasi modello statistico o di apprendimento automatico ha alcuni parametri che influenzano notevolmente il modo in cui i dati vengono modellati. Ad esempio, ARIMA ha valori p, d, q. Questi parametri devono essere decisi in modo tale che l'errore tra i valori effettivi e quelli modellati sia minimo. Si dice che la calibrazione dei parametri sia l'attività più cruciale e dispendiosa in termini di tempo per l'adattamento del modello. Quindi, è molto essenziale per noi scegliere i parametri ottimali.

Metodi per la calibrazione dei parametri

Esistono vari modi per calibrare i parametri. Questa sezione parla di alcuni di essi in dettaglio.

Hit-and-try

Un modo comune per calibrare i modelli è la calibrazione manuale, in cui si inizia visualizzando le serie temporali e provando intuitivamente alcuni valori dei parametri e modificandoli più e più volte fino a ottenere un adattamento sufficientemente buono. Richiede una buona comprensione del modello che stiamo provando. Per il modello ARIMA, la calibrazione della mano viene eseguita con l'aiuto del grafico di auto-correlazione per il parametro 'p', il grafico di auto-correlazione parziale per il parametro 'q' e il test ADF per confermare la stazionarietà delle serie temporali e l'impostazione del parametro 'd' . Discuteremo tutto questo in dettaglio nei prossimi capitoli.

Grid Search

Un altro modo per calibrare i modelli è la ricerca sulla griglia, il che significa essenzialmente provare a costruire un modello per tutte le possibili combinazioni di parametri e selezionare quello con il minimo errore. Ciò richiede tempo e quindi è utile quando il numero di parametri da calibrare e l'intervallo di valori che assumono sono inferiori poiché ciò comporta più cicli for nidificati.

Algoritmo genetico

L'algoritmo genetico funziona sul principio biologico che una buona soluzione alla fine evolverà verso la soluzione più "ottimale". Utilizza operazioni biologiche di mutazione, cross-over e selezione per arrivare finalmente ad una soluzione ottimale.

Per ulteriori informazioni è possibile leggere altre tecniche di ottimizzazione dei parametri come l'ottimizzazione bayesiana e l'ottimizzazione Swarm.

introduzione

Metodi naïve come presumere che il valore previsto al tempo "t" sia il valore effettivo della variabile al tempo "t-1" o la media mobile delle serie, vengono utilizzati per valutare il rendimento dei modelli statistici e dei modelli di apprendimento automatico e sottolineare il loro bisogno.

In questo capitolo, proviamo questi modelli su una delle caratteristiche dei nostri dati di serie temporali.

Per prima cosa vedremo la media della caratteristica "temperatura" dei nostri dati e la deviazione attorno ad essa. È anche utile vedere i valori di temperatura massimi e minimi. Possiamo usare le funzionalità della libreria numpy qui.

Visualizzazione delle statistiche

In [135]:

import numpy
print (
   'Mean: ',numpy.mean(df['T']), '; 
   Standard Deviation: ',numpy.std(df['T']),'; 
   \nMaximum Temperature: ',max(df['T']),'; 
   Minimum Temperature: ',min(df['T'])
)

Abbiamo le statistiche per tutte le 9357 osservazioni su una linea temporale equidistanziata che ci sono utili per comprendere i dati.

Ora proveremo il primo metodo ingenuo, impostando il valore previsto al momento uguale al valore effettivo della volta precedente e calcolando l'errore quadratico medio (RMSE) per quantificare le prestazioni di questo metodo.

Mostra il ^primo metodo ingenuo

In [136]:

df['T']
df['T_t-1'] = df['T'].shift(1)

In [137]:

df_naive = df[['T','T_t-1']][1:]

In [138]:

from sklearn import metrics
from math import sqrt

true = df_naive['T']
prediction = df_naive['T_t-1']
error = sqrt(metrics.mean_squared_error(true,prediction))
print ('RMSE for Naive Method 1: ', error)

RMSE per il metodo ingenuo 1: 12.901140576492974

Vediamo il prossimo metodo ingenuo, in cui il valore previsto al momento attuale è equiparato alla media dei periodi di tempo che lo precedono. Calcoleremo l'RMSE anche per questo metodo.

Mostra il 2 ^° metodo ingenuo

In [139]:

df['T_rm'] = df['T'].rolling(3).mean().shift(1)
df_naive = df[['T','T_rm']].dropna()

In [140]:

true = df_naive['T']
prediction = df_naive['T_rm']
error = sqrt(metrics.mean_squared_error(true,prediction))
print ('RMSE for Naive Method 2: ', error)

RMSE for Naive Method 2: 14.957633272839242

Qui puoi sperimentare vari numeri di periodi di tempo precedenti chiamati anche "ritardi" che desideri considerare, che qui vengono mantenuti come 3. In questi dati si può vedere che all'aumentare del numero di ritardi e di errori aumenta. Se il ritardo viene mantenuto 1, diventa lo stesso del metodo ingenuo utilizzato in precedenza.

Points to Note

È possibile scrivere una funzione molto semplice per calcolare l'errore quadratico medio della radice. Qui, abbiamo usato la funzione di errore quadratico medio dal pacchetto 'sklearn' e quindi abbiamo preso la sua radice quadrata.
In pandas df ['column_name'] può anche essere scritto come df.column_name, tuttavia per questo set di dati df.T non funzionerà come df ['T'] perché df.T è la funzione per trasporre un dataframe. Quindi usa solo df ['T'] o considera la possibilità di rinominare questa colonna prima di usare l'altra sintassi.

Per una serie temporale stazionaria, un modello di regressione automatica vede il valore di una variabile al tempo "t" come una funzione lineare dei valori "p" che lo precedono. Matematicamente può essere scritto come -

$$y_{t} = \:C+\:\phi_{1}y_{t-1}\:+\:\phi_{2}Y_{t-2}+...+\phi_{p}y_{t-p}+\epsilon_{t}$$

Dove, "p" è il parametro di tendenza auto-regressivo

$\epsilon_{t}$ è rumore bianco, e

$y_{t-1}, y_{t-2}\:\: ...y_{t-p}$ denotano il valore della variabile in periodi di tempo precedenti.

Il valore di p può essere calibrato utilizzando vari metodi. Un modo per trovare il valore apt di 'p' è tracciare il grafico di autocorrelazione.

Note- Dobbiamo separare i dati in train e test con un rapporto 8: 2 dei dati totali disponibili prima di eseguire qualsiasi analisi sui dati perché i dati di test servono solo a scoprire l'accuratezza del nostro modello e l'ipotesi è che non sono disponibili per noi fino a dopo che sono state fatte le previsioni. In caso di serie temporali, la sequenza dei punti dati è molto essenziale, quindi è necessario tenere presente di non perdere l'ordine durante la suddivisione dei dati.

Un grafico di autocorrelazione o un correlogramma mostra la relazione di una variabile con se stessa nelle fasi temporali precedenti. Utilizza la correlazione di Pearson e mostra le correlazioni all'interno dell'intervallo di confidenza del 95%. Vediamo come appare per la variabile 'temperatura' dei nostri dati.

Mostra ACP

In [141]:

split = len(df) - int(0.2*len(df))
train, test = df['T'][0:split], df['T'][split:]

In [142]:

from statsmodels.graphics.tsaplots import plot_acf

plot_acf(train, lags = 100)
plt.show()

Si presume che tutti i valori di ritardo che si trovano al di fuori della regione blu ombreggiata abbiano una correlazione cs.

Per una serie temporale stazionaria, un modello a media mobile vede il valore di una variabile al tempo "t" come una funzione lineare degli errori residui dai passi temporali "q" che lo precedono. L'errore residuo viene calcolato confrontando il valore al momento "t" con la media mobile dei valori precedenti.

Matematicamente può essere scritto come -

$$y_{t} = c\:+\:\epsilon_{t}\:+\:\theta_{1}\:\epsilon_{t-1}\:+\:\theta_{2}\:\epsilon_{t-2}\:+\:...+:\theta_{q}\:\epsilon_{t-q}\:$$

Dove "q" è il parametro di tendenza della media mobile

$\epsilon_{t}$ è rumore bianco, e

$\epsilon_{t-1}, \epsilon_{t-2}...\epsilon_{t-q}$ sono i termini di errore in periodi di tempo precedenti.

Il valore di "q" può essere calibrato utilizzando vari metodi. Un modo per trovare il valore apt di 'q' è tracciare il grafico di autocorrelazione parziale.

Un grafico di autocorrelazione parziale mostra la relazione di una variabile con se stessa nelle fasi temporali precedenti con le correlazioni indirette rimosse, a differenza del grafico di autocorrelazione che mostra le correlazioni dirette e indirette, vediamo come appare per la variabile 'temperatura' del nostro dati.

Mostra PACP

In [143]:

from statsmodels.graphics.tsaplots import plot_pacf

plot_pacf(train, lags = 100)
plt.show()

Un'autocorrelazione parziale viene letta allo stesso modo di un correlogramma.

Abbiamo già capito che per una serie temporale stazionaria una variabile al tempo "t" è una funzione lineare di osservazioni precedenti o errori residui. Quindi è tempo per noi di combinare i due e avere un modello di media mobile auto-regressiva (ARMA).

Tuttavia, a volte la serie temporale non è stazionaria, cioè le proprietà statistiche di una serie come la media, la varianza cambia nel tempo. E i modelli statistici che abbiamo studiato finora presumono che le serie temporali siano stazionarie, quindi, possiamo includere una fase di pre-elaborazione di differenziare le serie temporali per renderle stazionarie. Ora, è importante per noi scoprire se le serie temporali di cui abbiamo a che fare sono stazionarie o meno.

Vari metodi per trovare la stazionarietà di una serie temporale cercano la stagionalità o l'andamento nel grafico delle serie temporali, controllando la differenza di media e varianza per vari periodi di tempo, test Augmented Dickey-Fuller (ADF), test KPSS, esponente di Hurst ecc .

Vediamo se la variabile "temperatura" del nostro set di dati è una serie temporale stazionaria o meno utilizzando il test ADF.

In [74]:

from statsmodels.tsa.stattools import adfuller

result = adfuller(train)
print('ADF Statistic: %f' % result[0])
print('p-value: %f' % result[1])
print('Critical Values:')
for key, value In result[4].items()
   print('\t%s: %.3f' % (key, value))

Statistica ADF: -10.406056

valore p: 0,000000

Valori critici:

1%: -3,431

5%: -2,862

10%: -2,567

Ora che abbiamo eseguito il test ADF, interpretiamo il risultato. Per prima cosa confronteremo la statistica ADF con i valori critici, un valore critico più basso ci dice che la serie è molto probabilmente non stazionaria. Successivamente, vediamo il valore p. Un valore p maggiore di 0,05 suggerisce anche che la serie temporale non è stazionaria.

In alternativa, il valore p inferiore o uguale a 0,05 o la statistica ADF inferiore ai valori critici suggeriscono che la serie temporale è stazionaria.

Quindi, la serie temporale di cui abbiamo a che fare è già stazionaria. In caso di serie temporali stazionarie, impostiamo il parametro "d" a 0.

Possiamo anche confermare la stazionarietà delle serie temporali usando l'esponente di Hurst.

In [75]:

import hurst

H, c,data = hurst.compute_Hc(train)
print("H = {:.4f}, c = {:.4f}".format(H,c))

H = 0,1660, c = 5,0740

Il valore di H <0,5 mostra un comportamento anti-persistente e H> 0,5 mostra un comportamento persistente o una serie di trend. H = 0,5 mostra la camminata casuale / il moto browniano. Il valore di H <0,5, a conferma che la nostra serie è stazionaria.

Per le serie temporali non stazionarie, impostiamo il parametro "d" come 1. Inoltre, il valore del parametro di tendenza auto-regressivo "p" e il parametro di tendenza della media mobile "q", viene calcolato sulle serie temporali stazionarie, cioè tracciando ACP e PACP dopo aver differenziato le serie temporali.

Il modello ARIMA, che è caratterizzato da 3 parametri, (p, d, q) ci sono ora chiari, quindi modelliamo le nostre serie temporali e prevediamo i valori futuri della temperatura.

In [156]:

from statsmodels.tsa.arima_model import ARIMA

model = ARIMA(train.values, order=(5, 0, 2))
model_fit = model.fit(disp=False)

In [157]:

predictions = model_fit.predict(len(test))
test_ = pandas.DataFrame(test)
test_['predictions'] = predictions[0:1871]

In [158]:

plt.plot(df['T'])
plt.plot(test_.predictions)
plt.show()

In [167]:

error = sqrt(metrics.mean_squared_error(test.values,predictions[0:1871]))
print ('Test RMSE for ARIMA: ', error)

Test RMSE per ARIMA: 43.21252940234892

Nel capitolo precedente, abbiamo ora visto come funziona il modello ARIMA e le sue limitazioni di non poter gestire dati stagionali o serie temporali multivariate e, quindi, sono stati introdotti nuovi modelli per includere queste funzionalità.

Uno scorcio di questi nuovi modelli è dato qui -

Regressione automatica vettoriale (VAR)

È una versione generalizzata del modello di regressione automatica per serie temporali stazionarie multivariate. È caratterizzato dal parametro "p".

Media mobile vettoriale (VMA)

È una versione generalizzata del modello della media mobile per serie temporali stazionarie multivariate. È caratterizzato dal parametro "q".

Media mobile di regressione automatica vettoriale (VARMA)

È la combinazione di VAR e VMA e una versione generalizzata del modello ARMA per serie temporali stazionarie multivariate. È caratterizzato dai parametri "p" e "q". In modo molto simile, ARMA è in grado di agire come un modello AR impostando il parametro 'q' come 0 e come modello MA impostando il parametro 'p' come 0, VARMA è anche in grado di agire come un modello VAR impostando il parametro 'q' come 0 e come modello VMA impostando il parametro 'p' come 0.

In [209]:

df_multi = df[['T', 'C6H6(GT)']]
split = len(df) - int(0.2*len(df))
train_multi, test_multi = df_multi[0:split], df_multi[split:]

In [211]:

from statsmodels.tsa.statespace.varmax import VARMAX

model = VARMAX(train_multi, order = (2,1))
model_fit = model.fit()
c:\users\naveksha\appdata\local\programs\python\python37\lib\site-packages\statsmodels\tsa\statespace\varmax.py:152: 
   EstimationWarning: Estimation of VARMA(p,q) models is not generically robust, 
   due especially to identification issues. 
   EstimationWarning)
c:\users\naveksha\appdata\local\programs\python\python37\lib\site-packages\statsmodels\tsa\base\tsa_model.py:171: 
   ValueWarning: No frequency information was provided, so inferred frequency H will be used. 
  % freq, ValueWarning)
c:\users\naveksha\appdata\local\programs\python\python37\lib\site-packages\statsmodels\base\model.py:508: 
   ConvergenceWarning: Maximum Likelihood optimization failed to converge. Check mle_retvals 
  "Check mle_retvals", ConvergenceWarning)

In [213]:

predictions_multi = model_fit.forecast( steps=len(test_multi))
c:\users\naveksha\appdata\local\programs\python\python37\lib\site-packages\statsmodels\tsa\base\tsa_model.py:320: 
   FutureWarning: Creating a DatetimeIndex by passing range endpoints is deprecated.  Use `pandas.date_range` instead.
   freq = base_index.freq)
c:\users\naveksha\appdata\local\programs\python\python37\lib\site-packages\statsmodels\tsa\statespace\varmax.py:152: 
   EstimationWarning: Estimation of VARMA(p,q) models is not generically robust, due especially to identification issues.
   EstimationWarning)

In [231]:

plt.plot(train_multi['T'])
plt.plot(test_multi['T'])
plt.plot(predictions_multi.iloc[:,0:1], '--')
plt.show()

plt.plot(train_multi['C6H6(GT)'])
plt.plot(test_multi['C6H6(GT)'])
plt.plot(predictions_multi.iloc[:,1:2], '--')
plt.show()

Il codice sopra mostra come il modello VARMA può essere utilizzato per modellare serie temporali multivariate, sebbene questo modello potrebbe non essere più adatto ai nostri dati.

VARMA con variabili esogene (VARMAX)

È un'estensione del modello VARMA in cui vengono utilizzate variabili extra chiamate covariate per modellare la variabile primaria che ci interessa.

Media mobile stagionale integrata con regressione automatica (SARIMA)

Questa è l'estensione del modello ARIMA per gestire i dati stagionali. Divide i dati in componenti stagionali e non stagionali e li modella in modo simile. È caratterizzato da 7 parametri, per i parametri della parte non stagionale (p, d, q) come per il modello ARIMA e per i parametri della parte stagionale (P, D, Q, m) dove 'm' è il numero di periodi stagionali e P, D, Q sono simili ai parametri del modello ARIMA. Questi parametri possono essere calibrati utilizzando la ricerca sulla griglia o l'algoritmo genetico.

SARIMA con variabili esogene (SARIMAX)

Questa è l'estensione del modello SARIMA per includere variabili esogene che ci aiutano a modellare la variabile che ci interessa.

Può essere utile fare un'analisi di correlazione sulle variabili prima di metterle come variabili esogene.

In [251]:

from scipy.stats.stats import pearsonr
x = train_multi['T'].values
y = train_multi['C6H6(GT)'].values

corr , p = pearsonr(x,y)
print ('Corelation Coefficient =', corr,'\nP-Value =',p)
Corelation Coefficient = 0.9701173437269858
P-Value = 0.0

La correlazione di Pearson mostra una relazione lineare tra 2 variabili, per interpretare i risultati, prima guardiamo il valore p, se è inferiore a 0,05 allora il valore del coefficiente è significativo, altrimenti il valore del coefficiente non è significativo. Per un valore p significativo, un valore positivo del coefficiente di correlazione indica una correlazione positiva e un valore negativo indica una correlazione negativa.

Quindi, per i nostri dati, "temperatura" e "C6H6" sembrano avere una correlazione altamente positiva. Pertanto, lo faremo

In [297]:

from statsmodels.tsa.statespace.sarimax import SARIMAX

model = SARIMAX(x, exog = y, order = (2, 0, 2), seasonal_order = (2, 0, 1, 1), enforce_stationarity=False, enforce_invertibility = False)
model_fit = model.fit(disp = False)
c:\users\naveksha\appdata\local\programs\python\python37\lib\site-packages\statsmodels\base\model.py:508: 
   ConvergenceWarning: Maximum Likelihood optimization failed to converge. Check mle_retvals
   "Check mle_retvals", ConvergenceWarning)

In [298]:

y_ = test_multi['C6H6(GT)'].values
predicted = model_fit.predict(exog=y_)
test_multi_ = pandas.DataFrame(test)
test_multi_['predictions'] = predicted[0:1871]

In [299]:

plt.plot(train_multi['T'])
plt.plot(test_multi_['T'])
plt.plot(test_multi_.predictions, '--')

Fuori [299]:

[<matplotlib.lines.Line2D at 0x1eab0191c18>]

Le previsioni qui sembrano prendere variazioni maggiori ora rispetto alla modellazione ARIMA univariata.

Inutile dire che SARIMAX può essere utilizzato come modello ARX, MAX, ARMAX o ARIMAX impostando solo i parametri corrispondenti su valori diversi da zero.

Media mobile integrata frazionaria auto regressiva (FARIMA)

A volte, può accadere che la nostra serie non sia stazionaria, ma la differenza con il parametro 'd' che assume il valore 1 può sovrascriverlo. Quindi, dobbiamo differenziare le serie temporali utilizzando un valore frazionario.

Nel mondo della scienza dei dati non esiste un modello superiore, il modello che funziona sui tuoi dati dipende molto dal tuo set di dati. La conoscenza di vari modelli ci consente di sceglierne uno che funzioni sui nostri dati e di sperimentare con quel modello per ottenere i migliori risultati. E i risultati dovrebbero essere visti come grafici e metriche di errore, a volte anche un piccolo errore può essere negativo, quindi tracciare e visualizzare i risultati è essenziale.

Nel prossimo capitolo esamineremo un altro modello statistico, il livellamento esponenziale.

In questo capitolo parleremo delle tecniche coinvolte nel livellamento esponenziale delle serie temporali.

Livellamento esponenziale semplice

Il livellamento esponenziale è una tecnica per smussare le serie temporali univariate assegnando pesi decrescenti esponenzialmente ai dati in un periodo di tempo.

Matematicamente, il valore della variabile al tempo 't + 1' dato il valore al tempo t, y_ (t + 1 | t) è definito come -

$$y_{t+1|t}\:=\:\alpha y_{t}\:+\:\alpha\lgroup1 -\alpha\rgroup y_{t-1}\:+\alpha\lgroup1-\alpha\rgroup^{2}\:y_{t-2}\:+\:...+y_{1}$$

dove,$0\leq\alpha \leq1$ è il parametro di levigatura e

$y_{1},....,y_{t}$ sono i valori precedenti del traffico di rete ai tempi 1, 2, 3,…, t.

Questo è un metodo semplice per modellare una serie temporale senza una chiara tendenza o stagionalità. Ma il livellamento esponenziale può essere utilizzato anche per le serie temporali con tendenza e stagionalità.

Triplo livellamento esponenziale

Il metodo Triple Exponential Smoothing (TES) o Holt's Winter applica il livellamento esponenziale tre volte - livellamento del livello $l_{t}$, attenuazione della tendenza $b_{t}$e levigatura stagionale $S_{t}$, con $\alpha$, $\beta^{*}$ e $\gamma$ come parametri di levigatura con 'm' come frequenza della stagionalità, cioè il numero di stagioni in un anno.

A seconda della natura della componente stagionale, TES ha due categorie:

Holt-Winter's Additive Method - Quando la stagionalità è di natura additiva.
Holt-Winter’s Multiplicative Method - Quando la stagionalità è di natura moltiplicativa.

Per le serie temporali non stagionali, abbiamo solo il livellamento della tendenza e il livellamento del livello, chiamato metodo di tendenza lineare di Holt.

Proviamo ad applicare il triplo livellamento esponenziale ai nostri dati.

In [316]:

from statsmodels.tsa.holtwinters import ExponentialSmoothing

model = ExponentialSmoothing(train.values, trend= )
model_fit = model.fit()

In [322]:

predictions_ = model_fit.predict(len(test))

In [325]:

plt.plot(test.values)
plt.plot(predictions_[1:1871])

Fuori [325]:

[<matplotlib.lines.Line2D at 0x1eab00f1cf8>]

Qui, abbiamo addestrato il modello una volta con il set di addestramento e poi continuiamo a fare previsioni. Un approccio più realistico consiste nel riaddestrare il modello dopo una o più fasi temporali. Quando otteniamo la previsione per il tempo 't + 1' dai dati di allenamento 'til time' t ', la prossima previsione per il tempo' t + 2 'può essere effettuata utilizzando i dati di allenamento' til time 't + 1' come valore effettivo il valore a 't + 1' sarà quindi noto. Questa metodologia di fare previsioni per uno o più passaggi futuri e quindi riaddestrare il modello è chiamata previsione a rotazione o convalida in avanti.

Nella modellazione delle serie temporali, le previsioni nel tempo diventano sempre meno accurate e quindi è un approccio più realistico riqualificare il modello con dati effettivi man mano che diventano disponibili per ulteriori previsioni. Poiché l'addestramento dei modelli statistici non richiede tempo, la convalida diretta è la soluzione preferita per ottenere risultati più accurati.

Applichiamo la convalida di un passo avanti ai nostri dati e confrontiamoli con i risultati ottenuti in precedenza.

In [333]:

prediction = []
data = train.values
for t In test.values:
   model = (ExponentialSmoothing(data).fit())
   y = model.predict()
   prediction.append(y[0])
   data = numpy.append(data, t)

In [335]:

test_ = pandas.DataFrame(test)
test_['predictionswf'] = prediction

In [341]:

plt.plot(test_['T'])
plt.plot(test_.predictionswf, '--')
plt.show()

In [340]:

error = sqrt(metrics.mean_squared_error(test.values,prediction))
print ('Test RMSE for Triple Exponential Smoothing with Walk-Forward Validation: ', error)
Test RMSE for Triple Exponential Smoothing with Walk-Forward Validation:  11.787532205759442

Possiamo vedere che il nostro modello funziona notevolmente meglio ora. In effetti, il trend è seguito così da vicino che sulla trama le previsioni si sovrappongono ai valori effettivi. Puoi provare ad applicare la convalida walk-forward anche sui modelli ARIMA.

Nel 2017, Facebook ha reso open source il modello del profeta che era in grado di modellare le serie temporali con forti stagionalità multiple a livello di giorno, a livello di settimana, a livello di anno ecc. E di tendenza. Ha parametri intuitivi che un data scientist non esperto può sintonizzare per previsioni migliori. Fondamentalmente, è un modello regressivo additivo in grado di rilevare i punti di cambiamento per modellare le serie temporali.

Prophet scompone le serie temporali in componenti di tendenza $g_{t}$, stagionalità $S_{t}$ e vacanze $h_{t}$.

$$y_{t}=g_{t}+s_{t}+h_{t}+\epsilon_{t}$$

Dove, $\epsilon_{t}$ è il termine di errore.

Pacchetti simili per la previsione di serie temporali come l'impatto causale e il rilevamento delle anomalie sono stati introdotti in R rispettivamente da Google e Twitter.

Ora, abbiamo familiarità con la modellazione statistica sulle serie temporali, ma l'apprendimento automatico è di gran moda in questo momento, quindi è essenziale avere familiarità anche con alcuni modelli di apprendimento automatico. Inizieremo con il modello più popolare nel dominio delle serie temporali: il modello di memoria a lungo termine.

LSTM è una classe di reti neurali ricorrenti. Quindi, prima di poter passare a LSTM, è essenziale comprendere le reti neurali e le reti neurali ricorrenti.

Reti neurali

Una rete neurale artificiale è una struttura a strati di neuroni connessi, ispirata alle reti neurali biologiche. Non è un algoritmo ma combinazioni di vari algoritmi che ci consente di eseguire operazioni complesse sui dati.

Reti neurali ricorrenti

È una classe di reti neurali su misura per gestire i dati temporali. I neuroni di RNN hanno uno stato / memoria cellulare e l'input viene elaborato in base a questo stato interno, che si ottiene con l'aiuto di loop nella rete neurale. Ci sono moduli ricorrenti di strati "tanh" negli RNN che consentono loro di conservare le informazioni. Tuttavia, non per molto tempo, motivo per cui abbiamo bisogno dei modelli LSTM.

LSTM

È un tipo speciale di rete neurale ricorrente in grado di apprendere le dipendenze a lungo termine nei dati. Ciò si ottiene perché il modulo ricorrente del modello ha una combinazione di quattro strati che interagiscono tra loro.

L'immagine sopra mostra quattro livelli di rete neurale in riquadri gialli, operatori puntuali in cerchi verdi, input in cerchi gialli e stato della cella in cerchi blu. Un modulo LSTM ha uno stato della cella e tre porte che fornisce loro il potere di apprendere, disimparare o conservare selettivamente le informazioni da ciascuna delle unità. Lo stato della cella in LSTM aiuta le informazioni a fluire attraverso le unità senza essere alterate, consentendo solo poche interazioni lineari. Ogni unità ha un ingresso, un'uscita e una porta dimentica che può aggiungere o rimuovere le informazioni dallo stato della cella. Il dimenticare gate decide quali informazioni dallo stato della cella precedente devono essere dimenticate per cui utilizza una funzione sigmoide. La porta di ingresso controlla il flusso di informazioni allo stato corrente della cella utilizzando un'operazione di moltiplicazione puntiforme di "sigmoide" e "tanh" rispettivamente. Infine, il gate di output decide quali informazioni devono essere passate al successivo stato nascosto

Ora che abbiamo compreso il funzionamento interno del modello LSTM, implementiamolo. Per comprendere l'implementazione di LSTM, inizieremo con un semplice esempio: una linea retta. Vediamo se LSTM può apprendere la relazione di una linea retta e prevederla.

Per prima cosa creiamo il set di dati raffigurante una linea retta.

In [402]:

x = numpy.arange (1,500,1)
y = 0.4 * x + 30
plt.plot(x,y)

Fuori [402]:

[<matplotlib.lines.Line2D at 0x1eab9d3ee10>]

In [403]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

Ora che i dati sono stati creati e suddivisi in training e test. Convertiamo i dati delle serie temporali nella forma di dati di apprendimento supervisionato in base al valore del periodo di ricerca, che è essenzialmente il numero di ritardi che si vedono per prevedere il valore al tempo "t".

Quindi una serie temporale come questa -

time variable_x
t1  x1
t2  x2
 :   :
 :   :
T   xT

Quando il periodo di ricerca è 1, viene convertito in -

x1   x2
x2   x3
 :    :
 :    :
xT-1 xT

In [404]:

def create_dataset(n_X, look_back):
   dataX, dataY = [], []
   for i in range(len(n_X)-look_back):
      a = n_X[i:(i+look_back), ]
      dataX.append(a)
      dataY.append(n_X[i + look_back, ])
   return numpy.array(dataX), numpy.array(dataY)

In [405]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)

trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Ora addestreremo il nostro modello.

Piccoli batch di dati di addestramento vengono mostrati in rete, un'esecuzione di quando i dati di addestramento interi vengono mostrati al modello in batch e viene calcolato l'errore viene chiamata epoca. Le epoche devono essere eseguite finché l'errore non si riduce.

In [ ]:

from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(256, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(128,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic1.h5')

In [407]:

model.load_weights('LSTMBasic1.h5')
predict = model.predict(testx)

Ora vediamo come sono le nostre previsioni.

In [408]:

plt.plot(testx.reshape(398,2)[:,0:1], testx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Fuori [408]:

[<matplotlib.lines.Line2D at 0x1eac792f048>]

Ora, dovremmo provare a modellare un'onda seno o coseno in modo simile. Puoi eseguire il codice fornito di seguito e giocare con i parametri del modello per vedere come cambiano i risultati.

In [409]:

x = numpy.arange (1,500,1)
y = numpy.sin(x)
plt.plot(x,y)

Fuori [409]:

[<matplotlib.lines.Line2D at 0x1eac7a0b3c8>]

In [410]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

In [411]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)
trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

In [ ]:

model = Sequential()
model.add(LSTM(512, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(256,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic2.h5')

In [413]:

model.load_weights('LSTMBasic2.h5')
predict = model.predict(testx)

In [415]:

plt.plot(trainx.reshape(398,2)[:,0:1], trainx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Fuori [415]:

[<matplotlib.lines.Line2D at 0x1eac7a1f550>]

Ora sei pronto per passare a qualsiasi set di dati.

Per noi è importante quantificare le prestazioni di un modello per utilizzarlo come feedback e confronto. In questo tutorial abbiamo utilizzato uno dei più popolari errori quadratici medi della radice della metrica. Sono disponibili varie altre metriche di errore. Questo capitolo li discute in breve.

Errore quadratico medio

È la media del quadrato della differenza tra i valori previsti e i valori reali. Sklearn lo fornisce come una funzione. Ha le stesse unità dei valori vero e previsto al quadrato ed è sempre positivo.

$$MSE = \frac{1}{n} \displaystyle\sum\limits_{t=1}^n \lgroup y'_{t}\:-y_{t}\rgroup^{2}$$

Dove $y'_{t}$ è il valore previsto,

$y_{t}$ è il valore effettivo e

n è il numero totale di valori nel set di test.

È chiaro dall'equazione che MSE è più penalizzante per errori più grandi o valori anomali.

Root Mean Square Error

È la radice quadrata dell'errore quadratico medio. Inoltre è sempre positivo e rientra nell'intervallo dei dati.

$$RMSE = \sqrt{\frac{1}{n} \displaystyle\sum\limits_{t=1}^n \lgroup y'_{t}-y_{t}\rgroup ^2}$$

Dove, $y'_{t}$ è il valore previsto

$y_{t}$ è il valore effettivo e

n è il numero totale di valori nel set di test.

È nel potere dell'unità e quindi è più interpretabile rispetto a MSE. RMSE è anche più penalizzante per errori più grandi. Abbiamo utilizzato la metrica RMSE nel nostro tutorial.

Errore assoluto medio

È la media della differenza assoluta tra i valori previsti e i valori reali. Ha le stesse unità del valore previsto e reale ed è sempre positivo.

$$MAE = \frac{1}{n}\displaystyle\sum\limits_{t=1}^{t=n} | y'{t}-y_{t}\lvert$$

Dove, $y'_{t}$ è il valore previsto,

$y_{t}$ è il valore effettivo e

n è il numero totale di valori nel set di test.

Errore percentuale medio

È la percentuale della media della differenza assoluta tra i valori previsti e i valori reali, divisa per il valore reale.

$$MAPE = \frac{1}{n}\displaystyle\sum\limits_{t=1}^n\frac{y'_{t}-y_{t}}{y_{t}}*100\: \%$$

Dove, $y'_{t}$ è il valore previsto,

$y_{t}$ è il valore effettivo e n è il numero totale di valori nel set di test.

Tuttavia, lo svantaggio dell'utilizzo di questo errore è che l'errore positivo e gli errori negativi possono compensarsi a vicenda. Quindi viene utilizzato l'errore percentuale medio assoluto.

Errore percentuale medio assoluto

È la percentuale della media della differenza assoluta tra i valori previsti e i valori reali, divisa per il valore reale.

$$MAPE = \frac{1}{n}\displaystyle\sum\limits_{t=1}^n\frac{|y'_{t}-y_{t}\lvert}{y_{t}}*100\: \%$$

Dove $y'_{t}$ è il valore previsto

$y_{t}$ è il valore effettivo e

n è il numero totale di valori nel set di test.

Abbiamo discusso dell'analisi delle serie temporali in questo tutorial, che ci ha permesso di capire che i modelli delle serie temporali riconoscono prima la tendenza e la stagionalità dalle osservazioni esistenti e quindi prevedono un valore basato su questa tendenza e stagionalità. Tale analisi è utile in vari campi come:

Financial Analysis - Include previsioni di vendita, analisi dell'inventario, analisi del mercato azionario, stima dei prezzi.
Weather Analysis - Include la stima della temperatura, il cambiamento climatico, il riconoscimento del cambiamento stagionale, le previsioni del tempo.
Network Data Analysis - Include previsione dell'utilizzo della rete, rilevamento di anomalie o intrusioni, manutenzione predittiva.
Healthcare Analysis - Include la previsione del censimento, la previsione delle prestazioni assicurative, il monitoraggio dei pazienti.

L'apprendimento automatico si occupa di vari tipi di problemi. In effetti, quasi tutti i campi hanno uno scopo per essere automatizzati o migliorati con l'aiuto dell'apprendimento automatico. Di seguito sono riportati alcuni di questi problemi su cui si sta lavorando molto.

Dati di serie temporali

Questi sono i dati che cambiano in base al tempo, e quindi il tempo gioca un ruolo cruciale in esso, che abbiamo ampiamente discusso in questo tutorial.

Dati non di serie storiche

Sono i dati indipendenti dal tempo e una percentuale maggiore dei problemi di machine learning riguarda dati non di serie temporali. Per semplicità, lo classificheremo ulteriormente come:

Numerical Data - I computer, a differenza degli esseri umani, comprendono solo numeri, quindi tutti i tipi di dati alla fine vengono convertiti in dati numerici per l'apprendimento automatico, ad esempio i dati dell'immagine vengono convertiti in valori (r, b, g), i caratteri vengono convertiti in codici o parole ASCII sono indicizzati in numeri, i dati vocali vengono convertiti in file mfcc contenenti dati numerici.
Image Data - La visione artificiale ha rivoluzionato il mondo dei computer, ha varie applicazioni nel campo della medicina, delle immagini satellitari, ecc.
Text Data- Natural Language Processing (NLP) viene utilizzato per la classificazione del testo, il rilevamento delle parafrasi e il riepilogo del linguaggio. Questo è ciò che rende intelligenti Google e Facebook.
Speech Data- L'elaborazione del parlato implica il riconoscimento vocale e la comprensione del sentimento. Svolge un ruolo cruciale nel conferire ai computer le qualità simili a quelle umane.