Iniciando

El propósito de esta guía es ilustrar algunas de las características principales que proporciona scikit-learn. Asume un conocimiento muy básico de las prácticas de aprendizaje automático (ajuste de modelos, predicción, validación cruzada, etc.). Por favor, consulta nuestras instrucciones de instalación para instalar scikit-learn.

Scikit-learn es una biblioteca de aprendizaje automático de código abierto que soporta el aprendizaje supervisado y no supervisado. También proporciona varias herramientas para el ajuste de modelos, preprocesamiento de datos, selección y evaluación de modelos, y muchas otras utilidades.

Ajuste y predicción: fundamentos de los estimadores

Scikit-learn proporciona docenas de algoritmos de aprendizaje automático incorporados y modelos, llamados estimators. Cada estimador se puede ajustar a algunos datos utilizando su método fit.

Aquí hay un ejemplo simple donde se ajusta un RandomForestClassifier en algunos datos muy básicos:

>>> from sklearn.ensemble import RandomForestClassifier
>>> clf = RandomForestClassifier(random_state=0)
>>> X = [[ 1,  2,  3],  # 2 samples, 3 features
...      [11, 12, 13]]
>>> y = [0, 1]  # classes of each sample
>>> clf.fit(X, y)
RandomForestClassifier(random_state=0)

El método fit generalmente acepta 2 entradas:

• La matriz de muestras (o la matriz de diseño) X. El tamaño de X es normalmente (n_samples, n_features), lo que significa que las muestras se representan como filas y características se representan como columnas.

• Los valores de destino y que son números reales para las tareas de regresión, o enteros para la clasificación (o cualquier otro conjunto discreto de valores). Para tareas de aprendizaje no supervisadas, y no necesita ser especificado. y es generalmente un arreglo 1d donde la entrada i corresponde al destino de la muestra número i (fila) de X.

Se espera que tanto X como y sean arreglos de numpy o tipos de datos equivalentes de array-like, aunque algunos estimadores trabajan con otros formatos tales como matrices dispersas.

Una vez que el estimador está ajustado, se puede utilizar para predecir los valores de destino de los nuevos datos. No es necesario volver a entrenar el estimador:

>>> clf.predict(X)  # predict classes of the training data
array([0, 1])
>>> clf.predict([[4, 5, 6], [14, 15, 16]])  # predict classes of new data
array([0, 1])

Transformadores y preprocesadores

Los flujos de trabajo de aprendizaje automático a menudo están compuestos de diferentes partes. Un pipeline típico consiste en un paso de preprocesamiento que transforma o imputa los datos, y un predictor final que predice los valores objetivo.

En scikit-learn, los preprocesadores y transformadores siguen la misma API que los objetos del estimador (todos en realidad heredan de la misma clase BaseEstimator). Los objetos transformadores no tienen un método predict sino un método transform que produce una matriz de ejemplo recién transformada X:

>>> from sklearn.preprocessing import StandardScaler
>>> X = [[0, 15],
...      [1, -10]]
>>> # scale data according to computed scaling values
>>> StandardScaler().fit(X).transform(X)
array([[-1.,  1.],
       [ 1., -1.]])

A veces, quieres aplicar diferentes transformaciones a diferentes características: la ColumnTransformer está diseñada para estos casos de uso.

Pipelines: preprocesadores y estimadores de cadenas

Los transformadores y estimadores (predictores) se pueden combinar juntos en un solo objeto unificador: un Pipeline. El pipeline ofrece la misma API que un estimador regular: puede ser ajustado y utilizado para predicción con fit y predict. Como veremos más adelante, el uso de un pipeline también evitará la fuga de datos, es decir, revelar algunos datos de prueba en sus datos de entrenamiento.

En el siguiente ejemplo, cargar el conjunto de datos Iris, lo dividimos en conjuntos de entrenamientos y de pruebas, y calculamos la puntuación exacta de un pipeline en los datos de prueba:

>>> from sklearn.preprocessing import StandardScaler
>>> from sklearn.linear_model import LogisticRegression
>>> from sklearn.pipeline import make_pipeline
>>> from sklearn.datasets import load_iris
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.metrics import accuracy_score
...
>>> # create a pipeline object
>>> pipe = make_pipeline(
...     StandardScaler(),
...     LogisticRegression()
... )
...
>>> # load the iris dataset and split it into train and test sets
>>> X, y = load_iris(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
...
>>> # fit the whole pipeline
>>> pipe.fit(X_train, y_train)
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('logisticregression', LogisticRegression())])
>>> # we can now use it like any other estimator
>>> accuracy_score(pipe.predict(X_test), y_test)
0.97...

Evaluación del modelo

