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
- 1. Definir el problema y mirar el panorama general.
- 2. Obténer los datos
- 3. Explorar los datos para obtener información.
- 4. Preparación de los datos.
- 5. Exploración y selección de modelos
- 6. Afinar los modelos.
- 7. Interpretabilidad del modelo.
- 8. Presentacion de la solución.
- 9. Desplegar, monitorear y mantener el sistema.
Pasos para la construccion y seleccion de un Modelo de Machine Learning
- Preparacion de los datos
- Division de los datos entre datos de Entrenamiento (Para seleccionar el modelo, 80%) y datos de Test (para probar el modelo final, 20%)
- Se selecciona la medida de Evaluacion segun la aplicacion
- Usando solo los datos de Entrenamiento se selecciona los mejores modelos utilizando cross validation y comparando sus resultados
- Se toman los mejores modelos (1, 2 o 3 dependiendo de su rendimiento) y se ajustan los Hiper Parametros
- 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
- 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
Grid Search
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:
- scikit-learn https://scikit-learn.org/stable/
- catboost https://catboost.ai/
- xgboost https://xgboost.readthedocs.io/en/latest/
- lightgbm https://lightgbm.readthedocs.io/en/latest/
- Local Cascade Ensemble (LCE) https://pypi.org/project/lcensemble/
Referencias
- Cheatsheet scikitlearn https://datacamp-community-prod.s3.amazonaws.com/5433fa18-9f43-44cc-b228-74672efcd116
- Errores Comunes y recomendaciones
- Metricas de Regresion
- Metricas de Clasificacion
- Metricas de Clustering
- Conceptos de machine learning Visuales
Phd. Jose R. Zapata