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

A

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!

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con tus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad