如何合并多个Keras模型获单一输出且无需再训练？如何循环创建多CNN模型训练？

Hey there! Let's break down your two Keras questions with practical, actionable solutions:

Since you don't want to do extra training, you'll want to use model ensembling techniques that combine the outputs of your pre-trained models directly. Two common, effective approaches are weighted averaging (great for probability outputs) and hard voting (ideal for classification tasks where you pick the most frequent predicted class).

Here's how to implement both using Keras' Functional API:

First, assume you have your 5 pre-trained models ready: #

# Example: list of your already trained models
trained_models = [model1, model2, model3, model4, model5]

Option 1: Weighted Average (Equal Weights) #

This averages the probability outputs of all models, working well for both classification and regression tasks.

from tensorflow.keras.layers import Average, Input
from tensorflow.keras.models import Model

# Define a shared input layer (all models must accept the same input shape)
input_layer = Input(shape=input_shape)

# Get outputs from each pre-trained model
model_outputs = [model(input_layer) for model in trained_models]

# Merge outputs using average (you can customize weights if needed, e.g., [0.2, 0.2, 0.2, 0.2, 0.2] for equal)
merged_output = Average()(model_outputs)

# Create the final ensemble model
ensemble_model = Model(inputs=input_layer, outputs=merged_output)

# Now you can use this model for predictions directly—no training required!
# predictions = ensemble_model.predict(x_test)

Option 2: Hard Voting (Classification Only) #

If you're working on a classification task, this method takes the most frequent predicted class across all models:

from tensorflow.keras.layers import Lambda, Input
from tensorflow.keras.models import Model
import tensorflow as tf

input_layer = Input(shape=input_shape)
model_outputs = [model(input_layer) for model in trained_models]

# Custom lambda layer to compute the majority vote
def majority_vote(outputs):
    # Convert probability outputs to class labels
    class_predictions = tf.argmax(outputs, axis=-1)
    # Get the most frequent label across models
    return tf.math.mode(class_predictions, axis=0)[0]

merged_output = Lambda(majority_vote)(model_outputs)
ensemble_model = Model(inputs=input_layer, outputs=merged_output)

The critical thing here is to create a fresh model instance every iteration—if you reuse the same model object, you'll just overwrite its weights instead of training a new, independent model. The cleanest way to handle this is to wrap your model-building code in a reusable function.

Step 1: Define a model-building function #

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense
import keras

def build_cnn(input_shape, num_classes):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
    model.add(Conv2D(64, (3, 3), activation='relu'))
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(128, activation='relu'))
    model.add(Dropout(0.5))
    model.add(Dense(num_classes, activation='softmax'))
    model.compile(
        loss=keras.losses.categorical_crossentropy,
        optimizer=keras.optimizers.SGD(),
        metrics=['accuracy']
    )
    return model

Step 2: Loop to train multiple models #

num_models = 5
trained_models = []
batch_size = 32  # Adjust to your preferred batch size
epochs = 10      # Adjust to your desired training epochs

for idx in range(num_models):
    print(f"Starting training for model {idx+1}/{num_models}")
    # Create a brand new model instance each time
    current_model = build_cnn(input_shape, num_classes)
    # Train the model on your data
    history = current_model.fit(
        x_train, y_train,
        batch_size=batch_size,
        epochs=epochs,
        verbose=1,
        validation_data=(x_test, y_test)
    )
    # Evaluate and log the model's performance
    test_loss, test_acc = current_model.evaluate(x_test, y_test, verbose=0)
    print(f"Model {idx+1} test accuracy: {test_acc:.4f}\n")
    # Add the trained model to your list
    trained_models.append(current_model)

Now trained_models holds 5 independently trained CNN models, ready to be merged using the method from question 1!

内容的提问来源于stack exchange，提问作者Hasan