如何用Keras将多单通道图像合并为多通道输入馈入CNN？

Absolutely, you don't need to preprocess all your files upfront — you can handle the merging dynamically using Keras/TensorFlow tools, which is perfect for large datasets where precomputing everything would eat up too much storage. Here are two reliable, practical approaches:

1. Custom Keras Sequence Generator #

You can build a custom generator that extends keras.utils.Sequence (safe for multi-processing) to load and merge the three channel files on the fly. Here's a simplified, ready-to-adapt example:

import numpy as np
import keras
from PIL import Image
import os
from glob import glob

class MultiChannelGenerator(keras.utils.Sequence):
    def __init__(self, base_dir, class_names, batch_size=32, target_size=(256,256)):
        self.base_dir = base_dir
        self.class_names = class_names
        self.batch_size = batch_size
        self.target_size = target_size
        
        # Collect all unique sample prefixes (e.g., "img01" from "img01_blue.tif")
        self.sample_list = []
        for cls in class_names:
            cls_dir = os.path.join(base_dir, cls)
            blue_files = glob(os.path.join(cls_dir, "*_blue.tif"))
            for f in blue_files:
                prefix = os.path.basename(f).replace("_blue.tif", "")
                self.sample_list.append((prefix, cls))
        
        # Shuffle samples to ensure randomness during training
        np.random.shuffle(self.sample_list)
        
    def __len__(self):
        # Calculate number of batches per epoch
        return int(np.ceil(len(self.sample_list) / self.batch_size))
    
    def __getitem__(self, idx):
        # Grab the current batch of samples
        batch_samples = self.sample_list[idx*self.batch_size : (idx+1)*self.batch_size]
        
        # Initialize arrays for batch data and labels
        x_batch = np.zeros((len(batch_samples), *self.target_size, 3), dtype=np.float32)
        y_batch = np.zeros((len(batch_samples), len(self.class_names)), dtype=np.float32)
        
        for i, (prefix, cls) in enumerate(batch_samples):
            # Load each channel image
            blue_img = np.array(Image.open(os.path.join(self.base_dir, cls, f"{prefix}_blue.tif")).resize(self.target_size)) / 255.0
            yellow_img = np.array(Image.open(os.path.join(self.base_dir, cls, f"{prefix}_yellow.tif")).resize(self.target_size)) / 255.0
            red_img = np.array(Image.open(os.path.join(self.base_dir, cls, f"{prefix}_red.tif")).resize(self.target_size)) / 255.0
            
            # Merge into a single 3-channel array
            x_batch[i] = np.stack([blue_img, yellow_img, red_img], axis=-1)
            
            # One-hot encode the class label
            y_batch[i, self.class_names.index(cls)] = 1.0
        
        return x_batch, y_batch

To use this generator with your model:

# Replace with your actual class folder names and data path
class_names = ["cat", "dog"]
train_generator = MultiChannelGenerator(base_dir="/path/to/your/dataset", class_names=class_names, batch_size=16)

# Train your CNN
model.fit(train_generator, epochs=15)

2. tf.data.Dataset (Modern, Scalable Approach) #

For better performance with large datasets, use tf.data.Dataset to build an optimized pipeline that handles loading and merging in parallel. Here's how:

import tensorflow as tf
import os

def load_and_merge_channels(prefix, cls, base_dir, target_size):
    # Helper to load and preprocess a single channel image
    def load_single_channel(path):
        img = tf.io.read_file(path)
        img = tf.io.decode_tiff(img)
        img = tf.image.resize(img, target_size)
        return tf.cast(img, tf.float32) / 255.0
    
    # Load all three channels
    blue = load_single_channel(os.path.join(base_dir, cls, f"{prefix}_blue.tif"))
    yellow = load_single_channel(os.path.join(base_dir, cls, f"{prefix}_yellow.tif"))
    red = load_single_channel(os.path.join(base_dir, cls, f"{prefix}_red.tif"))
    
    # Merge into a 3-channel tensor
    merged_img = tf.stack([blue, yellow, red], axis=-1)
    
    # One-hot encode the label
    label = tf.one_hot(tf.argmax(tf.convert_to_tensor(cls == class_names)), depth=len(class_names))
    return merged_img, label

# Prepare list of all samples
base_dir = "/path/to/your/dataset"
class_names = ["cat", "dog"]
sample_list = []

for cls in class_names:
    cls_dir = os.path.join(base_dir, cls)
    blue_files = tf.io.gfile.glob(os.path.join(cls_dir, "*_blue.tif"))
    for f in blue_files:
        prefix = os.path.basename(f).replace("_blue.tif", "")
        sample_list.append((prefix, cls))

# Build the dataset pipeline
batch_size = 16
target_size = (256, 256)

dataset = tf.data.Dataset.from_tensor_slices(sample_list)
dataset = dataset.map(
    lambda x, y: load_and_merge_channels(x, y, base_dir, target_size),
    num_parallel_calls=tf.data.AUTOTUNE
)
dataset = dataset.shuffle(buffer_size=1000).batch(batch_size).prefetch(tf.data.AUTOTUNE)

# Train your model
model.fit(dataset, epochs=15)

Quick Tips #

• Both methods let you skip precomputing merged files, saving disk space and avoiding redundant work.
• The tf.data approach is faster for large datasets, as it uses TensorFlow's optimized I/O and parallel processing.
• Adjust target_size, batch_size, and class names to match your specific dataset structure.

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