elección de funciones con sklearn

y pandas
Introducción a los métodos de Selección de
características y su implementación en Python

Abhini Shetye
Seguir
11 de febrero · 8 min de lectura

La selección de funciones es uno de los primeros e importantes

pasos al realizar cualquier tarea de aprendizaje
automático. Una característica en el caso de un conjunto de
datos simplemente significa una columna. Cuando obtenemos
cualquier conjunto de datos, no necesariamente cada columna
(característica) tendrá un impacto en la variable de salida. Si
agregamos estas características irrelevantes en el modelo, solo
empeorará el modelo (Garbage In Garbage Out). Esto da lugar
a la necesidad de hacer una selección de funciones.

Cuando se trata de la implementación de la selección de

funciones en Pandas, las funciones numéricas y categóricas
deben tratarse de manera diferente. Aquí discutiremos
primero sobre la selección de características numéricas. Por lo
tanto, antes de implementar los siguientes métodos, debemos
asegurarnos de que el DataFrame solo contenga funciones
numéricas. Además, se analizan los siguientes métodos para el
problema de regresión, lo que significa que las variables de
entrada y salida son de naturaleza continua.
La selección de funciones se puede hacer de varias maneras,
pero en general hay 3 categorías:
1. Método de filtro (mapa de calor/correlación de Pearson)
2. Método de envoltura (RFE)
3. Método integrado

Sobre el conjunto de datos:

Utilizaremos el conjunto de datos incorporado de Boston que
se puede cargar a través de sklearn. Seleccionaremos
características usando los métodos enumerados anteriormente
para el problema de regresión de predecir la columna
"MEDV". En el siguiente fragmento de código, importaremos
todas las bibliotecas necesarias y cargaremos el conjunto de
datos.
#
importación de bibliotecas de sklearn.datasets import
load_boston
import pandas como pd
import numpy as np
import matplotlib
import matplotlib.pyplot como plt
import seaborn as sns
import statsmodels.api como sm
% matplotlib en línea
desde sklearn.model_selection import
train_test_splitarRemortearmoarmode_arquitectura
Linear de sklearn
from sklearn.feature_selection import RFE
from sklearn.linear_model import RidgeCV, LassoCV, Ridge, Lasso
# Carga del conjunto de datos
x = load_boston ()
df = pd.DataFrame (x.data, columnas = x.feature_names)
df ["MEDV"] = x.target
X = df.drop ("MEDV", 1) #Feature Matrix
y = df ["MEDV"] #Target Variable
df.head ()
1. Método de filtro:
Como su nombre indica, en este método, filtra y toma solo el
subconjunto de las características relevantes. El modelo se
construye después de seleccionar las características. El filtrado
aquí se realiza utilizando la matriz de correlación y se realiza
con mayor frecuencia mediante la correlación de Pearson .

Aquí primero trazaremos el mapa de calor de correlación de

Pearson y veremos la correlación de variables independientes
con la variable de salida MEDV. Solo seleccionaremos
características que tengan una correlación de más de 0.5
(tomando el valor absoluto) con la variable de salida.

El coeficiente de correlación tiene valores entre -1 y 1

