Keras中LSTM神经网络输入形状错误问题求助

Hey there! Based on your description of building an LSTM for sequence classification (2000-float sequences, ~1485 samples, integer outputs), here's a step-by-step guide to get you up and running:

• Reshape your input data: LSTMs expect input in the shape (number_of_samples, sequence_length, number_of_features). Since each of your sequences is 2000 single float values, your input shape will be (1485, 2000, 1). Reshape your numpy arrays with something like:

  X = X.reshape((X.shape[0], 2000, 1))
  

• Encode your labels: For multi-class classification (outputs 1, 2, 3...), convert integer labels to one-hot encoded vectors. Using Keras:

  from tensorflow.keras.utils import to_categorical
  y = to_categorical(y_labels, num_classes=num_classes)
  

  Or scikit-learn:

  from sklearn.preprocessing import LabelBinarizer
  lb = LabelBinarizer()
  y = lb.fit_transform(y_labels)
  

• Split into train/validation sets: Use an 80/20 split to monitor overfitting during training:

  from sklearn.model_selection import train_test_split
  X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)
  

• Standardize your data: LSTMs are sensitive to feature scales. Normalize sequences to mean 0 and standard deviation 1:

  from sklearn.preprocessing import StandardScaler
  scaler = StandardScaler()
  # Reshape to 2D for scaling, then back to 3D
  X_train_scaled = scaler.fit_transform(X_train.reshape(-1, 1)).reshape(X_train.shape)
  X_val_scaled = scaler.transform(X_val.reshape(-1, 1)).reshape(X_val.shape)
  

Here's a robust starting architecture using Keras (adjust based on your number of classes):

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.regularizers import L2

num_classes = 3  # Update to match your actual number of output classes

model = Sequential([
    # LSTM layer with 128 units, plus L2 regularization to fight overfitting
    LSTM(128, 
         input_shape=(2000, 1), 
         return_sequences=False,
         kernel_regularizer=L2(0.001)),
    Dropout(0.3),  # Dropout layer to reduce overfitting
    Dense(64, activation='relu', kernel_regularizer=L2(0.001)),
    Dropout(0.3),
    # Output layer with softmax for multi-class classification
    Dense(num_classes, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Verify the architecture
model.summary()

Use early stopping to halt training when validation performance plateaus, and restore the best model weights:

from tensorflow.keras.callbacks import EarlyStopping

early_stopping = EarlyStopping(
    monitor='val_loss',
    patience=5,  # Wait 5 epochs without improvement before stopping
    restore_best_weights=True,
    verbose=1
)

# Start training (small batch size avoids memory issues with long sequences)
history = model.fit(
    X_train_scaled, y_train,
    batch_size=16,
    epochs=50,
    validation_data=(X_val_scaled, y_val),
    callbacks=[early_stopping]
)

• Fight overfitting: If validation accuracy drops while training accuracy rises, reduce LSTM units (e.g., 64 instead of 128) or add more dropout.
• Handle class imbalance: If some classes have far fewer samples, use the class_weight parameter in model.fit() to assign higher weights to underrepresented classes.
• Try bidirectional LSTMs: If your sequence has meaningful context in both directions, wrap the LSTM layer:

  from tensorflow.keras.layers import Bidirectional
  Bidirectional(LSTM(128, input_shape=(2000, 1)))
  

• Visualize training: Plot trends to spot issues early:

  import matplotlib.pyplot as plt
  
  plt.plot(history.history['accuracy'], label='Training Accuracy')
  plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
  plt.xlabel('Epoch')
  plt.ylabel('Accuracy')
  plt.legend()
  plt.show()
  

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