Aplicar métodos de filtro en Python para la selección de características

Los algoritmos de aprendizaje automático y aprendizaje profundo aprenden de los datos, que consisten en diferentes tipos de características. El tiempo de entrenamiento y el rendimiento de una máquina le...

Introducción

Los algoritmos de aprendizaje automático y aprendizaje profundo aprenden de los datos, que consisten en 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 retener aquellas características en el conjunto de datos que realmente ayuden a nuestro modelo de aprendizaje automático a aprender algo.

Las características 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 características más adecuadas para entrenar el modelo de aprendizaje automático se denomina "selección de características".

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

  • Los modelos con menos número de características tienen mayor explicabilidad
  • Es más fácil implementar modelos de aprendizaje automático con características reducidas
  • Menos características conducen a una mayor generalización 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 filtro. En este artículo, estudiaremos algunos de los métodos de filtro básicos para la selección de funciones.

Métodos de filtro 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. Esta 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 proceso de selección de funciones.

Los métodos de filtrado se pueden clasificar en general en dos categorías: Métodos de filtrado univariados y Métodos de filtrado multivariados.

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 univariante, por ejemplo puntuación de pescador, información mutua y [diferencia](https:/ /en.wikipedia.org/wiki/Variance) de la función.

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

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

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

Eliminación de 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 en la clasificación del registro en cuestión. Por lo tanto, es recomendable 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 Satisfacción del Cliente Santander, que se puede descargar desde 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 función VarianceThreshold de la biblioteca Aprender de Python. Ejecute el siguiente script para importar las bibliotecas requeridas y el conjunto de datos:

1
2
3
4
5
6
7
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:\Datasets\santandar_data.csv", nrows=40000)
santandar_data.shape

Filtré los primeros 40 mil registros. En la salida, 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 entrenamiento y prueba

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 entrenamiento y prueba. Ejecute el siguiente script:

1
2
3
4
5
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 varianza

Ahora es el momento de eliminar las características constantes. Para hacerlo, usaremos la función VarianceThreshold que importamos anteriormente. La función requiere un valor para su parámetro umbral. 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.

1
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:

1
constant_filter.fit(train_features)

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

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

En el resultado, debería ver 320, lo que significa que de las 370 funciones del conjunto de entrenamiento, 320 funciones no son constantes.

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

1
2
3
4
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 constantes, ejecute el siguiente script:

1
2
for column in constant_columns:
    print(column)

La salida se ve así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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 método transform() del constant_filter. Ejecute el siguiente script para hacerlo:

1
2
3
4
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 casi constantes

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

En esta sección, crearemos un filtro casi constante con la ayuda de la función VarianceThreshold. Sin embargo, en lugar de pasar 0 como valor para el parámetro umbral, pasaremos 0,01, lo que significa que si la varianza de los valores en una columna es inferior a 0,01, eliminaremos 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 la sección anterior. Importaremos el conjunto de datos y las bibliotecas, realizaremos una división de prueba de entrenamiento y eliminaremos primero las características constantes.

Importación de bibliotecas y conjuntos de datos necesarios

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

1
2
3
4
5
6
7
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:\Datasets\santandar_data.csv", nrows=40000)
santandar_data.shape
División de datos en conjuntos de entrenamiento y prueba
1
2
3
4
5
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 varianza

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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 funciones casi constantes mediante el umbral de varianza

Vamos a crear nuestro filtro cuasi-constante. Ejecute el siguiente script para hacerlo:

1
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 método fit() como se muestra a continuación.

1
qconstant_filter.fit(train_features)

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

1
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 casi constantes, ejecute el siguiente script:

1
2
3
4
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.

Ahora imprimamos los nombres de todas las columnas cuasi-constantes. Ejecute el siguiente script:

1
2
for column in qconstant_columns:
    print(column)

En la salida, debería ver los siguientes nombres de columna:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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 columnas no constantes y no cuasi constantes, podemos usar el método transform() de qconstant_filter. Ejecute el siguiente script para hacerlo:

