Scikit Learn - API Estimator

Dans ce chapitre, nous allons découvrir Estimator API(Interface de programmation d'applications). Commençons par comprendre ce qu'est une API Estimator.

Qu'est-ce que l'API Estimator

C'est l'une des principales API implémentées par Scikit-learn. Il fournit une interface cohérente pour une large gamme d'applications ML, c'est pourquoi tous les algorithmes d'apprentissage automatique de Scikit-Learn sont implémentés via l'API Estimator. L'objet qui apprend des données (ajustement des données) est un estimateur. Il peut être utilisé avec l'un des algorithmes tels que la classification, la régression, le clustering ou même avec un transformateur, qui extrait des fonctionnalités utiles à partir de données brutes.

Pour ajuster les données, tous les objets estimateurs exposent une méthode d'ajustement qui prend un ensemble de données présenté comme suit -

estimator.fit(data)

Ensuite, tous les paramètres d'un estimateur peuvent être fixés, comme suit, lorsqu'il est instancié par l'attribut correspondant.

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

La sortie de ce qui précède serait 1.

Une fois que les données sont équipées d'un estimateur, les paramètres sont estimés à partir des données disponibles. Maintenant, tous les paramètres estimés seront les attributs de l'objet estimateur se terminant par un trait de soulignement comme suit -

estimator.estimated_param_

Utilisation de l'API Estimator

Les principales utilisations des estimateurs sont les suivantes -

Estimation et décodage d'un modèle

L'objet Estimator est utilisé pour l'estimation et le décodage d'un modèle. De plus, le modèle est estimé comme une fonction déterministe de ce qui suit -

  • Les paramètres fournis dans la construction d'objet.

  • L'état aléatoire global (numpy.random) si le paramètre random_state de l'estimateur est défini sur aucun.

  • Toutes les données transmises à l'appel le plus récent à fit, fit_transform, or fit_predict.

  • Toutes les données transmises dans une séquence d'appels à partial_fit.

Mappage d'une représentation de données non rectangulaire en données rectangulaires

Il mappe une représentation de données non rectangulaire en données rectangulaires. En termes simples, il prend une entrée où chaque échantillon n'est pas représenté comme un objet de type tableau de longueur fixe, et produit un objet de type tableau de fonctionnalités pour chaque échantillon.

Distinction entre les échantillons carottés et périphériques

Il modélise la distinction entre les échantillons de base et les échantillons périphériques en utilisant les méthodes suivantes -

  • fit

  • fit_predict si transductif

  • prédire si inductif

Des principes directeurs

Lors de la conception de l'API Scikit-Learn, en gardant à l'esprit les principes directeurs suivants:

Cohérence

Ce principe stipule que tous les objets doivent partager une interface commune tirée d'un ensemble limité de méthodes. La documentation doit également être cohérente.

Hiérarchie d'objets limitée

Ce principe directeur dit -

  • Les algorithmes doivent être représentés par des classes Python

  • Les ensembles de données doivent être représentés dans un format standard comme les tableaux NumPy, Pandas DataFrames, SciPy sparse matrix.

  • Les noms de paramètres doivent utiliser des chaînes Python standard.

Composition

Comme nous le savons, les algorithmes ML peuvent être exprimés comme la séquence de nombreux algorithmes fondamentaux. Scikit-learn utilise ces algorithmes fondamentaux chaque fois que nécessaire.

Valeurs par défaut sensibles

Selon ce principe, la bibliothèque Scikit-learn définit une valeur par défaut appropriée chaque fois que les modèles ML nécessitent des paramètres spécifiés par l'utilisateur.

Inspection

Conformément à ce principe directeur, chaque valeur de paramètre spécifiée est exposée en tant qu'attributs publics.

Étapes d'utilisation de l'API Estimator

Voici les étapes d'utilisation de l'API d'estimation Scikit-Learn -

Étape 1: Choisissez une classe de modèle

Dans cette première étape, nous devons choisir une classe de modèle. Cela peut être fait en important la classe Estimator appropriée depuis Scikit-learn.

Étape 2: Choisissez les hyperparamètres du modèle

Dans cette étape, nous devons choisir des hyperparamètres de modèle de classe. Cela peut être fait en instanciant la classe avec les valeurs souhaitées.

Étape 3: Organisation des données

Ensuite, nous devons organiser les données en matrice de caractéristiques (X) et vecteur cible (y).

Étape 4: montage du modèle

Maintenant, nous devons adapter le modèle à vos données. Cela peut être fait en appelant la méthode fit () de l'instance de modèle.

Étape 5: application du modèle

Après avoir ajusté le modèle, nous pouvons l'appliquer à de nouvelles données. Pour un apprentissage supervisé, utilisezpredict()méthode pour prédire les étiquettes des données inconnues. Alors que pour l'apprentissage non supervisé, utilisezpredict() ou transform() pour déduire les propriétés des données.

Exemple d'apprentissage supervisé

Ici, comme exemple de ce processus, nous prenons le cas courant de l'ajustement d'une ligne à des données (x, y) ie simple linear regression.

Tout d'abord, nous devons charger l'ensemble de données, nous utilisons l'ensemble de données iris -

Exemple

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

Production

(150, 4)

Exemple

y_iris = iris['species']
y_iris.shape

Production

(150,)

Exemple

Maintenant, pour cet exemple de régression, nous allons utiliser les exemples de données suivants -

%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);

