Por lo general, se puede desarrollar un modelo de aprendizaje automático más simple y de mejor rendimiento eliminando las características de entrada (columnas) del conjunto de datos de formación.
Esto se llama selección de características y hay muchos tipos diferentes de algoritmos que pueden ser utilizados.
Es posible enmarcar el problema de la selección de características como un problema de optimización. En el caso de que haya pocas características de entrada, se pueden evaluar todas las combinaciones posibles de características de entrada y encontrar definitivamente el mejor subconjunto. En el caso de un gran número de características de entrada, se puede utilizar un algoritmo de optimización estocástica para explorar el espacio de búsqueda y encontrar un subconjunto efectivo de características.
En este tutorial, descubrirá cómo utilizar los algoritmos de optimización para la selección de características en el aprendizaje automático.
Después de completar este tutorial, lo sabrás:
- El problema de la selección de características puede definirse en términos generales como un problema de optimización.
- Cómo enumerar todos los posibles subconjuntos de características de entrada para un conjunto de datos.
- Cómo aplicar la optimización estocástica para seleccionar un subconjunto óptimo de características de entrada.
Empecemos.
Cómo usar la optimización para la selección de características
Foto de Gregory «Slobirdr» Smith, algunos derechos reservados.
Resumen del Tutorial
Este tutorial está dividido en tres partes; son:
- Optimización para la selección de características
- Enumerar todos los subconjuntos de características
- Optimizar subconjuntos de características
Optimización para la selección de características
La selección de características es el proceso de reducir el número de variables de entrada cuando se desarrolla un modelo predictivo.
Es conveniente reducir el número de variables de entrada para reducir el costo computacional de la modelación y, en algunos casos, mejorar el rendimiento del modelo. Existen muchos tipos diferentes de algoritmos de selección de características, aunque en general pueden agruparse en dos tipos principales: métodos de envoltura y de filtro.
Los métodos de selección de características de la envoltura crean muchos modelos con diferentes subconjuntos de características de entrada y seleccionan aquellas características que resultan en el modelo de mejor rendimiento de acuerdo con una métrica de rendimiento. Estos métodos no se preocupan por los tipos de variables, aunque pueden ser costosos desde el punto de vista computacional. RFE es un buen ejemplo de un método de selección de características de envoltura.
Los métodos de selección de características de filtro utilizan técnicas estadísticas para evaluar la relación entre cada variable de entrada y la variable objetivo, y estas puntuaciones se utilizan como base para elegir (filtrar) las variables de entrada que se utilizarán en el modelo.
- Selección de características de la envoltura: Busca subconjuntos de características que funcionen bien.
- Selección de características de filtro: Seleccione subconjuntos de características en base a su relación con el objetivo.
Para más información sobre la elección de los algoritmos de selección de características, consulte el tutorial:
Un método popular de envoltura es el algoritmo de eliminación de características recursivas, o RFE.
La RFE funciona buscando un subconjunto de características, comenzando con todas las características del conjunto de datos de entrenamiento y eliminando con éxito las características hasta que quede el número deseado.
Esto se logra ajustando el algoritmo de aprendizaje de máquina utilizado en el núcleo del modelo, clasificando las características por su importancia, descartando las características menos importantes y volviendo a ajustar el modelo. Este proceso se repite hasta que quede un número determinado de características.
Para más información sobre RFE, vea el tutorial:
El problema de la selección de características de la envoltura puede enmarcarse como un problema de optimización. Es decir, encontrar un subconjunto de características de entrada que resulten en el mejor rendimiento del modelo.
El RFE es un enfoque para resolver este problema sistemáticamente, aunque puede estar limitado por un gran número de características.
Un enfoque alternativo sería utilizar un algoritmo de optimización estocástica, como un algoritmo de escalada de colinas estocástico, cuando el número de características es muy grande. Cuando el número de características es relativamente pequeño, puede ser posible enumerar todos los posibles subconjuntos de características.
- Pocas variables de entrada: Enumere todos los subconjuntos posibles de características.
- Muchas características de entrada: Algoritmo de optimización estocástica para encontrar buenos subconjuntos de características.
Ahora que estamos familiarizados con la idea de que la selección de características puede ser explorada como un problema de optimización, veamos cómo podríamos enumerar todos los posibles subconjuntos de características.
Enumerar todos los subconjuntos de características
Cuando el número de variables de entrada es relativamente pequeño y la evaluación del modelo es relativamente rápida, entonces puede ser posible enumerar todos los posibles subconjuntos de variables de entrada.
Esto significa evaluar el rendimiento de un modelo utilizando un arnés de prueba dado cada posible grupo único de variables de entrada.
Exploraremos cómo hacer esto con un ejemplo trabajado.
Primero, definamos un pequeño conjunto de datos de clasificación binaria con pocas características de entrada. Podemos usar la función make_classification() para definir un conjunto de datos con cinco variables de entrada, dos de las cuales son informativas, y 1.000 filas.
El ejemplo que figura a continuación define el conjunto de datos y resume su forma.
|
# Definir un pequeño conjunto de datos de clasificación de sklearn.conjuntos de datos importación hacer_clasificación # Definir el conjunto de datos X, y = make_classification(n_muestras=1000, n_funciones=5, n_informativo=2, n_redundante=3, estado_aleatorio=1) # resumir la forma del conjunto de datos imprimir(X.forma, y.forma) |
Ejecutando el ejemplo se crea el conjunto de datos y se confirma que tiene la forma deseada.
A continuación, podemos establecer una línea de base en el rendimiento utilizando un modelo evaluado en todo el conjunto de datos.
Usaremos un DecisionTreeClassifier como modelo porque su rendimiento es bastante sensible a la elección de las variables de entrada.
Evaluaremos el modelo utilizando buenas prácticas, como la validación cruzada estratificada con tres repeticiones y 10 pliegues.
El ejemplo completo figura a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Evaluar un árbol de decisiones en todo el conjunto de pequeños datos de numpy importación significa de numpy importación std de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación puntaje_valor_cruzado de sklearn.model_selection importación RepeatedStratifiedKFold de sklearn.árbol importación DecisionTreeClassifier # Definir el conjunto de datos X, y = make_classification(n_muestras=1000, n_funciones=3, n_informativo=2, n_redundante=1, estado_aleatorio=1) # Definir el modelo modelo = DecisionTreeClassifier() # Definir el procedimiento de evaluación cv = RepeatedStratifiedKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # Evaluar el modelo resultados = puntaje_valor_cruzado(modelo, X, y, puntuación=«exactitud, cv=cv, n_jobs=–1) # Informe del resultado imprimir(«Precisión media: %.3f (%.3f) % (significa(resultados), std(resultados))) |
Al ejecutar el ejemplo se evalúa el árbol de decisiones en todo el conjunto de datos y se informa de la exactitud de la clasificación de la media y la desviación estándar.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que el modelo alcanzó una precisión de alrededor del 80,5 por ciento.
|
Precisión media: 0,805 (0,030) |
A continuación, podemos intentar mejorar el rendimiento del modelo utilizando un subconjunto de las características de entrada.
Primero, debemos elegir una representación para enumerar.
En este caso, enumeraremos una lista de valores booleanos, con un valor para cada característica de entrada: Verdadero si se va a utilizar la función y Falso si la característica no se va a utilizar como entrada.
Por ejemplo, con las cinco características de entrada la secuencia[[Verdad, Verdad, Verdad, Verdad, Verdad]utilizaría todas las funciones de entrada, y[[Verdadero, Falso, Falso, Falso, Falso]sólo utilizaría la primera función de entrada como entrada.
Podemos enumerar todas las secuencias de valores booleanos con el longitud=5 usando la función product() Python. Debemos especificar los valores válidos[[Verdadero, falso]y el número de pasos en la secuencia, que es igual al número de variables de entrada.
La función devuelve un iterable que podemos enumerar directamente para cada secuencia.
|
... # Determinar el número de columnas n_cols = X.forma[[1] best_subset, mejor_puntuación = Ninguno, 0.0 # enumerar todas las combinaciones de características de entrada para subconjunto en producto([[Verdadero, Falso], repita=n_cols): ... |
Para una determinada secuencia de valores booleanos, podemos enumerarla y transformarla en una secuencia de índices de columna para cada Verdadero en la secuencia.
|
... # Convertir en índices de columna ix = [[i para i, x en enumerar(subconjunto) si x] |
Si la secuencia no tiene índices de columna (en el caso de todas las Falso valores), entonces podemos saltarnos esa secuencia.
|
# Marcar por ahora la columna (todo falso) si len(ix) == 0: Continúa |
Podemos usar los índices de las columnas para elegir las columnas del conjunto de datos.
|
... # Seleccionar columnas X_nuevo = X[[:, ix] |
Y este subconjunto del conjunto de datos puede entonces ser evaluado como lo hicimos antes.
|
... # Definir el modelo modelo = DecisionTreeClassifier() # Definir el procedimiento de evaluación cv = RepeatedStratifiedKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # Evaluar el modelo resultados = puntaje_valor_cruzado(modelo, X_nuevo, y, puntuación=«exactitud, cv=cv, n_jobs=–1) # Resumir las puntuaciones resultado = significa(resultados) |
Si la precisión del modelo es mejor que la mejor secuencia encontrada hasta ahora, podemos almacenarla.
|
... # Comprueba si es mejor que lo mejor hasta ahora si mejor_puntuación es Ninguno o resultado >= mejor_puntuación: # mejor resultado best_subset, mejor_puntuación = ix, resultado |
Y eso es todo.
A continuación se presenta el ejemplo completo de selección de características enumerando todos los subconjuntos de características posibles.
|
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 |
# Selección de características enumerando todos los posibles subconjuntos de características de itertools importación producto de numpy importación significa de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación puntaje_valor_cruzado de sklearn.model_selection importación RepeatedStratifiedKFold de sklearn.árbol importación DecisionTreeClassifier # Definir el conjunto de datos X, y = make_classification(n_muestras=1000, n_funciones=5, n_informativo=2, n_redundante=3, estado_aleatorio=1) # Determinar el número de columnas n_cols = X.forma[[1] best_subset, mejor_puntuación = Ninguno, 0.0 # enumerar todas las combinaciones de características de entrada para subconjunto en producto([[Verdadero, Falso], repita=n_cols): # Convertir en índices de columna ix = [[i para i, x en enumerar(subconjunto) si x] # Marcar por ahora la columna (todo falso) si len(ix) == 0: Continúa # Seleccionar columnas X_nuevo = X[[:, ix] # Definir el modelo modelo = DecisionTreeClassifier() # Definir el procedimiento de evaluación cv = RepeatedStratifiedKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # Evaluar el modelo resultados = puntaje_valor_cruzado(modelo, X_nuevo, y, puntuación=«exactitud, cv=cv, n_jobs=–1) # Resumir las puntuaciones resultado = significa(resultados) # Reportar el progreso… imprimir(‘>f(%s) = %f ‘ % (ix, resultado)) # Comprueba si es mejor que lo mejor hasta ahora si mejor_puntuación es Ninguno o resultado >= mejor_puntuación: # mejor resultado best_subset, mejor_puntuación = ix, resultado # reportar mejor imprimir(«¡Hecho!) imprimir(«f(%s) = %f % (best_subset, mejor_puntuación)) |
La ejecución del ejemplo informa de la precisión de la clasificación media del modelo para cada subconjunto de características consideradas. El mejor subconjunto se informa al final de la ejecución.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que el mejor subconjunto de características involucraba características en los índices [2, 3, 4] que resultó en una precisión de clasificación media de alrededor del 83,0 por ciento, que es mejor que el resultado reportado anteriormente usando todas las características de entrada.
|
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 |
>f([0, 1, 2, 3, 4]) = 0.813667 >f([0, 1, 2, 3]) = 0.827667 >f([0, 1, 2, 4]) = 0.815333 >f([0, 1, 2]) = 0.824000 >f([0, 1, 3, 4]) = 0.821333 >f([0, 1, 3]) = 0.825667 >f([0, 1, 4]) = 0.807333 >f([0, 1]) = 0.817667 >f([0, 2, 3, 4]) = 0.830333 >f([0, 2, 3]) = 0.819000 >f([0, 2, 4]) = 0.828000 >f([0, 2]) = 0.818333 >f([0, 3, 4]) = 0.830333 >f([0, 3]) = 0.821333 >f([0, 4]) = 0.816000 >f([0]) = 0.639333 >f([1, 2, 3, 4]) = 0.823667 >f([1, 2, 3]) = 0.821667 >f([1, 2, 4]) = 0.823333 >f([1, 2]) = 0.818667 >f([1, 3, 4]) = 0.818000 >f([1, 3]) = 0.820667 >f([1, 4]) = 0.809000 >f([1]) = 0.797000 >f([2, 3, 4]) = 0.827667 >f([2, 3]) = 0.755000 >f([2, 4]) = 0.827000 >f([2]) = 0.516667 >f([3, 4]) = 0.824000 >f([3]) = 0.514333 >f([4]) = 0.777667 ¡Hecho! f([0, 3, 4]) = 0.830333 |
Ahora que sabemos cómo enumerar todos los posibles subconjuntos de características, veamos cómo podríamos usar un algoritmo de optimización estocástica para elegir un subconjunto de características.
Optimizar subconjuntos de características
Podemos aplicar un algoritmo de optimización estocástica al espacio de búsqueda de subconjuntos de características de entrada.
En primer lugar, definamos un problema mayor que tiene muchas más características, haciendo que la evaluación del modelo sea demasiado lenta y el espacio de búsqueda demasiado grande para enumerar todos los subconjuntos.
Definiremos un problema de clasificación con 10.000 filas y 500 características de entrada, 10 de las cuales son relevantes y las 490 restantes son redundantes.
|
# Definir un gran conjunto de datos de clasificación de sklearn.conjuntos de datos importación hacer_clasificación # Definir el conjunto de datos X, y = make_classification(n_muestras=10000, n_funciones=500, n_informativo=10, n_redundante=490, estado_aleatorio=1) # resumir la forma del conjunto de datos imprimir(X.forma, y.forma) |
Ejecutando el ejemplo se crea el conjunto de datos y se confirma que tiene la forma deseada.
Podemos establecer una línea de base en el rendimiento evaluando un modelo en el conjunto de datos con todas las características de entrada.
Debido a que el conjunto de datos es grande y el modelo es lento de evaluar, modificaremos la evaluación del modelo para usar una validación cruzada triple, por ejemplo, menos pliegues y sin repeticiones.
El ejemplo completo figura a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
# Evaluar un árbol de decisiones en todo el conjunto de datos más grande # de numpy importación significa de numpy importación std de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación puntaje_valor_cruzado de sklearn.model_selection importación EstratificadoKFold de sklearn.árbol importación DecisionTreeClassifier # Definir el conjunto de datos X, y = make_classification(n_muestras=10000, n_funciones=500, n_informativo=10, n_redundante=490, estado_aleatorio=1) # Definir el modelo modelo = DecisionTreeClassifier() # Definir el procedimiento de evaluación cv = EstratificadoKFold(n_splits=3) # Evaluar el modelo resultados = puntaje_valor_cruzado(modelo, X, y, puntuación=«exactitud, cv=cv, n_jobs=–1) # Informe del resultado imprimir(«Precisión media: %.3f (%.3f) % (significa(resultados), std(resultados))) |
Al ejecutar el ejemplo se evalúa el árbol de decisiones en todo el conjunto de datos y se informa de la exactitud de la clasificación de la media y la desviación estándar.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que el modelo alcanzó una precisión de alrededor del 91,3 por ciento.
Esto proporciona una línea de base que esperaríamos que superara el uso de la selección de características.
|
Precisión media: 0,913 (0,001) |
Usaremos un simple algoritmo de escalada de colinas estocástico como algoritmo de optimización.
Primero, debemos definir la función objetivo. Tomará el conjunto de datos y un subconjunto de características para utilizar como entrada y devolver una precisión estimada del modelo de 0 (peor) a 1 (mejor). Es un problema de optimización de la maximización.
Esta función objetiva es simplemente la decodificación de la secuencia y el paso de evaluación del modelo de la sección anterior.
El objetivo() La función que figura a continuación implementa esto y devuelve tanto la puntuación como el subconjunto decodificado de las columnas utilizadas para la presentación de informes útiles.
|
# Función objetiva def objetivo(X, y, subconjunto): # Convertir en índices de columna ix = [[i para i, x en enumerar(subconjunto) si x] # Marcar por ahora la columna (todo falso) si len(ix) == 0: volver 0.0 # Seleccionar columnas X_nuevo = X[[:, ix] # Definir el modelo modelo = DecisionTreeClassifier() # Evaluar el modelo resultados = puntaje_valor_cruzado(modelo, X_nuevo, y, puntuación=«exactitud, cv=3, n_jobs=–1) # Resumir las puntuaciones resultado = significa(resultados) volver resultado, ix |
También necesitamos una función que pueda dar un paso en el espacio de búsqueda.
Dada una solución existente, debe modificarla y devolver una nueva solución en estrecha proximidad. En este caso, lo conseguiremos volteando aleatoriamente la inclusión/exclusión de columnas en la subsiguiente.
Cada posición de la secuencia se considerará de forma independiente y se volteará probabilísticamente cuando la probabilidad de volteo sea un hiperparámetro.
El mutar() La función siguiente implementa esto dada una solución candidata (secuencia de booleanos) y un hiperparámetro de mutación, creando y devolviendo una solución modificada (un paso en el espacio de búsqueda).
Cuanto más grande es el p_mutar (en el rango de 0 a 1), cuanto mayor sea el paso en el espacio de búsqueda.
|
# operador de la mutación def mutar(solución, p_mutar): # Hacer una copia niño = solución.copia() para i en rango(len(niño)): # comprobar si hay una mutación si rand() < p_mutar: # Voltear la inclusión niño[[i] = no niño[[i] volver niño |
Ahora podemos implementar el algoritmo de escalada de colinas.
La solución inicial es una secuencia generada al azar, que luego se evalúa.
|
... # Generar un punto inicial solución = elección([[Verdadero, Falso], tamaño=X.forma[[1]) # Evaluar el punto inicial solution_eval, ix = objetivo(X, y, solución) |
Luego hacemos un bucle de un número fijo de iteraciones, creando versiones mutadas de la solución actual, evaluándolas y guardándolas si la puntuación es mejor.
|
... # Corre la subida de la colina para i en rango(n_iter): # dar un paso candidato = mutar(solución, p_mutar) # Evaluar el punto de candidato candidato_eval, ix = objetivo(X, y, candidato) # comprobar si debemos mantener el nuevo punto si candidato_eval >= solution_eval: # Almacena el nuevo punto solución, solution_eval = candidato, candidato_eval # Reportar el progreso… imprimir(‘>%d f(%s) = %f’ % (i+1, len(ix), solution_eval)) |
El escalada de colinas() La función que se indica a continuación implementa esto, tomando como argumentos el conjunto de datos, la función objetiva y los hiperparámetros, y devuelve el mejor subconjunto de columnas del conjunto de datos y el rendimiento estimado del modelo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Algoritmo de búsqueda local de escalada de colinas def escalada(X, y, objetivo, n_iter, p_mutar): # Generar un punto inicial solución = elección([[Verdadero, Falso], tamaño=X.forma[[1]) # Evaluar el punto inicial solution_eval, ix = objetivo(X, y, solución) # Corre la subida de la colina para i en rango(n_iter): # dar un paso candidato = mutar(solución, p_mutar) # Evaluar el punto de candidato candidato_eval, ix = objetivo(X, y, candidato) # comprobar si debemos mantener el nuevo punto si candidato_eval >= solution_eval: # Almacena el nuevo punto solución, solution_eval = candidato, candidato_eval # Reportar el progreso… imprimir(‘>%d f(%s) = %f’ % (i+1, len(ix), solution_eval)) volver solución, solution_eval |
Podemos llamar a esta función y pasar nuestro conjunto de datos sintéticos para realizar la optimización para la selección de características.
En este caso, ejecutaremos el algoritmo durante 100 iteraciones y haremos unos cinco giros a la secuencia de una mutación dada, lo cual es bastante conservador.
|
... # Definir el conjunto de datos X, y = make_classification(n_muestras=10000, n_funciones=500, n_informativo=10, n_redundante=490, estado_aleatorio=1) # Definir las iteraciones totales n_iter = 100 # probabilidad de incluir/excluir una columna p_mut = 10.0 / 500.0 # realizar la búsqueda de la escalada de la colina subconjunto, puntuación = escalada(X, y, objetivo, n_iter, p_mut) |
Al final de la ejecución, convertiremos la secuencia booleana en índices de columnas (para que podamos ajustar un modelo final si queremos) y reportaremos el rendimiento de la mejor subsecuente.
|
... # Convertir en índices de columna ix = [[i para i, x en enumerar(subconjunto) si x] imprimir(«¡Hecho!) imprimir(Mejor: f(%d) = %f’. % (len(ix), puntuación)) |
Acoplando todo esto, el ejemplo completo se enumera a continuación.
|
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 |
# Optimización estocástica para la selección de características de numpy importación significa de numpy.al azar importación rand de numpy.al azar importación elección de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación puntaje_valor_cruzado de sklearn.árbol importación DecisionTreeClassifier # Función objetiva def objetivo(X, y, subconjunto): # Convertir en índices de columna ix = [[i para i, x en enumerar(subconjunto) si x] # Marcar por ahora la columna (todo falso) si len(ix) == 0: volver 0.0 # Seleccionar columnas X_nuevo = X[[:, ix] # Definir el modelo modelo = DecisionTreeClassifier() # Evaluar el modelo resultados = puntaje_valor_cruzado(modelo, X_nuevo, y, puntuación=«exactitud, cv=3, n_jobs=–1) # Resumir las puntuaciones resultado = significa(resultados) volver resultado, ix # operador de la mutación def mutar(solución, p_mutar): # Hacer una copia niño = solución.copia() para i en rango(len(niño)): # comprobar si hay una mutación si rand() < p_mutar: # Voltear la inclusión niño[[i] = no niño[[i] volver niño # Algoritmo de búsqueda local de escalada de colinas def escalada(X, y, objetivo, n_iter, p_mutar): # Generar un punto inicial solución = elección([[Verdadero, Falso], tamaño=X.forma[[1]) # Evaluar el punto inicial solution_eval, ix = objetivo(X, y, solución) # Corre la subida de la colina para i en rango(n_iter): # dar un paso candidato = mutar(solución, p_mutar) # Evaluar el punto de candidato candidato_eval, ix = objetivo(X, y, candidato) # comprobar si debemos mantener el nuevo punto si candidato_eval >= solution_eval: # Almacena el nuevo punto solución, solution_eval = candidato, candidato_eval # Reportar el progreso… imprimir(‘>%d f(%s) = %f’ % (i+1, len(ix), solution_eval)) volver solución, solución_eval # Definir el conjunto de datos X, y = make_classification(n_muestras=10000, n_funciones=500, n_informativo=10, n_redundante=490, estado_aleatorio=1) # Definir las iteraciones totales n_iter = 100 # probabilidad de incluir/excluir una columna p_mut = 10.0 / 500.0 # realizar la búsqueda de la escalada de la colina subconjunto, puntuación = escalada(X, y, objetivo, n_iter, p_mut) # Convertir en índices de columna ix = [[i para i, x en enumerar(subconjunto) si x] imprimir(«¡Hecho!) imprimir(Mejor: f(%d) = %f’. % (len(ix), puntuación)) |
La ejecución del ejemplo informa de la precisión de la clasificación media del modelo para cada subconjunto de características consideradas. El mejor subconjunto se informa al final de la ejecución.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que el mejor rendimiento se logró con un subconjunto de 239 características y una precisión de clasificación de aproximadamente 91,8 por ciento.
Esto es mejor que un modelo evaluado en todas las características de entrada.
Aunque el resultado es mejor, sabemos que podemos hacerlo mucho mejor, tal vez con el ajuste de los hiperparámetros del algoritmo de optimización o tal vez utilizando un algoritmo de optimización alternativo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
… >80 f(240) = 0.918099 >81 f(236) = 0.918099 >82 f(238) = 0.918099 >83 f(236) = 0.918099 >84 f(239) = 0.918099 >85 f(240) = 0.918099 >86 f(239) = 0.918099 >87 f(245) = 0.918099 >88 f(241) = 0.918099 >89 f(239) = 0.918099 >90 f(239) = 0.918099 >91 f(241) = 0.918099 >92 f(243) = 0.918099 >93 f(245) = 0.918099 >94 f(239) = 0.918099 >95 f(245) = 0.918099 >96 f(244) = 0.918099 >97 f(242) = 0.918099 >98 f(238) = 0.918099 >99 f(248) = 0.918099 >100 f(238) = 0.918099 ¡Hecho! Mejor: f(239) = 0.918099 |
Más lecturas
Esta sección proporciona más recursos sobre el tema si desea profundizar en él.
Tutoriales
APIs
Resumen
En este tutorial, descubriste cómo utilizar los algoritmos de optimización para la selección de características en el aprendizaje automático.
Específicamente, aprendiste:
- El problema de la selección de características puede definirse en términos generales como un problema de optimización.
- Cómo enumerar todos los posibles subconjuntos de características de entrada para un conjunto de datos.
- Cómo aplicar la optimización estocástica para seleccionar un subconjunto óptimo de características de entrada.
¿Tiene alguna pregunta?
Haga sus preguntas en los comentarios de abajo y haré lo posible por responder.
