寻求可在GPU上优化Keras神经网络超参数的Python3库

Got it, let's tackle this—since you're stuck with scikit-learn's KerasClassifier only using CPU, here are three solid Python libraries that let you run Keras hyperparameter optimization on GPU, along with quick implementation snippets to get you started:

Optuna #

Optuna is a flexible, open-source hyperparameter optimization framework that plays nicely with Keras and fully leverages your GPU (as long as your Keras setup is already configured to use GPU). It supports pruning of unpromising trials early to save computation time, which is great for maximizing GPU resource efficiency.

Here's a quick example:

import optuna
from tensorflow import keras
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.datasets import mnist

# Load and preprocess sample data
(x_train, y_train), (x_val, y_val) = mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255
x_val = x_val.reshape(-1, 784).astype("float32") / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_val = keras.utils.to_categorical(y_val, 10)

def objective(trial):
    # Define hyperparameter search space
    units = trial.suggest_int("units", 32, 256)
    dropout_rate = trial.suggest_float("dropout_rate", 0.1, 0.5)
    learning_rate = trial.suggest_float("learning_rate", 1e-5, 1e-2, log=True)
    
    # Build Keras model (automatically uses GPU if available)
    model = keras.Sequential([
        Dense(units, activation="relu", input_shape=(784,)),
        Dropout(dropout_rate),
        Dense(10, activation="softmax")
    ])
    
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
        loss="categorical_crossentropy",
        metrics=["accuracy"]
    )
    
    # Train model
    history = model.fit(
        x_train, y_train,
        validation_data=(x_val, y_val),
        epochs=10,
        batch_size=128,
        verbose=0
    )
    
    # Return validation accuracy as the objective to maximize
    return history.history["val_accuracy"][-1]

# Run optimization
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=20)

print(f"Best accuracy: {study.best_value:.4f}")
print(f"Best hyperparameters: {study.best_params}")

Key note: Optuna doesn't interfere with Keras's GPU usage—if your TensorFlow/Keras is set up to detect your GPU (e.g., CUDA/cuDNN installed correctly), every trial's model training will run on GPU automatically.

Keras Tuner #

Keras Tuner is an official Google library built specifically for tuning Keras models, so it's seamlessly integrated and works out of the box with GPU-accelerated Keras. It supports multiple search algorithms like random search, Bayesian optimization, and Hyperband.

Example implementation:

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.layers import Dense, Dropout
from kerastuner.tuners import RandomSearch
from tensorflow.keras.datasets import mnist

# Load and preprocess data
(x_train, y_train), (x_val, y_val) = mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255
x_val = x_val.reshape(-1, 784).astype("float32") / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_val = keras.utils.to_categorical(y_val, 10)

def build_model(hp):
    model = keras.Sequential()
    model.add(Dense(
        units=hp.Int("units", min_value=32, max_value=256, step=32),
        activation="relu",
        input_shape=(784,)
    ))
    model.add(Dropout(
        hp.Float("dropout_rate", min_value=0.1, max_value=0.5, step=0.1)
    ))
    model.add(Dense(10, activation="softmax"))
    
    model.compile(
        optimizer=keras.optimizers.Adam(
            hp.Float("learning_rate", min_value=1e-5, max_value=1e-2, sampling="log")
        ),
        loss="categorical_crossentropy",
        metrics=["accuracy"]
    )
    return model

# Initialize tuner with search settings
tuner = RandomSearch(
    build_model,
    objective="val_accuracy",
    max_trials=20,
    executions_per_trial=1,
    directory="keras_tuner_dir",
    project_name="mnist_tuning"
)

# Start hyperparameter search
tuner.search(
    x_train, y_train,
    epochs=10,
    batch_size=128,
    validation_data=(x_val, y_val),
    verbose=0
)

# Retrieve best results
best_model = tuner.get_best_models(num_models=1)[0]
best_params = tuner.get_best_hyperparameters(num_trials=1)[0]

print(f"Best validation accuracy: {tuner.oracle.get_best_trials(1)[0].score:.4f}")
print(f"Best hyperparameters: {best_params.values}")

Key note: Keras Tuner uses your existing Keras GPU configuration directly. You can verify GPU detection with tf.config.list_physical_devices('GPU') before running the tuner.

Ray Tune #

Ray Tune is a distributed hyperparameter tuning framework that excels at scaling across multiple GPUs (or even clusters). It integrates with Keras and lets you explicitly specify GPU resources per trial, making it ideal for large-scale optimization tasks.

Here's a quick example:

import ray
from ray import tune
from ray.tune.schedulers import ASHAScheduler
from tensorflow import keras
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.datasets import mnist

# Initialize Ray
ray.init()

# Load and preprocess data
(x_train, y_train), (x_val, y_val) = mnist.load_data()
x_train = x_train.reshape(-1, 784).astype("float32") / 255
x_val = x_val.reshape(-1, 784).astype("float32") / 255
y_train = keras.utils.to_categorical(y_train, 10)
y_val = keras.utils.to_categorical(y_val, 10)

def train_model(config):
    model = keras.Sequential([
        Dense(config["units"], activation="relu", input_shape=(784,)),
        Dropout(config["dropout_rate"]),
        Dense(10, activation="softmax")
    ])
    
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=config["learning_rate"]),
        loss="categorical_crossentropy",
        metrics=["accuracy"]
    )
    
    history = model.fit(
        x_train, y_train,
        validation_data=(x_val, y_val),
        epochs=10,
        batch_size=128,
        verbose=0
    )
    
    # Report validation accuracy to Ray Tune
    tune.report(val_accuracy=history.history["val_accuracy"][-1])

# Define hyperparameter search space
search_space = {
    "units": tune.randint(32, 256),
    "dropout_rate": tune.uniform(0.1, 0.5),
    "learning_rate": tune.loguniform(1e-5, 1e-2)
}

# Initialize scheduler to prune unpromising trials early
scheduler = ASHAScheduler(metric="val_accuracy", mode="max")

# Run tuning with GPU allocation
analysis = tune.run(
    train_model,
    config=search_space,
    scheduler=scheduler,
    num_samples=20,
    resources_per_trial={"gpu": 1}  # Assign 1 GPU per trial
)

print(f"Best validation accuracy: {analysis.best_result['val_accuracy']:.4f}")
print(f"Best hyperparameters: {analysis.best_config}")

# Shutdown Ray
ray.shutdown()

Key note: The resources_per_trial={"gpu": 1} parameter lets you control GPU allocation per trial. If you have multiple GPUs, you can adjust this to run parallel trials across all available hardware.

All three libraries above will utilize your GPU as long as your TensorFlow/Keras environment is properly set up for GPU acceleration (double-check that you have compatible CUDA/cuDNN versions installed for your TensorFlow release).

内容的提问来源于stack exchange，提问作者a'-