Creación de modelos de aprendizaje en Scikit-learn: una biblioteca de aprendizaje automático de Python

Posted on by Rudeus Greyrat

Requisito previo: Primeros pasos con el aprendizaje automático  
scikit-learn es una biblioteca Python de código abierto que implementa una variedad de algoritmos de aprendizaje automático, preprocesamiento, validación cruzada y visualización mediante una interfaz unificada.

Características importantes de scikit-learn: 

  • Herramientas simples y eficientes para la minería y el análisis de datos. Cuenta con varios algoritmos de clasificación, regresión y agrupamiento que incluyen máquinas de vectores de soporte, bosques aleatorios, aumento de gradiente, k-means, etc.
  • Accesible para todos y reutilizable en varios contextos.
  • Construido sobre NumPy, SciPy y matplotlib.
  • Código abierto, utilizable comercialmente: licencia BSD.

En este artículo, veremos cómo podemos construir fácilmente un modelo de aprendizaje automático usando scikit-learn. 

Instalación:

Scikit-learn requiere:  

  • NumPy
  • SciPy como sus dependencias.

Antes de instalar scikit-learn, asegúrese de tener instalados NumPy y SciPy. Una vez que tenga una instalación funcional de NumPy y SciPy, la forma más fácil de instalar scikit-learn es usando pip: 

pip install -U scikit-learn

Empecemos ahora con el proceso de modelado.

Paso 1: Cargue un conjunto de datos

Un conjunto de datos no es más que una colección de datos. Un conjunto de datos generalmente tiene dos componentes principales: 

  • Características : (también conocidas como predictores, entradas o atributos) son simplemente las variables de nuestros datos. Pueden ser más de uno y, por lo tanto, representados por una array de características (‘X’ es una notación común para representar una array de características). Una lista de todos los nombres de características se denomina nombres de características .
  • Respuesta : (también conocida como destino, etiqueta o salida) Esta es la variable de salida que depende de las variables de características. Generalmente tenemos una sola columna de respuesta y está representada por un vector de respuesta (‘y’ es una notación común para representar el vector de respuesta). Todos los valores posibles que toma un vector de respuesta se denominan nombres de objetivo .

Cargando un conjunto de datos de ejemplo: scikit-learn viene cargado con algunos conjuntos de datos de ejemplo, como los conjuntos de datos de iris y dígitos para la clasificación y el conjunto de datos de precios de la vivienda de Boston para la regresión. 

A continuación se muestra un ejemplo de cómo se puede cargar un conjunto de datos de ejemplo: 

Python

# load the iris dataset as an example 
from sklearn.datasets import load_iris 
iris = load_iris() 
    
# store the feature matrix (X) and response vector (y) 
X = iris.data 
y = iris.target 
    
# store the feature and target names 
feature_names = iris.feature_names 
target_names = iris.target_names 
    
# printing features and target names of our dataset 
print("Feature names:", feature_names) 
print("Target names:", target_names) 
    
# X and y are numpy arrays 
print("\nType of X is:", type(X)) 
    
# printing first 5 input rows 
print("\nFirst 5 rows of X:\n", X[:5])

Producción: 

Feature names: ['sepal length (cm)','sepal width (cm)',
                'petal length (cm)','petal width (cm)']
Target names: ['setosa' 'versicolor' 'virginica']

Type of X is: 

First 5 rows of X:
 [[ 5.1  3.5  1.4  0.2]
 [ 4.9  3.   1.4  0.2]
 [ 4.7  3.2  1.3  0.2]
 [ 4.6  3.1  1.5  0.2]
 [ 5.   3.6  1.4  0.2]]

Cargando un conjunto de datos externo: Ahora, considere el caso cuando queremos cargar un conjunto de datos externo. Para este propósito, podemos usar la biblioteca pandas para cargar y manipular fácilmente conjuntos de datos.

Para instalar pandas, use el siguiente comando pip:  

pip install pandas

