Keras CNN训练参数含义及小数据集模型精度提升咨询

Hey there! Let's tackle your two questions about Keras CNNs step by step:

Training parameters are the learnable variables your model adjusts during training to capture patterns in your data. In a CNN, these primarily include:

• Weights: For convolutional layers, these are the values inside each filter that detect specific features (edges, textures, object parts, etc.). For dense layers, they're the connection values between neurons.
• Biases: A single value added to the output of each filter or neuron, helping the model shift its predictions to better fit the data.

For example, your initial Conv2D(28, (5,5), padding='same') layer with input shape (100,100,1) has a parameter count of (5*5*1 + 1)*28 = 728 — the 5*5*1 is the weight count per filter, plus 1 for the bias term, multiplied by 28 total filters.

More parameters mean a model has greater "capacity" to learn complex patterns, but this isn't always a good thing (as you've discovered with your tiny dataset).

First off: More parameters do NOT guarantee higher accuracy, especially with a tiny dataset like 144 images. Here's why your model isn't improving:
Your model has over 111 million parameters — way too much capacity for such a small dataset. Instead of learning generalizable features that work on new data, it's just memorizing every detail (including random noise) in your training samples. This is called overfitting, and it's why your validation accuracy stays stuck at 0.56.

Here are actionable optimizations tailored to your small dataset:

• Data Augmentation (Most Critical!)
  Generate synthetic variations of your images to artificially expand your dataset. This helps the model learn robust, generalizable features instead of memorizing training samples. Example code:

  from keras.preprocessing.image import ImageDataGenerator
  
  datagen = ImageDataGenerator(
      rotation_range=25,
      width_shift_range=0.15,
      height_shift_range=0.15,
      horizontal_flip=True,
      zoom_range=0.2,
      fill_mode='nearest'
  )
  # Fit the generator on your training data
  datagen.fit(train_images)
  # Use it during training with model.fit(datagen.flow(...))
  

• Shrink Your Model Capacity
  Stop adding layers/filters — start small. Try reducing your initial convolutional layer to something like Conv2D(16, (3,3), padding='same') and limit yourself to 2-3 convolutional blocks max. Smaller models can't overfit as easily on tiny datasets.

• Add Regularization

  • L2 Regularization: Penalize large weights to prevent overfitting. Add it to your layers:

    from keras import regularizers
    Conv2D(16, (3,3), padding='same', kernel_regularizer=regularizers.l2(0.001))
    

  • Dropout: Randomly turn off neurons during training to break co-dependencies between features. Insert it after convolutional or dense layers:

    from keras.layers import Dropout
    x = Dropout(0.2)(x)
    

• Use Transfer Learning
  Leverage pre-trained models (like VGG16, ResNet50) that already learned general image features from massive datasets. Freeze most of the pre-trained layers, then train only a small custom top layer on your data. This gives you a powerful model without needing to train everything from scratch.

• Early Stopping
  Stop training as soon as your validation accuracy stops improving to avoid overfitting further. Example:

  from keras.callbacks import EarlyStopping
  early_stop = EarlyStopping(
      monitor='val_acc',
      patience=5,  # Stop after 5 epochs with no improvement
      restore_best_weights=True  # Revert to the best model weights
  )
  model.fit(..., callbacks=[early_stop])
  

• Tweak Training Hyperparameters

  • Use a smaller learning rate (e.g., 1e-4 instead of the default 1e-3) to prevent the model from updating weights too drastically.
  • Reduce the number of training epochs — you might be training far longer than needed.

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