# Librerías básicas NumPy, Pandas, Matplotlib y Seaborn. import numpy as np import pandas as pd import matplotlib as mpl from matplotlib import pyplot as plt import seaborn as sns

# Actualizar scikit-learn a la última versión !pip install -U scikit-learn # Importar scikit-learn import sklearn

# Configuraciones para las librerías y módulos usados. # Ignorar las advertencias o warnings. import warnings warnings.simplefilter(action='ignore') # Configurar el formato por defecto de la # librería de visualización Matplotlib. %matplotlib inline %config InlineBackend.figure_format = 'retina' mpl.rcParams['figure.dpi'] = 105 mpl.rcParams['figure.figsize'] = (9, 7) sns.set_theme()

red = pd.read_csv('/work/wine-quality/winequality-red .csv', sep = ';') red.head(5)

red.info()

red.describe().loc[['mean', 'min', 'max'], :]

white = pd.read_csv('/work/wine-quality/winequality-white.csv', sep = ';') white.head(5)

white.info()

white.describe().loc[['mean', 'min', 'max'], :]

fig = plt.figure(figsize=(5,5)) sns.countplot('quality', data=red, palette='coolwarm')

fig, ax1 = plt.subplots(3,4, figsize=(17,17)) k = 0 columns = list(red.columns) for i in range(3): for j in range(4): sns.boxplot(red['quality'], red[columns[k]], ax = ax1[i][j], palette='coolwarm') k += 1 plt.show()

fig = plt.figure(figsize=(5,5)) sns.countplot('quality', data=white, palette='coolwarm')

fig, ax1 = plt.subplots(3,4, figsize=(17,17)) k = 0 columns = list(red.columns) for i in range(3): for j in range(4): sns.boxplot(white['quality'], white[columns[k]], ax = ax1[i][j], palette='coolwarm') k += 1 plt.show()

plt.figure(figsize = (12,12)) sns.heatmap(red.corr(), annot=True, cmap='coolwarm')

plt.figure(figsize = (12,12)) sns.heatmap(white.corr(), annot=True, cmap='coolwarm')

print(red.shape, white.shape)

label1 = [] for i in range(1599): label1.append(0) label2 = [] for i in range(4898): label2.append(1)

red['label'] = label1 white['label'] = label2

concat = pd.concat([red,white]) print(concat.shape) print(concat.head(5))

from sklearn.preprocessing import StandardScaler complete = concat.drop(columns = ['label','quality']) sc = StandardScaler() X_scaled = sc.fit_transform(complete.values) pd.DataFrame(X_scaled).head(5)

X_white = white.drop(columns = ['quality','label']) X_red = red.drop(columns=['quality','label']) y_white = white['quality'] y_red = red['quality'] print('Las dimensiones para el conjunto X de vinos blancos son {} \nLas dimensiones para el conjunto X de vinos rojos son {}'.format(X_white.shape, X_red.shape)) print('\nLas dimensiones para y de vinos blancos son {} \nLas dimensiones para y de vinos rojos son {}'.format(y_white.shape, y_red.shape)) X_white_scaled = sc.fit_transform(X_white) X_red_scaled = sc.fit_transform(X_red)

