Machine Learning con Scikit Learn

Por Jose R. Zapata


Scikit-learn es una biblioteca de código abierto de Python que implementa una gran variedad de algoritmos de aprendizaje automático, Preprocesamiento, validación cruzada y visualización.

Proceso de un Proyecto de Machine Learning

En este link encuentran un listado de los pasos a realizar en un proyecto de machine Learning:

https://medium.com/@joserzapata/paso-a-paso-en-un-proyecto-machine-learning-bcdd0939d387

Pasos para la construccion y seleccion de un Modelo de Machine Learning

Construir Modelo

  1. Preparacion de los datos
  2. Division de los datos entre datos de Entrenamiento (Para seleccionar el modelo, 80%) y datos de Test (para probar el modelo final, 20%)
  3. Se selecciona la medida de Evaluacion segun la aplicacion
  4. Usando solo los datos de Entrenamiento se selecciona los mejores modelos utilizando cross validation y comparando sus resultados
  5. Se toman los mejores modelos (1, 2 o 3 dependiendo de su rendimiento) y se ajustan los Hiper Parametros
  6. Se toman los parametros del mejor modelo y se entrena con todos los datos de Entrenamiento y se evalua su rendimiento con los datos de TEST
  7. Si hay un buen resultado se pasa a la etapa de Implementacion (Deployment), en caso contrario segun sea el problema, se prueba con otros modelos o se devuelve a la etapa de Feature Engineering.

Ejemplo Basico con un solo modelo

Ejemplo simple sin realizar el proceso de Cross validacion ni hiperparametrizacion, se muestra con el fin de acercar los metodos de entrenamiento de modelos y de entrenamietno de transformadores

## Importar Librerias
from sklearn import neighbors, datasets, preprocessing
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

##  Cargar Dataset
iris = datasets.load_iris()
## Definir cual es la columna de salida
## este dataset ya esta representado como numpy.array
X, y = iris.data[:, :2], iris.target

## Division del dataset en datos de entrenamiento y de prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

## Standarizacion de los valores
scaler = preprocessing.StandardScaler().fit(X_train)

X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

## Seleccion del algoritmo de machine learning
knn = neighbors.KNeighborsClassifier(n_neighbors=5)

## Entrenamiento del Modelo
knn.fit(X_train, y_train)

## Prediccion
y_pred = knn.predict(X_test)

# Evaluacion
accuracy_score(y_test, y_pred)
0.8

Ejemplo de clasificacion Completo con un modelo

Ejemplo de pasos completo usando Scikit learn con un solo modelo

  • division de datos
  • preprocesamiento
  • cross-validation
  • evaluacion
  • hiperparametrizacion
  • Entrenamiento final

en estos pasos falta el proceso de seleccion de modelo (escoger un modelo entre varias opciones de algoritmos)

import seaborn as sns
iris_df = sns.load_dataset('iris')
iris_df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):
 #   Column        Non-Null Count  Dtype  
---  ------        --------------  -----  
 0   sepal_length  150 non-null    float64
 1   sepal_width   150 non-null    float64
 2   petal_length  150 non-null    float64
 3   petal_width   150 non-null    float64
 4   species       150 non-null    object 
dtypes: float64(4), object(1)
memory usage: 6.0+ KB
iris_df.sample(5)

sepal_length sepal_width petal_length petal_width species
32 5.2 4.1 1.5 0.1 setosa
137 6.4 3.1 5.5 1.8 virginica
131 7.9 3.8 6.4 2.0 virginica
37 4.9 3.6 1.4 0.1 setosa
46 5.1 3.8 1.6 0.2 setosa

Importar librerias

## Importar Librerias
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import LabelEncoder
from sklearn.pipeline import Pipeline

from sklearn.decomposition import PCA

from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

from sklearn.metrics import accuracy_score

from sklearn.ensemble import RandomForestClassifier

Encode Columna Target

le = LabelEncoder()
iris_df['species'] = le.fit_transform(iris_df['species'])

Division datos de entrenamiento y test

## X es igual a todo el dataframe menos la
## la columna de salida

X = iris_df.drop(columns=['species'])
y = iris_df['species']

## Division del dataset en datos de entrenamiento y de prueba
## datos stratificados bassados en la columna y
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2,
                                                    stratify=y,
                                                    random_state=42)

pipeline

pipeline_data = Pipeline([
    ('scaler3', StandardScaler()),
    ('pca3', PCA(n_components=3))    
])
X_transformed = pipeline_data.fit_transform(X_train)

Cross validation

model_rf = RandomForestClassifier()
scoring = 'accuracy'
kfold = KFold(n_splits=10)
cv_results = cross_val_score(model_rf, X_transformed, y_train, cv=kfold, scoring=scoring)
print(f'Resultado Promedio = {cv_results.mean()}')
print(f'Resultado STD = {cv_results.std()}')
Resultado Promedio = 0.9166666666666666
Resultado STD = 0.08333333333333333

