Resumen completo del ajuste de hiperparámetros del aprendizaje automático (con código)

Cuenta pública: Youerhut
Autor: Peter
Editor: Peter

Hola a todos, soy Peter ~

El tema de este artículo: Ajuste de hiperparámetros para el modelado de aprendizaje automático . La imagen de apertura:

El artículo es muy largo, se recomienda guardarlo directamente ~

1. ¿Qué son los hiperparámetros del aprendizaje automático?

Los hiperparámetros de aprendizaje automático son parámetros cuyos valores se establecen antes de iniciar el proceso de aprendizaje, en lugar de datos de parámetros obtenidos mediante el entrenamiento.

Los hiperparámetros son opciones que se establecen fuera del entrenamiento del modelo y no se optimizan ni cambian durante el entrenamiento. En cambio, deben configurarse manualmente antes del entrenamiento y tienen un gran impacto en el rendimiento del modelo.

2. ¿Por qué deberíamos ajustar los hiperparámetros del aprendizaje automático?

En el aprendizaje automático, a menudo es necesario seleccionar y ajustar hiperparámetros para una tarea específica. Por ejemplo, en una máquina de vectores de soporte (SVM), un hiperparámetro importante es el parámetro de regularización C, que puede controlar la complejidad del modelo y afectar la capacidad de generalización del modelo. Al entrenar redes neuronales, la tasa de aprendizaje y el tamaño del lote también son hiperparámetros comunes, que pueden afectar la velocidad de convergencia del modelo y el efecto de predicción final.

El ajuste de los hiperparámetros del aprendizaje automático consiste en encontrar un conjunto óptimo de combinaciones de hiperparámetros que permitan que el modelo funcione mejor en una tarea específica. Ajustar los hiperparámetros es muy importante para mejorar el rendimiento del modelo, evitar el sobreajuste y acelerar la convergencia.

Diferentes combinaciones de hiperparámetros pueden afectar significativamente el rendimiento del modelo, por lo que es necesario encontrar la mejor combinación de hiperparámetros mediante el ajuste.

A continuación se describen cuatro aspectos: métodos de ajuste directo, como la búsqueda en cuadrícula, herramientas de ajuste como Optuna, ajuste basado en AutoML y ajuste basado en algoritmos.

3. Método de ajuste de hiperparámetros

Los métodos de ajuste de hiperparámetros comúnmente utilizados incluyen los siguientes:

• Búsqueda de cuadrícula: la búsqueda de cuadrícula es un método simple de ajuste de hiperparámetros. Calcula el rendimiento de cada conjunto de parámetros en el conjunto de validación especificando exhaustivamente combinaciones de parámetros y, finalmente, selecciona los parámetros con el mejor rendimiento.

• Optimización bayesiana: la optimización bayesiana es un algoritmo de optimización que utiliza el teorema de Bayes y métodos de optimización para encontrar la solución óptima global. Es adecuado para problemas de optimización de muestras limitadas, de alto costo y de alta dimensión.

• Búsqueda aleatoria: la búsqueda aleatoria es un método de ajuste de hiperparámetros basado en un muestreo aleatorio que encuentra la solución óptima seleccionando aleatoriamente una combinación de parámetros en el espacio de parámetros.

3.1 Búsqueda de cuadrícula Búsqueda de cuadrícula

1. ¿Qué es la búsqueda en cuadrícula?

Grid Search es un método de ajuste de hiperparámetros que agota combinaciones de parámetros especificadas, calcula el rendimiento de cada conjunto de parámetros en el conjunto de validación y finalmente selecciona la combinación de parámetros con el mejor rendimiento.

https://pyimagesearch.com/2021/05/24/grid-search-hyperparameter-tuning-with-scikit-learn-gridsearchcv/

La búsqueda de cuadrícula es un método de ajuste simple pero eficaz que se utiliza a menudo para determinar la mejor combinación de hiperparámetros.

2. Práctica de Python de búsqueda en cuadrícula

from sklearn.model_selection import GridSearchCV  
from sklearn.svm import SVC  
from sklearn.datasets import load_iris  
  
# 加载数据集  
iris = load_iris()  
X = iris.data  
y = iris.target  
  
# 定义模型  
svm = SVC(kernel='linear', C=100, gamma='auto')  
  
# 定义网格搜索参数范围  
param_grid = {  
    'C': [0.1, 1, 10, 100],  
    'gamma': [1e-3, 1e-2, 1e-1, 1],  
}  
  
# 创建网格搜索对象  
grid_search = GridSearchCV(svm, param_grid, cv=5)  
  
# 对数据进行网格搜索  
grid_search.fit(X, y)  
  
# 输出最佳参数组合和对应的得分  
print('Best parameters:', grid_search.best_params_)  
print('Best score:', grid_search.best_score_)

• La búsqueda de cuadrícula se implementa utilizando la clase GridSearchCV en la biblioteca Scikit-learn.

• Se define una cuadrícula de parámetros (param_grid), que contiene diferentes combinaciones de valores de los dos hiperparámetros C y gamma.

• Creó un objeto GridSearchCV y pasó la cuadrícula de parámetros, el modelo SVM y los parámetros de validación cruzada (cv).

• Utilice los atributos best_params_ y best_score_ para generar la mejor combinación de parámetros y la puntuación correspondiente

3.2 Búsqueda aleatoria Búsqueda aleatoria

1. ¿Qué es la búsqueda aleatoria?

La búsqueda aleatoria es un método de optimización que busca posibles soluciones generando puntos aleatoriamente dentro de un rango permitido y calculando el valor de la función objetivo para cada punto. Luego, selecciona el siguiente punto a buscar en función del valor de la función objetivo para acercarse gradualmente a la solución óptima.

Este método es adecuado para manejar problemas de optimización de alta dimensión, no lineales, no convexos o discontinuos, especialmente cuando el costo computacional de las soluciones exactas es muy alto.

2. Práctica de Python basada en búsqueda aleatoria

import numpy as np  
from sklearn.datasets import load_iris  
from sklearn.ensemble import RandomForestClassifier  
  
# 加载数据集  
iris = load_iris()  
X = iris.data  
y = iris.target  
  
# 定义随机搜索函数  
def random_search(X, y, model, param_space, iteration_num):  
    best_score = -1  
    best_params = None  
    for i in range(iteration_num):  
        # 从参数空间中随机采样一组超参数  
        params = {k: v[np.random.randint(len(v))] for k, v in param_space.items()}  
        # 训练模型并计算验证集上的准确率  
        model.set_params(**params)  
        score = model.score(X[:100], y[:100])  
        # 更新最优解  
        if score > best_score:  
            best_score = score  
            best_params = params  
    return best_score, best_params  
  
# 定义随机森林分类器模型  
model = RandomForestClassifier()  
  
# 定义超参数空间  
param_space = {  
    'n_estimators': [100, 200, 300, 400, 500],  
    'max_depth': [2, 3, 4, 5, 6],  
    'max_features': ['auto', 'sqrt', 'log2'],  
    'bootstrap': [True, False]  
}  
  
# 执行随机搜索  
best_score, best_params = random_search(X, y, model, param_space, 100)  
print('最佳准确率：', best_score)  
print('最佳超参数：', best_params)

• Utilice un modelo de clasificador de bosque aleatorio y defina cuatro hiperparámetros que deben optimizarse: n_estimators, max_ Depth, max_features y bootstrap.

• Muestre aleatoriamente 100 conjuntos de hiperparámetros del espacio de parámetros, luego use la precisión en el conjunto de validación para evaluar la calidad de estos hiperparámetros y finalmente genere la mejor precisión y los mejores hiperparámetros correspondientes.

Comparación entre optimización de búsqueda en cuadrícula y optimización de búsqueda aleatoria:

3.3 optimización bayesiana

1. ¿Qué es la optimización bayesiana?

La optimización bayesiana es un algoritmo de optimización de caja negra que se utiliza para resolver problemas de valores extremos de funciones con expresiones desconocidas. Se basa en el teorema de Bayes y describe la distribución posterior de la función objetivo mediante la construcción de un modelo de probabilidad y utiliza este modelo para seleccionar el siguiente punto de muestreo para maximizar el valor del muestreo.

La idea central es utilizar la regresión del proceso gaussiano (GPR) para modelar la distribución de la función objetivo . GPR cree que la función objetivo es un proceso aleatorio compuesto por una serie de puntos de datos de entrenamiento (entrada y salida) y utiliza un modelo de probabilidad gaussiano para describir la distribución de probabilidad de este proceso aleatorio. La optimización bayesiana actualiza la distribución posterior de la función objetivo agregando continuamente puntos de muestra hasta que la distribución posterior básicamente se ajusta a la distribución verdadera.

La optimización bayesiana tiene dos procesos centrales:

• Función previa (PF): PF utiliza principalmente la regresión del proceso gaussiano para modelar la distribución previa de la función objetivo.

• Función de Adquisición (AC): AC incluye principalmente métodos como Mejora Esperada (EI), Probabilidad de Mejora (PI) y Límite Superior de Confianza (UCB), que se utilizan para medir la contribución de cada punto a la optimización de la función objetivo y seleccione el siguiente punto de muestreo.

La optimización bayesiana se utiliza en el algoritmo AutoML en el aprendizaje automático para determinar automáticamente los hiperparámetros del algoritmo de aprendizaje automático. También es un método de búsqueda de valores extremos globales, especialmente adecuado para funciones no lineales no convexas de alta dimensión, con buen efecto y eficiencia.