En pandas, los tipos de datos importantes son:
Serie : la serie es una array etiquetada unidimensional capaz de contener cualquier tipo de datos.

DataFrame : es una estructura de datos etiquetada bidimensional con columnas de tipos potencialmente diferentes. Puede pensar en ello como una hoja de cálculo o una tabla SQL, o un dict de objetos Series. Generalmente es el objeto pandas más utilizado.
Nota: El archivo CSV utilizado en el siguiente ejemplo se puede descargar desde aquí: weather.csv

Python

import pandas as pd 
    
# reading csv file 
data = pd.read_csv('weather.csv') 
    
# shape of dataset 
print("Shape:", data.shape) 
    
# column names 
print("\nFeatures:", data.columns) 
    
# storing the feature matrix (X) and response vector (y) 
X = data[data.columns[:-1]] 
y = data[data.columns[-1]] 
    
# printing first 5 rows of feature matrix 
print("\nFeature matrix:\n", X.head()) 
    
# printing first 5 values of response vector 
print("\nResponse vector:\n", y.head())

Producción: 

Shape: (14, 5)

Features: Index([u'Outlook', u'Temperature', u'Humidity', 
                u'Windy', u'Play'], dtype='object')

Feature matrix:
     Outlook Temperature Humidity  Windy
0  overcast         hot     high  False
1  overcast        cool   normal   True
2  overcast        mild     high   True
3  overcast         hot   normal  False
4     rainy        mild     high  False

Response vector:
0    yes
1    yes
2    yes
3    yes
4    yes
Name: Play, dtype: object

Paso 2: dividir el conjunto de datos
Un aspecto importante de todos los modelos de aprendizaje automático es determinar su precisión. Ahora, para determinar su precisión, uno puede entrenar el modelo usando el conjunto de datos dado y luego predecir los valores de respuesta para el mismo conjunto de datos usando ese modelo y, por lo tanto, encontrar la precisión del modelo. 
Pero este método tiene varios defectos, como: 

  • El objetivo es estimar el rendimiento probable de un modelo con datos fuera de la muestra .
  • Maximizar la precisión del entrenamiento recompensa los modelos demasiado complejos que no necesariamente generalizarán nuestro modelo.
  • Los modelos innecesariamente complejos pueden sobreajustarse a los datos de entrenamiento.

Una mejor opción es dividir nuestros datos en dos partes: la primera para entrenar nuestro modelo de aprendizaje automático y la segunda para probar nuestro modelo. 

Para resumir:  

  • Divida el conjunto de datos en dos partes: un conjunto de entrenamiento y un conjunto de prueba.
  • Entrene al modelo en el conjunto de entrenamiento.
  • Pruebe el modelo en el conjunto de prueba y evalúe qué tan bien funcionó nuestro modelo.

Ventajas de la división tren/prueba:  

  • El modelo se puede entrenar y probar con datos diferentes a los utilizados para el entrenamiento.
  • Los valores de respuesta se conocen para el conjunto de datos de prueba, por lo que se pueden evaluar las predicciones.
  • La precisión de la prueba es una mejor estimación que la precisión del entrenamiento del rendimiento fuera de la muestra.

Considere el siguiente ejemplo: 

Python

# load the iris dataset as an example
from sklearn.datasets import load_iris
iris = load_iris()
  
# store the feature matrix (X) and response vector (y)
X = iris.data
y = iris.target
  
# splitting X and y into training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
  
# printing the shapes of the new X objects
print(X_train.shape)
print(X_test.shape)
  
# printing the shapes of the new y objects
print(y_train.shape)
print(y_test.shape)

Producción: 

(90L, 4L)
(60L, 4L)
(90L,)
(60L,)

