Contenidos de la sección
En esta sección, presentamos el aprendizaje automático vocabulario que usamos a lo largo de scikit-learn y damos un ejemplo de aprendizaje simple.
Aprendizaje automático: la configuración del problema
En general, un problema de aprendizaje considera un conjunto de n muestras de datos y luego intenta predecir las propiedades de los datos desconocidos. Si cada muestra tiene más de un número y, por ejemplo, una entrada multidimensional (también conocida como multivariado datos), se dice que tiene varios atributos o características.
Los problemas de aprendizaje se dividen en algunas categorías:
-
aprendizaje supervisado, en el que los datos vienen con atributos adicionales que queremos predecir (haga clic aquí para ir a la página de aprendizaje supervisado de scikit-learn) .Este problema puede ser:
- clasificación: las muestras pertenecen a dos o más clases y queremos aprender de los datos ya etiquetados cómo predecir la clase de datos no etiquetados. Un ejemplo de un problema de clasificación sería el reconocimiento de dígitos escritos a mano, en el que el objetivo es asignar cada vector de entrada a una de un número finito de categorías discretas. Otra forma de pensar en la clasificación es como una forma discreta (en oposición a continua) de aprendizaje supervisado donde uno tiene un número limitado de categorías y para cada una de las n muestras proporcionadas, uno es tratar de etiquetarlas con la categoría o clase correcta. .
- regresión: si la salida deseada consta de una o más variables continuas, la tarea se llama regresión. Un ejemplo de un problema de regresión sería la predicción de la longitud de un salmón en función de su edad y peso.
- aprendizaje sin supervisión, en el que los datos de entrenamiento consisten en un conjunto de vectores de entrada x sin ningún valor objetivo correspondiente. El objetivo de tales problemas puede ser descubrir grupos de ejemplos similares dentro de los datos, donde se llama agrupamiento, o para determinar la distribución de datos dentro del espacio de entrada, conocido como estimación de densidad, o para proyectar los datos desde un espacio de alta dimensión a dos o tres dimensiones con el propósito de visualización (haga clic aquí para ir a la página de aprendizaje no supervisado de Scikit-Learn).
Equipo de entrenamiento y equipo de prueba
El aprendizaje automático consiste en aprender algunas propiedades de un conjunto de datos y luego probar esas propiedades con otro conjunto de datos. Una práctica común en el aprendizaje automático es evaluar un algoritmo dividiendo un conjunto de datos en dos. Llamamos a uno de esos conjuntos el conjunto de entrenamiento, sobre el que aprendemos algunas propiedades; llamamos al otro conjunto el conjunto de prueba, en el que probamos las propiedades aprendidas.
Cargando un conjunto de datos de ejemplo
scikit-learn viene con algunos conjuntos de datos estándar, por ejemplo, el iris y digitos conjuntos de datos para la clasificación y el conjunto de datos de diabetes para la regresión.
A continuación, iniciamos un intérprete de Python desde nuestro shell y luego cargamos el iris y digits conjuntos de datos. Nuestra convención de notación es que $ denota el indicador de shell mientras >>> denota el indicador del intérprete de Python:
$ python >>> from sklearn import datasets >>> iris = datasets.load_iris() >>> digits = datasets.load_digits()
Un conjunto de datos es un objeto similar a un diccionario que contiene todos los datos y algunos metadatos sobre los datos. Estos datos se almacenan en el .data miembro, que es un n_samples, n_features formación. En el caso de un problema supervisado, una o más variables de respuesta se almacenan en el .target miembro. Se pueden encontrar más detalles sobre los diferentes conjuntos de datos en el sección dedicada.
Por ejemplo, en el caso del conjunto de datos de dígitos, digits.data da acceso a las funciones que se pueden utilizar para clasificar las muestras de dígitos:
>>> print(digits.data) [[ 0. 0. 5. ... 0. 0. 0.] [ 0. 0. 0. ... 10. 0. 0.] [ 0. 0. 0. ... 16. 9. 0.] ... [ 0. 0. 1. ... 6. 0. 0.] [ 0. 0. 2. ... 12. 0. 0.] [ 0. 0. 10. ... 12. 1. 0.]]
y digits.target da la verdad básica para el conjunto de datos de dígitos, que es el número correspondiente a cada imagen de dígitos que estamos tratando de aprender:
>>> digits.target array([0, 1, 2, ..., 8, 9, 8])
Forma de las matrices de datos
Los datos son siempre una matriz 2D, forma (n_samples, n_features), aunque los datos originales pueden haber tenido una forma diferente. En el caso de los dígitos, cada muestra original es una imagen de forma (8, 8) y se puede acceder mediante:
>>> digits.images[0] array([[ 0., 0., 5., 13., 9., 1., 0., 0.], [ 0., 0., 13., 15., 10., 15., 5., 0.], [ 0., 3., 15., 2., 0., 11., 8., 0.], [ 0., 4., 12., 0., 0., 8., 8., 0.], [ 0., 5., 8., 0., 0., 9., 8., 0.], [ 0., 4., 11., 0., 1., 12., 7., 0.], [ 0., 2., 14., 5., 10., 12., 0., 0.], [ 0., 0., 6., 13., 10., 0., 0., 0.]])
los ejemplo simple en este conjunto de datos ilustra cómo a partir del problema original se puede dar forma a los datos para el consumo en scikit-learn.
Cargando desde conjuntos de datos externos
Para cargar desde un conjunto de datos externo, consulte cargando conjuntos de datos externos.
Aprender y predecir
En el caso del conjunto de datos de dígitos, la tarea es predecir, dada una imagen, qué dígito representa. Se nos dan muestras de cada una de las 10 clases posibles (los dígitos del cero al nueve) en las que encajar un estimador ser capaz de predecir las clases a las que pertenecen las muestras invisibles.
En scikit-learn, un estimador para clasificación es un objeto Python que implementa los métodos fit(X, y) y predict(T).
Un ejemplo de estimador es la clase sklearn.svm.SVC, que implementa clasificación de vectores de apoyo. El constructor del estimador toma como argumentos los parámetros del modelo.
Por ahora, consideraremos el estimador como una caja negra:
>>> from sklearn import svm >>> clf = svm.SVC(gamma=0.001, C=100.)
Elección de los parámetros del modelo.
En este ejemplo, establecemos el valor de gamma a mano. Para encontrar buenos valores para estos parámetros, podemos usar herramientas como búsqueda de cuadrícula y validación cruzada.
los clf (para clasificador) la instancia del estimador se ajusta primero al modelo; es decir, debe aprender del modelo. Esto se hace pasando nuestro conjunto de entrenamiento al fit método. Para el conjunto de entrenamiento, usaremos todas las imágenes de nuestro conjunto de datos, excepto la última imagen, que reservaremos para nuestra predicción. Seleccionamos el set de entrenamiento con el [:-1] Sintaxis de Python, que produce una nueva matriz que contiene todo menos el último elemento de digits.data:
>>> clf.fit(digits.data[:-1], digits.target[:-1]) SVC(C=100.0, gamma=0.001)
Ahora usted puede predecir nuevos valores. En este caso, predecirá utilizando la última imagen de digits.data. Al predecir, determinará la imagen del conjunto de entrenamiento que mejor se adapta a la última imagen.
>>> clf.predict(digits.data[-1:]) array([8])
La imagen correspondiente es:
Como puede ver, es una tarea desafiante: después de todo, las imágenes tienen mala resolución. ¿Estás de acuerdo con el clasificador?
Un ejemplo completo de este problema de clasificación está disponible como un ejemplo que puede ejecutar y estudiar: Reconocer dígitos escritos a mano.
Convenciones
Los estimadores de scikit-learn siguen ciertas reglas para hacer que su comportamiento sea más predictivo. Estos se describen con más detalle en el Glosario de términos comunes y elementos de API.
Tipo de fundición
A menos que se especifique lo contrario, la entrada se enviará a float64:
>>> import numpy as np >>> from sklearn import random_projection >>> rng = np.random.RandomState(0) >>> X = rng.rand(10, 2000) >>> X = np.array(X, dtype='float32') >>> X.dtype dtype('float32') >>> transformer = random_projection.GaussianRandomProjection() >>> X_new = transformer.fit_transform(X) >>> X_new.dtype dtype('float64')
En este ejemplo, X es float32, que se lanza a float64 por fit_transform(X).
Los objetivos de regresión se lanzan a float64 y se mantienen los objetivos de clasificación:
>>> from sklearn import datasets >>> from sklearn.svm import SVC >>> iris = datasets.load_iris() >>> clf = SVC() >>> clf.fit(iris.data, iris.target) SVC() >>> list(clf.predict(iris.data[:3])) [0, 0, 0] >>> clf.fit(iris.data, iris.target_names[iris.target]) SVC() >>> list(clf.predict(iris.data[:3])) ['setosa', 'setosa', 'setosa']
Aquí, el primero predict() devuelve una matriz de enteros, ya que iris.target (una matriz de enteros) se usó en fit. El segundo predict() devuelve una matriz de cadenas, ya que iris.target_names era para encajar.
Reajuste y actualización de parámetros
Los hiperparámetros de un estimador se pueden actualizar después de haber sido construido a través de la set_params () método. Vocación fit() más de una vez sobrescribirá lo aprendido por cualquier fit():
>>> import numpy as np >>> from sklearn.datasets import load_iris >>> from sklearn.svm import SVC >>> X, y = load_iris(return_X_y=True) >>> clf = SVC() >>> clf.set_params(kernel='linear').fit(X, y) SVC(kernel='linear') >>> clf.predict(X[:5]) array([0, 0, 0, 0, 0]) >>> clf.set_params(kernel='rbf').fit(X, y) SVC() >>> clf.predict(X[:5]) array([0, 0, 0, 0, 0])
Aquí, el kernel predeterminado rbf se cambia primero a linear vía SVC.set_params() después de que se ha construido el estimador y se ha cambiado de nuevo a rbf para reajustar el estimador y hacer una segunda predicción.
Adaptación multiclase frente a multilabel
Cuando usas multiclass classifiers, la tarea de aprendizaje y predicción que se realiza depende del formato de los datos objetivo que se ajustan a:
>>> from sklearn.svm import SVC >>> from sklearn.multiclass import OneVsRestClassifier >>> from sklearn.preprocessing import LabelBinarizer >>> X = [[1, 2], [2, 4], [4, 5], [3, 2], [3, 1]] >>> y = [0, 0, 1, 1, 2] >>> classif = OneVsRestClassifier(estimator=SVC(random_state=0)) >>> classif.fit(X, y).predict(X) array([0, 0, 1, 1, 2])
En el caso anterior, el clasificador se ajusta a una matriz 1d de etiquetas multiclase y el predict() Por tanto, el método proporciona las correspondientes predicciones multiclase. También es posible encajar en una matriz 2d de indicadores de etiquetas binarias:
>>> y = LabelBinarizer().fit_transform(y) >>> classif.fit(X, y).predict(X) array([[1, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 0]])
Aquí, el clasificador es fit() en una representación de etiqueta binaria 2d de y, utilizando el LabelBinarizer. En este caso predict() devuelve una matriz 2d que representa las predicciones de múltiples etiquetas correspondientes.
Tenga en cuenta que las instancias cuarta y quinta devolvieron todos ceros, lo que indica que no coincidieron con ninguna de las tres etiquetas. fit sobre. Con salidas de etiquetas múltiples, es igualmente posible que a una instancia se le asignen múltiples etiquetas:
>>> from sklearn.preprocessing import MultiLabelBinarizer >>> y = [[0, 1], [0, 2], [1, 3], [0, 2, 3], [2, 4]] >>> y = MultiLabelBinarizer().fit_transform(y) >>> classif.fit(X, y).predict(X) array([[1, 1, 0, 0, 0], [1, 0, 1, 0, 0], [0, 1, 0, 1, 0], [1, 0, 1, 0, 0], [1, 0, 1, 0, 0]])
En este caso, el clasificador se ajusta a instancias a cada una de las cuales se le asignaron múltiples etiquetas. los MultiLabelBinarizer se utiliza para binarizar la matriz 2d de múltiples etiquetas para fit sobre. Como resultado, predict() devuelve una matriz 2d con múltiples etiquetas predichas para cada instancia.