La optimización bayesiana trata una función como un proceso estocástico que satisface una determinada distribución. Al encontrar el valor de la función dentro del dominio de definición, la fórmula bayesiana se utiliza para actualizar la estimación de la distribución y luego encontrar la ubicación del punto extremo más probable según la nueva distribución. , mejorando así la precisión de la estimación de la función y sus valores extremos.

2. Optimización bayesiana en la práctica de Python

import numpy as np  
from scipy.optimize import minimize  
from sklearn.gaussian_process import GaussianProcessRegressor  
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C  
  
# 定义目标函数  
def f(x):  
    return np.sin(5 * x) + np.cos(x)  
  
# 定义高斯过程回归模型  
kernel = C(1.0, (1e-3, 1e3)) * RBF(10, (1e-2, 1e2))  
gpr = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)  
  
# 定义贝叶斯优化函数  
def bayesian_optimization(X_train, y_train, X_test):  
    # 训练高斯过程回归模型  
    gpr.fit(X_train, y_train)  
    # 计算测试集的预测值和方差  
    y_pred, sigma = gpr.predict(X_test, return_std=True)  
    # 计算期望改进（Expected Improvement）  
    gap = y_pred - f(X_test)  
    improvement = (gap + np.sqrt(sigma ** 2 + 1e-6) * np.abs(gap).mean()) * 0.5  
    # 计算高斯过程回归模型的超参数  
    result = minimize(gpr.kernel_, np.zeros(gpr.kernel_.shape[0]), method='L-BFGS-B')  
    hyperparameters = result.x  
    # 输出最优超参数和对应的期望改进值  
    return hyperparameters, improvement.max()  
  
# 定义贝叶斯优化的迭代次数和采样点数量  
n_iter = 20  
n_samples = 5  
  
# 进行贝叶斯优化  
results = []  
for i in range(n_iter):  
    # 在定义域内随机采样n_samples个点  
    X_train = np.random.uniform(-2 * np.pi, 2 * np.pi, (n_samples, 1))  
    y_train = f(X_train)  
    # 进行贝叶斯优化并记录最优超参数和对应的期望改进值  
    result = bayesian_optimization(X_train, y_train, X_test=np.random.uniform(-2 * np.pi, 2 * np.pi, (100, 1)))  
    results.append(result)  
    print('Iter: {}, Hyperparameters: {:.2f}, Expected Improvement: {:.4f}'.format(i, result[0][0], result[1]))

• Definir la función objetivo f

• Utilice el modelo de regresión del proceso gaussiano (GPR) para modelar la distribución de la función objetivo.

• Defina la función de optimización bayesiana bayesian_optimization; el conjunto de entrenamiento, el conjunto de prueba y el número de puntos de muestreo se utilizan como entradas, y se generan los hiperparámetros óptimos y los valores de mejora esperados correspondientes.

• La mejora esperada sirve como una función de adquisición, actualiza la distribución posterior de la función objetivo agregando continuamente puntos de muestra y utilizando el método LBFGS-B para minimizar los hiperparámetros del modelo de regresión del proceso gaussiano.

4. Herramientas de ajuste basadas en hiperparámetros

4.1 ¿Qué es una biblioteca de optimización de hiperparámetros?

La biblioteca de optimización de hiperparámetros es una biblioteca o herramienta de software para la optimización automatizada de hiperparámetros. Estas bibliotecas utilizan diferentes algoritmos y técnicas para automatizar el proceso de búsqueda y optimización de hiperparámetros.

Las bibliotecas de optimización de hiperparámetros a menudo proporcionan interfaces fáciles de usar que permiten a los usuarios definir los hiperparámetros y las funciones objetivas que se optimizarán. Utilizan diferentes algoritmos y técnicas como búsqueda en cuadrícula, búsqueda aleatoria, algoritmo genético, optimización bayesiana, etc. para buscar y optimizar el espacio de hiperparámetros. Los objetivos de estas bibliotecas son reducir la carga de trabajo del ajuste manual de hiperparámetros, mejorar el rendimiento del modelo y acelerar el proceso de capacitación de los modelos de aprendizaje automático.

4.2 Herramientas comunes de optimización de hiperparámetros

A continuación se muestran varias bibliotecas de optimización de hiperparámetros de uso común:

• scikit-Optimizar

• hiperóptica

• Optar

• Menta verde

• Optimización de hiperparámetros basada en procesos gaussianos (GPGO)

• melodía de rayo

• GPyOpt

• SigOpt

• Sintonizador ruidoso

Todas estas bibliotecas proporcionan diferentes algoritmos y herramientas para lograr la optimización de hiperparámetros y tienen diferentes características y ventajas. Podrás elegir la biblioteca que mejor se adapte a ti en función de tus necesidades.

4.3 Biblioteca Scikit-Optimize

1. Introducción a la biblioteca Scikit-Optimize

Scikit-optimize es una biblioteca de Python para ejecutar algoritmos de optimización basados ​​en scipy. Su objetivo es proporcionar una herramienta simple pero eficaz para problemas de optimización en aprendizaje automático y computación científica. Scikit-optimize proporciona muchos algoritmos de optimización diferentes, incluido el descenso de gradiente, la búsqueda aleatoria, la optimización bayesiana, etc.

Scikit-optimize proporciona muchos espacios de búsqueda predefinidos y funciones objetivas para configurar fácilmente tareas de optimización de hiperparámetros. Los usuarios pueden definir sus propios espacios de búsqueda y funciones objetivas para adaptarse a modelos y tareas específicos de aprendizaje automático. Scikit-optimize también proporciona herramientas de visualización para ayudar a los usuarios a comprender mejor el proceso de optimización y los resultados.

2. Optimización práctica de la biblioteca Scikit-Optimize basada en Python

import numpy as np  
from sklearn.datasets import load_iris  
from sklearn.ensemble import RandomForestClassifier  
from sklearn.model_selection import train_test_split  
from sklearn.metrics import accuracy_score  
from skopt import gp_minimize  
  
# 加载数据集  
iris = load_iris()  
X = iris.data  
y = iris.target  
  
# 划分训练集和测试集  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
  
# 定义机器学习模型  
clf = RandomForestClassifier()  
  
# 定义搜索空间和目标函数  
search_space = {  
    'n_estimators': [100, 200, 500],  
    'max_depth': [3, 5, None],  
    'max_features': ['auto', 'sqrt', 'log2']  
}  
  
def objective(x):  
    clf.set_params(**{search_space[name]: x[name] for name in x})  
    clf.fit(X_train, y_train)  
    y_pred = clf.predict(X_test)  
    return -accuracy_score(y_test, y_pred)  
  
# 执行优化算法  
res = gp_minimize(objective, search_space, n_calls=20, random_state=42)  
  
# 输出最优超参数组合和对应的验证准确率  
print("Best hyperparameters:", res.x)  
print("Max validation accuracy:", res.fun)

4.4 Biblioteca Hyperopt

1. Introducción a la biblioteca Hyperopt

Hyperopt es una biblioteca de Python para búsqueda inteligente de algoritmos para modelos de aprendizaje automático. Utiliza principalmente tres algoritmos: algoritmo de búsqueda aleatoria, algoritmo de recocido simulado y algoritmo TPE (estimador Parzen estructurado en árbol).

Instale la biblioteca Hyperopt: puede usar el comando pip para instalar la biblioteca Hyperopt:

pip install hyperopt

Pasos de uso:

• Prepare la función objetivo: la función objetivo debe ser una función optimizable que acepte una lista de hiperparámetros como entrada y devuelva un valor escalar. En Hyperopt, use fn para especificar la función objetivo.

• Defina el espacio de búsqueda de hiperparámetros: utilice el módulo hp de Hyperopt para definir el espacio de búsqueda de hiperparámetros. Puede utilizar funciones como hp.choice y hp.uniform para definir diferentes tipos de hiperparámetros.

• Optimice usando la función fmin: Optimice usando la función fmin de Hyperopt, que acepta la función objetivo, el espacio de búsqueda de hiperparámetros y el algoritmo de optimización como entrada y devuelve la mejor combinación de hiperparámetros.

Dirección oficial de aprendizaje: https://github.com/hyperopt/hyperopt

2. Casos prácticos basados ​​en la optimización de Python.

from hyperopt import hp, fmin, tpe  
from sklearn.datasets import load_iris  
from sklearn.model_selection import train_test_split  
from sklearn.svm import SVC  
  
# 加载数据集  
iris = load_iris()  
X = iris.data  
y = iris.target  
  
# 划分训练集和测试集  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
  
# 定义目标函数  
def objective(params):  
    clf = SVC(kernel=params['kernel'], C=params['C'], gamma=params['gamma'])  
    clf.fit(X_train, y_train)  
    score = clf.score(X_test, y_test)  
    return -score  # 因为Hyperopt需要最小化目标函数，所以我们需要将准确率取反  
  
# 定义超参数搜索空间  
space = {  
    'kernel': hp.choice('kernel', ['linear', 'poly', 'rbf', 'sigmoid']),  
    'C': hp.uniform('C', 0.001, 10),  
    'gamma': hp.uniform('gamma', 0.001, 10)  
}  
  
# 使用贝叶斯优化进行超参数搜索  
best = fmin(fn=objective, space=space, algo=tpe.suggest, max_evals=100)  
print('Best parameters: ', best)

4.5 Biblioteca Optuna

1. Introducción a la biblioteca Optuna