- Un valor más cercano a 0 implica una correlación más débil
(0 exacto implica que no hay correlación)
- Un valor más cercano a 1 implica una correlación positiva
más fuerte
- Un valor más cercano a -1 implica una correlación negativa
más fuerte
# Uso de Pearson Correlation
plt.figure (figsize = (12,10))
cor = df.corr ()
sns.heatmap (cor, annot = True, cmap = plt.cm.Reds)
plt.show ()
# Correlación con la variable de salida
cor_target = abs (cor ["MEDV"]) #Seleccionar características
altamente correlacionadas
relevantes_características = cor_target [cor_target> 0.5]
relevantes_características
Como podemos ver, solo las características RM, PTRATIO y
LSTAT están altamente correlacionadas con la variable de
salida MEDV. Por lo tanto, eliminaremos todas las demás
funciones aparte de estas. Sin embargo, este no es el final del
proceso.Una de las suposiciones de la regresión lineal es que
las variables independientes no deben estar correlacionadas
entre sí.Si estas variables están correlacionadas entre sí,
entonces necesitamos mantener solo una de ellas y descartar el
resto. Así que verifiquemos la correlación de las características
seleccionadas entre sí. Esto se puede hacer comprobándolo
visualmente desde la matriz de correlación anterior o desde el
fragmento de código a continuación.
print (df [["" LSTAT "," PTRATIO "]]. corr ())
print (df [[" "RM", "LSTAT"]]. corr ())

Del código anterior, se ve que las variables RM y LSTAT están

altamente correlacionadas entre sí (-0.613808). Por lo tanto,
mantendríamos solo una variable y descartaríamos la
otra. Mantendremos LSTAT ya que su correlación con MEDV
es mayor que la de RM.

Después de soltar RM, nos quedan dos funciones, LSTAT y

PTRATIO. Estas son las características finales dadas por la
correlación de Pearson.
2. Método de envoltura:
Un método de envoltura necesita un algoritmo de aprendizaje
automático y utiliza su rendimiento como criterio de
evaluación. Esto significa que alimenta las funciones al
algoritmo de aprendizaje automático seleccionado y, en
función del rendimiento del modelo, agrega / elimina las
funciones. Este es un proceso iterativo y computacionalmente
costoso, pero es más preciso que el método de filtro.

Existen diferentes métodos de envoltura, como la eliminación

hacia atrás, la selección hacia adelante, la eliminación
bidireccional y la RFE. Discutiremos Backward Elimination y
RFE aquí.

yo. Eliminación hacia atrás

Como su nombre lo indica, al principio le brindamos todas las
características posibles al modelo. Verificamos el rendimiento
del modelo y luego eliminamos iterativamente las
características de peor rendimiento una por una hasta que el
rendimiento general del modelo se encuentre en un rango
aceptable.

La métrica de rendimiento utilizada aquí para evaluar el

rendimiento de la característica es pvalue . Si el valor p está
por encima de 0.05, eliminamos la característica, de lo
contrario la conservamos.

Primero ejecutaremos una iteración aquí solo para tener una

idea del concepto y luego ejecutaremos el mismo código en un
bucle, que dará el conjunto final de características. Aquí
estamos utilizando el modelo OLS que significa "mínimos
cuadrados ordinarios". Este modelo se utiliza para realizar una
regresión lineal.
# Agregar columna constante de unidades, obligatorio para
sm.OLS modelo
X_1 = sm.add_constant (X) # Ajuste de modelo sm.OLS
model = sm.OLS (y, X_1) .fit ()
model.pvalues

Como podemos ver, la variable 'EDAD' tiene el valor más alto

de 0.9582293, que es mayor que 0.05. Por lo tanto,
eliminaremos esta característica y crearemos el modelo una
vez más. Este es un proceso iterativo y se puede realizar de una
vez con la ayuda del bucle. Este enfoque se implementa a
continuación, lo que daría el conjunto final de variables que
son CRIM, ZN, CHAS, NOX, RM, DIS, RAD, TAX, PTRATIO,
B y LSTAT
#Backward Elimination
cols = list (X.columns)
pmax = 1
while (len (cols)> 0):
p = []
X_1 = X [cols]
X_1 = sm.add_constant (X_1)
model = sm.OLS (y, X_1) .fit ()
p = pd.Series (model.pvalues.values [1:], index = cols)
pmax = max (p)
feature_with_p_max = p.idxmax ()
if (pmax> 0.05):
cols.remove ( feature_with_p_max)
else:
break selected_features_BE = cols
print (selected_features_BE) Salida: ['CRIM', 'ZN', 'CHAS',
'NOX', 'RM', 'DIS', 'RAD', 'TAX', 'PTRATIO' , 'B', 'LSTAT']

ii) RFE (eliminación de funciones recursivas)

El método de eliminación de características recursivas (RFE)
funciona eliminando recursivamente los atributos y
construyendo un modelo sobre los atributos que
quedan. Utiliza métrica de precisión para clasificar la
característica según su importancia. El método RFE toma el
modelo a utilizar y la cantidad de características requeridas
como entrada. Luego da la clasificación de todas las variables,
siendo 1 la más importante. También brinda su soporte, True
es una característica relevante y False es una característica
irrelevante.
model = LinearRegression () #Inicialización del modelo RFE
rfe = RFE (modelo, 7) #Transformación de datos mediante RFE
X_rfe = rfe.fit_transform (X, y) # Ajuste de los datos al
modelo
model.fit (X_rfe, y)
print (rfe. support_)
print (rfe.ranking_) Salida: [False False False True True True
False True True False True False
True]
[2 4 3 1 1 1 7 1 1 5 1 6 1]
Aquí tomamos el modelo LinearRegression con 7
características y RFE otorgó la clasificación de características
como anteriormente, pero la selección del número '7' fue
aleatoria. Ahora necesitamos encontrar la cantidad óptima de
características, para las cuales la precisión es la más
alta. Hacemos eso usando el bucle que comienza con 1
característica y va hasta 13. Luego tomamos el que tiene la
precisión más alta.
#no de características
nof_list = np.arange (1,13)
high_score = 0
#Variable para almacenar las características óptimas
nof = 0
score_list = []
para n en rango (len (nof_list)):
X_train, X_test, y_train, y_test = train_test_split (X, y,
test_size = 0.3, random_state = 0)
model = LinearRegression ()
rfe = RFE (model, nof_list [n])
X_train_rfe = rfe.fit_transform (X_train, y_train)
X_test_rfe = rfe.transform (X_test)
model. fit (X_train_rfe, y_train)
score = model.score (X_test_rfe, y_test)
score_list.append (score)
if (score> high_score):
high_score = score
nof = nof_list [n]print ("Número óptimo de
características:% d"% nof)
print ("Puntaje con% d características:% f"% (nof, puntaje
alto)) Salida: Número óptimo de características: 10
Puntaje con 10 características: 0.663581

Como se ve en el código anterior, el número óptimo de

características es 10. Ahora alimentamos 10 como número de
características a RFE y obtenemos el conjunto final de
características proporcionadas por el método RFE, de la
siguiente manera:
cols = list (X.columns)
model = LinearRegression () #Inicialización del modelo RFE
rfe = RFE (model, 10) #Transformación de datos
mediante RFE
X_rfe = rfe.fit_transform (X, y) # Ajuste de los datos al
modelo
model.fit ( X_rfe, y)
temp = pd.Series (rfe.support_, index = cols)
selected_features_rfe = temp [temp == True] .index
print (selected_features_rfe) Salida: Índice (['CRIM', 'ZN',
'INDUS', 'CHAS', 'NOX', 'RM', 'DIS', 'RAD', 'PTRATIO',
'LSTAT'],
dtype = 'object')

3. Método incrustado
Los métodos integrados son iterativos en un sentido que se
encarga de cada iteración del proceso de capacitación del
modelo y extrae cuidadosamente las características que más
contribuyen a la capacitación para una iteración en
particular. Los métodos de regularización son los métodos
integrados más utilizados que penalizan una característica
dado un umbral de coeficiente.

Aquí haremos la selección de características usando la

regularización de Lasso. Si la característica es irrelevante, el
lazo penaliza su coeficiente y lo convierte en 0. Por lo tanto, las
características con coeficiente = 0 se eliminan y se toma el
resto.
reg = LassoCV ()
reg.fit (X, y)
print ("Mejor alfa usando LassoCV incorporado:% f"% reg.alpha_)
print ("Mejor puntaje usando LassoCV incorporado:% f"%
reg.score (X, y))
coef = pd.Series (reg.coef_, index = X.columns)

print ("Lasso eligió" + str (sum (coef! = 0)) + "variables y

eliminó las otras" + str (sum (coef == 0)) + "variables")
imp_coef = coef.sort_values ()
import matplotlib
matplotlib.rcParams ['figure.figsize'] = (8.0, 10.0)
imp_coef.plot (kind = "barh")
plt.title ("Importancia de la característica usando el modelo
Lasso")
Aquí el modelo Lasso ha tomado todas las características
excepto NOX, CHAS e INDUS.

Conclusión:
Vimos cómo seleccionar características usando múltiples
métodos para Datos numéricos y comparamos sus
resultados. Ahora surge una confusión sobre qué método elegir
en qué situación. Los siguientes puntos lo ayudarán a tomar
esta decisión.

1. El método de filtro es menos preciso. Es excelente mientras

se hace EDA, también se puede usar para verificar la multi-
linealidad en los datos.
2. Los métodos Wrapper y Embedded dan resultados más
precisos, pero como son computacionalmente caros, estos
métodos son adecuados cuando tiene características
menores (~ 20).

En el próximo blog, veremos algunos métodos más de

selección de funciones para seleccionar funciones numéricas y
categóricas.