Ajustar un modelo a algunos datos no implica que vaya a predecir bien sobre datos no vistos. Esto necesita ser evaluado directamente. Acabamos de ver el ayudante train_test_split que divide un conjunto de datos en conjuntos de entrenamiento y pruebas, pero scikit-learn proporciona muchas otras herramientas para la evaluación del modelo, en particular para validación cruzada.

Aquí mostramos brevemente cómo realizar un procedimiento de validación cruzada de 5 pliegues, usando el ayudante cross_validate. Ten en cuenta que también es posible iterar manualmente sobre los pliegues, usar diferentes estrategias de división de datos y usar funciones personalizadas de puntuación. Por favor, consulta nuestro Manual de usuario para más detalles:

>>> from sklearn.datasets import make_regression
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.model_selection import cross_validate
...
>>> X, y = make_regression(n_samples=1000, random_state=0)
>>> lr = LinearRegression()
...
>>> result = cross_validate(lr, X, y)  # defaults to 5-fold CV
>>> result['test_score']  # r_squared score is high because dataset is easy
array([1., 1., 1., 1., 1.])

Búsqueda automática de parámetros

Todos los estimadores tienen parámetros (a menudo llamados hiper-parámetros en la literatura) que pueden ser sintonizados. La potencia de generalización de un estimador a menudo depende de unos pocos parámetros. Por ejemplo, un RandomForestRegressor tiene el parámetro n_estimators que determina el número de árboles en el bosque, y un parámetro max_depth que determina la profundidad máxima de cada árbol. Muy a menudo, no está claro cuáles deben ser los valores exactos de estos parámetros, ya que dependen de los datos disponibles.

Scikit-learn proporciona herramientas para encontrar automáticamente las mejores combinaciones de parámetros (a través de validación cruzada). En el siguiente ejemplo, buscamos aleatoriamente el espacio de parámetros de un bosque aleatorio con un objeto RandomizedSearchCV. Cuando la búsqueda termina, el RandomizedSearchCV se comporta como un andomForestRegressor que ha sido ajustado con el mejor conjunto de parámetros. Lee más en el Manual de Usuario:

>>> from sklearn.datasets import fetch_california_housing
>>> from sklearn.ensemble import RandomForestRegressor
>>> from sklearn.model_selection import RandomizedSearchCV
>>> from sklearn.model_selection import train_test_split
>>> from scipy.stats import randint
...
>>> X, y = fetch_california_housing(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
...
>>> # define the parameter space that will be searched over
>>> param_distributions = {'n_estimators': randint(1, 5),
...                        'max_depth': randint(5, 10)}
...
>>> # now create a searchCV object and fit it to the data
>>> search = RandomizedSearchCV(estimator=RandomForestRegressor(random_state=0),
...                             n_iter=5,
...                             param_distributions=param_distributions,
...                             random_state=0)
>>> search.fit(X_train, y_train)
RandomizedSearchCV(estimator=RandomForestRegressor(random_state=0), n_iter=5,
                   param_distributions={'max_depth': ...,
                                        'n_estimators': ...},
                   random_state=0)
>>> search.best_params_
{'max_depth': 9, 'n_estimators': 4}

>>> # the search object now acts like a normal random forest estimator
>>> # with max_depth=9 and n_estimators=4
>>> search.score(X_test, y_test)
0.73...

Nota

En la práctica, casi siempre quieres buscar sobre un pipeline, en lugar de un solo estimador. Una de las razones principales es que si se aplica un paso de preprocesamiento a todo el conjunto de datos sin usar un pipeline, y luego realizar cualquier tipo de validación cruzada, estaríamos rompiendo el supuesto fundamental de independencia entre los datos de entrenamiento y de pruebas. De hecho, dado que se preprocesaron los datos utilizando el conjunto de datos completo, algunas informaciones sobre los conjuntos de pruebas están disponibles para los de entrenamiento. Esto llevará a sobreestimar el poder de generalización del estimador (puedes leer más en este post de Kaggle).

El uso de un pipeline para la validación cruzada y la búsqueda te evitará en gran medida este fallo común.

Pasos siguientes

Hemos cubierto brevemente el ajuste y predicción del estimador, pasos de preprocesamiento, pipelines, herramientas de validación cruzada y búsquedas automáticas de hiper-parámetros. Esta guía debería darte una visión general de algunas de las principales características de la biblioteca, pero ¡hay mucho más en scikit-learn!

Por favor, consulta nuestra Manual de Usuario para obtener más información sobre todas las herramientas que proporcionamos. También puede encontrar una lista exhaustiva de la API pública en el Referencia de la API.

También puedes mirar nuestros numerosos ejemplos que ilustran el uso de scikit-learn en muchos contextos diferentes.

Los tutoriales también contienen recursos de aprendizaje adicionales.