Optuna es una biblioteca para la optimización de hiperparámetros que admite la definición de funciones objetivo, la búsqueda en el espacio de hiperparámetros y la optimización automática.

Puede utilizar el comando pip para instalar la biblioteca Optuna:

pip install Optuna

Pasos de uso:

• Defina el espacio de búsqueda: utilice la función de distribución proporcionada por Optuna para definir el espacio de búsqueda de hiperparámetros. Por ejemplo, para un número de punto flotante con un rango de valores de [0, 1], puede usar la función uniforme para definir el espacio de búsqueda del hiperparámetro.

• Defina la función objetivo: la función objetivo es el modelo que debe optimizarse y puede ser cualquier objeto invocable, como funciones de Python, métodos de clase, etc. La entrada de la función objetivo es el valor del hiperparámetro y la salida es el indicador de rendimiento del modelo.

• Cree un experimento de Optuna: cree un objeto de experimento de Optuna y especifique la función objetivo y el algoritmo de búsqueda.

• Ejecute un experimento de Optuna: ejecute un experimento de Optuna para realizar una búsqueda de hiperparámetros. Después de cada experimento, Optuna actualizará los valores de los hiperparámetros y registrará los indicadores de rendimiento del experimento actual. Puede establecer la cantidad de intentos o el tiempo para controlar el tamaño del espacio de búsqueda y el límite de tiempo de búsqueda.

• Analice los resultados de la prueba: una vez completada la prueba, puede utilizar las herramientas de visualización proporcionadas por Optuna para analizar los resultados de la prueba y seleccionar la combinación óptima de hiperparámetros.

2. Casos de uso basados ​​en Python

import numpy as np  
from sklearn.datasets import make_regression  
from sklearn.model_selection import train_test_split  
from sklearn.linear_model import SGDRegressor  
  
# 生成数据集  
X, y = make_regression(n_samples=100, n_features=1, noise=0.1)  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
  
# 定义目标函数  
def objective(trial):  
    # 定义超参数  
    learning_rate = trial.suggest_float('learning_rate', 1e-10, 1e-5)  
    batch_size = trial.suggest_int('batch_size', 32, 256)  
    optimizer = trial.suggest_categorical('optimizer', ['sgd', 'adam'])  
  
    # 创建模型  
    model = SGDRegressor(learning_rate=learning_rate, batch_size=batch_size, optimizer=optimizer)  
  
    # 训练模型  
    model.fit(X_train, y_train)  
  
    # 计算性能指标  
    loss = np.mean((model.predict(X_test) - y_test) ** 2)  
    return loss

# 创建Optuna的study对象，并指定需要优化的目标函数和搜索空间
import optuna  
study = optuna.create_study()  
study.optimize(objective, n_trials=100)

# 最佳的超参数组合
print(study.best_params)  # 输出最佳的超参数组合  
print(study.best_value)   # 输出最佳的性能指标值

4.6Biblioteca de menta verde

1. Introducción a la biblioteca Spearmint

Spearmint es una biblioteca para optimizar la inferencia bayesiana. Se basa en el algoritmo descrito en el artículo "Optimización bayesiana práctica". Esta biblioteca se puede utilizar para realizar optimización bayesiana, un algoritmo para optimización global que encuentra principalmente configuraciones que minimizan una función objetivo. (Se recomienda usar menos)

https://github.com/JasperSnoek/spearmint

La biblioteca Spearmint proporciona una forma de formular y optimizar problemas de inferencia bayesiana. Permite a los usuarios definir funciones objetivas, así como restricciones y límites utilizados para describir problemas de optimización. Los algoritmos centrales de la biblioteca son responsables de optimizar la función objetivo de acuerdo con estas definiciones. Las ventajas de la biblioteca Spearmint incluyen:

• Expresión flexible de funciones objetivas: Spearmint admite múltiples tipos de datos y estructuras de modelos complejas, lo que permite a los usuarios expresar de manera flexible varias funciones objetivas.

• Alto rendimiento: Spearmint mejora la velocidad de ejecución mediante una implementación eficiente y algoritmos de optimización, lo que le permite manejar conjuntos de datos a gran escala y modelos complejos.

• Fácil de usar: Spearmint proporciona una interfaz simple y fácil de usar, que permite a los usuarios configurar y ejecutar tareas de optimización fácilmente.

• Soporte de la comunidad: Spearmint es un proyecto de código abierto respaldado por una comunidad activa, lo que significa que los usuarios pueden recibir comentarios y apoyo de otros desarrolladores.

2. Casos prácticos basados ​​en Spearmint

import numpy as np  
import spearmint as sp  
from scipy.stats import norm  
  
# 定义目标函数  
def objective(x):  
    # 假设目标函数是一个简单的二次函数，其中x是一个向量  
    return x[0]**2 + x[1]**2  
  
# 定义Spearmint的优化器  
spearmint = sp.Spearmint()  
  
# 设置要优化的参数范围  
var_names = ['var1', 'var2']  
bounds = [[-5, 5], [-5, 5]]  
priors = [sp.priors.NormalPrior(0, 1), sp.priors.NormalPrior(0, 1)]  
  
# 运行贝叶斯优化，设置最大迭代次数为10次  
results = spearmint.optimize(objective, var_names, bounds, priors, n_iter=10)  
  
# 输出最优的参数组合和对应的函数值  
print('最优参数组合：', results.x)  
print('最优函数值：', results.func)

Biblioteca 4.7GPGO

1. Introducción a GPGO

El nombre completo de GPGO es Optimización de procesos gaussianos para optimización de hiperparámetros, es la biblioteca de optimización de hiperparámetros de Google, utiliza procesos gaussianos (procesos gaussianos) para la optimización de hiperparámetros y está especialmente diseñada para TensorFlow y Keras.

El proceso gaussiano es un potente modelo bayesiano no paramétrico que proporciona un marco probabilístico para la optimización de hiperparámetros que gestiona automáticamente el equilibrio entre exploración y explotación.

Instalar antes de usar:

pip install gpgo

Pasos de uso:

• Primero, es necesario definir la función objetivo a optimizar (por ejemplo, la pérdida de entrenamiento de una red neuronal).

• En segundo lugar, es necesario definir el espacio de búsqueda, es decir, el posible rango de valores de los hiperparámetros.

• Luego, ejecute el proceso de optimización usando GPGO. En cada iteración, el optimizador selecciona un conjunto de hiperparámetros y evalúa el rendimiento de ese conjunto de hiperparámetros utilizando una función objetivo.

• Finalmente, el optimizador actualiza sus creencias sobre los hiperparámetros óptimos en función de los resultados de la evaluación y continúa la búsqueda hasta que se alcanza una condición de terminación preestablecida (por ejemplo, se alcanza el número máximo de iteraciones o se encuentra una combinación satisfactoria de hiperparámetros).

2. casos prácticos de Python

import numpy as np  
import tensorflow as tf  
from tensorflow.keras.datasets import mnist  
from tensorflow.keras.models import Sequential  
from tensorflow.keras.layers import Dense, Flatten  
from gpgo import GPGO  
  
# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()  
# 数据缩放
x_train = x_train / 255.0  
x_test = x_test / 255.0  
  
# 1-定义神经网络模型  
model = Sequential([  
    Flatten(input_shape=(28, 28)),  
    Dense(128, activation='relu'),  
    Dense(64, activation='relu'),  
    Dense(10)  
])  
  
#2- 定义优化目标函数（即神经网络的训练损失）  
def loss_fn(y_true, y_pred):  
    return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred))  
  
# 3-定义优化器并设置超参数的搜索空间  
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-4)  
hyperparams = {  
    'kernel__lgcp': [5, 10, 20],  
    'kernel__scale': [1e-4, 1e-3, 1e-2],  
    'kernel__lengthscale': [1., 5., 10.]  
}  
  
# 4-创建GPGO优化器并运行优化过程  
gpgo = GPGO(optimizer=optimizer, loss_fn=loss_fn, hyperparams=hyperparams, datasets=(x_train, y_train), epochs=10)  
best_params, best_loss = gpgo.run()

• Cargue el conjunto de datos MNIST y defina un modelo de red neuronal simple

• Se define la función objetivo de optimización, que es la pérdida de entrenamiento de la red neuronal.

• Creé un optimizador GPGO y le pasé el espacio de búsqueda de hiperparámetros.

• Utilice runel método para ejecutar el proceso de optimización y generar los mejores hiperparámetros y la menor pérdida de entrenamiento.

4.8Biblioteca Ray Tune

1. Introducción

Ray Tune es una biblioteca de optimización de hiperparámetros para Ray que se puede utilizar para optimizar el rendimiento de modelos de aprendizaje profundo. Se basa en las interfaces de Scikit-learn y Google Vizier y proporciona una API simple y fácil de usar para definir y ejecutar experimentos de búsqueda de hiperparámetros.

Las características de Ray Tune incluyen:

• Admite una variedad de algoritmos de optimización de hiperparámetros, como búsqueda de cuadrícula, búsqueda aleatoria y optimización bayesiana.

• Puede gestionar automáticamente el progreso y los resultados de los experimentos y proporcionar una interfaz visual clara.

• Se puede extender fácilmente a entornos distribuidos y admite la búsqueda de hiperparámetros paralelos de múltiples nodos.

• Se integra perfectamente con el marco de Ray y se puede extender fácilmente a otras tareas de Ray.

Dirección oficial de aprendizaje: https://docs.ray.io/en/latest/tune/index.html

