Scikit Learn: API de Estimator

En este capítulo, aprenderemos sobre Estimator API(Interfaz de programación de aplicaciones). Comencemos por comprender qué es una API de Estimator.

¿Qué es la API de Estimator?

Es una de las principales API implementadas por Scikit-learn. Proporciona una interfaz coherente para una amplia gama de aplicaciones de aprendizaje automático, por eso todos los algoritmos de aprendizaje automático en Scikit-Learn se implementan a través de la API de Estimator. El objeto que aprende de los datos (ajustando los datos) es un estimador. Se puede utilizar con cualquiera de los algoritmos como clasificación, regresión, agrupación o incluso con un transformador, que extrae características útiles de los datos sin procesar.

Para ajustar los datos, todos los objetos estimadores exponen un método de ajuste que toma un conjunto de datos que se muestra a continuación:

estimator.fit(data)

A continuación, todos los parámetros de un estimador se pueden configurar, como sigue, cuando es instanciado por el atributo correspondiente.

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

La salida de lo anterior sería 1.

Una vez que los datos se ajustan con un estimador, los parámetros se estiman a partir de los datos disponibles. Ahora, todos los parámetros estimados serán los atributos del objeto estimador que terminan con un guión bajo de la siguiente manera:

estimator.estimated_param_

Uso de la API de Estimator

Los principales usos de los estimadores son los siguientes:

Estimación y decodificación de un modelo

El objeto estimador se utiliza para estimar y decodificar un modelo. Además, el modelo se estima como una función determinista de lo siguiente:

  • Los parámetros que se proporcionan en la construcción de objetos.

  • El estado aleatorio global (numpy.random) si el parámetro random_state del estimador se establece en none.

  • Cualquier dato pasado a la llamada más reciente a fit, fit_transform, or fit_predict.

  • Cualquier dato pasado en una secuencia de llamadas a partial_fit.

Mapeo de la representación de datos no rectangulares en datos rectangulares

Asigna una representación de datos no rectangular a datos rectangulares. En palabras simples, toma entrada donde cada muestra no se representa como un objeto tipo matriz de longitud fija y produce un objeto tipo matriz de características para cada muestra.

Distinción entre muestras centrales y periféricas

Modela la distinción entre muestras centrales y periféricas utilizando los siguientes métodos:

  • fit

  • fit_predict si es transductivo

  • predecir si es inductivo

Principios rectores

Al diseñar la API de Scikit-Learn, se deben tener en cuenta los principios rectores siguientes:

Consistencia

Este principio establece que todos los objetos deben compartir una interfaz común extraída de un conjunto limitado de métodos. La documentación también debe ser coherente.

Jerarquía de objetos limitada

Este principio rector dice:

  • Los algoritmos deben estar representados por clases de Python

  • Los conjuntos de datos deben representarse en formato estándar como matrices NumPy, Pandas DataFrames, matriz dispersa SciPy.

  • Los nombres de los parámetros deben usar cadenas estándar de Python.

Composición

Como sabemos, los algoritmos ML se pueden expresar como la secuencia de muchos algoritmos fundamentales. Scikit-learn hace uso de estos algoritmos fundamentales siempre que sea necesario.

Defaults sensatos

De acuerdo con este principio, la biblioteca Scikit-learn define un valor predeterminado apropiado siempre que los modelos de AA requieran parámetros especificados por el usuario.

Inspección

Según este principio rector, cada valor de parámetro especificado se expone como atributos públicos.

Pasos para usar la API de Estimator

Los siguientes son los pasos para usar la API de estimador de Scikit-Learn:

Paso 1: elige una clase de modelo

En este primer paso, debemos elegir una clase de modelo. Puede hacerlo importando la clase Estimator apropiada de Scikit-learn.

Paso 2: elige hiperparámetros del modelo

En este paso, debemos elegir los hiperparámetros del modelo de clase. Se puede hacer instanciando la clase con los valores deseados.

Paso 3: organizar los datos

A continuación, necesitamos organizar los datos en la matriz de características (X) y el vector objetivo (y).

Paso 4: Ajuste del modelo

