Regression och probabilistisk klassificeringsproblem kan lösas med den Gaussiska processen (GP), en övervakad inlärningsteknik. Eftersom varje Gauss-process kan ses som en oändligt dimensionell generalisering av multivariat Gaussiska fördelningar , termen gaussisk förekommer i namnet. Vi kommer att diskutera Gaussiska processer för regression i det här inlägget, som också kallas Gaussisk processregression (GPR). Många verkliga problem inom materialvetenskap, kemi, fysik och biologi har lösts med hjälp av GPR.
bash while loop
Innehållsförteckning
- Gaussisk processregression (GPR)
- Nyckelbegrepp för Gaussisk processregression (GPR)
- Matematiskt koncept för Gaussisk processregression (GPR)
- Implementering av Gaussisk process i Python
Gaussisk processregression (GPR)
Gaussisk processregression (GPR) är en kraftfull och flexibel icke-parametrisk regressionsteknik som används i maskininlärning och statistik . Det är särskilt användbart när man hanterar problem som involverar kontinuerliga data, där förhållandet mellan indatavariabler och utdata inte är explicit känt eller kan vara komplext. GPR är ett Bayesianskt tillvägagångssätt som kan modellera säkerhet i förutsägelser, vilket gör det till ett värdefullt verktyg för olika applikationer, inklusive optimering, tidsserieprognoser och mer. GPR är baserat på konceptet med en Gaussisk process, som är en samling slumpvariabler, vars ändliga antal har en gemensam Gaussisk fördelning. En Gaussprocess kan ses som en fördelning av funktioner.
Nyckelbegrepp för Gaussisk processregression (GPR)
Gaussain-processen
En icke-parametrisk, probabilistisk modell som kallas a Gaussisk process (GP) används i statistik och maskininlärning för regression, klassificering och kvantifiering av osäkerhet. Den visar en grupp slumpvariabler, som var och en har en gemensam Gaussisk fördelning och kan ha ett ändligt antal. Allmänna läkare är en mångsidig och effektiv teknik för att modellera intrikata relationer i data och producera prognoser med relaterad osäkerhet.
Egenskaper hos Gaussiska processer :
- Icke-parametrisk natur : Allmänläkare kan anpassa sig till datas komplexitet eftersom de inte förlitar sig på ett visst antal modellparametrar
- Probabilistiska förutsägelser : Förutsägelser från allmänläkare kan kvantifieras eftersom de levererar förutsägelser som sannolikhetsfördelningar.
- Interpolation och utjämning : GPs är användbara för bullriga eller oregelbundet samplade data eftersom de är bra på att jämna ut brusiga data och interpolera mellan datapunkter.
- Marginalisering av hyperparametrar : Genom att eliminera kravet på explicit hyperparameterjustering marginaliserar de hyperparametrar, vilket gör modellen enklare.
Medelfunktion
Det förutsagda värdet för funktionen som modelleras vid varje ingångspunkt representeras av medelfunktion i Gaussiska processer (GPs). Det fungerar som ett grundläggande antagande om den underliggande datastrukturen. Medelfunktionen är ofta inställd på noll som standard, inte nödvändigtvis och kan ändras baserat på dataegenskaper eller domänexpertis. Genom att påverka prognosernas centrala tendens hjälper det allmänläkare att identifiera mönster eller trender i data. Allmänna läkare ger probabilistiska förutsägelser som innehåller osäkerhet såväl som punktuppskattningar genom att inkludera medelfunktionen
Kovariansfunktion (kärna).
De kovariansfunktion , även kallad kärnfunktionen, mäter hur lika indatapunkterna är varandra i Gaussiska processer (GPs). Det är väsentligt för att karakterisera beteendet hos GP-modellen, vilket påverkar urvalet av funktioner från den tidigare distributionen. Kovariansfunktionen mäter parvisa likheter för att fastställa korrelationen mellan funktionsvärden. Allmänna läkare kan anpassa sig till ett brett spektrum av datamönster, från smidiga trender till komplexa strukturer, eftersom olika kärnfunktioner fångar olika typer av korrelationer. Modellens prestanda kan påverkas kraftigt av kärnvalet.
Tidigare distributioner
De tidigare distribution , i Gaussiska processer (GPs), är vår förståelse av funktioner före observation av data. Vanligtvis beskrivs den av en kovariansfunktion (kärna) och en medelfunktion. Medan kovariansfunktionen beskriver likheten eller korrelationen mellan funktionsvärden vid olika ingångspunkter, kodar medelfunktionen våra tidigare förväntningar. Detta används i förväg av husläkare för att skapa en fördelning över funktioner. Hos GP kan priors väljas för att representera dataosäkerhet, integrera domänkunskap eller indikera jämnhet.
Posteriora distributioner
Gaussiska processer senare distribution visar våra reviderade antaganden om funktioner efter dataobservation. Den sammanställer sannolikheten för data givet funktionen och den tidigare fördelningen. Den bakre GP-regression erbjuder en fördelning över funktioner som närmast matchar de observerade data. Genom att tillåta probabilistiska förutsägelser och kvantifiering av osäkerhet, återspeglar den bakre fördelningen avvägningen mellan de tidigare föreställningarna som lagrats i den tidigare distributionen och informationen som tillhandahålls av data.
Matematiskt koncept för Gaussisk processregression (GPR)
För regressionsuppgifter används en icke-parametrisk, probabilistisk maskininlärningsmodell som kallas Gaussian Process (GP) regression. När man modellerar intrikata och tvetydiga interaktioner mellan in- och utdatavariabler är det ett kraftfullt verktyg. En multivariat Gauss-fördelning antas producera datapunkterna i GP-regression, och målet är att härleda denna fördelning.
GP-regressionsmodellen har följande matematiska uttryck. Låt oss anta x1, x2,…..,xnär indatapunkterna, där x tillhör reella tal(-2,-1,0,1…), (xi
Låt oss anta y1, och2 ,……., ochnär utgångsvärdena, där yitillhör ett reellt tal (yi
GP-regressionsmodellen gör antagandet att en gaussisk process med en medelfunktion (
Sedan, vid en uppsättning testplatser x*, ges fördelningen av f av:
Vanligtvis används kärnfunktioner för att definiera medelfunktionen och kovariansfunktionen. Som en illustration beskrivs den kvadratiska exponentiella kärnan som ofta används som:
Var,
k(x_{i}, x_{j}) = Kärnfunktionen representeras av detta, och den beräknar korrelationen eller likheten mellan två indatapunkter, xioch xj.sigma^2 = Kärnans variansparameter är denna. Det fastställer kärnfunktionens skala eller vertikala spridning. Den reglerar hur starkt datapunkterna är korrelerade. En högresigma^2 ger en kärnfunktion med större varians.- exp: Exponentialfunktionen är ansvarig för att höja e till argumentets makt.
||x_{i} – x_{j}||^2 : Skillnaden mellan indatapunkterna, xioch xj, är det kvadratiska euklidiska avståndet. Den geometriska separationen mellan punkterna i särdragsutrymmet mäts.- l2: Detta är en representation av kärnans längdskala eller karakteristiska längd. Den reglerar den hastighet med vilken kärnfunktionen försämras när datapunkter är längre ifrån varandra. Ett lägre l gör att kärnan bryts ned snabbare.
GP-regressionsmodellen tillämpar Bayesiansk slutledning för att bestämma fördelningen av f som är mest sannolikt att ha producerat data givet en uppsättning träningsdata (x, y). För att göra detta måste den bakre fördelningen av f givet data beräknas, vilket definieras enligt följande:
där den marginella sannolikheten för datan är p(y|x), den tidigare fördelningen av f är p(f), och sannolikheten för datan givet funktionen f är (y|x,f).
Efter att ha lärt sig den bakre fördelningen av f, beräknar modellen den bakre prediktiva fördelningen för att göra förutsägelser vid ytterligare testpunkter x*. Det kan definieras enligt följande:
tostring-metoden i java
Var,
p(f^*|x*, y, x) = Detta visar, givet träningsdata y och x, den villkorade sannolikheten för de förutsagda funktionsvärdena f*vid en ny ingångspunkt x*För att uttrycka det på ett annat sätt, det är sannolikhetsfördelningen över alla potentiella funktionsvärden på den nya inmatningsplatsen x*, beroende på de observerade data y och deras matchande indataplatser x.int p(f^*|x^*, f)p(f|y,x)df = En integral används i denna del av ekvationen för att bestämma den villkorade sannolikheten. Integralen omfattar alla potentiella värden för funktionen f.p(f^*|x^*, f) = Detta är den villkorade sannolikhetsfördelningen av de förväntade funktionsvärdena f*vid x*, givet funktionsvärdena f på några mellanliggande platser.p(f|y,x) = Givet de observerade data (y) och deras indatalägen (x), är detta den villkorade sannolikhetsfördelningen av funktionsvärdena (f).
För uppgifter som osäkerhetsmedvetet beslutsfattande och aktivt lärande erbjuder denna fördelning ett mått på förutsägelsens osäkerhet, vilket kan vara till hjälp.
Steg i Gaussisk processregression
- Datainsamling : Samla input-outdataparen för ditt regressionsproblem.
- Välj en kärnfunktion : Välj en lämplig kovariansfunktion (kärna) som passar ditt problem. Valet av kärna påverkar formen på de funktioner som GPR kan modellera.
- Parameteroptimering : Uppskatta hyperparametrarna för kärnfunktionen genom att maximera sannolikheten för data. Detta kan göras med hjälp av optimeringstekniker som gradientnedstigning.
- Förutsägelse: Med en ny input, använd den tränade GPR-modellen för att göra förutsägelser. GPR ger både det förutsagda medelvärdet och den associerade osäkerheten (variansen).
Implementering av Gaussisk processregression (GPR)
Pytonorm 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()> Produktion:
I den här koden genererar du först några exempeldatapunkter med extra brus och definierar sedan en RBF-kärna och skapar en Gaussisk processregressor med det. Modellen tränas på träningsdata och används för att göra förutsägelser på testdata. Slutligen visualiseras resultaten med ett diagram som visar träningsdata, det förutsagda medelvärdet och 95 % konfidensintervall.
array slicing java
Implementering av Gaussisk process i Python
Scikit Lär dig
Pytonorm 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__)> De nödvändiga biblioteken för Gaussisk processregression (GPR) i Python importeras med denna kod; dessa är SciPy för linjära algebrafunktioner, NumPy för numeriska operationer, och Matplotlib för datavisualisering. För att säkerställa att den är kompatibel med de nödvändiga paketen, verifierar den dessutom versionen av Python och skriver ut den, tillsammans med versionerna av NumPy och scikit-learn (sklearn).
Urval av kärnor
Pytonorm 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_, '
')> Produktion:
[RBF(längdskala=1),
RationalQuadratic(alpha=1, length_scale=1),
ExpSineSquared(length_scale=1, periodicity=10),
DotProduct(sigma_0=1) ** 2,
Maternal(length_scale=1, nu=1,5)]
Koden anger antalet testplatser (n) och initierar en slumpmässigt frö . För att visa de valda kärnorna genererar den en lista med flera kärnfunktioner och skriver ut listan.
Kärnjämförelse och visualisering
Pytonorm 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, '
')> Produktion:
RBF
gp.kernel_ RBF(length_scale=1,93)
gp.log_marginal_likelihood: -3.444937833462133
-------------------------------------------------- -
Rationell kvadratisk
gp.kernel_ RationalQuadratic(alpha=1e+05, length_scale=1,93)
gp.log_marginal_likelihood: -3.4449718909150966
--------------------------------------------------
ExpSineSquared
gp.kernel_ ExpSineSquared(length_scale=0,000524, periodicity=2,31e+04)
gp.log_marginal_likelihood: -3.4449381454930217
--------------------------------------------------
Punkt produkt
exempel på delsträng i java
gp.kernel_ DotProduct(sigma_0=0,998) ** 2
gp.log_marginal_likelihood: -150204291.56018084
--------------------------------------------------
Moderlig
gp.kernel_ Matern(length_scale=1,99, nu=1,5)
gp.log_marginal_likelihood: -5.131637070524745
--------------------------------------------------
Koden börjar med att loopa över de olika kärnfunktionerna som listas i kernel_-listan. En Gaussisk processregressor (gp) görs med den specifika kärnan för varje kärna. För Gauss-processen etablerar detta kovariansstrukturen. För att bedöma den tidigare fördelningen upprättas en uppsättning testingångspunkter som kallas x_test, med värden från -5 till 5. Denna uppsättning punkter omvandlas till en kolumnvektor.
Med hjälp av gp.predict-metoden bestäms den tidigare fördelningens medelvärde (mu_prior) och standardavvikelse (sd_prior) vid varje testpunkt. Standardavvikelsevärden begärs med alternativet return_std=True. gp.sample_y (x_test, 3) används för att få tre funktionsexempel från den tidigare distributionen.
Den första subplotten visar den tidigare fördelningens medelvärde, med standardavvikelsen representerad av ett skuggat område. Proverna överlagras som streckade linjer, medan medelvärdet visas som en heldragen linje. Det finns en subplot som heter Prior. Det finns en definierad uppsättning träningsdatapunkter (x_train) och målvärden (y_train) som följer med dem. Gaussiska processmodellen anpassas med dessa punkter (gp.fit(x_train, y_train)). Fem datapunkter med motsvarande sinusvärden utgör träningsdata i denna kod.
Efter träningsdataanpassningsfasen beräknar proceduren den bakre fördelningens medelvärde (mu_post) och standardavvikelse (sd_post) för samma testpunkter (x_test). gp.sample_y(x_test, 3) används också för att producera funktionsprov från den bakre fördelningen. Den andra subplotten överlagrar de samplade funktionerna som prickade linjer och visar medelvärdet av den bakre fördelningen, skuggad med standardavvikelsen. Inritade i blått är träningsdatapunkterna. Underhandlingen har namnet Posterior.
För att se de föregående och bakre diagrammen för den aktuella kärnan och få en visuell förståelse av modellens beteende, ring Matplotlibs plt.show() funktion.
Koden visar detaljer om den aktuella kärnan, såsom gp.kernel_, vilket indikerar den aktuella kärnan som används, och gp.log_marginal_likelihood (gp.kernel_.theta), vilket ger loggen marginell sannolikhet för modellen som använder den aktuella kärnan, efter varje uppsättning föregående och posteriora plotter.
Fördelar med Gaussisk processregression (GPR)
Gaussisk processregression (GPR) har ett antal fördelar i en rad tillämpningar:
- GPR tillhandahåller ett probabilistiskt ramverk för regression, vilket innebär att det inte bara ger punktskattningar utan också ger osäkerhetsuppskattningar för förutsägelser.
- Det är mycket flexibelt och kan fånga komplexa relationer i data.
- GPR kan anpassas till olika applikationer, inklusive tidsserieprognoser, optimering och Bayesiansk optimering.
Utmaningar med Gaussisk processregression (GPR)
- GPR kan vara beräkningsmässigt dyrt när man hanterar stora datamängder, eftersom inversion av en kovariansmatris krävs.
- Valet av kärnfunktionen och dess hyperparametrar kan avsevärt påverka modellens prestanda.
Bra exempel på GPR-applikationer
- Aktieprisprognos: GPR kan användas för att modellera och förutsäga aktiekurser, med hänsyn till volatiliteten och osäkerheten på finansmarknaderna.
- Datorexperiment: GPR är användbart för att optimera komplexa simuleringar genom att modellera input-output-relationerna och identifiera de mest inflytelserika parametrarna.
- Anomalidetektering: GPR kan tillämpas på anomalidetektering, där den identifierar ovanliga mönster i tidsseriedata genom att fånga normala datafördelningar.
Slutsats
Sammanfattningsvis är Gaussisk processregression ett värdefullt verktyg för dataanalys och förutsägelse i situationer där det är viktigt att förstå osäkerheten i förutsägelser. Genom att utnyttja probabilistisk modellering och kärnfunktioner kan GPR ge korrekta och tolkbara resultat. Det är dock avgörande att ta hänsyn till beräkningskostnaden och behovet av expertinput när du implementerar GPR i praktiken.