2. Casos prácticos de optimización proporcionados por el sitio web oficial:

from ray import tune

def objective(config):  # 1-定义目标优化函数
    score = config["a"] ** 2 + config["b"]
    return {"score": score}

search_space = {  # 2-定义超参数搜索空间
    "a": tune.grid_search([0.001, 0.01, 0.1, 1.0]),
    "b": tune.choice([1, 2, 3]),
}

tuner = tune.Tuner(objective, param_space=search_space)  # 3-执行搜索过程
results = tuner.fit()
print(results.get_best_result(metric="score", mode="min").config)  # 最佳超参数组合

4.9 Optimización bayesiana

1. Introducción

La optimización bayesiana, también conocida como diseño experimental bayesiano o diseño secuencial, es una técnica de optimización global que utiliza el razonamiento bayesiano y el proceso gaussiano. Es un método para encontrar el valor máximo o mínimo de una función desconocida en el menor número de iteraciones posibles, especialmente indicado para optimizar funciones de alto coste o situaciones donde se requiere un equilibrio entre exploración y desarrollo.

Dirección oficial de aprendizaje: https://github.com/bayesian-optimization/BayesianOptimization

Instalar primero:

pip install bayesian-optimization

2. casos prácticos de Python

import numpy as np  
from sklearn.gaussian_process import GaussianProcessRegressor  
from scipy.optimize import minimize  
  
# 定义目标函数  
def target_function(x):  
    return np.sin(5 * x) + np.cos(2 * x) + np.random.normal(0, 0.1, size=x.shape)  
  
# 定义高斯过程模型  
def gpr_model(X, y):  
    kernel = 1.0 * np.eye(X.shape[0]) + 0.5 * np.ones((X.shape[0], X.shape[0]))  
    gpr = GaussianProcessRegressor(kernel=kernel)  
    gpr.fit(X, y)  
    return gpr  
  
# 定义Bayesian Optimization函数  
def bayesian_optimization(n_iterations, n_initial_points):  
    # 初始化数据点  
    x_initial = np.random.uniform(-5, 5, n_initial_points)  
    y_initial = target_function(x_initial)  
  
    # 初始化高斯过程模型  
    X_train = np.vstack((x_initial, x_initial))  
    y_train = np.vstack((y_initial, y_initial))  
    gpr = gpr_model(X_train, y_train)  
  
    # 进行n_iterations次迭代  
    for i in range(n_iterations):  
        # 使用EI策略选择新的数据点  
        acquisition_func = gpr.predictive_mean + np.sqrt(gpr.predictive_covariance(x_initial)[:, None, None]) * np.random.randn(*x_initial.shape)  
        EI = -gpr.negative_log_predictive_density(y_initial, acquisition_func)  
        x_new = x_initial[np.argmax(EI)]  
        y_new = target_function(x_new)  
        
        X_train = np.vstack((X_train, x_new))  
        y_train = np.vstack((y_train, y_new)) 
        
        gpr = gpr_model(X_train, y_train)  
        
        x_initial = np.vstack((x_initial, x_new))  
        y_initial = np.vstack((y_initial, y_new)) 
        
        print("Iteration {}: Best value = {} at x = {}".format(i+1, np.min(y_initial), np.argmin(y_initial)))  
    return x_initial[np.argmin(y_initial)], np.min(y_initial)  
  
# 运行Bayesian Optimization函数并输出结果  
best_x, best_y = bayesian_optimization(n_iterations=10, n_initial_points=3)  
print("Best x = {}, best y = {}".format(best_x, best_y))

• Se define una función objetivo target_function, que es una combinación de funciones seno y coseno con ruido aleatorio;

• Se define un modelo de proceso gaussiano gpr_modelque utiliza un núcleo constante para construir el proceso gaussiano;

• Define una bayesian_optimizationfunción que utiliza el algoritmo de optimización bayesiano para encontrar el valor máximo de la función objetivo;

• Finalmente llame a bayesian_optimizationla función y genere el resultado.

Biblioteca 4.9GPyOpt

1. Introducción

GPyOpt es una biblioteca de Python basada en GPy para implementar la optimización bayesiana. Proporciona un marco flexible que puede manejar problemas de optimización con varios tipos de modelos sustitutos, como procesos gaussianos y bosques aleatorios.

La biblioteca GPyOpt está diseñada para resolver problemas prácticos, que incluyen, entre otros, optimización de funciones, optimización de hiperparámetros, ajuste de parámetros de modelo en aprendizaje profundo, etc. Los usuarios pueden personalizar el modelo de proxy según sea necesario y pueden integrarlo fácilmente con bibliotecas de terceros. Además, GPyOpt admite una variedad de algoritmos de optimización, como optimización bayesiana, optimización de enjambre de partículas, etc., para satisfacer las necesidades de diferentes escenarios de aplicación.

Dirección oficial de aprendizaje: https://sheffieldml.github.io/GPyOpt/

Instalar directamente usando pip:

pip install gpyopt

Instalación basada en código fuente:

# git clone https://github.com/SheffieldML/GPyOpt.git
# cd GPyOpt
# git checkout devel
# nosetests GPyOpt/testing

Requisitos de versión para los tres paquetes dependientes principales:

• GPy (>=1.0.8)

• numeroso (>=1,7)

• picante (>=0,16)

2. Casos de uso basados ​​en Python

Utilice la biblioteca GPyOpt para resolver un problema simple de optimización de funciones: intente encontrar el valor máximo de una función

import numpy as np  
from gpyopt import Optimizer  
  
# 定义目标函数  
def f(x):  
    return -x**2  
  
# 定义初始点  
x0 = np.array([0.0])  
# 定义优化器  
optimizer = Optimizer(f=f, x0=x0)  
# 设置优化选项  
optimizer.set_verbose(True)  # 设置是否输出优化信息  
optimizer.set_stop_condition(stop='max_iter', value=100)  # 设置最大迭代次数和停止条件  
  
# 运行优化  
optimizer.optimize()  
  
# 输出结果  
print('最优解:', optimizer.x_opt)  
print('最优值:', optimizer.f_opt)

4.10Biblioteca SigOpt

1. Introducción

La biblioteca de optimización de hiperparámetros SigOpt es una biblioteca de software para optimizar modelos de aprendizaje automático. El algoritmo de optimización de SigOpt utiliza optimización bayesiana, un algoritmo de optimización utilizado para encontrar el óptimo global, que a menudo se utiliza para encontrar la mejor combinación de hiperparámetros en modelos de aprendizaje profundo.

La API de SigOpt facilita el ajuste de los hiperparámetros del modelo y se puede integrar con muchas bibliotecas de aprendizaje automático diferentes (incluidas TensorFlow, PyTorch, Scikit-learn, etc.). SigOpt también proporciona una interfaz visual para ayudar a los usuarios a monitorear y ajustar el proceso de optimización. Al utilizar SigOpt, los desarrolladores pueden encontrar combinaciones óptimas de hiperparámetros más rápidamente, mejorando el rendimiento y la precisión del modelo.

Dirección oficial de aprendizaje: https://docs.sigopt.com/intro/main-concepts

instalación basada en pip:

pip install sigopt

2. Casos prácticos basados ​​en Python

import torch  
import torch.nn as nn  
from torch.utils.data import DataLoader  
from torchvision import datasets, transforms
# 优化相关
import sigopt  
from sigopt.api import create_run  
from sigopt.config import get_version_id  
from sigopt.local import local_experiment  
from sigopt.run import run_fn, get_default_args, get_default_config, get_default_options, get_default_suggestion_callback, run_in_notebook, run_in_script, run_in_jupyter_notebook   # 用于定义运行函数和运行环境  
from sigopt.suggestion import get_suggestion, get_suggestion_from_web  # 用于获取建议的超参数值


# 定义学习率和批量大小
space = {  
  "learning_rate": (1e-5, 1e-2, "log-uniform"),  
  "batch_size": (32, 256, "uniform")  
}

# 定义基于pytorch的深度学习模型
class SimpleModel(nn.Module):  
  def __init__(self):  
    super(SimpleModel, self).__init__()  
    self.fc = nn.Linear(784, 10)  
      
  def forward(self, x):  
    x = x.view(-1, 784)  
    x = self.fc(x)  
    return x

# 加载mnist数据集
transform = transforms.Compose([  
  transforms.ToTensor(),    # 转成张量
  transforms.Normalize((0.1307,), (0.3081,))  # 数据标准化  
])  
train_dataset = datasets.MNIST(root="data", train=True, transform=transform, download=True)  
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True)

# 优化过程
def objective(config):  # 定义优化目标函数，即模型的准确率  
  model = SimpleModel()  # 创建模型实例  
  optimizer = torch.optim.Adam(model.parameters(), lr=config["learning_rate"])  # 创建优化器并设置学习率  
  criterion = nn.CrossEntropyLoss()  # 创建损失函数  
  train_loss = 0.0  
  correct = 0.0  
  total = 0.0  
  for i, data in enumerate(train_loader, 0):  # 对训练集进行迭代，计算损失和准确率  
    inputs, labels = data  # 获取输入和标签数据  
    optimizer.zero_grad()  # 清零梯度缓存  
    outputs = model(inputs)  # 前向传播，计算输出张量  
    loss = criterion(outputs, labels)  # 计算损失张量  
    loss.backward()  # 反向传播，计算梯度张量并更新权重参数  
    train_loss += loss.item()  # 累加损失值并计算平均损失值和准确率 
    
    _, predicted = torch.max(outputs.data, 1)  # 找到最大概率的标签作为预测结果并计算准确率  
    total += labels.size(0)  # 累加样本数以计算总体准确率  
    correct += predicted.eq(labels.data).cpu().sum()  # 累加正确预测的样本数并计算准确率  
  accuracy = correct / total  # 计算总体准确率并返回给优化器作为目标函数值  
  return accuracy, {"learning_rate": config["learning_rate"], "batch_size": config["batch_size"]}  # 将目标函数值和超参数值返回给优化器

4.11 Sintonizador Keras

KerasTuner es un marco de optimización de hiperparámetros distribuidos fácil de usar que resuelve algunos de los puntos débiles al realizar búsquedas de hiperparámetros. Utiliza métodos avanzados de búsqueda y optimización, como la búsqueda HyperBand y la optimización bayesiana, para ayudar a encontrar hiperparámetros óptimos de la red neuronal.

Comando de instalación:

pip install keras-tuner --upgrade

Dirección oficial de aprendizaje: https://keras.io/keras_tuner/

2. Casos prácticos

import keras_tuner
from tensorflow import keras

# 定义网络模型
def build_model(hp):
    model = keras.Sequential()
    model.add(keras.layers.Dense(
        hp.Choice("units", [8,16,32]),
        activation="relu"
    ))
    model.add(keras.layers.Dense(1,activation="relu"))
    model.compile(loss="mse")
    return model

tuner = keras_tuner.RandomSearch(
    build_model,
    objective="val_loss",
    max_trials=5
)

tuner.search(x_train, y_train, epochs=5, validation_data=(x_val, y_val))

Caso completo: https://www.analyticsvidhya.com/blog/2021/06/tuning-hyperparameters-of-an-artificial-neural-network-leveraging-keras-tuner/

5. Ajuste de hiperparámetros basado en la biblioteca AutoML

5.1 ¿Qué es la biblioteca AutoML?

Una biblioteca automatizada de aprendizaje automático (AutoML) es una herramienta o biblioteca de software diseñada para automatizar los flujos de trabajo de aprendizaje automático. Estas bibliotecas utilizan diferentes algoritmos y técnicas para automatizar el proceso de tareas de aprendizaje automático, incluido el preprocesamiento de datos, selección de características, selección de modelos, optimización de parámetros, evaluación de modelos, etc.

El propósito de AutoML es simplificar el proceso de aprendizaje automático para que los no profesionales también puedan aplicar el aprendizaje automático o ayudar a los profesionales a manejar las tareas de aprendizaje automático de manera más eficiente. Estas bibliotecas suelen proporcionar interfaces fáciles de usar y son capaces de manejar conjuntos de datos a gran escala.

5.2 Bibliotecas comunes de aprendizaje automático automatizado

Existen varios tipos de bibliotecas automatizadas de aprendizaje automático:

• Auto-Sklearn . Auto-Sklearn es una biblioteca AutoML de código abierto construida sobre el paquete scikit-learn. Encuentra el modelo con mejor rendimiento, así como el mejor conjunto de hiperparámetros para un conjunto de datos determinado. Incluye algunas técnicas de ingeniería de características, como codificación de punto único, normalización de características, reducción de dimensionalidad, etc. Esta biblioteca es adecuada para conjuntos de datos pequeños y medianos, pero no para conjuntos de datos grandes.

• H2O AutoML . H2O AutoML es una completa herramienta de automatización de aprendizaje automático de extremo a extremo que puede manejar varios tipos de conjuntos de datos, incluidos datos pequeños y grandes, datos estándar y no estándar. Automatiza todo el proceso de aprendizaje automático, incluida la preparación de datos, la selección de modelos, la selección de funciones, la optimización de modelos, etc.

• Auto-Keras . Auto-Keras es una biblioteca automática de aprendizaje automático basada en el marco de aprendizaje profundo de Keras. Su objetivo es proporcionar un proceso de diseño y capacitación altamente automatizado para modelos de aprendizaje profundo para resolver el problema de que los usuarios pueden necesitar escribir repetidamente una gran cantidad de código cuando enfrentan diferentes tareas.

• AutoGluón . AutoGluon es una biblioteca de aprendizaje automático de aprendizaje profundo de código abierto desarrollada y mantenida por el equipo de AWS. Está diseñado para ayudar a los desarrolladores a automatizar todos los procesos de aprendizaje automático, incluido el preprocesamiento de datos, la ingeniería de funciones, la selección de modelos y el ajuste de hiperparámetros. AutoGluon utiliza una tecnología llamada "búsqueda de arquitectura neuronal" para seleccionar automáticamente la mejor arquitectura de modelo.

• Pycaret . PyCaret es una biblioteca de aprendizaje automático de código abierto y de bajo código diseñada para simplificar los flujos de trabajo de aprendizaje automático y aumentar la productividad. Es una biblioteca de Python que encapsula varias bibliotecas y marcos de aprendizaje automático populares, como scikit-learn, XGBoost, LightGBM, CatBoost, spaCy, Optuna, Hyperopt, Ray, etc. PyCaret también proporciona un conjunto de API fáciles de usar que pueden ayudarlo a completar diversas tareas de aprendizaje automático, incluido el preprocesamiento de datos, el entrenamiento, la evaluación y la implementación de modelos.

• MLBox . MLBox es una potente biblioteca automatizada de aprendizaje automático diseñada para proporcionar a los ingenieros e investigadores de aprendizaje automático una solución integral de aprendizaje automático. Desarrollado por una empresa nacional, encapsula una variedad de marcos y algoritmos de aprendizaje automático populares, como scikit-learn, XGBoost, LightGBM, CatBoost, spaCy, Optuna, Hyperopt, Ray, etc., y los integra en un marco unificado que proporciona API simples y fáciles de usar, lo que hace que el proceso de aprendizaje automático sea más eficiente y conveniente.

• Auto-PyTorch . Auto-PyTorch es una biblioteca automática de aprendizaje automático basada en PyTorch. Su objetivo es proporcionar soluciones automatizadas para la búsqueda de hiperparámetros y la selección de modelos para ayudar a los usuarios a mejorar la eficiencia y la precisión al entrenar modelos de aprendizaje profundo.

5.3Auto-Sklearn

1. Introducción

Auto-Sklearn es una biblioteca AutoML de código abierto que aprovecha la popular biblioteca de aprendizaje automático Scikit-Learn para la transformación de datos y los algoritmos de aprendizaje automático. Auto-Sklearn fue desarrollado por Matthias Feurer et al. descrito en su artículo de 2015 titulado "aprendizaje automático automatizado eficiente y robusto".

Auto-Sklearn selecciona automáticamente el mejor algoritmo de aprendizaje y sus hiperparámetros mediante metaaprendizaje o aumento de gradiente. También puede ajustar automáticamente la complejidad y la integración del modelo, así como realizar un procesamiento previo y posterior de datos.

Comando de instalación:

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple auto-sklearn

Dirección oficial de aprendizaje: https://automl.github.io/auto-sklearn/master/

2. Estudio de caso

import autosklearn.classification  # 基于自动化机器学习库的分类模型
import sklearn.model_selection
import sklearn.datasets
import sklearn.metrics

if __name__ == "__main__":
    X, y = sklearn.datasets.load_digits(return_X_y=True)
    # 数据切分
    X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X, y, random_state=1)
    # 基于自动化机器学习库的分类模型
    automl = autosklearn.classification.AutoSklearnClassifier()
    # 模型训练和预测
    automl.fit(X_train, y_train)
    y_hat = automl.predict(X_test)
    print("Accuracy score", sklearn.metrics.accuracy_score(y_test, y_hat))

5.4H2O AutoML

1. Introducción

H2O AutoML es una herramienta automatizada de aprendizaje automático desarrollada por H2O.ai. Permite a los científicos y analistas de datos crear modelos predictivos de alta calidad de forma más rápida y sencilla mediante la automatización de procesos y técnicas en el campo del aprendizaje automático.

H2O AutoML admite una variedad de algoritmos y selecciones de modelos, incluidos métodos basados ​​en árboles, modelos lineales y modelos de aprendizaje profundo. La herramienta también proporciona funciones como ingeniería automática de funciones, validación cruzada de modelos y optimización de hiperparámetros, que pueden ayudar a los usuarios a realizar automáticamente procesos como limpieza de datos, ingeniería de funciones, selección y ajuste de modelos, mejorando así la precisión y eficiencia del modelo. .

Dirección de aprendizaje del sitio web oficial: https://docs.h2o.ai/h2o/latest-stable/h2o-docs/automl.html

2. Casos de uso

import h2o
from h2o.automl import H2OAutoML

# 启动H2O
h2o.init()

# 导入一个二分类数据集
train = h2o.import_file("https://s3.amazonaws.com/erin-data/higgs/higgs_train_10k.csv")
test = h2o.import_file("https://s3.amazonaws.com/erin-data/higgs/higgs_test_5k.csv")

x = train.columns
y = "response"
x.remove(y)

# 转成向量
train[y] = train[y].asfactor()
test[y] = test[y].asfactor()

# 训练模型：最多20个基线模型
aml = H2OAutoML(max_models=20, seed=1)
aml.train(x=x, y=y, training_frame=train)

# 查看模型效果 
lb = aml.leaderboard
lb.head(rows=lb.nrows) 

# 预测
preds = aml.predict(test)
# preds = aml.leader.predict(test)

# 模型排行输出
lb = h2o.automl.get_leaderboard(aml, extra_columns = "ALL")