La función train_test_split toma varios argumentos que se explican a continuación:  

  • X, y : Estos son la array de características y el vector de respuesta que deben dividirse.
  • test_size : Es la relación entre los datos de prueba y los datos dados. Por ejemplo, establecer test_size = 0,4 para 150 filas de X produce datos de prueba de 150 x 0,4 = 60 filas.
  • random_state : si usa random_state = some_number, entonces puede garantizar que su división será siempre la misma. Esto es útil si desea obtener resultados reproducibles, por ejemplo, al probar la coherencia en la documentación (para que todos puedan ver los mismos números).

Paso 3: Entrenamiento del modelo

Ahora es el momento de entrenar algunos modelos de predicción utilizando nuestro conjunto de datos. Scikit-learn proporciona una amplia gama de algoritmos de aprendizaje automático que tienen una interfaz unificada/coherente para ajustar, predecir la precisión, etc.
El ejemplo que se proporciona a continuación usa el clasificador KNN (K vecinos más cercanos) .

Nota : No entraremos en los detalles de cómo funciona el algoritmo, ya que solo nos interesa comprender su implementación. 

Ahora, considere el siguiente ejemplo: 

Python

# load the iris dataset as an example
from sklearn.datasets import load_iris
iris = load_iris()
  
# store the feature matrix (X) and response vector (y)
X = iris.data
y = iris.target
  
# splitting X and y into training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
  
# training the model on training set
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
  
# making predictions on the testing set
y_pred = knn.predict(X_test)
  
# comparing actual response values (y_test) with predicted response values (y_pred)
from sklearn import metrics
print("kNN model accuracy:", metrics.accuracy_score(y_test, y_pred))
  
# making prediction for out of sample data
sample = [[3, 5, 4, 2], [2, 3, 5, 4]]
preds = knn.predict(sample)
pred_species = [iris.target_names[p] for p in preds]
print("Predictions:", pred_species)
  
# saving the model
from sklearn.externals import joblib
joblib.dump(knn, 'iris_knn.pkl')

Producción: 

kNN model accuracy: 0.983333333333
Predictions: ['versicolor', 'virginica']

Puntos importantes a tener en cuenta del código anterior:  

  • Creamos un objeto clasificador knn usando: 
 knn = KNeighborsClassifier(n_neighbors=3)
  • El clasificador se entrena utilizando datos de X_train. El proceso se denomina ajuste . Pasamos la array de características y el vector de respuesta correspondiente. 
 knn.fit(X_train, y_train)
  • Ahora, necesitamos probar nuestro clasificador en los datos de X_test. El método knn.predict se usa para este propósito. Devuelve el vector de respuesta previsto, y_pred . 
 y_pred = knn.predict(X_test)
  • Ahora, estamos interesados ​​en encontrar la precisión de nuestro modelo comparando y_test e y_pred . Esto se hace usando el método Accuracy_Score del módulo de métricas : 
print(metrics.accuracy_score(y_test, y_pred))
  • Considere el caso en el que desea que su modelo haga predicciones a partir de datos de muestra . Entonces, la entrada de muestra puede simplemente pasarse de la misma manera que pasamos cualquier array de características. 
sample = [[3, 5, 4, 2], [2, 3, 5, 4]]
preds = knn.predict(sample)
  • Si no está interesado en entrenar su clasificador una y otra vez y usar el clasificador previamente entrenado, puede guardar su clasificador usando joblib . Todo lo que necesitas hacer es: 
joblib.dump(knn, 'iris_knn.pkl')
  • En caso de querer cargar un clasificador ya guardado, utilice el siguiente método: 
knn = joblib.load('iris_knn.pkl') 

A medida que nos acercamos al final de este artículo, aquí hay algunos beneficios de usar scikit-learn sobre otras bibliotecas de aprendizaje automático (como las bibliotecas R):  

  • Interfaz coherente con los modelos de aprendizaje automático
  • Proporciona muchos parámetros de ajuste pero con valores predeterminados sensibles
  • Documentación excepcional
  • Amplio conjunto de funcionalidades para tareas complementarias .
  • Comunidad activa para el desarrollo y soporte.

Referencias:  

Este artículo es una contribución de Nikhil Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *