Minería de Datos: Preprocesamiento y clasificación
Máster en Ciencias de Datos e Ingeniería de Computadores
Reducción de dimensionalidad
Reducción de dimensionalidad
Una de las prácticas más comunes de procesamiento de datos es la reducción de la dimensional, lo cual ayuda a transformar o seleccionar las características que mejor representan la estructura, y que por tanto, son más adecuadas para el aprendizaje.
Reducción de la Dimensionalidad No supervisada
Si el número de características es alto, puede ser útil reducirlas mediante una fase no supervisada.
Principal Components Analysis (PCA)
Descomponer un dataset multivariante en un conjunto de componentes ortogonales que explica la cantidad de varianza.
from sklearn import preprocessing, datasets, decomposition#Load the iris dataset and scale itX_iris, y_iris = datasets.load_iris(return_X_y=True)scaler = preprocessing.StandardScaler().fit(X_iris)X_scaled = scaler.transform(X_iris)
Aplico el PCA:
#Apply principal componentes analysis to reduce the iris number of features from 4 to 3pca = decomposition.PCA(n_components=3)X_reduced = pca.fit_transform(X_scaled)print(X_scaled[:3,:])print("Con menos dimensión")print(X_reduced[:3,:])
Esta técnica hace clusters de forma jerárquica y va agrupando características que se comportan de forma similar.
import numpy as npfrom sklearn import cluster#Build a FeatureAgglomeration object and transform the iris dataset for it to have 3 featuresagglo = cluster.FeatureAgglomeration(n_clusters=3, pooling_func=np.mean, linkage="ward")X_reduced2 = agglo.fit_transform(X_scaled)print(X_scaled[:3,:])print("Con menos dimensión")print(X_reduced2[:3,:])
#Plot the iris dataset in a 2D pairplotiris = datasets.load_iris(as_frame=True)palette = sns.color_palette("hls", 3)g = sns.pairplot(iris.frame, hue="target", palette=palette, height=1.25, aspect=2)plt.show()
Visualizando en 2D el PCA:
df = pd.DataFrame(X_reduced, columns=["X1", "X2", "X3"])#Plot the iris dataset in a 2D pairplotdf["target"] = iris.frame["target"]g = sns.pairplot(df, hue="target", palette=sns.color_palette("hls", 3), height=1.25, aspect=2)plt.show()
Visualizando en 2D la reducción mediante Aglomeración:
df = pd.DataFrame(X_reduced2, columns=["X1", "X2", "X3"])#Plot the iris dataset in a 2D pairplotdf["target"] = iris.frame["target"]g = sns.pairplot(df, hue="target", palette=sns.color_palette("hls", 3), height=1.25, aspect=2)plt.show()
Selección de Características
Selección de Características
En este caso se reducen las características eligiendo las características que permitirían un mejor desempeño del clasificador.
Eliminar características con menor varianza
Es un modelo muy simple. Borra todas las características cuya varianza no cumpla un umbral.
Por defecto borra las que tengan 0 varianza.
# Load the iris dataset and plt the variance for each featureiris = datasets.load_iris(as_frame=True)X_iris = iris.datay_iris = iris.targetX_iris.var()
from sklearn.feature_selection import VarianceThreshold#Build a variance threshold selector and transform the iris dataet for it to have three featuressel = VarianceThreshold(threshold=0.2)X_reduced3 = sel.fit_transform(X_iris)print(X_reduced3.shape)print(X_iris.iloc[:3,:])print("Tras reducir")print(X_reduced3[:3,:])
from yellowbrick.features import Rank1D, Rank2Dvisualizer = Rank2D(algorithm='pearson').fit(X_iris, y_iris)visualizer.transform(X_iris); visualizer.show()
<AxesSubplot: title={'center': 'Pearson Ranking of 4 Features'}>
Aplicar la importancia según métrica
from yellowbrick.features import Rank1Dvisualizer = Rank1D(algorithm='shapiro')visualizer.fit(X_iris, y_iris)visualizer.transform(X_iris); visualizer.show()
<AxesSubplot: title={'center': 'Shapiro Ranking of 4 Features'}>
Selección Univariante
La selección de características univariante funciona seleccionando escogiendo las mejores características según tests univariantes.
from sklearn.feature_selection import SelectKBest, chi2, SelectPercentile# Según el criterio chi-squared dustribution for it to have three featuressel = SelectKBest(chi2, k=3)X_reduced4 = sel.fit_transform(X_iris, y_iris)print(X_reduced4.shape)print(X_iris.iloc[:3,:])print("Tras reducir")print(X_reduced4[:3,:])
Dado un estimador que asigna pesos a características, la eliminación recursiva, recursive feature elimination (RFE) selecciona recursivamente menos y menos características.
Primero se entrena el estimador, y se mide la importancia de cada atributo.
Las menos importantes son eliminadas del conjunto de características de forma recursiva hasta que se alcanza el número de características deseadas.
Vamos a aplicarlo hasta 2 características:
from sklearn.svm import SVCfrom sklearn.feature_selection import RFE#Use a Support Vector Classifier as the base model for feature selectionsvc = SVC(kernel="linear", C=1)#Build a RFE model with the SVC to reduce the number of features of iris to 2rfe = RFE(estimator=svc, n_features_to_select=2, step=1)ranking = rfe.fit(X_iris, y_iris).ranking_X_reduced_rfe = rfe.fit_transform(X_iris, y_iris)print(ranking);print(X_reduced_rfe.shape)print(X_iris.iloc[:3,:])print("Reduced");print(X_reduced_rfe[:3,:])
#Code from sklearn documentationfrom sklearn.svm import SVCfrom sklearn.datasets import load_digitsfrom sklearn.feature_selection import RFEimport matplotlib.pyplot as plt# Load the digits datasetdigits = load_digits()X = digits.images.reshape((len(digits.images), -1))y = digits.target# Create the RFE object and rank each pixelsvc = SVC(kernel="linear", C=1)rfe = RFE(estimator=svc, n_features_to_select=1, step=1)rfe.fit(X, y);
Vamos a visualizar el ranking por pixel:
ranking = rfe.ranking_.reshape(digits.images[0].shape)# Plot pixel rankingplt.matshow(ranking, cmap=plt.cm.Blues)plt.colorbar()plt.title("Ranking of pixels with RFE")plt.show()
Selección de Características con SelectFromModel
SelectFromModel es un meta-transformador que puede usar cualquier estimador que asigne importancia de los atributos:
Si quedan por debajo de un umbral se eliminan.
Se puede usar también mean, median y multiplicadores como 0.1*mean.
from sklearn.svm import LinearSVCfrom sklearn.feature_selection import SelectFromModel#Use a LinearSVC as the base model for feature selectionlsvc = LinearSVC(C=0.01, penalty="l1", dual=False).fit(X_iris, y_iris)#Build a model-based selector with the lsvc to reduce the number of features of iris, preserving only thos avobe the average relevanceSFmodel = SelectFromModel(lsvc, prefit=True, threshold="1.25*mean")X_reduced_model = SFmodel.transform(X_iris)print(X_iris.iloc[:5,:])print(X_reduced_model.shape)print(X_reduced_model[:5,:])
from sklearn.ensemble import ExtraTreesClassifier#now we do the same but using a tree classifier as the base model for feature selectionclf = ExtraTreesClassifier(n_estimators=50)clf = clf.fit(X_iris, y_iris)SFmodel = SelectFromModel(clf, prefit=True, threshold="1.25*mean")X_reduced = SFmodel.transform(X_iris)#We can use any model that computes the faeture importance a the base modelprint(clf.feature_importances_)print(X_reduced.shape)
#We can do the same for the diabetes datasetdiabetes = datasets.load_diabetes()X_diabetes = diabetes.datay_diabetes = diabetes.targetfrom sklearn.linear_model import RidgeCVridge = RidgeCV(alphas=np.logspace(-6, 6, num=5)).fit(X_diabetes, y_diabetes)importance = np.abs(ridge.coef_)df = pd.DataFrame({"feature_names": diabetes.feature_names, "importance": importance})sns.catplot(x="feature_names", y="importance", data=df, kind="bar", errorbar=None, aspect=2, height=4, color="skyblue")plt.show()
Selección de Características Secuencial
La selección secuencial (Forward-SFS) busca iterativamente una nueva característica a añadir a las ya seleccionadas. Empieza con cero características y escoge aquella que maximiza aplicando CV usando un estimador (cualquiera le vale, pero mejor que no sea lento) sobre una única característica.
Luego repite el procedimiento añadiendo una nueva característica cada vez, hasta terminar con el número pedido de características.
Backward-SFS
Backward-SFS sigue la misma idea, pero al revés, en vez de ir añadiendo va eliminando características aplicando un estimador.
No dan los mismos resultado, ni son igualmente eficientes. Si tenemos 10 características y queremos siete será más eficiente Backward-SFS que Forward-SFS.
Scikit-learn ofrece SequentialFeatureSelector que implementa ambos ( direction puede ser forward o backward).
Ejemplo:
from sklearn.feature_selection import SequentialFeatureSelectorimport warningswarnings.filterwarnings('ignore')#Perform FORDWARD feature selection over the diabetes dataset to reduce it to 3 dimensionssfs_forward = SequentialFeatureSelector(clf, n_features_to_select=3, direction="forward")sfs_forward_fitted = sfs_forward.fit(X_diabetes, y_diabetes)X_reduced_for = sfs_forward.transform(X_diabetes)print(X_reduced_for.shape)print(sfs_forward_fitted.get_support())atribs = np.array(diabetes.feature_names)print("Atributos elegidos")print(atribs[sfs_forward_fitted.get_support()])
#Perform BACKWARD feature selection over the diabetes dataset to reduce it to 3 dimensionssfs_backward = SequentialFeatureSelector(clf, n_features_to_select=3, direction="backward")sfs_backward_fitted = sfs_backward.fit(X_diabetes, y_diabetes)X_reduced_back = sfs_backward_fitted.transform(X_diabetes)print(X_reduced_back.shape)print(sfs_backward_fitted.get_support())print("Atributos elegidos")print(atribs[sfs_backward_fitted.get_support()])
A menudo los datos contienen instancias redundantes. Como el tamaño puede afectar a la calidad de los resultados (y el tiempo) vamos a intentar reducirlo.
También es importante cuando las muestras están poco balanceadas.
Veremos dos enfoques: generación de prototipos, y selección de prototipos.
En este caso se reducen las muestras pero las que quedan son generadas (no seleccionadas) del original. La técnica más usada es el K-Means, y sintetizar cada clase con un centroide del K-Means en vez de uar las muestras originales.
Vamos a crear unos datos de ejemplo:
from sklearn.datasets import make_classificationfrom collections import Counter#Create an artificial datasets to see the effects of under-sampling and over-samplingX, y = make_classification(n_samples=5000, n_features=2, n_informative=2, n_redundant=0, n_repeated=0, n_classes=3, n_clusters_per_class=1, weights=[0.01, 0.05, 0.94], class_sep=0.8, random_state=10)print(sorted(Counter(y).items()))
Edited Nearest Neighbours aplica el algoritmo de vecinos más cercanos y borra las instancias que no son suficientemente similares a las del vecindario.
Para cada instancia, se calculas sus vecinas y si no se cumple el criterio se borra.
Existen dos criterio a la hora de comparar las vecindas:
La mayoría (kind_sel='mode') deben pertenecer a la misma clase.
Que todas (kind_sel='all') pertenezcan a la misma clase.
El primero es más conservador y el segundo excluye más.
Aplicamos primero el más conservador:
from imblearn.under_sampling import EditedNearestNeighboursenn = EditedNearestNeighbours(kind_sel="all")X_resampled, y_resampled = enn.fit_resample(X, y)print(X_resampled.shape)print(sorted(Counter(y_resampled).items()))reduced = (X.shape[0]-X_resampled.shape[0])/X.shape[0]print(f"Reduce el {100*reduced:.2} %")
Aunque no es reducción vamos a ver cómo se pueden sobre-muestrear las instancias para tener más ejemplares de las clases minoritarias y obtener mejor resultados.
imblearn ofrece varios, como el aleatorio, SMOTE, entre otros. Vamos a ver los dos primeros.
Primero creamos los datos
from sklearn.datasets import make_classificationX, y = make_classification(n_samples=500, n_features=2, n_informative=2, n_redundant=0, n_repeated=0, n_classes=3, n_clusters_per_class=1, weights=[0.01, 0.05, 0.94], class_sep=0.8, random_state=42)print(sorted(Counter(y).items()))
# eliminar outliers como aquellos casos fuera de 1.25 veces el rango intercuartilratio =1.25Q1 = X_df.quantile(0.25)Q3 = X_df.quantile(0.75)IQR = Q3 - Q1outliers = ((X_df < (Q1 - ratio * IQR)) |(X_df > (Q3 + ratio * IQR))).any(axis=1)X_df_irq= X_df.copy()X_df_irq["outlier"] = outliers
Scikit-learn ofrece distintos algoritmos para detectar outliersEn la Documentación
Vamos a probar Isolation Forest.
Isolation Forest
‘Aisla’ observaciones aleatoriamente escogiendo una característica y aleatoriamente divide recursivamente según sus valores, usando una estructura de árbol.
Cerca de -1 si lo considera outlier, 1 en caso contrario.
from sklearn.ensemble import IsolationForestclf = IsolationForest(n_estimators=10, warm_start=True)clf.fit(X_df) # fit 10 treesX_df_if = X_df.copy()X_df_if["outlier"] = clf.predict(X_df) <1print(X_df_if.head(3))
Esta técnica mide la desviación local de una muestra respecto a los vecinos (usando k-vecinos). Al comparar la distancia local con la de los vecinos, se ientifica las instancias con una densidad sustanciamente menor que sus vecinos.
Cerca de -1 si lo considera outlier, 1 en caso contrario.
Reduce usando PCA o el cluster agglomerativo la dimensionalidad de los valores numéricos del problema en 2 componentes. Nota: Es cómodo usar el atributo select_dtypes de pandas para filtrar atributos de tipo np.number.
Visualiza la representación, resaltando la especie. ¿Es separable en dos?
Ejercicios de selección de características
Vamos a usar aquí el dataset de estudiantes.
students = pd.read_csv("estudiantes.csv")
Target es el valor con el que se quiere predecir, que indica si los estudiantes terminan la carrera o no.
Elimina directamente los atributos con valores perdidos, y usa StandardScaler sobre el resto.
Separa el atributo Target en otra variable.
Visualizar usando yellobricks la importancia de las características.
Carga el estimador
from sklearn import svmlsvc = svm.LinearSVC(C=0.01, penalty="l1", dual=False)
Usando SelectModel con ese estimador eliminar el 20% de los atributos.
Usa SequentialFeatureSelector con ese estimador para eliminar el 20% de los atributos en ambas direcciones, ¿cuáles son eliminados?
¿Son iguales en ambas direcciones?
Ejercicio de Balanceo
Students no está bien balanceado. Haz un Random Under sampling y comprueba que ahora sí esté balanceado.
Haz un Edited Nearest Neighbours sobre el original menos conservador, ¿cuántos ha quitado?
Ejercicio de anomalías
Elimina Datos anómalos usando LocalOutlierFactor e indica el porcentaje de eliminados.