Obtenga el efecto de un solo modelo:

m = aml.leader
# 等效
m = aml.get_best_model()

# 使用非默认指标获取最佳模型
m = aml.get_best_model(criterion="logloss")
# 基于默认的排序指标获取XGBoost模型
xgb = aml.get_best_model(algorithm="xgboost")
# 基于logloss指标获取 XGBoost 
xgb = aml.get_best_model(algorithm="xgboost", criterion="logloss")
# 指定获取某个特殊的模型
m = h2o.get_model("StackedEnsemble_BestOfFamily_AutoML_20191213_174603")

# 获取模型的参数信息
xgb.params.keys()
# 特定参数
xgb.params['ntrees']

Obtenga el registro de entrenamiento y la información del tiempo de H2O:

log = aml.event_log  # 日志
info = aml.training_info  # 时间

5.5Auto-Duro

1. Introducción

Auto-Keras es una herramienta automatizada de aprendizaje automático (AutoML) diseñada para simplificar la construcción y optimización de modelos de aprendizaje profundo. Utiliza la tecnología de búsqueda de arquitectura neuronal (NAS) para seleccionar automáticamente las estructuras de modelo e hiperparámetros apropiados, lo que reduce en gran medida el tedioso trabajo de ajuste manual.

Auto-Keras utiliza algoritmos de búsqueda inteligentes para buscar automáticamente la mejor estructura de modelo e hiperparámetros adecuados para el conjunto de datos, proporcionando así el mejor rendimiento del modelo. Proporciona una interfaz simple y fácil de usar, que permite incluso a los usuarios sin un conocimiento profundo del aprendizaje profundo crear rápidamente potentes modelos de aprendizaje profundo.

Auto-Keras admite una variedad de tipos de datos, incluidos datos estructurados tradicionales, imágenes, texto y series temporales. También proporciona muchas funciones avanzadas, como selección automatizada de modelos, interfaz de usuario simple, soporte para múltiples tipos de datos, etc., lo que permite a los usuarios sin conocimientos profesionales crear rápidamente potentes modelos de aprendizaje automático.

Instalar Auto-Keras:

pip install autokeras

Requisitos de versión correspondientes para Python y TensorFlow: Python >= 3.7 y TensorFlow >= 2.8.0 .

Dirección oficial de aprendizaje: https://autokeras.com/

2. Casos prácticos

import numpy as np
import tensorflow as tf
from tensorflow.keras.datasets import mnist

import autokeras as ak

# 导入数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
print(x_train.shape)  # (60000, 28, 28)
print(y_train.shape)  # (60000,)
print(y_train[:3])  # array([7, 2, 1], dtype=uint8)

# 创建模型并训练
clf = ak.ImageClassifier(overwrite=True, max_trials=1)
clf.fit(x_train, y_train, epochs=10)
# 预测模型
predicted_y = clf.predict(x_test)
# 评估模型
clf.evaluate(x_test, y_test)

Utilice el conjunto de datos de validación:

clf.fit(
    x_train,
    y_train,
    validation_split=0.15,   # 验证集比例
    epochs=10,
)

# 手动切分验证集
split = 50000
x_val = x_train[split:]
y_val = y_train[split:]
x_train = x_train[:split]
y_train = y_train[:split]
clf.fit(
    x_train,
    y_train,
    validation_data=(x_val, y_val),
    epochs=10,
)

Espacio de búsqueda personalizado:

input_node = ak.ImageInput()
output_node = ak.ImageBlock(
    block_type = "resnet",
    normalize=True,  # 标准化
    augment=False  # 没有数据增强
)(input_node)

output_node = ak.Classification()(output_node)

clf = ak.AutoModel(inputs=input_node, 
                  outputs=output_node,
                  overwrite=True,
                  max_trials=1)

clf.fit(x_train,y_train, epochs=10)

5.6AutoGluón

1. Introducción

AutoGluon es un marco de aprendizaje automático automatizado desarrollado y mantenido por el equipo de AWS. Puede ajustar automáticamente los hiperparámetros y seleccionar el mejor modelo de aprendizaje profundo para resolver problemas de regresión y clasificación. AutoGluon proporciona una interfaz fácil de usar para controlar los procesos automatizados de aprendizaje automático y puede integrarse con otros marcos de aprendizaje profundo de uso común.

El principio de AutoGluon se basa en la idea del aprendizaje automático automatizado y utiliza una serie de algoritmos y tecnologías para realizar el proceso de aprendizaje automático automatizado. Entre ellos, AutoGluon utiliza una tecnología llamada "búsqueda de arquitectura neuronal" para seleccionar automáticamente la mejor arquitectura de modelo. Además, AutoGluon también proporciona algunas funciones prácticas, como mejora automática de datos, selección automática de modelo, ajuste automático de la tasa de aprendizaje, etc.

Instalación bajo el sistema Windows 10:

https://auto.gluon.ai/stable/install.html

conda create -n myenv python=3.9 -y   # 创建虚拟环境  指定python版本
conda activate myenv  # 进入虚拟环境

pip install -U pip
pip install -U setuptools wheel
# 安装torch相关
pip install torch==1.13.1+cpu torchvision==0.14.1+cpu -f https://download.pytorch.org/whl/cpu/torch_stable.html
# 安装
pip install autogluon

Dirección de aprendizaje del sitio web oficial: https://auto.gluon.ai/stable/index.html

AutoGluon requiere Python versión 3.8, 3.9 o 3.10 y está disponible en Linux, MacOS y Windows.

2. Casos prácticos

import pandas as pd
import numpy as np
np.random.seed=42

import warnings
warnings.filterwarnings("ignore")

from autogluon.tabular import TabularDataset, TabularPredictor
# 读取在线数据
data_url = 'https://raw.githubusercontent.com/mli/ag-docs/main/knot_theory/'
train = TabularDataset(f'{data_url}train.csv')
# 数据基本信息
train.shape  # (10000, 19)
train.columns 
# 结果
Index(['Unnamed: 0', 'chern_simons', 'cusp_volume',
       'hyperbolic_adjoint_torsion_degree', 'hyperbolic_torsion_degree',
       'injectivity_radius', 'longitudinal_translation',
       'meridinal_translation_imag', 'meridinal_translation_real',
       'short_geodesic_imag_part', 'short_geodesic_real_part', 'Symmetry_0',
       'Symmetry_D3', 'Symmetry_D4', 'Symmetry_D6', 'Symmetry_D8',
       'Symmetry_Z/2 + Z/2', 'volume', 'signature'],
      dtype='object')

# 目标变量
label  = "signature"
train[label].describe()
# 模型训练
predictor = TabularPredictor(label=label).fit(train)
# 模型预测
test = TabularDataset(f"{data_url}test.csv")
pred = predictor.predict(test.drop(columns=label))

# 模型评估
predictor.evaluate(test, silent=True)
# 结果
{'accuracy': 0.9448,
 'balanced_accuracy': 0.7445352845015228,
 'mcc': 0.9323703476874563}

# 对比不同模型
predictor.leaderboard(test, silent=True)

5.7PyCaret

1. Introducción

PyCaret es una biblioteca de aprendizaje automático de código abierto y de bajo código diseñada para simplificar los flujos de trabajo de aprendizaje automático y aumentar la productividad. Es una biblioteca de Python que encapsula varias bibliotecas y marcos de aprendizaje automático populares, como scikit-learn, XGBoost, LightGBM, CatBoost, spaCy, Optuna, Hyperopt, Ray, etc.

Dirección oficial de aprendizaje: https://pycaret.org/

Instale pycaret según la fuente de Tsinghua:

pip install pycaret  -i  https://pypi.tuna.tsinghua.edu.cn/simple

# 相关依赖安装
pip install pycaret[analysis]
pip install pycaret[models]
pip install pycaret[tuner]
pip install pycaret[mlops]
pip install pycaret[parallel]
pip install pycaret[test]
pip install pycaret[analysis,models]

Requisitos de versión:

• Python 3.7, 3.8, 3.9 y 3.10

• Ubuntu 16.04 o posterior

• Windows 7 o posterior

2. Casos prácticos

Un caso práctico sobre un problema de clasificación binaria, utilizando el conjunto de datos incorporado

from pycaret.datasets import get_data
from pycaret.classification import *

data = get_data("diabetes")
# 查看数据基本信息

# 1-函数式API
s = setup(data, target="Class variable",session_id=123)

# 2-OOP API
from pycaret.classification import ClassificationExperiment
s = ClassificationExperiment()
s.setup(data, target="Class variable", session_id=123)

# 比较不同模型

# 函数式API
# best = compare_models()
# OOP-API
best = s.compare_models()

# 模型分析

# 函数式API
# evaluate_model(best)
# OOP-API
s.evaluate_model(best)

# 模型预测

# 函数式API
# predict_model(best)
# OOP-API
s.predict_model(best)

Para guardar y cargar modelos utilice:

# functional API
# save_model(best, 'my_first_pipeline')
# OOP API
s.save_model(best, 'my_first_pipeline')

# functional API
# loaded_model = load_model('my_first_pipeline')
# OOP API
loaded_model = s.load_model('my_first_pipeline')
print(loaded_model)

Caja de 5,8 ml.

1. Introducción

MLBox es una potente biblioteca automatizada de aprendizaje automático diseñada para proporcionar a los ingenieros e investigadores de aprendizaje automático una solución integral de aprendizaje automático.

MLBox proporciona una variedad de funciones de preprocesamiento de datos, ingeniería de características, selección de modelos y optimización de hiperparámetros para ayudar a los usuarios a construir y evaluar rápidamente varios modelos de aprendizaje automático. También admite muchos tipos de tareas, incluidas clasificación, regresión, agrupación, detección de anomalías, etc. Además, MLBBox también proporciona algunas funciones adicionales, como la interpretación y la implementación de modelos, que pueden ayudar a los usuarios a comprender y aplicar mejor los modelos de aprendizaje automático. Proporciona las siguientes funciones:

• Realice rápidamente la lectura de datos y el preprocesamiento/limpieza/formateo de datos distribuidos.

• Selección de funciones de alta confiabilidad y detección de fugas de información.

• Optimización precisa de hiperparámetros en un espacio de alta dimensión.

• Modelos predictivos de última generación (Deep Learning, Stacking, LightGBM, etc.) para clasificación y regresión.

• Predicciones con explicaciones de modelos.

Dirección de aprendizaje del sitio web oficial: https://mlbox.readthedocs.io/en/latest/

Requisitos de la versión de Python: Versiones de Python: 3.5 - 3.7 y solo versión de 64 bits (los sistemas Windows de 32 bits ya no son compatibles).

pip install mlbox

Instalación basada en código fuente:

# linux 或者Macos
git clone git://github.com/AxeldeRomblay/mlbox
cd MLBox
python setup.py install

2. Casos prácticos

from mlbox.preprocessing import *
from mlbox.optimisation import *
from mlbox.prediction import *

paths = ["<file_1>.csv", "<file_2>.csv", ..., "<file_n>.csv"] 
target_name = "<my_target>" 

data = Reader(sep=",").train_test_split(paths, target_name)  
data = Drift_thresholder().fit_transform(data)

# 评估模型
Optimiser().evaluate(None, data)

# 自定义搜索参数
space = {
        'ne__numerical_strategy' : {"space" : [0, 'mean']},
        'ce__strategy' : {"space" : ["label_encoding", "random_projection", "entity_embedding"]},
        'fs__strategy' : {"space" : ["variance", "rf_feature_importance"]},
        'fs__threshold': {"search" : "choice", "space" : [0.1, 0.2, 0.3]},
        'est__strategy' : {"space" : ["LightGBM"]},
        'est__max_depth' : {"search" : "choice", "space" : [5,6]},
        'est__subsample' : {"search" : "uniform", "space" : [0.6,0.9]}
        }
best = opt.optimise(space, data, max_evals = 5)

# 预测
Predictor().fit_predict(best, data)

5.9Pytorch automático

1. Introducción

Auto-PyTorch es un marco automático de aprendizaje automático que utiliza PyTorch para implementar la búsqueda automática de arquitecturas de redes neuronales. Auto-PyTorch puede seleccionar automáticamente la mejor arquitectura de red neuronal en función de las características del conjunto de datos, optimizando así el rendimiento del modelo.

El algoritmo de Auto-PyTorch busca automáticamente la arquitectura, los hiperparámetros, etc. de la red neuronal para encontrar el modelo que funciona mejor en un conjunto de datos específico. Esta búsqueda automática puede acelerarse mediante la computación GPU, lo que reduce en gran medida el tedioso trabajo de ajustar manualmente los parámetros y la arquitectura del modelo.

Para utilizar Auto-PyTorch, primero debe instalar PyTorch y la biblioteca Auto-PyTorch. Luego, puede definir conjuntos de datos de entrenamiento y prueba escribiendo código Python simple y llamando a la API de Auto-PyTorch para el entrenamiento y prueba automática del modelo.

Dirección del sitio web oficial de GitHub: https://github.com/automl/Auto-PyTorch

Instalar:

pip install autoPyTorch
# 时序预测相关
pip install autoPyTorch[forecasting]

Instalación manual:

# 创建虚拟环境
conda create -n auto-pytorch python=3.8
conda activate auto-pytorch
conda install swig
python setup.py install

2. Casos prácticos

from autoPyTorch.api.tabular_classification import TabularClassificationTask

# 导入数据
import sklearn.model_selection
import sklearn.datasets
import sklearn.metrics
X, y = sklearn.datasets.load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = sklearn.model_selection.train_test_split(X, y, random_state=1)

# 实例化分类模型
api = TabularClassificationTask()

# 自动化搜索
api.search(
    X_train=X_train,
    y_train=y_train,
    X_test=X_test,
    y_test=y_test,
    optimize_metric='accuracy',
    total_walltime_limit=300,
    func_eval_time_limit_secs=50
)

# 计算准确率
y_pred = api.predict(X_test)
score = api.score(y_pred, y_test)
print("Accuracy score", score)

6. Ajuste de hiperparámetros basado en algoritmos

6.1 Ajuste de hiperparámetros basado en algoritmos

La optimización de hiperparámetros basada en algoritmos se refiere al ajuste automático de los hiperparámetros ejecutando diferentes algoritmos, como algoritmos genéticos, algoritmos de optimización de enjambre de partículas, etc., para encontrar la combinación óptima de hiperparámetros. Este método utiliza algoritmos para buscar en el espacio de hiperparámetros y encontrar la combinación óptima de hiperparámetros.

La optimización de hiperparámetros basada en algoritmos generalmente requiere establecer algunos parámetros, como el tamaño de la población, el número de iteraciones, etc., que afectarán el efecto de optimización. Al ejecutar el algoritmo, los efectos de diferentes combinaciones de hiperparámetros se evalúan en función de ciertos criterios de evaluación y se busca gradualmente la combinación de hiperparámetros óptima.

6.2 Algoritmos comunes utilizados para la optimización de hiperparámetros

• Optimización bayesiana e HyperBand: un algoritmo de optimización de hiperparámetros que combina optimización bayesiana y algoritmos HyperBand. El objetivo de BOHB es encontrar la combinación óptima de hiperparámetros dentro de un presupuesto determinado para que el modelo de aprendizaje automático pueda lograr el mejor rendimiento en una tarea específica.

• Algoritmo de optimización genética: el algoritmo de optimización genética es un método para buscar soluciones óptimas simulando el proceso de evolución natural. Es un método de optimización global que puede buscar la solución óptima dentro de un espacio de solución más grande.

• Algoritmo de optimización de gradiente: el algoritmo de optimización de gradiente es un algoritmo de optimización basado en el descenso de gradiente y se utiliza para resolver problemas de optimización complejos. Busca la solución óptima ajustando iterativamente los parámetros y minimizando la función de pérdida. En el algoritmo de descenso de gradiente, en cada iteración, el algoritmo ajusta los parámetros y actualiza los valores de los parámetros en función de la dirección del gradiente actual. Como el descenso del gradiente de impulso, el algoritmo Adam y el algoritmo L-BFGS, etc.

• Algoritmo de optimización de la población: El algoritmo de optimización de la población es un algoritmo de optimización basado en el principio de evolución biológica en la naturaleza, simula el proceso de evolución biológica y encuentra gradualmente la solución óptima mediante iteración continua y el proceso de supervivencia del más apto. La idea central del algoritmo de optimización de la población es transformar el problema a optimizar en una función de aptitud y luego encontrar gradualmente la solución óptima mediante iteraciones continuas y el proceso de supervivencia del más apto.

6.3 Optimización bayesiana e HyperBand (BOHB)

1. Introducción

La optimización bayesiana y HyperBand combinan el algoritmo Hyperband y la optimización bayesiana. El algoritmo BOHB utiliza el algoritmo de optimización bayesiano para el muestreo y evalúa combinaciones de hiperparámetros para encontrar la mejor combinación de hiperparámetros. Combina las ventajas de la búsqueda global y local y puede encontrar rápidamente la combinación óptima de hiperparámetros a la vez que es robusto y escalable.

El algoritmo BOHB es adecuado para tareas de aprendizaje profundo y, al seleccionar los hiperparámetros apropiados, el rendimiento y la precisión del modelo se pueden mejorar significativamente. Funciona en diferentes modelos y conjuntos de datos, y se pueden agregar fácilmente nuevos hiperparámetros y restricciones.

Los pasos del algoritmo BOHB son los siguientes:

1. Inicialización: seleccione el rango inicial y la distribución de los hiperparámetros, defina las métricas de evaluación y el número de evaluaciones.

2. Ejecute el algoritmo de optimización bayesiano: según el rango y la distribución iniciales, se generan, evalúan y seleccionan combinaciones de hiperparámetros utilizando el algoritmo de optimización bayesiano.

3. Asignación de recursos y selección de modelo basada en el algoritmo HyperBand: según los resultados de la evaluación del algoritmo de optimización bayesiano, el modelo se divide en varios niveles y se asignan diferentes recursos según los niveles.

4. Repita los pasos 2 y 3 hasta alcanzar el número preestablecido de evaluaciones o presupuesto.

5. Genere la combinación de hiperparámetros óptima: seleccione la combinación de hiperparámetros óptima de todos los resultados de la evaluación como resultado final.

referencias:

https://www.automl.org/blog_bohb/

https://neptune.ai/blog/hyperband-and-bohb-understanding-state-of-the-art-hyperparameter-optimization-algorithms

2. casos prácticos de Python

import numpy as np  
from keras.models import Sequential  
from keras.layers import Dense  
from keras.optimizers import Adam  
from keras.losses import BinaryCrossentropy  
from keras.metrics import Accuracy  
from keras.utils import to_categorical  
from sklearn.model_selection import train_test_split  
from bandit import Bandit  
  
