I problemi di regressione e classificazione probabilistica possono essere risolti utilizzando il processo gaussiano (GP), una tecnica di apprendimento supervisionato. Poiché ogni processo gaussiano può essere pensato come una generalizzazione multivariata a dimensione infinita Distribuzioni gaussiane , nel nome compare il termine gaussiano. Discuteremo dei processi gaussiani per la regressione in questo post, noto anche come regressione del processo gaussiano (GPR). Numerosi problemi del mondo reale nei campi della scienza dei materiali, della chimica, della fisica e della biologia sono stati risolti con l'uso del GPR.
Tabella dei contenuti
- Regressione del processo gaussiano (GPR)
- Concetti chiave della regressione del processo gaussiano (GPR)
- Concetto matematico di regressione del processo gaussiano (GPR)
- Implementazione del processo gaussiano in Python
Regressione del processo gaussiano (GPR)
La regressione del processo gaussiano (GPR) è una tecnica di regressione non parametrica potente e flessibile utilizzata in apprendimento automatico E statistiche . È particolarmente utile quando si affrontano problemi che coinvolgono dati continui, dove la relazione tra variabili di input e output non è esplicitamente nota o può essere complessa. GPR è un approccio bayesiano in grado di modellare la certezza nelle previsioni, rendendolo uno strumento prezioso per varie applicazioni, tra cui l'ottimizzazione, la previsione di serie temporali e altro ancora. Il GPR si basa sul concetto di processo gaussiano, che è una raccolta di variabili casuali, qualsiasi numero finito delle quali ha una distribuzione gaussiana congiunta. Un processo gaussiano può essere pensato come una distribuzione di funzioni.
Concetti chiave della regressione del processo gaussiano (GPR)
Processo di Gaussain
Un modello probabilistico non parametrico chiamato a Processo gaussiano (GP) è utilizzato nelle statistiche e nell'apprendimento automatico per la regressione, la classificazione e la quantificazione dell'incertezza. Rappresenta un gruppo di variabili casuali, ciascuna delle quali ha una distribuzione gaussiana congiunta e può avere un numero finito. I GP sono una tecnica versatile ed efficace per modellare relazioni complesse tra i dati e produrre previsioni con relativa incertezza.
Caratteristiche dei processi gaussiani :
- Natura non parametrica : I medici di base possono adattarsi alla complessità dei dati perché non si basano su un numero prestabilito di parametri del modello
- Previsioni probabilistiche : Le previsioni dei medici di base possono essere quantificate perché forniscono previsioni come distribuzioni di probabilità.
- Interpolazione e livellamento : I GP sono utili per dati rumorosi o campionati in modo irregolare perché sono efficaci nel livellamento dei dati rumorosi e nell'interpolazione tra i punti dati.
- Emarginazione degli iperparametri : Eliminando la necessità di una modifica esplicita degli iperparametri, emarginano gli iperparametri, rendendo il modello più semplice.
Funzione media
Il valore previsto della funzione modellata in ciascun punto di input è rappresentato da funzione media nei processi gaussiani (GP). Funziona come una presunzione fondamentale per quanto riguarda la struttura dei dati sottostante. La funzione media è spesso impostata su zero per impostazione predefinita, non necessariamente, e può essere modificata in base alle proprietà dei dati o alle competenze del settore. Influenzando la tendenza centrale delle previsioni, aiuta i medici di medicina generale a identificare modelli o tendenze nei dati. I GP forniscono previsioni probabilistiche che contengono incertezza e stime puntuali includendo la funzione media
Funzione di covarianza (kernel).
IL funzione di covarianza , denominata anche funzione kernel, misura quanto simili sono tra loro i punti dati di input nei processi gaussiani (GP). È essenziale per caratterizzare il comportamento del modello GP, influenzando la selezione delle funzioni dalla distribuzione precedente. La funzione di covarianza misura le somiglianze a coppie per accertare la correlazione tra i valori della funzione. I GP possono adattarsi a un'ampia gamma di modelli di dati, da tendenze uniformi a strutture complesse, poiché diverse funzioni del kernel catturano diversi tipi di correlazioni. Le prestazioni del modello possono essere notevolmente influenzate dalla selezione del kernel.
Distribuzioni precedenti
IL distribuzione preventiva , nei processi gaussiani (GP), è la nostra comprensione delle funzioni prima dell'osservazione di qualsiasi dato. Di solito è descritto da una funzione di covarianza (nucleo) e da una funzione media. Mentre la funzione di covarianza descrive la somiglianza o la correlazione tra i valori della funzione in vari punti di input, la funzione media codifica le nostre precedenti aspettative. Questo viene utilizzato in anticipo dai medici di base per creare una distribuzione sulle funzioni. Nei GP, i valori a priori possono essere selezionati per rappresentare l'incertezza dei dati, integrare la conoscenza del dominio o indicare la fluidità.
Distribuzioni posteriori
Processi gaussiani distribuzione successiva mostra le nostre ipotesi riviste sulle funzioni in seguito all'osservazione dei dati. Mette insieme la verosimiglianza dei dati data la funzione e la distribuzione precedente. Il posteriore nella regressione GP offre una distribuzione sulle funzioni che corrispondono maggiormente ai dati osservati. Consentendo previsioni probabilistiche e quantificazione dell'incertezza, la distribuzione a posteriori riflette il compromesso tra le convinzioni precedenti memorizzate nella distribuzione a priori e le informazioni fornite dai dati.
Concetto matematico di regressione del processo gaussiano (GPR)
Per le attività di regressione viene utilizzato un modello probabilistico e non parametrico di apprendimento automatico denominato regressione del processo gaussiano (GP). Quando si modellano interazioni complesse e ambigue tra variabili di input e output, è uno strumento potente. Si presuppone una distribuzione gaussiana multivariata per produrre i punti dati nella regressione GP e l'obiettivo è dedurre questa distribuzione.
Il modello di regressione GP ha la seguente espressione matematica. Supponiamo x1, X2,…..,XNsono i punti dati di input, dove x appartengono a numeri reali (-2,-1,0,1…), (xio
Supponiamo che y1, E2,……., ENsono i valori di output, dove yioappartiene al numero reale (yio
Il modello di regressione GP presuppone che un processo gaussiano con una funzione media (
Quindi, in un insieme di posizioni test x*, la distribuzione di f è data da:
In genere, le funzioni del kernel vengono utilizzate per definire la funzione media e la funzione di covarianza. A titolo illustrativo, il kernel esponenziale quadrato che viene spesso utilizzato è descritto come:
errore: impossibile trovare o caricare la classe principale
Dove,
k(x_{i}, x_{j}) = La funzione del kernel è rappresentata da questo e calcola la correlazione o la somiglianza tra due punti dati di input, xioe xJ.sigma^2 = Il parametro di varianza del kernel è questo. Stabilisce la scala o la diffusione verticale della funzione kernel. Regola la forza con cui i punti dati sono correlati. Un più altosigma^2 produce una funzione del kernel con maggiore varianza.- exp: la funzione esponenziale è responsabile dell'elevazione di e alla potenza dell'argomentazione.
||x_{i} – x_{j}||^2 : La differenza tra i punti dati di input, xioe xJ, è la distanza euclidea quadrata. Viene misurata la separazione geometrica tra i punti nello spazio delle caratteristiche.- l2: Questa è una rappresentazione della scala di lunghezza del kernel o lunghezza caratteristica. Regola la velocità con cui la funzione del kernel si deteriora quando i punti dati sono più distanti. Un valore l inferiore fa sì che il kernel si degradi più velocemente.
Il modello di regressione GP applica l'inferenza bayesiana per determinare la distribuzione di f che con maggiore probabilità ha prodotto i dati dato un insieme di dati di addestramento (x, y). Per fare ciò è necessario calcolare la distribuzione a posteriori di f dati i dati, che è definita come segue:
dove la probabilità marginale dei dati è p(y|x), la distribuzione a priori di f è p(f) e la probabilità dei dati data la funzione f è (y|x,f).
Dopo aver appreso la distribuzione a posteriori di f, il modello calcola la distribuzione predittiva a posteriori per effettuare previsioni in corrispondenza di ulteriori punti di test x*. Può essere definito come segue:
Dove,
p(f^*|x*, y, x) = Ciò mostra, dati i dati di addestramento yex, la probabilità condizionata dei valori della funzione prevista f*in un nuovo punto di input x*Per dirla in altro modo, è la distribuzione di probabilità su tutti i potenziali valori della funzione nel nuovo sito di input x*, condizionato ai dati osservati y e alle rispettive posizioni di input corrispondenti x.int p(f^*|x^*, f)p(f|y,x)df = In questa sezione dell'equazione viene utilizzato un integrale per determinare la probabilità condizionale. L'integrale comprende tutti i valori potenziali della funzione f.p(f^*|x^*, f) = Questa è la distribuzione di probabilità condizionata dei valori attesi della funzione f*all'x*, dati i valori della funzione f in alcune posizioni intermedie.p(f|y,x) = Dati i dati osservati (y) e le loro posizioni di input (x), questa è la distribuzione di probabilità condizionata dei valori della funzione (f).
Per attività come il processo decisionale consapevole dell’incertezza e l’apprendimento attivo, questa distribuzione offre una misura dell’incertezza della previsione, che può essere utile.
Passaggi nella regressione del processo gaussiano
- Raccolta dati : Raccogli le coppie di dati input-output per il tuo problema di regressione.
- Scegli una funzione del kernel : seleziona una funzione di covarianza (kernel) appropriata adatta al tuo problema. La scelta del kernel influenza la forma delle funzioni che il GPR può modellare.
- Ottimizzazione dei parametri : Stimare gli iperparametri della funzione del kernel massimizzando la verosimiglianza dei dati. Questo può essere fatto utilizzando tecniche di ottimizzazione come la discesa del gradiente.
- Predizione: Dato un nuovo input, utilizza il modello GPR addestrato per fare previsioni. Il GPR fornisce sia la media prevista che l'incertezza associata (varianza).
Implementazione della regressione del processo gaussiano (GPR)
Pitone import numpy as np import matplotlib.pyplot as plt from sklearn.gaussian_process import GaussianProcessRegressor from sklearn.gaussian_process.kernels import RBF from sklearn.model_selection import train_test_split # Generate sample data np.random.seed(0) X = np.sort(5 * np.random.rand(80, 1), axis=0) y = np.sin(X).ravel() # Add noise to the data y += 0.1 * np.random.randn(80) # Define the kernel (RBF kernel) kernel = 1.0 * RBF(length_scale=1.0) # Create a Gaussian Process Regressor with the defined kernel gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10) # Split the data into training and testing sets X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.5, random_state=0) # Fit the Gaussian Process model to the training data gp.fit(X_train, y_train) # Make predictions on the test data y_pred, sigma = gp.predict(X_test, return_std=True) # Visualize the results x = np.linspace(0, 5, 1000)[:, np.newaxis] y_mean, y_cov = gp.predict(x, return_cov=True) plt.figure(figsize=(10, 5)) plt.scatter(X_train, y_train, c='r', label='Training Data') plt.plot(x, y_mean, 'k', lw=2, zorder=9, label='Predicted Mean') plt.fill_between(x[:, 0], y_mean - 1.96 * np.sqrt(np.diag(y_cov)), y_mean + 1.96 * np.sqrt(np.diag(y_cov)), alpha=0.2, color='k', label='95% Confidence Interval') plt.xlabel('X') plt.ylabel('y') plt.legend() plt.show()> Produzione:
In questo codice, genera prima alcuni punti dati di esempio con rumore aggiunto, quindi definisci un kernel RBF e crea un file Regressore di processo gaussiano con esso. Il modello viene addestrato sui dati di training e utilizzato per fare previsioni sui dati di test. Infine, i risultati vengono visualizzati con un grafico che mostra i dati di training, la media prevista e l'intervallo di confidenza al 95%.
Implementazione del processo gaussiano in Python
Scikit Impara
Pitone import matplotlib.pyplot as plt import numpy as np from scipy import linalg from sklearn.gaussian_process import kernels,GaussianProcessRegressor ## check version import sys import sklearn print(sys.version) !python --version print("numpy:", np.__version__) print("sklearn:",sklearn.__version__)> Le librerie necessarie per la regressione del processo gaussiano (GPR) in Python vengono importate da questo codice; questi sono SciPy per le funzioni di algebra lineare, NumPy per operazioni numeriche, e Matplotlib per la visualizzazione dei dati. Per assicurarsi che sia compatibile con i pacchetti necessari, verifica inoltre la versione di Python e la stampa, insieme alle versioni di NumPy e scikit-learn (sklearn).
Selezione del kernel
Pitone np.random.seed(0) n=50 kernel_ =[kernels.RBF (), kernels.RationalQuadratic(), kernels.ExpSineSquared(periodicity=10.0), kernels.DotProduct(sigma_0=1.0)**2, kernels.Matern() ] print(kernel_, '
')> Produzione:
[RBF(lunghezza_scala=1),
RazionaleQuadratico(alfa=1, lunghezza_scala=1),
ExpSineSquared(lunghezza_scala=1, periodicità=10),
PuntoProdotto(sigma_0=1) ** 2,
Materno(length_scale=1, nu=1.5)]
Il codice specifica il numero di siti di test (n) e inizializza a seme casuale . Per visualizzare i kernel scelti, genera un elenco di diverse funzioni del kernel e stampa l'elenco.
Confronto e visualizzazione del kernel
Pitone for kernel in kernel_: # Gaussian process gp = GaussianProcessRegressor(kernel=kernel) # Prior x_test = np.linspace(-5, 5, n).reshape(-1, 1) mu_prior, sd_prior = gp.predict(x_test, return_std=True) samples_prior = gp.sample_y(x_test, 3) # plot plt.figure(figsize=(10, 3)) plt.subplot(1, 2, 1) plt.plot(x_test, mu_prior) plt.fill_between(x_test.ravel(), mu_prior - sd_prior, mu_prior + sd_prior, color='aliceblue') plt.plot(x_test, samples_prior, '--') plt.title('Prior') # Fit x_train = np.array([-4, -3, -2, -1, 1]).reshape(-1, 1) y_train = np.sin(x_train) gp.fit(x_train, y_train) # posterior mu_post, sd_post = gp.predict(x_test, return_std=True) mu_post = mu_post.reshape(-1) samples_post = np.squeeze(gp.sample_y(x_test, 3)) # plot plt.subplot(1, 2, 2) plt.plot(x_test, mu_post) plt.fill_between(x_test.ravel(), mu_post - sd_post, mu_post + sd_post, color='aliceblue') plt.plot(x_test, samples_post, '--') plt.scatter(x_train, y_train, c='blue', s=50) plt.title('Posterior') plt.show() print("gp.kernel_", gp.kernel_) print("gp.log_marginal_likelihood:", gp.log_marginal_likelihood(gp.kernel_.theta)) print('-'*50, '
')> Produzione:
RBF
gp.kernel_RBF(length_scale=1.93)
gp.log_marginal_likelihood: -3.444937833462133
-------------------------------------------------- -
Quadratica razionale
gp.kernel_ RationalQuadratic(alpha=1e+05, length_scale=1.93)
gp.log_marginal_likelihood: -3.4449718909150966
--------------------------------------------------
ExpSineSquared
gp.kernel_ ExpSineSquared(length_scale=0.000524, periodicità=2.31e+04)
gp.log_marginal_likelihood: -3.4449381454930217
--------------------------------------------------
Prodotto scalare
gp.kernel_ DotProduct(sigma_0=0.998) ** 2
gp.log_marginal_likelihood: -150204291.56018084
--------------------------------------------------
Materno
gp.kernel_ Matern(length_scale=1.99, nu=1.5)
gp.log_marginal_likelihood: -5.131637070524745
--------------------------------------------------
Il codice inizia eseguendo un loop sulle varie funzioni del kernel elencate nella kernel_list. Un regressore di processo gaussiano (gp) viene realizzato utilizzando il kernel particolare per ogni kernel. Per il processo gaussiano, ciò stabilisce la struttura di covarianza. Per valutare la distribuzione precedente, viene stabilito un insieme di punti di input del test chiamato x_test, con valori compresi tra -5 e 5. Questo insieme di punti viene trasformato in un vettore colonna.
Utilizzando il metodo gp.predict, la media della distribuzione a priori (mu_prior) e la deviazione standard (sd_prior) vengono determinate in ciascun punto di test. I valori di deviazione standard vengono richiesti utilizzando l'opzione return_std=True. gp.campione_y (x_test, 3) viene utilizzato per ottenere tre esempi di funzioni dalla distribuzione precedente.
La prima sottotrama mostra la media della distribuzione precedente, con la deviazione standard rappresentata da un'area ombreggiata. I campioni sono sovrapposti come linee tratteggiate, mentre la media viene visualizzata come linea continua. C'è una sottotrama chiamata Prior. Esiste un insieme definito di punti dati di allenamento (x_train) e valori obiettivo (y_train) che li accompagnano. Il modello del processo gaussiano viene adattato utilizzando questi punti (gp.fit(x_train, y_train)). Cinque punti dati con valori sinusoidali corrispondenti costituiscono i dati di addestramento in questo codice.
Dopo la fase di adattamento dei dati di addestramento, la procedura calcola la media della distribuzione a posteriori (mu_post) e la deviazione standard (sd_post) per gli stessi punti di test (x_test). gp.sample_y(x_test, 3) viene utilizzato anche per produrre campioni di funzioni dalla distribuzione a posteriori. La seconda sottotrama sovrappone le funzioni campionate come linee tratteggiate e mostra la media della distribuzione a posteriori, ombreggiata con la deviazione standard. In blu sono rappresentati i punti dati di allenamento. La sottotrama ha il nome Posterior.
Per vedere i grafici precedente e posteriore per il kernel corrente e ottenere una comprensione visiva del comportamento del modello, chiama la funzione plt.show() di Matplotlib.
Il codice mostra i dettagli sul kernel corrente, come gp.kernel_, che indica il kernel corrente in uso, e gp.log_marginal_likelihood (gp.kernel_.theta), che fornisce la probabilità marginale logaritmica del modello che utilizza il kernel corrente, dopo ogni serie di grafici precedenti e posteriori.
Vantaggi della regressione del processo gaussiano (GPR)
La regressione del processo gaussiano (GPR) presenta numerosi vantaggi in una vasta gamma di applicazioni:
- Il GPR fornisce un quadro probabilistico per la regressione, il che significa che non solo fornisce stime puntuali ma fornisce anche stime di incertezza per le previsioni.
- È altamente flessibile e può acquisire relazioni complesse nei dati.
- Il GPR può essere adattato a varie applicazioni, tra cui previsione di serie temporali, ottimizzazione e ottimizzazione bayesiana.
Sfide della regressione del processo gaussiano (GPR)
- Il GPR può essere computazionalmente costoso quando si ha a che fare con set di dati di grandi dimensioni, poiché è richiesta l'inversione di una matrice di covarianza.
- La scelta della funzione del kernel e dei suoi iperparametri può avere un impatto significativo sulle prestazioni del modello.
Buoni esempi di applicazioni GPR
- Previsione del prezzo delle azioni: Il GPR può essere utilizzato per modellare e prevedere i prezzi delle azioni, tenendo conto della volatilità e dell’incertezza nei mercati finanziari.
- Esperimenti informatici: Il GPR è utile per ottimizzare simulazioni complesse modellando le relazioni input-output e identificando i parametri più influenti.
- Rilevamento anomalie: Il GPR può essere applicato al rilevamento di anomalie, dove identifica modelli insoliti nei dati delle serie temporali acquisendo le normali distribuzioni dei dati.
Conclusione
In conclusione, la regressione del processo gaussiano è uno strumento prezioso per l'analisi dei dati e la previsione in situazioni in cui è essenziale comprendere l'incertezza nelle previsioni. Sfruttando la modellazione probabilistica e le funzioni del kernel, il GPR può fornire risultati accurati e interpretabili. Tuttavia, è fondamentale considerare il costo computazionale e la necessità del contributo di esperti quando si implementa nella pratica il GPR.
sostituzione in Java