Scikit Learn - Proceso de modelado
Este capítulo trata sobre el proceso de modelado involucrado en Sklearn. Entendamos lo mismo en detalle y comencemos con la carga del conjunto de datos.
Carga del conjunto de datos
Una colección de datos se llama conjunto de datos. Tiene los siguientes dos componentes:
Features- Las variables de los datos se denominan características. También se conocen como predictores, entradas o atributos.
Feature matrix - Es la colección de características, en caso de que haya más de una.
Feature Names - Es la lista de todos los nombres de las funciones.
Response- Es la variable de salida que depende básicamente de las variables de características. También se conocen como destino, etiqueta o salida.
Response Vector- Se utiliza para representar la columna de respuesta. Generalmente, solo tenemos una columna de respuesta.
Target Names - Representa los posibles valores tomados por un vector de respuesta.
Scikit-learn tiene algunos conjuntos de datos de ejemplo como iris y digits para la clasificación y el Boston house prices para la regresión.
Ejemplo
A continuación se muestra un ejemplo para cargar iris conjunto de datos -
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names
print("Feature names:", feature_names)
print("Target names:", target_names)
print("\nFirst 10 rows of X:\n", X[:10])Salida
Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Target names: ['setosa' 'versicolor' 'virginica']
First 10 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]
[5.4 3.9 1.7 0.4]
[4.6 3.4 1.4 0.3]
[5. 3.4 1.5 0.2]
[4.4 2.9 1.4 0.2]
[4.9 3.1 1.5 0.1]
]Dividir el conjunto de datos
Para verificar la precisión de nuestro modelo, podemos dividir el conjunto de datos en dos partes:a training set y a testing set. Utilice el conjunto de entrenamiento para entrenar el modelo y el conjunto de pruebas para probar el modelo. Después de eso, podemos evaluar qué tan bien le fue a nuestro modelo.
Ejemplo
El siguiente ejemplo dividirá los datos en una proporción de 70:30, es decir, el 70% de los datos se utilizarán como datos de entrenamiento y el 30% como datos de prueba. El conjunto de datos es un conjunto de datos de iris como en el ejemplo anterior.
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size = 0.3, random_state = 1
)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)Salida
(105, 4)
(45, 4)
(105,)
(45,)Como se ve en el ejemplo anterior, usa train_test_split()función de scikit-learn para dividir el conjunto de datos. Esta función tiene los siguientes argumentos:
X, y - Aquí, X es el feature matrix y y es el response vector, que deben dividirse.
test_size- Esto representa la relación entre los datos de prueba y el total de datos proporcionados. Como en el ejemplo anterior, estamos configurandotest_data = 0.3 para 150 filas de X. Producirá datos de prueba de 150 * 0.3 = 45 filas.
random_size- Se utiliza para garantizar que la división siempre será la misma. Esto es útil en las situaciones en las que desea obtener resultados reproducibles.
Entrenar al modelo
A continuación, podemos usar nuestro conjunto de datos para entrenar algún modelo de predicción. Como se discutió, scikit-learn tiene una amplia gama deMachine Learning (ML) algorithms que tienen una interfaz consistente para ajustar, predecir la precisión, recuperar, etc.
Ejemplo
En el siguiente ejemplo, usaremos el clasificador KNN (K vecinos más cercanos). No entre en los detalles de los algoritmos KNN, ya que habrá un capítulo aparte para eso. Este ejemplo se utiliza para hacerle comprender solo la parte de implementación.
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data
y = iris.target
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
)
from sklearn.neighbors import KNeighborsClassifier
from sklearn import metrics
classifier_knn = KNeighborsClassifier(n_neighbors = 3)
classifier_knn.fit(X_train, y_train)
y_pred = classifier_knn.predict(X_test)
# Finding accuracy by comparing actual response values(y_test)with predicted response value(y_pred)
print("Accuracy:", metrics.accuracy_score(y_test, y_pred))
# Providing sample data and the model will make prediction out of that data
sample = [[5, 5, 3, 2], [2, 4, 3, 5]]
preds = classifier_knn.predict(sample)
pred_species = [iris.target_names[p] for p in preds] print("Predictions:", pred_species)Salida
Accuracy: 0.9833333333333333
Predictions: ['versicolor', 'virginica']Persistencia del modelo
Una vez que entrena el modelo, es deseable que el modelo se conserve para uso futuro, de modo que no tengamos que volver a entrenarlo una y otra vez. Se puede hacer con la ayuda dedump y load caracteristicas de joblib paquete.
Considere el siguiente ejemplo en el que guardaremos el modelo entrenado anterior (classifier_knn) para uso futuro:
from sklearn.externals import joblib
joblib.dump(classifier_knn, 'iris_classifier_knn.joblib')El código anterior guardará el modelo en un archivo llamado iris_classifier_knn.joblib. Ahora, el objeto se puede volver a cargar desde el archivo con la ayuda del siguiente código:
joblib.load('iris_classifier_knn.joblib')Procesamiento previo de los datos
Como estamos tratando con una gran cantidad de datos y esos datos están en forma sin procesar, antes de ingresar esos datos en los algoritmos de aprendizaje automático, debemos convertirlos en datos significativos. Este proceso se denomina preprocesamiento de datos. Scikit-learn tiene un paquete llamadopreprocessingpara este propósito. lospreprocessing El paquete tiene las siguientes técnicas:
Binarización
Esta técnica de preprocesamiento se utiliza cuando necesitamos convertir nuestros valores numéricos en valores booleanos.
Ejemplo
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]]
)
data_binarized = preprocessing.Binarizer(threshold=0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)En el ejemplo anterior, usamos threshold value = 0.5 y por eso, todos los valores por encima de 0.5 se convertirían a 1, y todos los valores por debajo de 0.5 se convertirían a 0.
Salida
Binarized data:
[
[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]
]Eliminación media
Esta técnica se utiliza para eliminar la media del vector de características de modo que cada característica se centre en cero.
Ejemplo
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]]
)
#displaying the mean and the standard deviation of the input data
print("Mean =", input_data.mean(axis=0))
print("Stddeviation = ", input_data.std(axis=0))
#Removing the mean and the standard deviation of the input data
data_scaled = preprocessing.scale(input_data)
print("Mean_removed =", data_scaled.mean(axis=0))
print("Stddeviation_removed =", data_scaled.std(axis=0))Salida
Mean = [ 1.75 -1.275 2.2 ]
Stddeviation = [ 2.71431391 4.20022321 4.69414529]
Mean_removed = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Stddeviation_removed = [ 1. 1. 1.]Escalada
Usamos esta técnica de preprocesamiento para escalar los vectores de características. La escala de los vectores de características es importante, porque las características no deben ser sintéticamente grandes o pequeñas.
Ejemplo
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]
]
)
data_scaler_minmax = preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax = data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)Salida
Min max scaled data:
[
[ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0.99029126 0. ]
]Normalización
Usamos esta técnica de preprocesamiento para modificar los vectores de características. La normalización de los vectores de características es necesaria para que los vectores de características se puedan medir a una escala común. Hay dos tipos de normalización de la siguiente manera:
Normalización L1
También se llama desviaciones mínimas absolutas. Modifica el valor de tal manera que la suma de los valores absolutos permanece siempre hasta 1 en cada fila. El siguiente ejemplo muestra la implementación de la normalización L1 en los datos de entrada.
Ejemplo
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]
]
)
data_normalized_l1 = preprocessing.normalize(input_data, norm='l1')
print("\nL1 normalized data:\n", data_normalized_l1)Salida
L1 normalized data:
[
[ 0.22105263 -0.2 0.57894737]
[-0.2027027 0.32432432 0.47297297]
[ 0.03571429 -0.56428571 0.4 ]
[ 0.42142857 0.16428571 -0.41428571]
]Normalización L2
También se llama mínimos cuadrados. Modifica el valor de tal manera que la suma de los cuadrados permanece siempre hasta 1 en cada fila. El siguiente ejemplo muestra la implementación de la normalización L2 en los datos de entrada.
Ejemplo
import numpy as np
from sklearn import preprocessing
Input_data = np.array(
[
[2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8]
]
)
data_normalized_l2 = preprocessing.normalize(input_data, norm='l2')
print("\nL1 normalized data:\n", data_normalized_l2)Salida
L2 normalized data:
[
[ 0.33946114 -0.30713151 0.88906489]
[-0.33325106 0.53320169 0.7775858 ]
[ 0.05156558 -0.81473612 0.57753446]
[ 0.68706914 0.26784051 -0.6754239 ]
]