# 加载数据集  
data = np.loadtxt('data.csv', delimiter=',')   # data数据集最后一个为预测目标变量，前面所有字段为特征变量
X = data[:, :-1]  
y = to_categorical(data[:, -1])  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
  
# 定义模型  
model = Sequential()  
model.add(Dense(64, activation='relu', input_shape=(X_train.shape[1],)))  
model.add(Dense(64, activation='relu'))  
model.add(Dense(y_train.shape[1], activation='softmax'))  
model.compile(optimizer=Adam(), loss=BinaryCrossentropy(), metrics=[Accuracy()])  
  
# 定义BOHB优化器  
def bohb(x):  
    model.set_weights(x)  
    history = model.fit(X_train, y_train, epochs=10, batch_size=32, validation_split=0.2)  
    loss, accuracy = history.history['val_loss'], history.history['val_accuracy']  
    return loss, accuracy  
  
# 定义Bandit类  
bandit = Bandit(bohb, n_iter=1000, n_restarts=10, noise=0.1)  
  
# 进行优化  
bandit.run()

6.4 Algoritmo genético

1. ¿Qué es el algoritmo genético?

El algoritmo de optimización genética es un algoritmo de optimización que busca soluciones óptimas simulando el proceso de evolución natural.

Este algoritmo está inspirado principalmente en los procesos de selección natural, cruce (recombinación de información genética) y mutación en la evolución biológica. Los algoritmos de optimización genética se utilizan generalmente para resolver algunos problemas de optimización complejos, como optimización de funciones, optimización combinatoria, optimización de parámetros en el aprendizaje automático, etc.

https://cloud.tencent.com/developer/article/1425840

2. Pasos básicos del algoritmo genético:

• Inicialización : primero, el algoritmo genera aleatoriamente una población que contiene posibles soluciones.

• Evaluación de aptitud : cada individuo (es decir, cada solución de la población) tiene un valor de aptitud correspondiente. Este valor de aptitud representa la excelencia del individuo y suele ser una medida del valor de la función objetivo.

• Selección : Seleccionar una parte de los individuos de la población para su reproducción en función de sus valores de aptitud. Los individuos con un alto estado físico tienen mayores posibilidades de ser seleccionados.

• Crossover : Los individuos seleccionados generan nuevos individuos a través de la operación de cruce. Este proceso simula la recombinación genética en la evolución biológica.

• Mutación : Para mantener la diversidad de la población, ciertos individuos serán mutados aleatoriamente, simulando mutaciones genéticas en la evolución biológica.

• Reemplazo : reemplazar algunos individuos de la población original con un lote de individuos recién generado para formar una nueva población.

• Condición de terminación : si se cumple la condición de terminación (como que se alcanza el número máximo de iteraciones o que la aptitud óptima ha alcanzado una cierta precisión), detenga la búsqueda; de lo contrario, regrese al paso 2.

3. Práctica de Python del algoritmo genético

import numpy as np  
  
# 目标函数  
def f(x):  
    return x ** 2  
  
# 遗传算法优化函数  
def genetic_algorithm(n_pop, n_gen, lower_bound, upper_bound):  
    # 初始化种群  
    pop = np.random.uniform(lower_bound, upper_bound, n_pop)  
    # 计算适应度  
    fit = np.array([f(x) for x in pop])  
    # 进行遗传优化  
    for gen in range(n_gen):  
        # 选择  
        idx = np.random.choice(np.arange(n_pop), size=n_pop, replace=True, p=fit/fit.sum())  
        pop = pop[idx]  
        fit = fit[idx]  
        # 交叉  
        for i in range(0, n_pop, 2):  
            if np.random.rand() < 0.5:  
                pop[i], pop[i+1] = pop[i+1], pop[i]  
            pop[i] = (pop[i] + pop[i+1]) / 2.0  
        # 突变  
        for i in range(n_pop):  
            if np.random.rand() < 0.1:  
                pop[i] += np.random.normal(0, 0.5)  
    # 返回最优解  
    return pop[np.argmin(fit)]  
  
# 参数设置  
n_pop = 100  # 种群大小  
n_gen = 100  # 迭代次数  
lower_bound = -10  # 下界  
upper_bound = 10  # 上界  
  
# 进行遗传优化  
best_x = genetic_algorithm(n_pop, n_gen, lower_bound, upper_bound)  
print('最优解：x = %.3f, f(x) = %.3f' % (best_x, f(best_x)))

• Se define la función objetivo f(x) = x**2 y luego se implementa una función de optimización del algoritmo genético.

• Genere una población aleatoria distribuida uniformemente basada en la biblioteca numpy y calcule la aptitud de cada individuo

• En un proceso iterativo, se generan nuevas poblaciones mediante selección de ruleta, cruce aritmético y operaciones de mutación aleatoria. Finalmente, devuelva al individuo con la menor aptitud, que es la solución óptima.

6.5 Algoritmo de optimización de gradiente

1. ¿Qué es la optimización del gradiente?

La optimización basada en gradientes es un método que utiliza información de gradientes para la optimización. El principio básico es utilizar la información de gradiente de la función objetivo para actualizar gradual e iterativamente los parámetros para encontrar el valor mínimo (o máximo) de la función objetivo.

Específicamente, el algoritmo de optimización de gradiente determina la dirección y el tamaño del paso de actualización de parámetros calculando el gradiente de la función objetivo, es decir, la pendiente tangente de la función en un punto determinado . En cada iteración, el algoritmo actualiza los parámetros basándose en la información del gradiente para que el valor de la función objetivo se actualice en la dirección opuesta al gradiente. A través de un proceso iterativo de este tipo, el algoritmo de optimización del gradiente puede acercarse gradualmente al punto mínimo de la función objetivo.

Los algoritmos de optimización de gradiente a menudo se combinan con otras técnicas de optimización, como el método de impulso, el recocido de tasa de aprendizaje, etc.

2. Implementación práctica en Python del algoritmo de optimización de gradiente

import numpy as np  
  
# 加载数据集  
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])  
y = np.array([0, 1, 1, 0])  
  
# 参数初始化  
theta = np.random.randn(2, 1)  
alpha = 0.1  # 学习率  
iters = 1000  
  
# 梯度下降算法  
for i in range(iters):  
    # 计算预测值和误差  
    y_pred = np.dot(X, theta) >= 0.5  
    error = y - y_pred  
    # 计算梯度  
    gradient = np.dot(X.T, error) / len(X) + alpha * theta  
    # 更新参数  
    theta -= gradient  
  
# 输出结果  
print('最优解：theta =', theta)

6.6 Algoritmo de optimización basado en la población

1. Principio del algoritmo de optimización de la población.

El principio de los algoritmos de optimización basados ​​en la población (POA) se basa en la sabiduría grupal y las reglas de evolución grupal y resuelve problemas complejos de optimización a través de algoritmos que simulan el proceso de evolución biológica. En el algoritmo de optimización de la población, cada individuo representa una posible solución y toda la población representa todas las soluciones posibles. Cada individuo tiene un valor de aptitud que indica qué tan bueno es en el problema de optimización.

La idea central del algoritmo es transformar el problema a optimizar en una función de aptitud y luego encontrar gradualmente la solución óptima a través de iteraciones continuas y el proceso de supervivencia del más apto. En cada iteración, cada individuo de la población se clasifica según su valor de aptitud y luego se selecciona, se cruza y se muta según una cierta probabilidad para generar nuevos individuos. Este proceso se repite hasta que se encuentra la solución óptima o se alcanza un número preestablecido de iteraciones.

El algoritmo de optimización de población tiene las ventajas de una gran capacidad de búsqueda global, menos dependencia de los problemas y una gran robustez, y es adecuado para resolver problemas complejos de optimización no lineal. Los algoritmos de optimización de poblaciones comunes incluyen algoritmo genético, algoritmo de optimización de enjambre de partículas, algoritmo de colonia de hormigas, etc.

2. Implementación práctica en Python del algoritmo de optimización de población

import numpy as np  
  
# 适应度函数  
def fitness(x):  
    return x ** 2  
  
# 初始化种群  
population_size = 100  
gene_length = 10  
population = np.random.randint(2, size=(population_size, 基因长度))  
  
# 迭代进化  
iters = 100    # 迭代次数
cross_entropy = 0.8   # 交叉概率
mutation_probability = 0.01    # 变异概率
  
for i in range(iters):  
    # 选择  
    selection_probability = fitness(population) / sum(fitness(population))  
    selected = np.random.choice(np.arange(population_size), size=population_size, p=selection_probability)  
    population = population[selected]  
  
    # 交叉  
    for j in range(population_size):  
        if np.random.rand() < cross_entropy:  
            pos = np.random.randint(gene_length)  
            population[j], population[j+1] = np.roll(population[j], pos), np.roll(population[j+1], pos)  
  
    # 变异  
    for j in range(population_size):  
        if np.random.rand() < mutation_probability:  
            pos = np.random.randint(gene_length)  
            population[j][pos] = 1 - population[j][pos]  
  
    # 计算适应度值并排序  
    fitness_value = np.array([fitness(x) for x in population])  
    fitness_value_index = np.argsort(fitness_value)[::-1]  
    population = population[fitness_value_index]  
  
# 输出最优解  
best_solution_index = np.argmax(fitness_value)  
best_solution = population[best_solution_index]  
print('最优解：',best_solution)

Cosas buenas para aprender, como tres veces seguidas ↓