Production

Nous avons donc les données ci-dessus pour notre exemple de régression linéaire.

Maintenant, avec ces données, nous pouvons appliquer les étapes mentionnées ci-dessus.

Choisissez une classe de modèle

Ici, pour calculer un modèle de régression linéaire simple, nous devons importer la classe de régression linéaire comme suit -

from sklearn.linear_model import LinearRegression

Choisissez les hyperparamètres du modèle

Une fois que nous avons choisi une classe de modèle, nous devons faire des choix importants qui sont souvent représentés sous forme d'hyperparamètres, ou les paramètres qui doivent être définis avant que le modèle ne soit adapté aux données. Ici, pour cet exemple de régression linéaire, nous aimerions ajuster l'intersection en utilisant lafit_intercept hyperparamètre comme suit -

Example

model = LinearRegression(fit_intercept = True)
model

Output

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

Organisation des données

Maintenant, comme nous savons que notre variable cible y est en forme correcte c'est-à-dire une longueur n_samplestableau de 1-D. Mais nous devons remodeler la matrice de caractéristiquesX en faire une matrice de taille [n_samples, n_features]. Cela peut être fait comme suit -

Example

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

Output

(40, 1)

Montage du modèle

Une fois que nous avons arrangé les données, il est temps d'ajuster le modèle, c'est-à-dire d'appliquer notre modèle aux données. Cela peut être fait avec l'aide defit() méthode comme suit -

Example

model.fit(X, y)

Output

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

Dans Scikit-learn, le fit() processus ont des traits de soulignement à la fin.

Pour cet exemple, le paramètre ci-dessous montre la pente de l'ajustement linéaire simple des données -

Example

model.coef_

Output

array([1.99839352])

Le paramètre ci-dessous représente l'intersection de l'ajustement linéaire simple aux données -

Example

model.intercept_

Output

-0.9895459457775022

Application du modèle à de nouvelles données

Après avoir entraîné le modèle, nous pouvons l'appliquer à de nouvelles données. La tâche principale de l'apprentissage automatique supervisé étant d'évaluer le modèle sur la base de nouvelles données qui ne font pas partie de l'ensemble d'apprentissage. Cela peut être fait avec l'aide depredict() méthode comme suit -

Example

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

Output

Exemple de travail / exécutable complet

%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);

Exemple d'apprentissage non supervisé

Ici, à titre d'exemple de ce processus, nous prenons le cas courant de la réduction de la dimensionnalité de l'ensemble de données Iris afin de pouvoir le visualiser plus facilement. Pour cet exemple, nous allons utiliser l'analyse en composantes principales (ACP), une technique de réduction de dimensionnalité linéaire rapide.

Comme l'exemple ci-dessus, nous pouvons charger et tracer les données aléatoires à partir du jeu de données iris. Après cela, nous pouvons suivre les étapes ci-dessous -

Choisissez une classe de modèle

from sklearn.decomposition import PCA

Choisissez les hyperparamètres du modèle

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)

Montage du modèle

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)

Transformez les données en deux dimensions

Example

X_2D = model.transform(X_iris)

Maintenant, nous pouvons tracer le résultat comme suit -

Output

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

Output

Exemple de travail / exécutable complet

%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);