基于历史与未来值的时间序列单步二分类建模求助

Hey Chris, let’s work through your time-series binary classification problem step by step—here’s a structured approach tailored to your data and goals:

First, let’s anchor on your requirements: you’ve got variable-length 3D position time-series from sensors, with grid-based cell features (cell_x, cell_y, cell_z), and you need to predict a 0/1 label for every time step using both historical and future context. This is a bit different from standard sequential forecasting or classification because we’re leveraging bidirectional context (past + future) for each individual time step.

These models are well-suited for variable-length sequences and bidirectional context:

• Bidirectional Transformer (Top Pick)：Transformers excel at capturing long-range temporal and spatial dependencies, and handle variable-length sequences natively with masking. Use a bidirectional encoder (like BERT’s architecture) where each time step’s token includes your raw position features + cell features, plus positional encoding (to preserve sequence order—critical even with grid cells). This model will naturally weigh both past and future steps when predicting each time step’s label.
• Non-Causal Temporal Convolutional Networks (TCNs)：If you’re working with large datasets and want faster training than transformers, TCNs with non-causal convolutions (allowing the model to "see" future steps) are a great alternative. They can capture local and global patterns efficiently, and support variable-length sequences via padding/masking.
• Bidirectional LSTM/GRU：A simpler option if you’re less familiar with transformers. Bidirectional recurrent layers let the model process sequences from both start-to-end and end-to-start, so each time step gets context from past and future. Note that LSTMs struggle with very long sequences (1000+ steps) compared to transformers, though.

Variable-length sequences require careful handling here:

• Dynamic Batching or Padding + Masking：
  • For frameworks like PyTorch, use pack_padded_sequence/pad_packed_sequence to handle variable lengths without wasting computation on padding.
  • If padding to a fixed length, always pass a sequence mask to your model so it ignores padded values (this is non-negotiable—otherwise the model will learn noise from padding).
• Feature Normalization & Encoding：
  • Normalize continuous position features (x, y, z) using standardization ((value - mean)/std) or min-max scaling to ensure they contribute equally to model training.
  • Encode discrete cell features (cell_x, cell_y, cell_z) with embeddings instead of one-hot encoding—this is far more efficient, especially if your grid has many cells. Map each cell ID to a low-dimensional vector that the model can learn.
• Train/Validation/Test Split：Split your data by sequences, not individual time steps, to avoid data leakage. For example, assign 70% of full sensor sequences to training, 20% to validation, 10% to test.

You already have grid cell features—here’s how to boost your model’s signal:

• Temporal context features：Time since the last step, relative position in the sequence (e.g., "step 15 of 42"), or rolling window stats (mean/median x/y/z over the past 5 steps).
• Spatial motion features：Displacement from the previous step (x_t - x_{t-1}, etc.), speed (displacement divided by time interval), or direction of movement.
• Cell transition features：Flag if the current cell is the same as the previous one, or count how many times this cell has been visited in the sequence so far.

• Loss Function：Use BinaryCrossEntropyLoss for standard binary classification. If your labels are imbalanced (e.g., 90% 0s and 10% 1s), add class weights or switch to Focal Loss to prioritize learning the minority class.
• Evaluation Metrics：Don’t rely solely on accuracy—use precision, recall, F1-score, and AUC-ROC to get a full picture of performance, especially if class balance is an issue.
• Regularization：Prevent overfitting with dropout layers (in transformers/LSTMs), L2 weight decay, or early stopping (stop training when validation loss stops improving).
• Handling Future Context：Since you’re allowed to use future data, you can feed full sequences to the model during training/prediction. Just make sure your test set doesn’t leak into training (i.e., don’t use future data from the test set during training preprocessing).

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