1
2
3
4
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 tanto nuestros conjuntos de entrenamiento como de prueba ahora contendrán 265 columnas, ya que las 50 columnas constantes y las 55 cuasi constantes se han eliminado de un total de 370 columnas predeterminadas.

Eliminación de funciones duplicadas

Las características duplicadas son las características que tienen valores similares. Las funciones duplicadas no agregan ningún valor al entrenamiento del algoritmo, sino que agregan una sobrecarga y un retraso innecesario al tiempo de entrenamiento. Por lo tanto, siempre se recomienda eliminar las entidades 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:

1
2
3
4
5
6
7
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:\Datasets\santandar_data.csv", nrows=20000)
santandar_data.shape

La eliminación de columnas duplicadas puede ser costosa desde el punto de vista computacional, ya que tenemos que tomar la transposición de la matriz de datos antes de que podamos eliminar las funciones duplicadas. Por lo tanto, en el script anterior, solo importamos los primeros 20 000 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 entrenamiento y prueba
1
2
3
4
5
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 funciones duplicadas mediante Transpose

A diferencia de las funciones constantes y casi constantes, no tenemos un método Python integrado que pueda eliminar las funciones 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:

1
2
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 marco de datos train_features_T. 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 el método duplicado() 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.

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

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

En la salida, debería ver 94.

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

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

Ahora, imprimamos la forma de nuestro nuevo conjunto de entrenamiento sin características duplicadas:

1
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:

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

En la salida, debería ver las siguientes columnas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
['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']

Eliminación de funciones correlacionadas

Además de las entidades duplicadas, un conjunto de datos también puede contener entidades correlacionadas. Dos o más de dos entidades están correlacionadas si están próximas entre sí en el espacio lineal.

Tomemos el ejemplo del conjunto de características para una canasta de frutas, el peso de la canasta 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 dichas características deben conservarse. Sin embargo, si dos o más de dos características están mutuamente correlacionadas, 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 Gestión de Siniestros, que puede ser descargado de Kaggle. Siga estos pasos para buscar y eliminar las entidades 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:

1
2
3
4
5
6
7
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:\Datasets\paribas_data.csv", nrows=20000)
paribas_data.shape

En el script anterior, importé el conjunto de datos junto con las bibliotecas requeridas. A continuación, imprimimos la forma de nuestro marco de datos. En el resultado, 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 {#preprocesamiento de datos}

Ejecute el siguiente script para eliminar las características no numéricas del conjunto de datos.

1
2
3
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 método select_dtypes() en nuestro conjunto de datos y le pasamos la lista num_colums que contiene el tipo de columnas que queremos conservar. El método select_dtypes() devolverá los nombres de las columnas numéricas especificadas, que almacenamos en la lista numeric_columns. A continuación, filtramos nuestras columnas del marco de datos paribas_data con la ayuda de la lista numerical_colums. Imprimamos la forma del marco de datos paribas_data para ver cuántas columnas numéricas tenemos, ejecute el siguiente script:

1
paribas_data.shape

En el resultado, 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 características.

División de datos en conjuntos de entrenamiento y prueba

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:

1
2
3
4
5
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 conjunto de prueba.

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

Para eliminar las características correlacionadas, podemos hacer uso del método corr() del marco de datos de pandas. El método corr() 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 el umbral de correlación, 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 en el conjunto de datos y un conjunto vacío que contendrá todas las características correlacionadas. Ejecute el siguiente script para hacerlo:

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

En el script anterior, creamos la matriz de correlación correlation_matrix para todas las columnas de nuestro conjunto de datos. También creamos un conjunto características_correlacionadas que contendrá los nombres de todas las características correlacionadas.

A continuación, recorreremos todas las columnas en correlation_matrix y agregaremos las columnas con un valor de correlación de 0.8 al conjunto correlated_features como se muestra a continuación. Puede establecer cualquier valor de umbral para la correlación.

1
2
3
4
5
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:

1
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:

1
print(correlated_features)

La salida se ve así:

1
{'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 enmascarado 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.

El siguiente script elimina estas columnas del conjunto de datos:

1
2
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 la capacitación 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 las características constantes y casi constantes y luego eliminando las 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! ción!