Informacion de la data

In [11]: import numpy as np

from sklearn.datasets import fetch_openml

from sklearn.impute import SimpleImputer

from sklearn.preprocessing import StandardScaler, OneHotEncoder

from sklearn.model_selection import train_test_split, GridSearchCV

In [12]: from IPython.display import Image

%matplotlib inline

In [19]: import os

os.chdir("C:/Users/SOCIAL DATA/Downloads")

In [20]: import pandas as pd

In [21]: data = pd.read_csv("diabetes.csv", sep=",")

In [22]: data.head()

Out[22]: Pregnancies Glucose BloodPressure SkinThickness Insulin BMI DiabetesPedigreeFunction Age Outcome

0 6 148 72 35 0 33.6 0.627 50 1

1 1 85 66 29 0 26.6 0.351 31 0

2 8 183 64 0 0 23.3 0.672 32 1

3 1 89 66 23 94 28.1 0.167 21 0

4 0 137 40 35 168 43.1 2.288 33 1

In [23]: data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Pregnancies 768 non-null int64
1 Glucose 768 non-null int64
2 BloodPressure 768 non-null int64
 3 SkinThickness 768 non-null int64
4 Insulin 768 non-null int64
5 BMI 768 non-null float64
6 DiabetesPedigreeFunction 768 non-null float64
7 Age 768 non-null int64
8 Outcome 768 non-null int64
dtypes: float64(2), int64(7)
memory usage: 54.1 KB
Definimos las columnas que son categoricas y numericas

In [69]: numeric_features = ['Glucose', 'BloodPressure', 'DiabetesPedigreeFunction', 'Age',

'SkinThickness','Insulin','BMI']

categorical_features = ['Pregnancies']

Existen dos Pipeline uno de la libreria SKlearn y otro de Imblearn.

La diferencia de Imblearn es que puede usar las funciones de balanceo de datos

Para que no haiga conflicto le añadimos un nombre que lo diferencie

In [70]: from imblearn.pipeline import Pipeline as imbPipeline

from sklearn.pipeline import Pipeline as skPipeline

Nos piden los siguientes requisitos:

- Numericas:Imputacion por la media y estandarizacion de los datos

- Categoricas:Imputacion por el mas frecuente y codificar las variables

categoricas
Se utiliza una canalización de aprendizaje automático para ayudar a automatizar los flujos de trabajo de
aprendizaje automático. Operan al permitir que una secuencia de datos se transforme y correlacione en un
modelo que se puede probar y evaluar para lograr un resultado.

In [71]: numeric_transformer = skPipeline(steps=[

('simple_imputer', SimpleImputer(strategy='mean')),

('scaler', StandardScaler())])

categorical_transformer = skPipeline(steps=[

('simple_imputer', SimpleImputer(strategy='most_frequent'))])

ColumnTransformer

Permite que diferentes columnas o subconjuntos de columnas de la entrada se transformen por separado y
las características generadas por cada transformador se concatenarán para formar un único espacio de
características.

In [72]: from sklearn.compose import ColumnTransformer

preprocessor = ColumnTransformer(

transformers=[

('num', numeric_transformer, numeric_features),

('cat', categorical_transformer, categorical_features)])

preprocessor

Out[72]: ColumnTransformer(n_jobs=None, remainder='drop', sparse_threshold=0.3,

transformer_weights=None,
transformers=[('num',
Pipeline(memory=None,
steps=[('simple_imputer',
SimpleImputer(add_indicator=False,
copy=True,
fill_value=None,
missing_values=nan,
strategy='mean',
verbose=0)),
('scaler',
 StandardScaler(copy=True,
with_mean=True,
with_std=True))],
verbose=False),
['Glucose', 'BloodPressure',
'DiabetesPedigreeFunction', 'Age',
'SkinThickness', 'Insulin', 'BMI']),
('cat',
Pipeline(memory=None,
steps=[('simple_imputer',
SimpleImputer(add_indicator=False,
copy=True,
fill_value=None,
missing_values=nan,
strategy='most_frequent',
verbose=0))],
verbose=False),
['Pregnancies'])],
verbose=False)
Un ejemplo de como funciona un Pipeline seria este diagrama donde los pasos que sigue son:

1.Estandarizacion

2.Realizar PCA

3.Aprendizaje del Algoritmo

4.Realizar la prediccion

In [8]: Image(filename='pipeline-diagram.png', width=400)

Out[8]:

Como podremos notar el orden es necesario para indicar al Pipeline que pasos tiene que realizar.

In [73]: from sklearn.ensemble import RandomForestClassifier

from imblearn.over_sampling import SMOTE

from sklearn.decomposition import PCA

#from sklearn.decomposition import FactorAnalysis

