如何将HDF5格式图像数据输入卷积神经网络完成训练、验证与测试？

Got it, let’s walk through exactly how to use your HDF5 dataset with models like VGG-16 or ResNet for training, validation, and testing. I’ll use TensorFlow/Keras here since it’s the most straightforward framework for this kind of computer vision task—let’s dive in!

First up, you’ll need the h5py library to read your HDF5 file. If you haven’t installed it yet, just run pip install h5py in your terminal. Then we’ll pull out all the datasets you stored:

import h5py
import numpy as np

# Open the HDF5 file in read mode
with h5py.File('your_dataset.h5', 'r') as f:
    # Extract each dataset into numpy arrays
    train_imgs = np.array(f['train_img'])
    train_labels = np.array(f['train_labels'])
    val_imgs = np.array(f['val_img'])
    val_labels = np.array(f['val_labels'])
    test_imgs = np.array(f['test_img'])
    test_labels = np.array(f['test_labels'])
    train_mean = np.array(f['train_mean'])  # We'll use this for normalization later

Pro tip: If your HDF5 file is huge and can’t fit entirely in memory, you can slice the datasets incrementally instead of loading everything at once—we’ll touch on that later if you need it.

VGG-16 and ResNet expect specific input formats, so let’s get our data ready:

from tensorflow.keras.utils import to_categorical

# Normalize images using the training mean you stored (this is way better than generic 0-1 scaling!)
train_imgs = train_imgs - train_mean
val_imgs = val_imgs - train_mean
test_imgs = test_imgs - train_mean

# Convert integer labels to one-hot encoding (if they aren't already)
if len(train_labels.shape) == 1:
    num_classes = len(np.unique(train_labels))
    train_labels = to_categorical(train_labels, num_classes)
    val_labels = to_categorical(val_labels, num_classes)
    test_labels = to_categorical(test_labels, num_classes)

# Ensure images match the model's input shape (e.g., 224x224x3 for VGG/ResNet)
# If your images are grayscale, repeat channels to make them RGB:
# train_imgs = np.repeat(train_imgs, 3, axis=-1)
# If they're the wrong size, resize with:
# train_imgs = tf.image.resize(train_imgs, (224, 224))

We’ll use transfer learning here—it’s way more efficient than training from scratch, especially if you don’t have a massive dataset. Here’s how to set up both models:

Option A: VGG-16 #

from tensorflow.keras.applications import VGG16
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Flatten, Dropout

# Load pre-trained VGG16 (trained on ImageNet) without the top classification layer
base_model = VGG16(weights='imagenet', include_top=False, input_shape=train_imgs.shape[1:])

# Freeze the base model initially so we don't overwrite its learned features
base_model.trainable = False

# Add custom classification layers on top
x = base_model.output
x = Flatten()(x)
x = Dense(512, activation='relu')(x)
x = Dropout(0.5)(x)  # Dropout prevents overfitting
predictions = Dense(num_classes, activation='softmax')(x)

# Assemble the full model
model = Model(inputs=base_model.input, outputs=predictions)

# Compile the model with Adam optimizer and categorical crossentropy loss
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Option B: ResNet50 #

Almost identical to VGG-16—just swap out the base model:

from tensorflow.keras.applications import ResNet50

base_model = ResNet50(weights='imagenet', include_top=False, input_shape=train_imgs.shape[1:])
base_model.trainable = False

x = base_model.output
x = Flatten()(x)
x = Dense(512, activation='relu')(x)
x = Dropout(0.5)(x)
predictions = Dense(num_classes, activation='softmax')(x)

model = Model(inputs=base_model.input, outputs=predictions)
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

We’ll add callbacks to save the best model and stop training early if validation performance drops (to avoid overfitting):

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

# Save the model with the highest validation accuracy
checkpoint = ModelCheckpoint('best_model.h5', monitor='val_accuracy', save_best_only=True, mode='max', verbose=1)
# Stop training if validation loss doesn't improve for 5 epochs
early_stop = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True, verbose=1)

# Start training
history = model.fit(
    train_imgs, train_labels,
    batch_size=32,  # Adjust based on your GPU memory
    epochs=20,
    validation_data=(val_imgs, val_labels),
    callbacks=[checkpoint, early_stop]
)

After initial training, you can unfreeze some layers of the base model to adapt its learned features to your specific dataset. Use a tiny learning rate so you don’t mess up the pre-trained weights:

import tensorflow as tf

# Unfreeze the last few layers of the base model (adjust the number based on your model)
base_model.trainable = True
fine_tune_at = 10  # For VGG16, this means we freeze the first 10 layers and train the rest
for layer in base_model.layers[:fine_tune_at]:
    layer.trainable = False

# Recompile with a lower learning rate
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Continue training for a few more epochs
history_fine = model.fit(
    train_imgs, train_labels,
    batch_size=32,
    epochs=10,
    validation_data=(val_imgs, val_labels),
    callbacks=[checkpoint, early_stop]
)

Once training is done, test your model on the held-out test data to get a final performance metric:

# Load the best saved model if you want to use it later
# model = tf.keras.models.load_model('best_model.h5')

# Evaluate the model
test_loss, test_acc = model.evaluate(test_imgs, test_labels, verbose=1)
print(f"Final Test Accuracy: {test_acc:.4f}")

# Get predictions for individual test samples (if needed)
predictions = model.predict(test_imgs)
predicted_classes = np.argmax(predictions, axis=1)
true_classes = np.argmax(test_labels, axis=1)

• If your HDF5 file is too big for memory: Create a custom data generator that loads batches of data from the HDF5 file on-the-fly instead of loading everything at once.
• Data augmentation: Add layers like RandomFlip, RandomRotation to your model (or use ImageDataGenerator) to reduce overfitting, especially if your dataset is small.
• Monitor training curves: Plot the training/validation accuracy and loss over epochs to spot overfitting early.

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