Ahora, necesitamos ajustar el modelo a sus datos. Se puede hacer llamando al método fit () de la instancia del modelo.

Paso 5: aplicar el modelo

Después de ajustar el modelo, podemos aplicarlo a nuevos datos. Para el aprendizaje supervisado, utilicepredict()método para predecir las etiquetas de datos desconocidos. Para el aprendizaje sin supervisión, utilicepredict() o transform() para inferir propiedades de los datos.

Ejemplo de aprendizaje supervisado

Aquí, como ejemplo de este proceso, estamos tomando el caso común de ajustar una línea a los datos (x, y), es decir simple linear regression.

Primero, necesitamos cargar el conjunto de datos, estamos usando el conjunto de datos de iris -

Ejemplo

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

Salida

(150, 4)

Ejemplo

y_iris = iris['species']
y_iris.shape

Salida

(150,)

Ejemplo

Ahora, para este ejemplo de regresión, usaremos los siguientes datos de muestra:

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

Salida

Entonces, tenemos los datos anteriores para nuestro ejemplo de regresión lineal.

Ahora, con estos datos, podemos aplicar los pasos antes mencionados.

Elija una clase de modelo

Aquí, para calcular un modelo de regresión lineal simple, necesitamos importar la clase de regresión lineal de la siguiente manera:

from sklearn.linear_model import LinearRegression

Elija hiperparámetros de modelo

Una vez que elegimos una clase de modelo, necesitamos tomar algunas decisiones importantes que a menudo se representan como hiperparámetros, o los parámetros que deben establecerse antes de que el modelo se ajuste a los datos. Aquí, para este ejemplo de regresión lineal, nos gustaría ajustar la intersección usando elfit_intercept hiperparámetro de la siguiente manera:

Example

model = LinearRegression(fit_intercept = True)
model

Output

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

Organizar los datos

Ahora, como sabemos que nuestra variable objetivo y está en forma correcta, es decir, una longitud n_samplesmatriz de 1-D. Pero, necesitamos remodelar la matriz de característicasX para convertirlo en una matriz de tamaño [n_samples, n_features]. Se puede hacer de la siguiente manera:

Example

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

Output

(40, 1)

Ajuste del modelo

Una vez que organizamos los datos, es hora de ajustar el modelo, es decir, de aplicar nuestro modelo a los datos. Esto se puede hacer con la ayuda defit() método de la siguiente manera -

Example

model.fit(X, y)

Output

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

En Scikit-learn, el fit() El proceso tiene algunos guiones bajos al final.

Para este ejemplo, el siguiente parámetro muestra la pendiente del ajuste lineal simple de los datos:

Example

model.coef_

Output

array([1.99839352])

El siguiente parámetro representa la intersección del ajuste lineal simple a los datos:

Example

model.intercept_

Output

-0.9895459457775022

Aplicar el modelo a nuevos datos

Después de entrenar el modelo, podemos aplicarlo a nuevos datos. Dado que la tarea principal del aprendizaje automático supervisado es evaluar el modelo en función de nuevos datos que no forman parte del conjunto de entrenamiento. Se puede hacer con la ayuda depredict() método de la siguiente manera -

Example

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

Output

Ejemplo completo de trabajo / ejecutable

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

Ejemplo de aprendizaje no supervisado

Aquí, como ejemplo de este proceso, tomamos el caso común de reducir la dimensionalidad del conjunto de datos Iris para que podamos visualizarlo más fácilmente. Para este ejemplo, vamos a utilizar el análisis de componentes principales (PCA), una técnica de reducción de dimensionalidad lineal rápida.

Como en el ejemplo anterior, podemos cargar y trazar los datos aleatorios del conjunto de datos del iris. Después de eso, podemos seguir los pasos a continuación:

Elija una clase de modelo

from sklearn.decomposition import PCA

Elija hiperparámetros de modelo

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)

Ajuste del modelo

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)

Transforma los datos a bidimensionales

Example

X_2D = model.transform(X_iris)

Ahora, podemos trazar el resultado de la siguiente manera:

Output

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

Output

Ejemplo completo de trabajo / ejecutable

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