smt = SMOTE(random_state=42)

pca = PCA(n_components=4)

#factor = FactorAnalysis(n_components=4, random_state=101)

clf = skPipeline(steps=[('preprocessor', preprocessor),

("pipeline", imbPipeline([

("smt", smt),

("pca",pca),

("classifier", RandomForestClassifier(n_estimators=100))

]))

])

 Se muestra el esquema de nuestro Pipeline

In [74]: clf

Out[74]: Pipeline(memory=None,
steps=[('preprocessor',
ColumnTransformer(n_jobs=None, remainder='drop',
sparse_threshold=0.3,
transformer_weights=None,
transformers=[('num',
Pipeline(memory=None,
steps=[('simple_imputer',
SimpleImputer(add_indicator=Fa
lse,
copy=True,
fill_value=None,
missing_values=n
an,
strategy='mean',
verbose=0)),
('scaler',
StandardScaler(copy=True,
with...
RandomForestClassifier(bootstrap=True,
class_weight=None,
criterion='gini',
max_depth=None,
max_features='auto',
max_leaf_nodes=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0.0,
n_estimators=100,
n_jobs=None,
oob_score=False,
random_state=None,
verbose=0,
warm_start=False))],
verbose=False))],
verbose=False)
Dividamos la data de entrenamiento y testeo

In [75]: X= data.iloc[:,0:8].values

In [76]: y= data.iloc[:,8].values

In [77]: X= pd.DataFrame(X, columns=['Pregnancies','Glucose','BloodPressure','SkinThickness',

'Insulin','BMI','DiabetesPedigreeFunction','Age'])

In [78]: y= pd.DataFrame(y, columns=['Outcome'])

In [79]: X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,

random_state=0)

Entrenamiento del Pipeline

In [80]: clf.fit(X_train,y_train)

C:\Users\SOCIAL DATA\AppData\Roaming\Python\Python37\site-packages\sklearn\utils\validation.py:72
4: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please chang
e the shape of y to (n_samples, ), for example using ravel().
y = column_or_1d(y, warn=True)
Out[80]: Pipeline(memory=None,
steps=[('preprocessor',
ColumnTransformer(n_jobs=None, remainder='drop',
sparse_threshold=0.3,
transformer_weights=None,
 transformers=[('num',
Pipeline(memory=None,
steps=[('simple_imputer',
SimpleImputer(add_indicator=Fa
lse,
copy=True,
fill_value=None,
missing_values=n
an,
strategy='mean',
verbose=0)),
('scaler',
StandardScaler(copy=True,
with...
RandomForestClassifier(bootstrap=True,
class_weight=None,
criterion='gini',
max_depth=None,
max_features='auto',
max_leaf_nodes=None,
min_impurity_decrease=0.0,
min_impurity_split=None,
min_samples_leaf=1,
min_samples_split=2,
min_weight_fraction_leaf=0.0,
n_estimators=100,
n_jobs=None,
oob_score=False,
random_state=None,
verbose=0,
warm_start=False))],
verbose=False))],
verbose=False)

Para ingresar a los Steps del Pipeline usamos "named_steps"

Para ingresar a los transformers ColumnTransformer seria "named_transformers"

Digamos que queremos ver la varianza explicada del PCA

In [14]: clf.named_steps.pipeline.named_steps.pca.explained_variance_

Out[14]: array([1.54840478, 0.89000857, 0.46115952, 0.34659193])

Digamos que queremos saber en que orden esta entrenando el OneHotEndocer

In [15]: clf.named_steps.preprocessor.named_transformers_

Out[15]: {'num': Pipeline(steps=[('simple_imputer', SimpleImputer()),

('scaler', StandardScaler())]),
'cat': Pipeline(steps=[('simple_imputer', SimpleImputer(strategy='most_frequent')),
('one_hot', OneHotEncoder(handle_unknown='ignore'))]),
'remainder': 'drop'}

In [16]: clf.named_steps.preprocessor.named_transformers_.cat.named_steps.one_hot.categories_

Out[16]: [array(['C', 'Q', 'S'], dtype=object),

array(['female', 'male'], dtype=object),
array([1.0, 2.0, 3.0], dtype=object)]

In [17]: print("model score: %.3f" % clf.score(X_test, y_test))

model score: 0.786

In [81]: from sklearn.metrics import classification_report#confusion_matrix, , precision_score

y_pred = clf.predict(X_test)

print(classification_report(y_test, y_pred))

precision recall f1-score support

 0 0.84 0.75 0.79 107
1 0.54 0.68 0.60 47

accuracy 0.73 154

macro avg 0.69 0.71 0.70 154
weighted avg 0.75 0.73 0.73 154

In [82]: from sklearn.metrics import classification_report#confusion_matrix, , precision_score

y_pred = clf.predict(X_train)

print(classification_report(y_train, y_pred))

precision recall f1-score support

0 1.00 1.00 1.00 393

1 1.00 1.00 1.00 221

accuracy 1.00 614

macro avg 1.00 1.00 1.00 614
weighted avg 1.00 1.00 1.00 614

En caso de que queramos obtener los parametros para realizar hiperparametros podemos obtener los
parametros del Pipeline

In [19]: clf.get_params().keys()

Out[19]: dict_keys(['memory', 'steps', 'verbose', 'preprocessor', 'pipeline', 'preprocessor__n_jobs', 'pre

processor__remainder', 'preprocessor__sparse_threshold', 'preprocessor__transformer_weights', 'pr
eprocessor__transformers', 'preprocessor__verbose', 'preprocessor__num', 'preprocessor__cat', 'pr
eprocessor__num__memory', 'preprocessor__num__steps', 'preprocessor__num__verbose', 'preprocessor
__num__simple_imputer', 'preprocessor__num__scaler', 'preprocessor__num__simple_imputer__add_indi
cator', 'preprocessor__num__simple_imputer__copy', 'preprocessor__num__simple_imputer__fill_valu
e', 'preprocessor__num__simple_imputer__missing_values', 'preprocessor__num__simple_imputer__stra
tegy', 'preprocessor__num__simple_imputer__verbose', 'preprocessor__num__scaler__copy', 'preproce
ssor__num__scaler__with_mean', 'preprocessor__num__scaler__with_std', 'preprocessor__cat__memor
y', 'preprocessor__cat__steps', 'preprocessor__cat__verbose', 'preprocessor__cat__simple_impute
r', 'preprocessor__cat__one_hot', 'preprocessor__cat__simple_imputer__add_indicator', 'preprocess
or__cat__simple_imputer__copy', 'preprocessor__cat__simple_imputer__fill_value', 'preprocessor__c
at__simple_imputer__missing_values', 'preprocessor__cat__simple_imputer__strategy', 'preprocessor
__cat__simple_imputer__verbose', 'preprocessor__cat__one_hot__categories', 'preprocessor__cat__on
e_hot__drop', 'preprocessor__cat__one_hot__dtype', 'preprocessor__cat__one_hot__handle_unknown',
'preprocessor__cat__one_hot__sparse', 'pipeline__memory', 'pipeline__steps', 'pipeline__verbose',
'pipeline__smt', 'pipeline__pca', 'pipeline__classifier', 'pipeline__smt__k_neighbors', 'pipeline
__smt__n_jobs', 'pipeline__smt__random_state', 'pipeline__smt__sampling_strategy', 'pipeline__pca
__copy', 'pipeline__pca__iterated_power', 'pipeline__pca__n_components', 'pipeline__pca__random_s
tate', 'pipeline__pca__svd_solver', 'pipeline__pca__tol', 'pipeline__pca__whiten', 'pipeline__cla
ssifier__bootstrap', 'pipeline__classifier__ccp_alpha', 'pipeline__classifier__class_weight', 'pi
peline__classifier__criterion', 'pipeline__classifier__max_depth', 'pipeline__classifier__max_fea
tures', 'pipeline__classifier__max_leaf_nodes', 'pipeline__classifier__max_samples', 'pipeline__c
lassifier__min_impurity_decrease', 'pipeline__classifier__min_impurity_split', 'pipeline__classif
ier__min_samples_leaf', 'pipeline__classifier__min_samples_split', 'pipeline__classifier__min_wei
ght_fraction_leaf', 'pipeline__classifier__n_estimators', 'pipeline__classifier__n_jobs', 'pipeli
ne__classifier__oob_score', 'pipeline__classifier__random_state', 'pipeline__classifier__verbos
e', 'pipeline__classifier__warm_start'])
Creamos uno nuevo que no este entrenado

In [20]: clf2 = skPipeline(steps=[('preprocessor', preprocessor),

("pipeline", imbPipeline([

("smt", smt),

("pca",pca),

("classifier", RandomForestClassifier(n_estimators=100))

]))

])

Y lo hacemos pasar por el GridSearchCV

In [21]: from sklearn.model_selection import GridSearchCV

param_grid = {

 'pipeline__pca__n_components': [1,2,3,4],

'pipeline__classifier__max_depth':[2,3,4],

search = GridSearchCV(clf2, param_grid, n_jobs=-1)

search.

(X_train, y_train)

print("Best parameter (CV score=%0.3f):" % search.best_score_)

print(search.best_params_)

Best parameter (CV score=0.777):

{'pipeline__classifier__max_depth': 4, 'pipeline__pca__n_components': 4}