Hiperparametrizacion

from sklearn.model_selection import GridSearchCV
param_grid = {"max_depth": [2, 3, None],
              "max_features": [1,2, 3, 4],
              "bootstrap": [True, False],
              "criterion": ["gini", "entropy"]
              }

grid_search = GridSearchCV(model_rf, param_grid=param_grid)
grid_search.fit(X,y)
GridSearchCV(estimator=RandomForestClassifier(),
             param_grid={'bootstrap': [True, False],
                         'criterion': ['gini', 'entropy'],
                         'max_depth': [2, 3, None],
                         'max_features': [1, 2, 3, 4]})
# mejor parametros
grid_search.best_params_
{'bootstrap': True, 'criterion': 'gini', 'max_depth': 3, 'max_features': 2}
print(f'Resultado Promedio = {grid_search.best_score_}')
print(f"Resultado STD = {grid_search.cv_results_['std_test_score'][grid_search.best_index_]}")
Resultado Promedio = 0.9666666666666668
Resultado STD = 0.02108185106778919

Evaluacion del mejor modelo

# entrenar modelo
mejor_modelo = RandomForestClassifier(**grid_search.best_params_)
mejor_modelo.fit(X_transformed,y_train)

# transformar los datos de test
X_test_transformed = pipeline_data.transform(X_test)

y_pred = mejor_modelo.predict(X_test_transformed)

# Evaluacion
accuracy_score(y_test, y_pred)
0.8666666666666667

Modelo Final

X_transformed_final = pipeline_data.fit_transform(X)

modelo_final = RandomForestClassifier(**grid_search.best_params_)
modelo_final.fit(X_transformed_final,y)

#accuracy final
# Evaluacion
accuracy_score(y, modelo_final.predict(X_transformed_final))
0.9533333333333334

Almacenar modelo Final

from joblib import dump # libreria de serializacion

# garbar el modelo en un archivo
dump(modelo_final, 'modelo_random_forest.joblib')

Preprocesamiento de Datos

https://scikit-learn.org/stable/modules/preprocessing.html

Ejemplo de algunos transformaciones y preparaciones de datos qeu se pueden hacer con scikit-learn

Standardizacion

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler().fit(X_train)
standardized_X = scaler.transform(X_train)
standardized_X_test = scaler.transform(X_test)

Normalizacion

from sklearn.preprocessing import Normalizer
scaler = Normalizer().fit(X_train)
normalized_X = scaler.transform(X_train)
normalized_X_test = scaler.transform(X_test)

Binarizacion

from sklearn.preprocessing import Binarizer
binarizer = Binarizer(threshold=0.0).fit(X)
binary_X = binarizer.transform(X)

Encoding Categorical Features

from sklearn.preprocessing import LabelEncoder
enc = LabelEncoder()
y = enc.fit_transform(y)

Imputacion de valores Faltantes

from sklearn.preprocessing import Imputer
imp = Imputer(missing_values=0, strategy='mean', axis=0)
imp.fit_transform(X_train)

Generacion de Caracteristicas Polinomiales

from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(5)
poly.fit_transform(X)

Creacion de Modelos

Ejemplos de algunos modelos supervizados y no supervizados

Estimadores Aprendizaje Supervisado

Regresion

Regresion lineal
from sklearn.linear_model import LinearRegression
lr = LinearRegression(normalize=True) # los parametros son opcionales
Arboles de Regresion
from sklearn.tree import DecisionTreeRegressor
dtr = DecisionTreeRegressor(random_state = 0) # los parametros son opcionales
Regresion Random Forest
from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor(n_estimators = 10, random_state = 0) # los parametros son opcionales

Clasificacion

Regresion Logistica
from sklearn.linear_model import LogisticRegression
lrc = LogisticRegression(random_state = 0) # los parametros son opcionales
Arboles de decision
from sklearn.tree import DecisionTreeClassifier
dtc = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)  # los parametros son opcionales
Clasificador Random Forest
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier(n_estimators = 10, criterion = 'entropy', random_state = 0) # los parametros son opcionales
Support Vector Machines (SVM)
from sklearn.svm import SVC
svc = SVC(kernel='linear') # los parametros son opcionales
Kernel Support Vector Machines (SVM)
from sklearn.svm import SVC
svck = SVC(kernel = 'rbf', random_state = 0) # los parametros son opcionales
Naive Bayes
from sklearn.naive_bayes import GaussianNB
gnb = GaussianNB()
KNN
from sklearn import neighbors
knn = neighbors.KNeighborsClassifier(n_neighbors=5) # los parametros son opcionales

