Aplicación de métodos de filtrado en Python para la selección de características

    Introducción

    Los algoritmos de aprendizaje automático y aprendizaje profundo aprenden de los datos, que constan de diferentes tipos de características. El tiempo de entrenamiento y el rendimiento de un algoritmo de aprendizaje automático dependen en gran medida de las características del conjunto de datos. Idealmente, solo deberíamos conservar aquellas características en el conjunto de datos que realmente ayuden a nuestro modelo de aprendizaje automático a aprender algo.

    Las funciones innecesarias y redundantes no solo ralentizan el tiempo de entrenamiento de un algoritmo, sino que también afectan el rendimiento del algoritmo. El proceso de selección de las funciones más adecuadas para entrenar el modelo de aprendizaje automático se denomina «selección de funciones».

    Existen varias ventajas de realizar la selección de funciones antes de entrenar modelos de aprendizaje automático, algunas de las cuales se enumeran a continuación:

    • Los modelos con menor número de características tienen mayor explicabilidad
    • Es más fácil implementar modelos de aprendizaje automático con funciones reducidas
    • Menos características conducen a una generalización mejorada que a su vez reduce el sobreajuste
    • La selección de funciones elimina la redundancia de datos
    • El tiempo de entrenamiento de los modelos con menos funciones es significativamente menor
    • Los modelos con menos funciones son menos propensos a errores

    Se han desarrollado varios métodos para seleccionar las características más óptimas para un algoritmo de aprendizaje automático. Una categoría de tales métodos se llama métodos de filtrado. En este artículo, estudiaremos algunos de los métodos de filtrado básicos para la selección de funciones.

    Métodos de filtrado para la selección de funciones

    Los métodos de filtros pertenecen a la categoría de métodos de selección de características que seleccionan características independientemente del modelo de algoritmo de aprendizaje automático. Ésta es una de las mayores ventajas de los métodos de filtrado. Las funciones seleccionadas mediante métodos de filtro se pueden utilizar como entrada para cualquier modelo de aprendizaje automático. Otra ventaja de los métodos de filtrado es que son muy rápidos. Los métodos de filtro son generalmente el primer paso en cualquier canal de selección de características.

    Los métodos de filtro se pueden clasificar en dos categorías: métodos de filtro univariante y métodos de filtro multivariante .

    Los métodos de filtro univariados son el tipo de métodos en los que las características individuales se clasifican según criterios específicos. A continuación, se seleccionan las N características principales. Se utilizan diferentes tipos de criterios de clasificación para los métodos de filtro univariados, por ejemplo , puntuación de Fisher , información mutua y varianza de la característica.

    Una de las principales desventajas de los métodos de filtro univariados es que pueden seleccionar características redundantes porque la relación entre características individuales no se tiene en cuenta al tomar decisiones. Los métodos de filtro univariados son ideales para eliminar características constantes y cuasi constantes de los datos.

    Los métodos de filtro multivariante son capaces de eliminar características redundantes de los datos, ya que tienen en cuenta la relación mutua entre las características. Se pueden utilizar métodos de filtro multivariante para eliminar características duplicadas y correlacionadas de los datos.

    En este artículo, veremos cómo podemos eliminar características constantes, cuasi constantes, duplicadas y correlacionadas de nuestro conjunto de datos con la ayuda de Python.

    Eliminar características constantes

    Las características constantes son el tipo de características que contienen solo un valor para todas las salidas en el conjunto de datos. Las características constantes no proporcionan información que pueda ayudar a clasificar el registro en cuestión. Por lo tanto, es aconsejable eliminar todas las características constantes del conjunto de datos.

    Veamos cómo podemos eliminar características constantes de un conjunto de datos. El conjunto de datos que vamos a utilizar para este ejemplo es el conjunto de datos de satisfacción del cliente de Santandar , que se puede descargar de Kaggle. Usaremos el archivo «train.csv». Sin embargo, le he cambiado el nombre a «santandar_data.csv» para facilitar la lectura.

    Importación de bibliotecas y conjuntos de datos necesarios

    Las características constantes tienen valores con varianza cero ya que todos los valores son iguales. Podemos encontrar las columnas constantes usando la VarianceThresholdfunción de la Biblioteca Scikit Learn de Python . Ejecute el siguiente script para importar las bibliotecas necesarias y el conjunto de datos:

    import pandas as pd
    import numpy as np
    from sklearn.model_selection import train_test_split
    from sklearn.feature_selection import VarianceThreshold
    
    santandar_data = pd.read_csv(r"E:Datasetssantandar_data.csv", nrows=40000)
    santandar_data.shape
    

    Filtre los 40 mil primeros registros. En el resultado, debería ver (40000, 371) lo que significa que tenemos 40 mil filas y 371 columnas en nuestro conjunto de datos.

    División de datos en conjuntos de prueba y entrenamiento

    Es importante mencionar aquí que, para evitar el sobreajuste, la selección de características solo debe aplicarse al conjunto de entrenamiento. Dividamos nuestros datos en conjuntos de prueba y entrenamiento. Ejecute el siguiente script:

    train_features, test_features, train_labels, test_labels=train_test_split(
        santandar_data.drop(labels=['TARGET'], axis=1),
        santandar_data['TARGET'],
        test_size=0.2,
        random_state=41)
    

    Eliminación de características constantes mediante el umbral de variación

    Ahora es el momento de eliminar las características constantes. Para hacerlo usaremos la VarianceThresholdfunción que importamos anteriormente. La función requiere un valor para su thresholdparámetro. Pasar un valor de cero para el parámetro filtrará todas las características con variación cero. Ejecute el siguiente script para crear un filtro para características constantes.

    constant_filter = VarianceThreshold(threshold=0)
    

    A continuación, simplemente debemos aplicar este filtro a nuestro conjunto de entrenamiento como se muestra en el siguiente ejemplo:

    constant_filter.fit(train_features)
    

    Ahora, para obtener todas las características que no son constantes, podemos usar el get_support()método del filtro que creamos. Ejecute el siguiente script para ver el número de características no constantes.

    len(train_features.columns[constant_filter.get_support()])
    

    En el resultado, debería ver 320, lo que significa que de 370 características en el conjunto de entrenamiento, 320 características no son constantes.

    Del mismo modo, puede encontrar el número de características constantes con la ayuda del siguiente script:

    constant_columns = [column for column in train_features.columns
                        if column not in train_features.columns[constant_filter.get_support()]]
    
    print(len(constant_columns))
    

    Para ver todas las columnas de constantes, ejecute el siguiente script:

    for column in constant_columns:
        print(column)
    

    La salida se ve así:

    ind_var2_0
    ind_var2
    ind_var18_0
    ind_var18
    ind_var27_0
    ind_var28_0
    ind_var28
    ind_var27
    ind_var34_0
    ind_var34
    ind_var41
    ind_var46_0
    ind_var46
    num_var18_0
    num_var18
    num_var27_0
    num_var28_0
    num_var28
    num_var27
    num_var34_0
    num_var34
    num_var41
    num_var46_0
    num_var46
    saldo_var18
    saldo_var28
    saldo_var27
    saldo_var34
    saldo_var41
    saldo_var46
    delta_imp_amort_var18_1y3
    delta_imp_amort_var34_1y3
    imp_amort_var18_hace3
    imp_amort_var18_ult1
    imp_amort_var34_hace3
    imp_amort_var34_ult1
    imp_reemb_var13_hace3
    imp_reemb_var17_hace3
    imp_reemb_var33_hace3
    imp_trasp_var17_out_hace3
    imp_trasp_var33_out_hace3
    num_var2_0_ult1
    num_var2_ult1
    num_reemb_var13_hace3
    num_reemb_var17_hace3
    num_reemb_var33_hace3
    num_trasp_var17_out_hace3
    num_trasp_var33_out_hace3
    saldo_var2_ult1
    saldo_medio_var13_medio_hace3
    

    Finalmente, para eliminar características constantes de los conjuntos de entrenamiento y prueba, podemos usar el transform()método de constant_filter. Ejecute el siguiente script para hacerlo:

    train_features = constant_filter.transform(train_features)
    test_features = constant_filter.transform(test_features)
    
    train_features.shape, test_features.shape
    

    Si ejecuta el script anterior, verá que tanto nuestros conjuntos de entrenamiento como de prueba ahora contendrán 320 columnas, ya que se han eliminado las 50 columnas constantes.

    Eliminación de características cuasi-constantes

    Las características cuasi constantes, como su nombre indica, son las características que son casi constantes. En otras palabras, estas características tienen los mismos valores para un subconjunto muy grande de salidas. Estas características no son muy útiles para hacer predicciones. No existe una regla sobre cuál debería ser el umbral para la varianza de las características cuasi constantes. Sin embargo, como regla general, elimine aquellas características cuasi constantes que tengan valores similares en más del 99% para las observaciones de salida.

    En esta sección, crearemos un filtro cuasi-constante con la ayuda de VarianceThresholdfunction. Sin embargo, en lugar de pasar 0 como valor para el thresholdparámetro, pasaremos 0.01, lo que significa que si la varianza de los valores en una columna es menor que 0.01, elimine esa columna. En otras palabras, elimine la columna de características donde aproximadamente el 99% de los valores son similares.

    Los pasos son bastante similares a los de la sección anterior. Importaremos el conjunto de datos y las bibliotecas, realizaremos la división de prueba de tren y eliminaremos las características constantes primero.

    Importación de bibliotecas y conjuntos de datos necesarios

    Ejecute el siguiente script para importar el conjunto de datos y las bibliotecas deseadas:

    import pandas as pd
    import numpy as np
    from sklearn.model_selection import train_test_split
    from sklearn.feature_selection import VarianceThreshold
    
    santandar_data = pd.read_csv(r"E:Datasetssantandar_data.csv", nrows=40000)
    santandar_data.shape
    

    División de datos en conjuntos de prueba y entrenamiento

    train_features, test_features, train_labels, test_labels = train_test_split(
        santandar_data.drop(labels=['TARGET'], axis=1),
        santandar_data['TARGET'],
        test_size=0.2,
        random_state=41)
    

    Eliminación de características constantes mediante el umbral de variación

    Antes de que podamos eliminar las características cuasi constantes, primero debemos eliminar las características constantes. Ejecute el siguiente script para hacerlo:

    constant_filter = VarianceThreshold(threshold=0)
    constant_filter.fit(train_features)
    
    len(train_features.columns[constant_filter.get_support()])
    
    constant_columns = [column for column in train_features.columns
                        if column not in train_features.columns[constant_filter.get_support()]]
    
    train_features.drop(labels=constant_columns, axis=1, inplace=True)
    test_features.drop(labels=constant_columns, axis=1, inplace=True)
    

    Eliminación de características cuasi-constantes mediante el umbral de variación

    Creemos nuestro filtro cuasi-constante. Ejecute el siguiente script para hacerlo:

    qconstant_filter = VarianceThreshold(threshold=0.01)
    

    El resto de los pasos son los mismos. Necesitamos aplicar el filtro a nuestro conjunto de entrenamiento usando el fit()método que se muestra a continuación.

    qconstant_filter.fit(train_features)
    

    Comprobemos el número de nuestras columnas no cuasi constantes. Ejecute el siguiente script:

    len(train_features.columns[qconstant_filter.get_support()])
    

    En el resultado, debería ver 265, lo que significa que de las 320 columnas que logramos después de eliminar las características constantes, 55 son casi constantes.

    Para verificar el número de columnas cuasi-constantes, ejecute el siguiente script:

    qconstant_columns = [column for column in train_features.columns
                        if column not in train_features.columns[qconstant_filter.get_support()]]
    
    print(len(qconstant_columns))
    

    Debería ver 55 en la salida.

    Imprimamos ahora los nombres de todas las columnas cuasi constantes. Ejecute el siguiente script:

    for column in qconstant_columns:
        print(column)
    

    En el resultado, debería ver los siguientes nombres de columna:

    ind_var1
    ind_var6_0
    ind_var6
    ind_var13_largo
    ind_var13_medio_0
    ind_var13_medio
    ind_var14
    ind_var17_0
    ind_var17
    ind_var19
    ind_var20_0
    ind_var20
    ind_var29_0
    ind_var29
    ind_var30_0
    ind_var31_0
    ind_var31
    ind_var32_cte
    ind_var32_0
    ind_var32
    ind_var33_0
    ind_var33
    ind_var40
    ind_var39
    ind_var44_0
    ind_var44
    num_var6_0
    num_var6
    num_var13_medio_0
    num_var13_medio
    num_op_var40_hace3
    num_var29_0
    num_var29
    delta_imp_aport_var33_1y3
    delta_num_aport_var33_1y3
    ind_var7_emit_ult1
    ind_var7_recib_ult1
    num_aport_var33_hace3
    num_aport_var33_ult1
    num_var7_emit_ult1
    num_meses_var13_medio_ult3
    num_meses_var17_ult3
    num_meses_var29_ult3
    num_meses_var33_ult3
    num_meses_var44_ult3
    num_reemb_var13_ult1
    num_reemb_var17_ult1
    num_reemb_var33_ult1
    num_trasp_var17_in_hace3
    num_trasp_var17_in_ult1
    num_trasp_var17_out_ult1
    num_trasp_var33_in_hace3
    num_trasp_var33_in_ult1
    num_trasp_var33_out_ult1
    num_venta_var44_hace3
    

    Finalmente, para ver si nuestros conjuntos de entrenamiento y prueba solo contienen las columnas no constantes y no cuasi constantes, podemos usar el transform()método de qconstant_filter. Ejecute el siguiente script para hacerlo:

    train_features = qconstant_filter.transform(train_features)
    test_features = qconstant_filter.transform(test_features)
    
    train_features.shape, test_features.shape
    

    Si ejecuta el script anterior, verá que nuestros conjuntos de entrenamiento y prueba ahora contendrán 265 columnas, ya que las 50 constantes y las 55 cuasi constantes se han eliminado de un total de 370 columnas predeterminadas.

    Eliminar funciones duplicadas

    Las entidades duplicadas son entidades que tienen valores similares. Las funciones duplicadas no agregan ningún valor al entrenamiento de algoritmos, sino que agregan gastos generales y retrasos innecesarios al tiempo de entrenamiento. Por lo tanto, siempre se recomienda eliminar las características duplicadas del conjunto de datos antes del entrenamiento.

    Importación de bibliotecas y conjuntos de datos necesarios

    Ejecute el siguiente script para importar el conjunto de datos y las bibliotecas deseadas:

    import pandas as pd
    import numpy as np
    from sklearn.model_selection import train_test_split
    from sklearn.feature_selection import VarianceThreshold
    
    santandar_data = pd.read_csv(r"E:Datasetssantandar_data.csv", nrows=20000)
    santandar_data.shape
    

    Eliminar columnas duplicadas puede ser costoso desde el punto de vista computacional, ya que tenemos que tomar la transposición de la matriz de datos antes de poder eliminar las características duplicadas. Por lo tanto, en el script anterior, solo importamos los primeros 20 mil registros de los datos de satisfacción del cliente de santandar que hemos estado usando en este artículo.

    División de datos en conjuntos de prueba y entrenamiento

    train_features, test_features, train_labels, test_labels = train_test_split(
        santandar_data.drop(labels=['TARGET'], axis=1),
        santandar_data['TARGET'],
        test_size=0.2,
        random_state=41)
    

    Eliminar funciones duplicadas mediante Transposición

    A diferencia de las características constantes y cuasi-constantes, no tenemos un método de Python integrado que pueda eliminar características duplicadas. Sin embargo, tenemos un método que puede ayudarnos a identificar filas duplicadas en un marco de datos de pandas. Usaremos este método para tomar primero una transposición de nuestro conjunto de datos como se muestra a continuación:

    train_features_T = train_features.T
    train_features_T.shape
    

    En el script anterior, tomamos la transposición de nuestros datos de entrenamiento y los almacenamos en el train_features_Tmarco de datos. Nuestro conjunto de entrenamiento inicial contiene 16000 filas y 370 columnas; si observa la forma del conjunto de entrenamiento transpuesto, verá que contiene 370 filas y 16000 columnas.

    Afortunadamente, en pandas tenemos un duplicated()método que puede ayudarnos a encontrar filas duplicadas del marco de datos. Recuerde, las filas del marco de datos transpuesto son en realidad las columnas o las características del marco de datos real.

    Busquemos el número total de características duplicadas en nuestro conjunto de datos usando el sum()método, encadenado con el duplicated()método como se muestra a continuación.

    print(train_features_T.duplicated().sum())
    

    En la salida, debería ver 94.

    Finalmente, podemos eliminar las filas duplicadas usando el drop_duplicates()método. Si pasa el valor de la cadena firstal keepparámetro del drop_duplicates()método, todas las filas duplicadas se descartarán excepto la primera copia. En el siguiente paso, eliminaremos todas las filas duplicadas y realizaremos la transposición del conjunto de entrenamiento transpuesto para obtener el conjunto de entrenamiento original que no contiene ninguna columna duplicada. Ejecute el siguiente script:

    unique_features = train_features_T.drop_duplicates(keep='first').T
    

    Ahora, imprimamos la forma de nuestro nuevo conjunto de entrenamiento sin funciones duplicadas:

    unique_features.shape
    

    En el resultado, debería ver (16000,276), puede ver que después de eliminar 94 columnas duplicadas, el tamaño de nuestro conjunto de funciones se ha reducido significativamente.

    Para ver los nombres de las columnas duplicadas, ejecute este script:

    duplicated_features = [dup_col for dup_col in train_features.columns if dup_col not in unique_features.columns]
    duplicated_features
    

    En el resultado, debería ver las siguientes columnas:

    ['ind_var2',
     'ind_var13_medio',
     'ind_var18_0',
     'ind_var18',
     'ind_var26',
     'ind_var25',
     'ind_var27_0',
     'ind_var28_0',
     'ind_var28',
     'ind_var27',
     'ind_var29_0',
     'ind_var29',
     'ind_var32',
     'ind_var34_0',
     'ind_var34',
     'ind_var37',
     'ind_var40_0',
     'ind_var40',
     'ind_var41',
     'ind_var39',
     'ind_var46_0',
     'ind_var46',
     'num_var13_medio',
     'num_var18_0',
     'num_var18',
     'num_var26',
     'num_var25',
     'num_op_var40_hace3',
     'num_op_var39_hace3',
     'num_var27_0',
     'num_var28_0',
     'num_var28',
     'num_var27',
     'num_var29_0',
     'num_var29',
     'num_var32',
     'num_var34_0',
     'num_var34',
     'num_var37',
     'num_var40_0',
     'num_var40',
     'num_var41',
     'num_var39',
     'num_var46_0',
     'num_var46',
     'saldo_var18',
     'saldo_var28',
     'saldo_var27',
     'saldo_var29',
     'saldo_var34',
     'saldo_var40',
     'saldo_var41',
     'saldo_var46',
     'delta_imp_amort_var18_1y3',
     'delta_imp_amort_var34_1y3',
     'delta_imp_reemb_var33_1y3',
     'delta_imp_trasp_var17_out_1y3',
     'delta_imp_trasp_var33_out_1y3',
     'delta_num_reemb_var13_1y3',
     'delta_num_reemb_var17_1y3',
     'delta_num_reemb_var33_1y3',
     'delta_num_trasp_var17_in_1y3',
     'delta_num_trasp_var17_out_1y3',
     'delta_num_trasp_var33_in_1y3',
     'delta_num_trasp_var33_out_1y3',
     'imp_amort_var18_hace3',
     'imp_amort_var18_ult1',
     'imp_amort_var34_hace3',
     'imp_amort_var34_ult1',
     'imp_var7_emit_ult1',
     'imp_reemb_var13_hace3',
     'imp_reemb_var17_hace3',
     'imp_reemb_var33_hace3',
     'imp_reemb_var33_ult1',
     'imp_trasp_var17_out_hace3',
     'imp_trasp_var17_out_ult1',
     'imp_trasp_var33_in_hace3',
     'imp_trasp_var33_out_hace3',
     'ind_var7_emit_ult1',
     'num_var2_0_ult1',
     'num_var2_ult1',
     'num_var7_emit_ult1',
     'num_reemb_var13_hace3',
     'num_reemb_var17_hace3',
     'num_reemb_var33_hace3',
     'num_reemb_var33_ult1',
     'num_trasp_var17_out_hace3',
     'num_trasp_var17_out_ult1',
     'num_trasp_var33_in_hace3',
     'num_trasp_var33_out_hace3',
     'saldo_var2_ult1',
     'saldo_medio_var13_medio_hace3',
     'saldo_medio_var13_medio_ult1',
     'saldo_medio_var29_hace3']
    

    Eliminar funciones correlacionadas

    Además de las características duplicadas, un conjunto de datos también puede contener características correlacionadas. Dos o más de dos características están correlacionadas si están cerca una de la otra en el espacio lineal .

    Tomemos el ejemplo del conjunto de características para una cesta de frutas, el peso de la cesta de frutas normalmente se correlaciona con el precio. Cuanto mayor sea el peso, mayor será el precio.

    La correlación entre las observaciones de salida y las características de entrada es muy importante y estas características deben mantenerse. Sin embargo, si dos o más de dos características están correlacionadas entre sí, transmiten información redundante al modelo y, por lo tanto, solo una de las características correlacionadas debe conservarse para reducir el número de características.

    El conjunto de datos que vamos a utilizar para esta sección es el conjunto de datos BNP Paribas Cardif Claims Management , que se puede descargar de Kaggle. Siga estos pasos para buscar y eliminar las características correlacionadas del conjunto de datos.

    Importación de bibliotecas y conjuntos de datos necesarios

    Ejecute el siguiente script para importar el conjunto de datos y las bibliotecas deseadas:

    import pandas as pd
    import numpy as np
    from sklearn.model_selection import train_test_split
    from sklearn.feature_selection import VarianceThreshold
    
    paribas_data = pd.read_csv(r"E:Datasetsparibas_data.csv", nrows=20000)
    paribas_data.shape
    

    En el script anterior, importé el conjunto de datos junto con las bibliotecas necesarias. A continuación, imprimimos la forma de nuestro marco de datos. En la salida, debería ver (20000, 133) lo que significa que nuestro conjunto de datos contiene 20 mil filas y 133 características.

    Para encontrar la correlación, solo necesitamos las características numéricas en nuestro conjunto de datos. Para filtrar todas las características, excepto las numéricas, necesitamos preprocesar nuestros datos.

    Preprocesamiento de datos

    Ejecute la siguiente secuencia de comandos para eliminar las características no numéricas del conjunto de datos.

    num_colums = ['int16', 'int32', 'int64', 'float16', 'float32', 'float64']
    numerical_columns = list(paribas_data.select_dtypes(include=num_colums).columns)
    paribas_data = paribas_data[numerical_columns]
    

    En la primera línea del script anterior, definimos una lista que contiene los tipos de datos de las columnas que queremos conservar en nuestro conjunto de datos. A continuación, llamamos al select_dtypes()método en nuestro conjunto de datos y le pasamos la num_columslista que contiene el tipo de columnas que queremos retener. El select_dtypes()método devolverá los nombres de las columnas numéricas especificadas, que almacenamos en la lista numeric_columns. A continuación, filtramos nuestras columnas del paribas_datamarco de datos con la ayuda de la numerical_columslista. paribas_dataImprimamos la forma del marco de datos para ver cuántas columnas numéricas tenemos, ejecute el siguiente script:

    paribas_data.shape
    

    En la salida, debería ver (20000, 114), lo que significa que ahora nuestro conjunto de datos contiene 20 mil registros y 114 características. Recuerde, anteriormente teníamos 133 funciones.

    División de datos en conjuntos de prueba y entrenamiento

    Como de costumbre, necesitamos dividir nuestros datos en conjuntos de entrenamiento y prueba antes de eliminar cualquier característica correlacionada, ejecute el siguiente script para dividir los datos en conjuntos de entrenamiento y prueba:

    train_features, test_features, train_labels, test_labels = train_test_split(
        paribas_data.drop(labels=['target', 'ID'], axis=1),
        paribas_data['target'],
        test_size=0.2,
        random_state=41)
    

    En el script anterior, dividimos nuestros datos en un 80% de entrenamiento y un 20% de prueba.

    Eliminación de funciones correlacionadas mediante el método corr ()

    Para eliminar las características correlacionadas, podemos hacer uso del corr()método del marco de datos de pandas. El corr()método devuelve una matriz de correlación que contiene la correlación entre todas las columnas del marco de datos. Luego podemos recorrer la matriz de correlación y ver si la correlación entre dos columnas es mayor que la correlación de umbral, agregar esa columna al conjunto de columnas correlacionadas. Podemos eliminar ese conjunto de columnas del conjunto de datos real.

    Primero creemos una matriz de correlación para las columnas del conjunto de datos y un conjunto vacío que contendrá todas las características correlacionadas. Ejecute el siguiente script para hacerlo:

    correlated_features = set()
    correlation_matrix = paribas_data.corr()
    

    En el script anterior, creamos una matriz de correlación correlation_matrixpara todas las columnas de nuestro conjunto de datos. También creamos un conjunto correlated_featuresque contendrá los nombres de todas las características correlacionadas.

    A continuación, recorreremos todas las columnas del correlation_matrixy agregaremos las columnas con un valor de correlación de 0.8 al correlated_featuresconjunto como se muestra a continuación. Puede establecer cualquier valor umbral para la correlación.

    for i in range(len(correlation_matrix .columns)):
        for j in range(i):
            if abs(correlation_matrix.iloc[i, j]) > 0.8:
                colname = correlation_matrix.columns[i]
                correlated_features.add(colname)
    

    Veamos el número total de columnas en nuestro conjunto de datos, con un valor de correlación superior a 0,8 con al menos otra columna. Ejecute el siguiente script:

    len(correlated_features)
    

    Debería ver 55 en la salida, que es casi el 40% de las características originales en el conjunto de datos. Puede ver cuánta información redundante contiene nuestro conjunto de datos. Ejecute el siguiente script para ver los nombres de estas funciones:

    print(correlated_features)
    

    La salida se ve así:

    {'v55', 'v105', 'v130', 'v12', 'v60', 'v67', 'v63', 'v46', 'v53', 'v43', 'v68', 'v123', 'v95', 'v103', 'v44', 'v108', 'v89', 'v104', 'v109', 'v83', 'v115', 'v21', 'v101', 'v93', 'v40', 'v78', 'v54', 'v118', 'v124', 'v73', 'v96', 'v121', 'v77', 'v114', 'v48', 'v116', 'v87', 'v86', 'v65', 'v122', 'v64', 'v81', 'v128', 'v49', 'v37', 'v84', 'v98', 'v111', 'v41', 'v25', 'v106', 'v32', 'v126', 'v76', 'v100'}
    

    El banco ha ocultado los nombres de las funciones ya que contienen información confidencial; sin embargo, puede ver los nombres en clave de las funciones. Estas columnas correlacionadas transmiten información similar al algoritmo de aprendizaje y, por lo tanto, deben eliminarse.

    La siguiente secuencia de comandos elimina estas columnas del conjunto de datos:

    train_features.drop(labels=correlated_features, axis=1, inplace=True)
    test_features.drop(labels=correlated_features, axis=1, inplace=True)
    

    Conclusión

    La selección de funciones juega un papel vital en el rendimiento y el entrenamiento de cualquier modelo de aprendizaje automático. Se han propuesto diferentes tipos de métodos para la selección de características para algoritmos de aprendizaje automático. En este artículo, estudiamos diferentes tipos de métodos de filtro para la selección de características usando Python.

    Comenzamos nuestra discusión eliminando características constantes y cuasi-constantes y luego eliminando características duplicadas. Finalmente, estudiamos cómo eliminar características correlacionadas de nuestro conjunto de datos.

    En el próximo artículo, veremos algunos de los otros tipos de métodos de selección de funciones. Hasta entonces, ¡feliz codificación!

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *