Scikit Learn - Estimator API

In questo capitolo, impareremo Estimator API(Interfaccia di programmazione applicazioni). Cominciamo con la comprensione di cos'è un'API di stima.

Cos'è Estimator API

È una delle principali API implementate da Scikit-learn. Fornisce un'interfaccia coerente per un'ampia gamma di applicazioni ML, ecco perché tutti gli algoritmi di apprendimento automatico in Scikit-Learn vengono implementati tramite l'API Estimator. L'oggetto che apprende dai dati (adattando i dati) è uno stimatore. Può essere utilizzato con qualsiasi algoritmo come classificazione, regressione, clustering o anche con un trasformatore, che estrae funzionalità utili dai dati grezzi.

Per l'adattamento dei dati, tutti gli oggetti dello stimatore espongono un metodo di adattamento che accetta un set di dati mostrato come segue:

estimator.fit(data)

Successivamente, tutti i parametri di uno stimatore possono essere impostati, come segue, quando viene istanziato dall'attributo corrispondente.

estimator = Estimator (param1=1, param2=2)
estimator.param1

L'output di quanto sopra sarebbe 1.

Una volta che i dati sono dotati di uno stimatore, i parametri vengono stimati dai dati a portata di mano. Ora, tutti i parametri stimati saranno gli attributi dell'oggetto stimatore che terminano con un trattino basso come segue:

estimator.estimated_param_

Utilizzo di Estimator API

Gli usi principali degli stimatori sono i seguenti:

Stima e decodifica di un modello

L'oggetto Stimator viene utilizzato per la stima e la decodifica di un modello. Inoltre, il modello è stimato come una funzione deterministica dei seguenti:

• I parametri forniti nella costruzione dell'oggetto.

• Lo stato casuale globale (numpy.random) se il parametro random_state dello stimatore è impostato su nessuno.

• Tutti i dati passati alla chiamata più recente a fit, fit_transform, or fit_predict.

• Tutti i dati passati in una sequenza di chiamate a partial_fit.

Mappatura della rappresentazione dei dati non rettangolari in dati rettangolari

Mappa una rappresentazione di dati non rettangolari in dati rettangolari. In parole semplici, prende l'input in cui ogni campione non è rappresentato come un oggetto simile a una matrice di lunghezza fissa e produce un oggetto di caratteristiche simile a una matrice per ogni campione.

Distinzione tra campioni principali e periferici

Modella la distinzione tra campioni principali e periferici utilizzando i seguenti metodi:

• fit

• fit_predict se trasduttivo

• prevedere se induttivo

Principi guida

Durante la progettazione dell'API Scikit-Learn, tenendo presenti i principi guida:

Consistenza

Questo principio afferma che tutti gli oggetti devono condividere un'interfaccia comune disegnata da un insieme limitato di metodi. Anche la documentazione dovrebbe essere coerente.

Gerarchia di oggetti limitata

Questo principio guida dice:

• Gli algoritmi dovrebbero essere rappresentati da classi Python

• I set di dati devono essere rappresentati in formato standard come array NumPy, Pandas DataFrames, matrice sparsa SciPy.

• I nomi dei parametri dovrebbero usare stringhe Python standard.

Composizione

Come sappiamo, gli algoritmi ML possono essere espressi come la sequenza di molti algoritmi fondamentali. Scikit-learn fa uso di questi algoritmi fondamentali ogni volta che è necessario.

Valori predefiniti ragionevoli

Secondo questo principio, la libreria Scikit-learn definisce un valore predefinito appropriato ogni volta che i modelli ML richiedono parametri specificati dall'utente.

Ispezione

In base a questo principio guida, ogni valore di parametro specificato viene esposto come attributi pubblici.

Passaggi per l'utilizzo dell'API Estimator

Di seguito sono riportati i passaggi per l'utilizzo dell'API per la stima di Scikit-Learn -

Passaggio 1: scegli una classe di modello

In questo primo passaggio, dobbiamo scegliere una classe di modello. Può essere fatto importando la classe Estimator appropriata da Scikit-learn.

Passaggio 2: scegliere gli iperparametri del modello

In questo passaggio, dobbiamo scegliere gli iperparametri del modello di classe. Può essere fatto istanziando la classe con i valori desiderati.

Passaggio 3: disposizione dei dati

Successivamente, dobbiamo organizzare i dati in matrice di caratteristiche (X) e vettore di destinazione (y).

Passaggio 4: adattamento del modello

Ora, dobbiamo adattare il modello ai tuoi dati. Può essere fatto chiamando il metodo fit () dell'istanza del modello.

Passaggio 5: applicazione del modello

Dopo aver adattato il modello, possiamo applicarlo a nuovi dati. Per l'apprendimento supervisionato, utilizzarepredict()metodo per prevedere le etichette per dati sconosciuti. Mentre per l'apprendimento senza supervisione, usapredict() o transform() per dedurre le proprietà dei dati.

Esempio di apprendimento supervisionato

Qui, come esempio di questo processo, stiamo prendendo un caso comune di adattamento di una linea a (x, y) dati, ad es simple linear regression.

Innanzitutto, dobbiamo caricare il set di dati, stiamo usando il set di dati iris -

Esempio

import seaborn as sns
iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape

Produzione

(150, 4)