Estimadores de Aprendizaje No supervizado

Principal Component Analysis (PCA)

from sklearn.decomposition import PCA
pca = PCA(n_components=0.95)

K Means

from sklearn.cluster import KMeans
k_means = KMeans(n_clusters=3, random_state=0)

Hierarchical

from sklearn.cluster import AgglomerativeClustering
hc = AgglomerativeClustering(n_clusters = 5, affinity = 'euclidean', linkage = 'ward') # los parametros son opcionales

Entrenamiento de Modelos

Aprendizaje Supervisado

# Regresion
lr.fit(X_train, y_train)
dtr.fit(X_train, y_train)
rfr.fit(X_train, y_train)

#Clasificacion
lrc.fit(X_train, y_train)
dtc.fit(X_train, y_train)
rfc.fit(X_train, y_train)
knn.fit(X_train, y_train)
svc.fit(X_train, y_train)
svck.fit(X_train, y_train)
gnb.fit(X_train, y_train)

Aprendizaje No Supervisado

k_means.fit(X_train)
pca_model = pca.fit_transform(X_train)

Prediccion

Estimacion Supervisada

# Regresion
y_pred = lr.predict(X_test)
y_pred = dtr.predict(X_test)
y_pred = rfr.predict(X_test)

# Clasificacion
y_pred = svc.predict(X_test)
y_pred = svck.predict(X_test)
y_pred = lrc.predict(X_test)
y_pred = dtc.predict(X_test)
y_pred = rfc.predict(X_test)
y_pred = gnb.predict(X_test)
y_pred = knn.predict_proba(X_test)

Estimacion No Supervisada

y_pred = k_means.predict(X_test)
y_hc = hc.fit_predict(X_train)

Evaluacion de los Modelos

Division datos de Entrenamiento y Prueba

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,random_state=0)

Metricas de Clasificacion

https://scikit-learn.org/stable/modules/model_evaluation.html#classification-metrics

Accuracy Score

knn.score(X_test, y_test)
from sklearn.metrics import accuracy_score
accuracy_score(y_test, y_pred)

Reporte de Clasificacion

from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))

Confusion Matrix

from sklearn.metrics import confusion_matrix
print(confusion_matrix(y_test, y_pred))

Metricas de Regresion

https://scikit-learn.org/stable/modules/model_evaluation.html#regression-metrics

Error absoluto medio (Mean Absolute Error)

from sklearn.metrics import mean_absolute_error
y_true = [3, -0.5, 2]
mean_absolute_error(y_true, y_pred)

Error Cuadratico Medio (Mean Squared Error)

from sklearn.metrics import mean_squared_error
mean_squared_error(y_test, y_pred)

R2 Score

from sklearn.metrics import r2_score
r2_score(y_true, y_pred)

Mean absolute percentage error (MAPE) regression loss

from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_true, y_pred)

Metricas de Clustering

https://scikit-learn.org/stable/modules/model_evaluation.html#clustering-metrics

Adjusted Rand Index

from sklearn.metrics import adjusted_rand_score
adjusted_rand_score(y_true, y_pred)

Homogeneidad

from sklearn.metrics import homogeneity_score
homogeneity_score(y_true, y_pred)

V-measure

from sklearn.metrics import v_measure_score
metrics.v_measure_score(y_true, y_pred)

Cross-Validation

https://scikit-learn.org/stable/modules/cross_validation.html

print(cross_val_score(knn, X_train, y_train, cv=4))
print(cross_val_score(lr, X, y, cv=2))

Sintonizacion del Modelo (Hyper - parametrizacion)

https://scikit-learn.org/stable/modules/grid_search.html4

from sklearn.model_selection import GridSearchCV
params = {"n_neighbors": np.arange(1,3), "metric": ["euclidean", "cityblock"]}
grid = GridSearchCV(estimator=knn,param_grid=params)# 5 CV
grid.fit(X_train, y_train)
print(grid.best_score_)
print(grid.best_estimator_.n_neighbors)

Optimizacion Aleatoria de hiper Parametros

# Ejemplo
from sklearn.model_selection import RandomizedSearchCV
params = {"n_neighbors": range(1,5), "weights": ["uniform", "distance"]}

rsearch = RandomizedSearchCV(estimator=knn,
           param_distributions=params,
           cv=4,
           n_iter=8,
           random_state=5)
rsearch.fit(X_train, y_train)
print(rsearch.best_score_)
print(rsearch.best_params_)
knn = neighbors.KNeighborsClassifier(n_neighbors=2, weights = "uniform")
knn.fit(X_train, y_train)

Librerias de Machine Learning en Python

Algunas de las librerias mas utilizadas en Python son:

Referencias

Phd. Jose R. Zapata