from sklearn.model_selection import train_test_split Xw_train, Xw_test, yw_train, yw_test = train_test_split(X_white_scaled, y_white, test_size= 0.3, # Proporción de datos usados para el grupo de evaluación. random_state= 333, # Semilla aleatoria para la replicabilidad. stratify=y_white) # Estratificar con respecto a la etiqueta. print(Xw_train.shape, Xw_test.shape, yw_train.shape, yw_test.shape)

Xr_train, Xr_test, yr_train, yr_test = train_test_split(X_red_scaled, y_red, test_size= 0.3, # Proporción de datos usados para el grupo de evaluación. random_state= 333, # Semilla aleatoria para la replicabilidad. stratify=y_red) # Estratificar con respecto a la etiqueta. print(Xw_train.shape, Xw_test.shape, yw_train.shape, yw_test.shape)

from sklearn.decomposition import PCA from sklearn.preprocessing import StandardScaler

complete = concat.drop(columns = ['label','quality']) complete.head(5)

pca = PCA(n_components = 11) transf = pca.fit_transform(X_scaled) explained_variance = pca.explained_variance_ratio_ cum_explained_variance = np.cumsum(explained_variance) components = range(1,12)

pd.DataFrame(transf)

#@title Curva acumulativa de la varianza explicada en función del número de componentes principales plt.figure(dpi = 100, figsize = (8, 6)) plt.xlabel('Número de componentes principales', fontdict= dict(family ='serif', size = 14)) plt.ylabel('Varianza explicada acumulativa', fontdict= dict(family ='serif', size = 14)) plt.plot(components, cum_explained_variance,'--b') plt.plot(components, cum_explained_variance,'b*', ms = 5) plt.show()

# Función para visualizar un conjunto de datos en 2D def plot_data(X, y): y_unique = np.unique(y) colors = plt.cm.rainbow(np.linspace(0.0, 1.0, y_unique.size)) for this_y, color in zip(y_unique, colors): this_X = X[y == this_y] plt.scatter(this_X[:, 0], this_X[:, 1], color=color, alpha=0.5, edgecolor='k', label="Class %s" % this_y) plt.legend(labels = ['red wine','white wine'])

#@title Vectores singulares más significativos después de la transformación lineal a través de PCA plt.figure(figsize = (10, 8), dpi = 105) plt.xlabel('Componente principal 1') plt.ylabel('Componente principal 2') plot_data(transf[:,0:2], concat['label'])

pd.DataFrame(pca.components_) #Las columnas son las 11 variables y las filas son los 11 componentes principales

# Gracicar la curva de aprendizaje de determinada métrica de agrupamiento. def plot_metric(K, scores, metric_name): plt.figure(dpi=110, figsize=(5, 5)) plt.plot(K, scores, 'bx-') plt.xticks(K); plt.xlabel('$k$', fontdict=dict(family = 'serif', size = 14)); plt.ylabel(metric_name, fontdict=dict(family = 'serif', size = 14)); plt.title(f'K vs {metric_name}', fontdict=dict(family = 'serif', size = 18)) plt.show()

# Gráfica individual del resultado de un agrupamiento. from sklearn.metrics import silhouette_score def plot_cluster_predictions(clustering, X, n_clusters = None, cmap = 'tab10', plot_data=True, plot_centers=True, show_metric=None, title_str="", ax = None): assert not hasattr(clustering, "n_clusters") or \ (hasattr(clustering, "n_clusters") and n_clusters is not None), "must specify `n_clusters` for "+str(clustering) if n_clusters is not None: clustering.n_clusters = n_clusters y = clustering.fit_predict(X) # remove elements tagged as noise (cluster nb<0) X = X[y>=0] y = y[y>=0] if n_clusters is None: n_clusters = len(np.unique(y)) if ax is None: ax = plt.gca() if plot_data: sns.scatterplot(X[:,0], X[:,1], hue = y, palette=cmap, legend = False, alpha=.5 ,ax = ax, s = 40) if plot_centers and hasattr(clustering, "cluster_centers_"): sns.scatterplot(clustering.cluster_centers_[:,0], clustering.cluster_centers_[:,1], hue = np.unique(y), s=180, lw=3, palette=cmap, edgecolor="black", legend = False, ax = ax) if show_metric is not None: if show_metric == 'inercia' and hasattr(clustering, 'inertia_'): inertia = clustering.inertia_ ax.set_title("Inercia = {:.0f}".format(inertia)+ title_str, fontdict=dict(family = 'serif', size = 20)) elif show_metric == 'silueta': sc = silhouette_score(X, y) if len(np.unique(y)) > 1 else 0 ax.set_title("Coeficiente de silueta = {:.3f}".format(sc)+ title_str, fontdict=dict(family = 'serif', size = 20)) else: ax.set_title("k={}".format(n_clusters) +title_str, fontdict=dict(family = 'serif', size = 20)) plt.axis("off") return

pd.DataFrame(Xr_train).head(3)

# Métodos de agrupamiento - Algoritmo K-means from sklearn.cluster import KMeans # Número de clusters que se desea generar. n = 7 km = KMeans(n_clusters = n) km.fit(Xr_train) y = km.predict(Xr_test)

from sklearn.model_selection import train_test_split Xred_train, Xred_test, yred_train, yred_test = train_test_split(X_red, y_red, test_size= 0.3, # Proporción de datos usados para el grupo de evaluación. random_state= 333, # Semilla aleatoria para la replicabilidad. stratify=y_red) # Estratificar con respecto a la etiqueta. print(Xw_train.shape, Xw_test.shape, yw_train.shape, yw_test.shape)

# Métodos de agrupamiento - Algoritmo K-means from sklearn.cluster import KMeans # Número de clusters que se desea generar. n = 7 km = KMeans(n_clusters = n) km.fit(Xred_train) y = km.predict(Xred_test)

inertia = [] silhouette = [] K = range(2, 15) for i in K: # Declaramos y ejecutamos el algoritmo K-means. model = KMeans(n_clusters=i) model.fit(Xr_train) # Predecimos las etiquetas de X_preprocessed. y = model.predict(Xr_test) # Almacenamos la métrica de inercia y el coeficiente de silueta. inertia.append(model.inertia_) silhouette.append(silhouette_score(Xr_test, y)) plot_metric(K, inertia, 'Inercia') plot_metric(K, silhouette, 'Coeficiente de silueta')

inertia = [] silhouette = [] K = range(2, 15) for i in K: # Declaramos y ejecutamos el algoritmo K-means. model = KMeans(n_clusters=i) model.fit(Xred_train) # Predecimos las etiquetas de X_preprocessed. y = model.predict(Xred_test) # Almacenamos la métrica de inercia y el coeficiente de silueta. inertia.append(model.inertia_) silhouette.append(silhouette_score(Xred_test, y)) plot_metric(K, inertia, 'Inercia') plot_metric(K, silhouette, 'Coeficiente de silueta')

def plot_extern_metric(X, y, metric, metric_name): scores = [] for i in range(2,20): model = KMeans(n_clusters=i, random_state=32) model.fit(X) y_pred = model.predict(X) scores.append(metric(y, y_pred)) plot_metric(range(2, 20), scores, metric_name)

from sklearn.metrics import adjusted_rand_score plot_extern_metric(Xr_test, yr_test, adjusted_rand_score, 'Índice de Rand')

plot_extern_metric(Xred_test, yred_test, adjusted_rand_score, 'Índice de Rand')

from sklearn.tree import DecisionTreeClassifier from sklearn.model_selection import GridSearchCV tree = DecisionTreeClassifier(random_state = 14) params = { 'criterion' : ['gini','entropy'], #2 'max_depth' : range(1,10), #9 'max_features': range(2,12) #10 } tree_grid_red = GridSearchCV(tree, param_grid= params, cv = 5) tree_grid_red.fit(Xr_train, yr_train)

tree_red = pd.DataFrame(tree_grid_red.cv_results_) tree_red.nlargest(5, 'mean_test_score')

from sklearn import metrics tree_best = tree_grid_red.best_estimator_ importance_red = tree_grid_red.best_estimator_.feature_importances_ yr_predict = tree_grid_red.predict(Xr_test) red_accuracy = metrics.accuracy_score(yr_test,yr_predict) print('La exactitud en el conjunto de validación para el mejor clasificador de vinos rojos fue {}'.format(round(tree_grid_red.best_score_,4))) print('La exactitud en el conjunto de prueba para el mejor clasificador de vinos rojos fue {}'.format(round(red_accuracy,4)))

metrics.plot_confusion_matrix(tree_grid_red, Xr_test,yr_test);

names = [] for col in white.columns: names.append(col) names = names[:11]

from sklearn.tree import export_graphviz export_graphviz(tree_best, out_file="tree.dot", class_names=['3','4','5','6','7','8'],feature_names=names,impurity=False, filled=True)

import graphviz with open("tree.dot") as f:dot_graph = f.read() display(graphviz.Source(dot_graph))

tree_grid_white = GridSearchCV(tree, param_grid= params, cv = 5) tree_grid_white.fit(Xw_train, yw_train)

tree_best_white = tree_grid_white.best_estimator_ importance_white = tree_grid_white.best_estimator_.feature_importances_ yw_predict = tree_grid_white.predict(Xw_test) white_accuracy = metrics.accuracy_score(yw_test,yw_predict) print('La exactitud en el conjunto de validación para el mejor clasificador de vinos rojos fue {}'.format(round(tree_grid_white.best_score_,4))) print('La exactitud en el conjunto de prueba para el mejor clasificador de vinos rojos fue {}'.format(round(white_accuracy,4)))

tree_white = pd.DataFrame(tree_grid_white.cv_results_) tree_white.nlargest(5,'mean_test_score')

metrics.plot_confusion_matrix(tree_grid_white.best_estimator_, Xw_test,yw_test) plt.show()

fig, axs = plt.subplots(1,2, sharey=True) axs[0].set(xlabel='Proporción de la importancia', ylabel='Variables predictoras',title = 'Vino blanco') axs[1].set(xlabel='Proporción de la importancia',title = 'Vino rojo') axs[0].barh(names, importance_white) axs[1].barh(names, importance_red) plt.show();

#Clasificador de vectores de soporte general. from sklearn.svm import SVC rbf_svm = SVC(kernel='rbf', # Kernel de tipo RBF gamma = 0.001) # Valor del argumento gamma rbf_svm.fit(Xr_train, yr_train);

# Los hiperparámetros deben estar en forma de diccionario. param_grid = {'C': [2**i for i in range(-3, 3, 1)], 'gamma': [2**i for i in range(-2, 2, 1)]} param_grid

# Búsqueda en cuadrícula de hiperparámetros. from sklearn.model_selection import GridSearchCV grid_clf = GridSearchCV(SVC(kernel='rbf'), param_grid=param_grid, cv = 5, verbose=1, return_train_score=True ) grid_clf.fit(Xr_train, yr_train)

# Mejores parámetros identificados. print(grid_clf.best_params_)

# Puntaje de la mejor combinación de parámetros. print(grid_clf.best_score_)

grid_clf.score(Xr_train, yr_train)

grid_clf.score(Xr_test, yr_test)

#Clasificador de vectores de soporte general. from sklearn.svm import SVC rbf_svm = SVC(kernel='rbf', # Kernel de tipo RBF gamma = 0.001) # Valor del argumento gamma rbf_svm.fit(Xw_train, yw_train);

# Los hiperparámetros deben estar en forma de diccionario. param_grid = {'C': [2**i for i in range(-2, 2, 1)], 'gamma': [2**i for i in range(-1, 1, 1)]} param_grid

# Búsqueda en cuadrícula de hiperparámetros. from sklearn.model_selection import GridSearchCV grid_clf = GridSearchCV(SVC(kernel='rbf'), param_grid=param_grid, cv = 5, verbose=1, return_train_score=True ) grid_clf.fit(Xw_train, yw_train)

# Mejores parámetros identificados. print(grid_clf.best_params_)

# Puntaje de la mejor combinación de parámetros. print(grid_clf.best_score_)

grid_clf.score(Xw_train, yw_train)

grid_clf.score(Xw_test, yw_test)

from sklearn.neural_network import MLPClassifier from sklearn.model_selection import RandomizedSearchCV mlp = MLPClassifier(random_state = 14) params = { 'activation' : ['identity', 'logistic', 'tanh', 'relu'], 'hidden_layer_sizes' : [(20,), (40,), (80,)], "max_iter": [1000,10000,100000], 'solver': ['adam','lbfgs','sgd'] } mlp_red = RandomizedSearchCV(mlp, param_distributions = params,cv=5,verbose=1,random_state = 14,n_iter=10) mlp_red.fit(Xr_train,yr_train)

mlp_red2 = RandomizedSearchCV(mlp, param_distributions = params,cv=5,verbose=1,random_state = 25,n_iter=10) #Cambiando semilla para tener mayores opciones mlp_red2.fit(Xr_train,yr_train)

print(mlp_red.best_score_) print(mlp_red.best_params_)

print(mlp_red2.best_score_) print(mlp_red2.best_params_)

yr_predict_mlp = mlp_red2.predict(Xr_test) red_accuracy = metrics.accuracy_score(yr_test,yr_predict_mlp) print('La exactitud en el conjunto de validación para el mejor clasificador de vinos rojos fue {}'.format(round(mlp_red2.best_score_,4))) print('\nLa exactitud en el conjunto de prueba para el mejor clasificador de vinos rojos fue {}'.format(round(red_accuracy,4))) print('\nLa mejor combinación de parametros encontrados fue {}'.format(mlp_red2.best_params_))

mlp_white = RandomizedSearchCV(mlp, param_distributions = params,cv=5,verbose=0,random_state = 14,n_iter=10) mlp_white.fit(Xw_train,yw_train)

yw_predict_mlp = mlp_white.predict(Xw_test) white_accuracy = metrics.accuracy_score(yw_test,yw_predict_mlp) print('La exactitud en el conjunto de validación para el mejor clasificador de vinos blancos fue {}'.format(round(mlp_white.best_score_,4))) print('\nLa exactitud en el conjunto de prueba para el mejor clasificador de vinos blancos fue {}'.format(round(white_accuracy,4))) print('\nLa mejor combinación de parametros encontrados fue {}'.format(mlp_white.best_params_))

cv_white_mlp = pd.DataFrame(mlp_white.cv_results_) cv_white_mlp.nlargest(5,'mean_test_score')