Esempio

y_iris = iris['species']
y_iris.shape

Produzione

(150,)

Esempio

Ora, per questo esempio di regressione, utilizzeremo i seguenti dati di esempio:

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);

Produzione

Quindi, abbiamo i dati sopra per il nostro esempio di regressione lineare.

Ora, con questi dati, possiamo applicare i passaggi sopra menzionati.

Scegli una classe di modello

Qui, per calcolare un semplice modello di regressione lineare, dobbiamo importare la classe di regressione lineare come segue:

from sklearn.linear_model import LinearRegression

Scegli gli iperparametri del modello

Una volta scelta una classe di modello, dobbiamo fare alcune scelte importanti che sono spesso rappresentate come iperparametri, ovvero i parametri che devono essere impostati prima che il modello si adatti ai dati. Qui, per questo esempio di regressione lineare, vorremmo adattare l'intercetta utilizzando ilfit_intercept iperparametro come segue -

Example

model = LinearRegression(fit_intercept = True)
model

Output

LinearRegression(copy_X = True, fit_intercept = True, n_jobs = None, normalize = False)

Organizzazione dei dati

Ora, come sappiamo che la nostra variabile di destinazione y è nella forma corretta, cioè una lunghezza n_samplesmatrice di 1-D. Ma dobbiamo rimodellare la matrice delle caratteristicheX per renderlo una matrice di dimensioni [n_samples, n_features]. Può essere fatto come segue:

Example

X = x[:, np.newaxis]
X.shape

Output

(40, 1)

Modello di montaggio

Una volta sistemati i dati, è il momento di adattare il modello, ovvero di applicare il nostro modello ai dati. Questo può essere fatto con l'aiuto difit() metodo come segue -

Example

model.fit(X, y)

Output

LinearRegression(copy_X = True, fit_intercept = True, n_jobs = None,normalize = False)

In Scikit-learn, il fit() ha alcuni trattini bassi finali.

Per questo esempio, il parametro seguente mostra la pendenza dell'adattamento lineare semplice dei dati -

Example

model.coef_

Output

array([1.99839352])

Il parametro seguente rappresenta l'intercetta dell'adattamento lineare semplice ai dati -

Example

model.intercept_

Output

-0.9895459457775022

Applicazione del modello a nuovi dati

Dopo aver addestrato il modello, possiamo applicarlo a nuovi dati. Poiché il compito principale dell'apprendimento automatico supervisionato è valutare il modello sulla base di nuovi dati che non fanno parte del set di addestramento. Può essere fatto con l'aiuto dipredict() metodo come segue -

Example

xfit = np.linspace(-1, 11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x, y)
plt.plot(xfit, yfit);

Output

Esempio completo di lavoro / eseguibile

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
y_iris = iris['species']
y_iris.shape

rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
from sklearn.linear_model import LinearRegression
model = LinearRegression(fit_intercept=True)
model
X = x[:, np.newaxis]
X.shape

model.fit(X, y)
model.coef_
model.intercept_

xfit = np.linspace(-1, 11)
Xfit = xfit[:, np.newaxis]
yfit = model.predict(Xfit)
plt.scatter(x, y)
plt.plot(xfit, yfit);

Esempio di apprendimento senza supervisione

Qui, come esempio di questo processo, stiamo prendendo un caso comune di riduzione della dimensionalità del dataset Iris in modo da poterlo visualizzare più facilmente. Per questo esempio, utilizzeremo l'analisi delle componenti principali (PCA), una tecnica di riduzione della dimensionalità lineare veloce.

Come nell'esempio sopra riportato, possiamo caricare e tracciare i dati casuali dal set di dati iris. Dopodiché possiamo seguire i passaggi come di seguito:

Scegli una classe di modello

from sklearn.decomposition import PCA

Scegli gli iperparametri del modello

Example

model = PCA(n_components=2)
model

Output

PCA(copy = True, iterated_power = 'auto', n_components = 2, random_state = None,
   svd_solver = 'auto', tol = 0.0, whiten = False)

Modello di montaggio

Example

model.fit(X_iris)

Output

PCA(copy = True, iterated_power = 'auto', n_components = 2, random_state = None,
   svd_solver = 'auto', tol = 0.0, whiten = False)

Trasforma i dati in bidimensionali

Example

X_2D = model.transform(X_iris)

Ora possiamo tracciare il risultato come segue:

Output

iris['PCA1'] = X_2D[:, 0]
iris['PCA2'] = X_2D[:, 1]
sns.lmplot("PCA1", "PCA2", hue = 'species', data = iris, fit_reg = False);

Output

Esempio completo di lavoro / eseguibile

%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

iris = sns.load_dataset('iris')
X_iris = iris.drop('species', axis = 1)
X_iris.shape
y_iris = iris['species']
y_iris.shape
rng = np.random.RandomState(35)
x = 10*rng.rand(40)
y = 2*x-1+rng.randn(40)
plt.scatter(x,y);
from sklearn.decomposition import PCA

model = PCA(n_components=2)
model
model.fit(X_iris)
X_2D = model.transform(X_iris)
iris['PCA1'] = X_2D[:, 0]
iris['PCA2'] = X_2D[:, 1]
sns.lmplot("PCA1", "PCA2", hue='species', data=iris, fit_reg=False);