Full Training Script Walkthrough

1┌─────────────────────────────────────────────────────────────┐
2│                    TRAINING SCRIPT FLOW                     │
3├─────────────────────────────────────────────────────────────┤
4│                                                             │
5│  1. SETUP & CONFIGURATION                                   │
6│     ├── Parse command-line arguments                        │
7│     ├── Set random seeds (reproducibility)                  │
8│     ├── Configure device (GPU/MPS/CPU)                      │
9│     └── Setup logging                                       │
10│                                                             │
11│  2. DATA LOADING                                            │
12│     ├── Load NASA C-MAPSS dataset                           │
13│     ├── Apply normalization (save scaler params)            │
14│     └── Create DataLoaders                                  │
15│                                                             │
16│  3. MODEL INITIALIZATION                                    │
17│     ├── Create DualTaskEnhancedModel                        │
18│     ├── Initialize loss functions (AMNL)                    │
19│     ├── Setup optimizer (AdamW)                             │
20│     ├── Setup scheduler (ReduceLROnPlateau)                 │
21│     └── Initialize enhancements (EMA, early stopping)       │
22│                                                             │
23│  4. TRAINING LOOP                                           │
24│     ├── For each epoch:                                     │
25│     │   ├── Apply LR warmup (first 10 epochs)               │
26│     │   ├── Apply adaptive weight decay                     │
27│     │   ├── Train batches (gradient accumulation)           │
28│     │   ├── Update EMA weights                              │
29│     │   ├── Evaluate on test set                            │
30│     │   ├── Update scheduler                                │
31│     │   ├── Save best model checkpoint                      │
32│     │   ├── Log metrics                                     │
33│     │   └── Check early stopping                            │
34│     └── Handle interrupts gracefully                        │
35│                                                             │
36│  5. FINALIZATION                                            │
37│     ├── Restore best model                                  │
38│     ├── Final comprehensive evaluation                      │
39│     ├── Save model and training history                     │
40│     └── Generate visualizations                             │
41│                                                             │
42└─────────────────────────────────────────────────────────────┘

1"""
2Enhanced NASA C-MAPSS SOTA Training Script
3AMNL: Adaptive Multi-task Normalized Loss
4State-of-the-Art on ALL 4 NASA C-MAPSS Datasets
5"""
6
7import torch
8import torch.nn as nn
9import torch.optim as optim
10from torch.utils.data import DataLoader
11import numpy as np
12import pandas as pd
13import matplotlib.pyplot as plt
14import seaborn as sns
15from sklearn.metrics import (
16    classification_report,
17    confusion_matrix,
18    accuracy_score,
19    f1_score
20)
21import os
22import sys
23import json
24import copy
25from datetime import datetime
26from pathlib import Path
27import logging
28import warnings
29from typing import Dict, List, Tuple, Optional
30import random
31from collections import defaultdict
32
33warnings.filterwarnings('ignore')
34
35# Local imports
36from src.models.enhanced_sota_rul_predictor import (
37    EnhancedNASACMAPSSDataset,
38    EnhancedSOTATurbofanRULModel,
39    nasa_scoring_function_comprehensive,
40    evaluate_model_comprehensive,
41    convert_numpy_types
42)

1if __name__ == "__main__":
2    import argparse
3
4    parser = argparse.ArgumentParser(
5        description='NASA C-MAPSS AMNL Training Script'
6    )
7    parser.add_argument(
8        '--dataset', type=str, default='FD001',
9        choices=['FD001', 'FD002', 'FD003', 'FD004'],
10        help='Dataset to train on'
11    )
12    parser.add_argument(
13        '--epochs', type=int, default=500,
14        help='Number of training epochs'
15    )
16    parser.add_argument(
17        '--batch_size', type=int, default=256,
18        help='Batch size'
19    )
20    parser.add_argument(
21        '--learning_rate', type=float, default=0.001,
22        help='Learning rate'
23    )
24    parser.add_argument(
25        '--seed', type=int, default=42,
26        help='Random seed for reproducibility'
27    )
28    parser.add_argument(
29        '--output_dir', type=str, default='models/nasa_cmapss',
30        help='Directory to save models'
31    )
32    parser.add_argument(
33        '--use_ema', action='store_true', default=True,
34        help='Use EMA weight tracking'
35    )
36    parser.add_argument(
37        '--use_mixed_precision', action='store_true', default=True,
38        help='Use mixed precision training'
39    )
40
41    args = parser.parse_args()
42
43    # Run training
44    model, history, results = train_enhanced_dual_task_model(
45        dataset_name=args.dataset,
46        epochs=args.epochs,
47        batch_size=args.batch_size,
48        learning_rate=args.learning_rate,
49        random_seed=args.seed,
50        use_ema=args.use_ema,
51        use_mixed_precision=args.use_mixed_precision,
52        output_dir=args.output_dir
53    )

1def set_seed(seed: int = 42):
2    """Set random seeds for reproducibility."""
3    random.seed(seed)
4    np.random.seed(seed)
5    torch.manual_seed(seed)
6    torch.cuda.manual_seed_all(seed)
7    torch.backends.cudnn.deterministic = True
8    torch.backends.cudnn.benchmark = False
9    print(f"Set random seed to {seed} for reproducibility")

1def setup_device(device: str = 'auto') -> torch.device:
2    """Configure compute device with detailed logging."""
3    if device == 'auto':
4        if torch.cuda.is_available():
5            device = torch.device('cuda')
6            logger.info("Using NVIDIA GPU (CUDA)")
7            logger.info(f"  GPU: {torch.cuda.get_device_name()}")
8            memory_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
9            logger.info(f"  Memory: {memory_gb:.1f} GB")
10        elif torch.backends.mps.is_available():
11            device = torch.device('mps')
12            logger.info("Using Apple Silicon GPU (MPS)")
13        else:
14            device = torch.device('cpu')
15            logger.info("Using CPU")
16    else:
17        device = torch.device(device)
18
19    return device

1# Setup logging
2log_dir = Path('logs')
3log_dir.mkdir(exist_ok=True)
4log_file = log_dir / f'training_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log'
5
6logging.basicConfig(
7    level=logging.INFO,
8    format='%(asctime)s - %(levelname)s - %(message)s',
9    handlers=[
10        logging.FileHandler(log_file),
11        logging.StreamHandler(sys.stdout)
12    ]
13)
14logger = logging.getLogger(__name__)

1# Load datasets
2logger.info(f"Loading {dataset_name} datasets...")
3
4train_dataset = EnhancedNASACMAPSSDataset(
5    dataset_name=dataset_name,
6    train=True,
7    random_seed=random_seed,
8    per_condition_norm=False  # Global normalization
9)
10
11# Get scaler parameters for test set normalization
12scaler_params = train_dataset.get_scaler_params()
13
14test_dataset = EnhancedNASACMAPSSDataset(
15    dataset_name=dataset_name,
16    train=False,
17    scaler_params=scaler_params,  # Use training set stats!
18    random_seed=random_seed,
19    per_condition_norm=False
20)
21
22# Create data loaders
23train_loader = DataLoader(
24    train_dataset,
25    batch_size=batch_size,
26    shuffle=True,
27    num_workers=2
28)
29test_loader = DataLoader(
30    test_dataset,
31    batch_size=batch_size,
32    shuffle=False,
33    num_workers=2
34)
35
36# Log dataset statistics
37logger.info(f"Training samples: {len(train_dataset):,}")
38logger.info(f"Test samples: {len(test_dataset):,}")
39logger.info(f"Input features: {train_dataset.sequences.shape[2]}")
40logger.info(f"Sequence length: {train_dataset.sequences.shape[1]}")

1# Analyze class distribution for health state task
2class_dist = train_dataset.get_class_distribution()
3logger.info(f"Health state distribution: {class_dist}")
4
5# Example output:
6# Health state distribution: {
7#   'healthy': 8500,     # RUL > 50
8#   'degrading': 6200,   # 15 < RUL <= 50
9#   'critical': 3000     # RUL <= 15
10# }

1# Dataset-specific dropout rates (tuned per dataset)
2dataset_dropout_config = {
3    'FD001': 0.3,  # Single operating condition
4    'FD002': 0.2,  # Multiple conditions (needs more capacity)
5    'FD003': 0.3,  # Single condition, two fault modes
6    'FD004': 0.2   # Multiple conditions, two fault modes
7}
8
9dropout_rate = dataset_dropout_config.get(dataset_name, 0.25)
10logger.info(f"Using dropout rate: {dropout_rate} for {dataset_name}")
11
12# Initialize model
13input_size = train_dataset.sequences.shape[2]
14
15model = DualTaskEnhancedModel(
16    input_size=input_size,
17    sequence_length=30,
18    hidden_size=256,
19    num_health_states=3,
20    dropout=dropout_rate,
21    use_attention=True,
22    use_residual=True
23).to(device)
24
25# Log model statistics
26total_params = sum(p.numel() for p in model.parameters())
27trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
28
29logger.info(f"Model Architecture:")
30logger.info(f"  Total parameters: {total_params:,}")
31logger.info(f"  Trainable parameters: {trainable_params:,}")

1# RUL loss: Weighted MSE with linear decay
2def weighted_mse_loss(pred, target, max_rul=125.0):
3    """Weighted MSE that emphasizes predictions near end-of-life."""
4    weights = 1.0 + (max_rul - target) / max_rul
5    squared_errors = (pred - target) ** 2
6    return torch.mean(weights * squared_errors)
7
8rul_criterion = weighted_mse_loss
9
10# Health classification loss: Cross-entropy
11health_criterion = nn.CrossEntropyLoss()
12
13# AMNL configuration
14AMNL_RUL_WEIGHT = 0.5
15AMNL_HEALTH_WEIGHT = 0.5
16
17logger.info(f"AMNL weights: {AMNL_RUL_WEIGHT}/{AMNL_HEALTH_WEIGHT}")

1# AdamW optimizer with decoupled weight decay
2optimizer = optim.AdamW(
3    model.parameters(),
4    lr=learning_rate,
5    weight_decay=1e-4,
6    betas=(0.9, 0.999),
7    eps=1e-8
8)
9
10# ReduceLROnPlateau scheduler
11scheduler = optim.lr_scheduler.ReduceLROnPlateau(
12    optimizer,
13    mode='min',
14    factor=0.5,      # Reduce LR by 50%
15    patience=30,     # Wait 30 epochs before reducing
16    min_lr=5e-6,     # Minimum learning rate
17    verbose=True
18)
19
20logger.info("Scheduler: ReduceLROnPlateau")
21logger.info("  Factor: 0.5, Patience: 30, Min LR: 5e-6")

1# Early stopping
2early_stopping = EarlyStopping(
3    patience=80,
4    min_delta=0.0001,
5    restore_best_weights=True
6)
7logger.info("Early stopping patience: 80 epochs")
8
9# Exponential Moving Average
10ema = ExponentialMovingAverage(model, decay=0.999) if use_ema else None
11if ema:
12    logger.info("EMA weight tracking enabled (decay=0.999)")
13
14# Mixed precision training
15scaler = None
16if use_mixed_precision and device.type == 'cuda':
17    scaler = torch.cuda.amp.GradScaler()
18    logger.info("Mixed precision training enabled (FP16)")
19
20# Gradient accumulation
21accumulation_steps = 2
22logger.info(f"Gradient accumulation: {accumulation_steps} steps")
23logger.info(f"Effective batch size: {batch_size * accumulation_steps}")

1# Training state tracking
2history = defaultdict(list)
3best_rmse_last_cycle = float('inf')
4best_model_state = None
5best_epoch = -1
6
7# EMA trackers for AMNL loss normalization
8rul_loss_ema = None
9health_loss_ema = None
10
11logger.info(f"Starting training for {epochs} epochs...")

1for epoch in range(epochs):
2    # ═══════════════════════════════════════════════════════════
3    # PHASE 1: Learning Rate Warmup (first 10 epochs)
4    # ═══════════════════════════════════════════════════════════
5    warmup_epochs = 10
6    if epoch < warmup_epochs:
7        warmup_factor = (epoch + 1) / warmup_epochs
8        for param_group in optimizer.param_groups:
9            param_group['lr'] = learning_rate * warmup_factor
10
11    # ═══════════════════════════════════════════════════════════
12    # PHASE 2: Adaptive Weight Decay
13    # ═══════════════════════════════════════════════════════════
14    if epoch < 50:
15        current_wd = 1e-4
16    elif epoch < 100:
17        current_wd = 5e-5
18    else:
19        current_wd = 1e-5
20
21    for param_group in optimizer.param_groups:
22        param_group['weight_decay'] = current_wd
23
24    # ═══════════════════════════════════════════════════════════
25    # PHASE 3: Training Phase
26    # ═══════════════════════════════════════════════════════════
27    model.train()
28    train_loss = 0.0
29    rul_loss_epoch = 0.0
30    health_loss_epoch = 0.0
31    grad_norm_sum = 0.0
32    n_accumulations = 0
33
34    for batch_idx, (sequences, targets) in enumerate(train_loader):
35        sequences = sequences.to(device)
36        rul_targets = targets.to(device).view(-1, 1)
37
38        # Generate health state labels from RUL
39        health_targets = rul_to_health_state(targets.numpy())
40        health_targets = torch.tensor(health_targets, dtype=torch.long).to(device)
41
42        # Zero gradients at accumulation boundary
43        if batch_idx % accumulation_steps == 0:
44            optimizer.zero_grad()
45
46        # Forward pass with mixed precision
47        if scaler:
48            with torch.cuda.amp.autocast():
49                rul_pred, health_pred = model(sequences)
50
51                # Compute task losses
52                rul_loss = rul_criterion(rul_pred, rul_targets)
53                health_loss = health_criterion(health_pred, health_targets)
54
55                # ─────────────────────────────────────────────────────
56                # AMNL: EMA-based adaptive scaling
57                # ─────────────────────────────────────────────────────
58                if rul_loss_ema is None:
59                    rul_loss_ema = rul_loss.item()
60                    health_loss_ema = health_loss.item()
61                else:
62                    rul_loss_ema = 0.9 * rul_loss_ema + 0.1 * rul_loss.item()
63                    health_loss_ema = 0.9 * health_loss_ema + 0.1 * health_loss.item()
64
65                # Normalize losses by their EMA
66                rul_scale = max(rul_loss_ema, 1e-6)
67                health_scale = max(health_loss_ema, 1e-6)
68
69                normalized_rul = rul_loss / rul_scale
70                normalized_health = health_loss / health_scale
71
72                # Combined AMNL loss (0.5/0.5)
73                total_loss = 0.5 * normalized_rul + 0.5 * normalized_health
74
75            # Backward pass with gradient scaling
76            scaled_loss = total_loss / accumulation_steps
77            scaler.scale(scaled_loss).backward()
78
79            # Optimizer step at accumulation boundary
80            if (batch_idx + 1) % accumulation_steps == 0:
81                scaler.unscale_(optimizer)
82                grad_norm = torch.nn.utils.clip_grad_norm_(
83                    model.parameters(), max_norm=1.0
84                )
85                scaler.step(optimizer)
86                scaler.update()
87
88                # Update EMA weights
89                if ema:
90                    ema.update(model)
91
92                grad_norm_sum += grad_norm.item()
93                n_accumulations += 1
94
95        else:
96            # Non-mixed precision path (CPU/MPS)
97            rul_pred, health_pred = model(sequences)
98
99            rul_loss = rul_criterion(rul_pred, rul_targets)
100            health_loss = health_criterion(health_pred, health_targets)
101
102            # AMNL scaling
103            if rul_loss_ema is None:
104                rul_loss_ema = rul_loss.item()
105                health_loss_ema = health_loss.item()
106            else:
107                rul_loss_ema = 0.9 * rul_loss_ema + 0.1 * rul_loss.item()
108                health_loss_ema = 0.9 * health_loss_ema + 0.1 * health_loss.item()
109
110            normalized_rul = rul_loss / max(rul_loss_ema, 1e-6)
111            normalized_health = health_loss / max(health_loss_ema, 1e-6)
112
113            total_loss = 0.5 * normalized_rul + 0.5 * normalized_health
114
115            scaled_loss = total_loss / accumulation_steps
116            scaled_loss.backward()
117
118            if (batch_idx + 1) % accumulation_steps == 0:
119                grad_norm = torch.nn.utils.clip_grad_norm_(
120                    model.parameters(), max_norm=1.0
121                )
122                optimizer.step()
123
124                if ema:
125                    ema.update(model)
126
127                grad_norm_sum += grad_norm.item()
128                n_accumulations += 1
129
130        train_loss += total_loss.item()
131        rul_loss_epoch += rul_loss.item()
132        health_loss_epoch += health_loss.item()
133
134    # Compute epoch averages
135    avg_train_loss = train_loss / len(train_loader)
136    avg_rul_loss = rul_loss_epoch / len(train_loader)
137    avg_health_loss = health_loss_epoch / len(train_loader)
138    avg_grad_norm = grad_norm_sum / max(n_accumulations, 1)
139
140    # ═══════════════════════════════════════════════════════════
141    # PHASE 4: Evaluation Phase
142    # ═══════════════════════════════════════════════════════════
143    model.eval()
144
145    # Apply EMA weights for evaluation
146    if ema:
147        ema.apply_shadow(model)
148
149    # Comprehensive evaluation
150    eval_results = evaluate_model_comprehensive(model, test_dataset, device)
151
152    # Restore training weights
153    if ema:
154        ema.restore(model)
155
156    # Extract key metrics
157    rmse_last = eval_results['RMSE_last_cycle']
158    rmse_all = eval_results['RMSE_all_cycles']
159    nasa_score = eval_results.get('nasa_score_paper', 0)
160
161    # Health state evaluation
162    health_accuracy = eval_results.get('health_accuracy', 0) * 100
163    health_f1 = eval_results.get('health_f1', 0) * 100
164
165    # ═══════════════════════════════════════════════════════════
166    # PHASE 5: Scheduler Update (after warmup)
167    # ═══════════════════════════════════════════════════════════
168    if epoch >= warmup_epochs:
169        scheduler.step(rmse_last)
170
171    current_lr = optimizer.param_groups[0]['lr']
172
173    # ═══════════════════════════════════════════════════════════
174    # PHASE 6: Best Model Checkpointing
175    # ═══════════════════════════════════════════════════════════
176    if rmse_last < best_rmse_last_cycle:
177        best_rmse_last_cycle = rmse_last
178        best_epoch = epoch
179
180        model.eval()
181        best_model_state = {
182            'model_state_dict': copy.deepcopy(model.state_dict()),
183            'optimizer_state_dict': copy.deepcopy(optimizer.state_dict()),
184            'epoch': epoch,
185            'rmse': rmse_last,
186            'metrics': copy.deepcopy(eval_results)
187        }
188        if ema:
189            best_model_state['ema_shadow'] = copy.deepcopy(ema.shadow)
190
191        logger.info(f"  New best model! RMSE: {rmse_last:.2f}")
192
193    # ═══════════════════════════════════════════════════════════
194    # PHASE 7: History Recording
195    # ═══════════════════════════════════════════════════════════
196    history['train_loss'].append(avg_train_loss)
197    history['rul_loss'].append(avg_rul_loss)
198    history['health_loss'].append(avg_health_loss)
199    history['test_rmse_all'].append(rmse_all)
200    history['test_rmse_last'].append(rmse_last)
201    history['nasa_score_paper'].append(nasa_score)
202    history['health_accuracy'].append(health_accuracy)
203    history['health_f1'].append(health_f1)
204    history['learning_rate'].append(current_lr)
205    history['gradient_norm'].append(avg_grad_norm)
206    history['weight_decay'].append(current_wd)
207
208    # ═══════════════════════════════════════════════════════════
209    # PHASE 8: Logging
210    # ═══════════════════════════════════════════════════════════
211    if (epoch + 1) % 10 == 0 or epoch < 10:
212        warmup_indicator = " [WARMUP]" if epoch < 10 else ""
213        logger.info(
214            f"Epoch [{epoch+1:3d}/{epochs}]{warmup_indicator} | "
215            f"Loss: {avg_train_loss:.4f} | "
216            f"RMSE: {rmse_last:.2f} | "
217            f"NASA: {nasa_score:.1f} | "
218            f"Health: {health_accuracy:.1f}% | "
219            f"LR: {current_lr:.6f}"
220        )
221
222    # ═══════════════════════════════════════════════════════════
223    # PHASE 9: Early Stopping Check
224    # ═══════════════════════════════════════════════════════════
225    if early_stopping(rmse_last, model):
226        logger.info(f"Early stopping triggered at epoch {epoch+1}")
227        logger.info(f"Best RMSE was {best_rmse_last_cycle:.2f} at epoch {best_epoch+1}")
228        break

1def train_enhanced_dual_task_model(
2    dataset_name: str = 'FD001',
3    epochs: int = 500,
4    batch_size: int = 256,
5    learning_rate: float = 0.001,
6    device: str = 'auto',
7    use_mixed_precision: bool = True,
8    use_ema: bool = True,
9    random_seed: int = 42,
10    output_dir: str = 'models/nasa_cmapss'
11) -> Tuple[nn.Module, Dict, Dict]:
12    """
13    Train AMNL dual-task model on NASA C-MAPSS.
14
15    Args:
16        dataset_name: One of FD001, FD002, FD003, FD004
17        epochs: Maximum training epochs
18        batch_size: Training batch size
19        learning_rate: Initial learning rate
20        device: 'auto', 'cuda', 'mps', or 'cpu'
21        use_mixed_precision: Enable FP16 training
22        use_ema: Enable EMA weight tracking
23        random_seed: Random seed for reproducibility
24        output_dir: Directory for saved models
25
26    Returns:
27        Tuple of (trained model, training history, final metrics)
28    """
29    logger.info(f"{'='*60}")
30    logger.info(f"Training AMNL Model on NASA C-MAPSS {dataset_name}")
31    logger.info(f"{'='*60}")
32
33    # ... [Setup, data loading, model init, training loop] ...
34
35    # ═══════════════════════════════════════════════════════════
36    # FINALIZATION
37    # ═══════════════════════════════════════════════════════════
38
39    # Restore best model
40    if best_model_state:
41        logger.info(f"Loading best model from epoch {best_epoch+1}")
42        model.load_state_dict(best_model_state['model_state_dict'])
43        if ema and 'ema_shadow' in best_model_state:
44            ema.shadow = best_model_state['ema_shadow']
45            ema.apply_shadow(model)
46
47    # Final comprehensive evaluation
48    model.eval()
49    final_results = evaluate_model_comprehensive(model, test_dataset, device)
50
51    # Log final results
52    logger.info(f"{'='*60}")
53    logger.info(f"Final {dataset_name} Results:")
54    logger.info(f"{'='*60}")
55    logger.info(f"RUL Prediction:")
56    logger.info(f"  RMSE (last-cycle): {final_results['RMSE_last_cycle']:.2f}")
57    logger.info(f"  RMSE (all-cycles): {final_results['RMSE_all_cycles']:.2f}")
58    logger.info(f"  NASA Score: {final_results.get('nasa_score_paper', 0):.1f}")
59    logger.info(f"Best epoch: {best_epoch+1}")
60
61    # Save model
62    os.makedirs(output_dir, exist_ok=True)
63    model_path = f'{output_dir}/{dataset_name}_amnl_seed{random_seed}.pth'
64
65    torch.save({
66        'model_state_dict': model.state_dict(),
67        'optimizer_state_dict': optimizer.state_dict(),
68        'dataset': dataset_name,
69        'final_metrics': convert_numpy_types(final_results),
70        'training_history': convert_numpy_types(dict(history)),
71        'best_epoch': best_epoch,
72        'model_config': {
73            'input_size': input_size,
74            'sequence_length': 30,
75            'hidden_size': 256,
76            'epochs_trained': epoch + 1,
77            'batch_size': batch_size,
78            'learning_rate': learning_rate,
79            'random_seed': random_seed,
80            'amnl_weights': '0.5/0.5'
81        },
82        'scaler_params': train_dataset.get_scaler_params()
83    }, model_path)
84
85    logger.info(f"Model saved to {model_path}")
86
87    # Create visualizations
88    create_comprehensive_visualizations(dict(history), dataset_name)
89
90    return model, dict(history), final_results

1# Train on FD001 (default)
2python train_amnl.py
3
4# Train on specific dataset
5python train_amnl.py --dataset FD002
6
7# Custom configuration
8python train_amnl.py \
9    --dataset FD003 \
10    --epochs 300 \
11    --batch_size 128 \
12    --learning_rate 0.0005 \
13    --seed 123 \
14    --output_dir models/experiment_v2
15
16# Train all four datasets
17for ds in FD001 FD002 FD003 FD004; do
18    python train_amnl.py --dataset $ds --output_dir models/all_datasets
19done

1============================================================
2Training AMNL Model on NASA C-MAPSS FD001
3============================================================
4Set random seed to 42 for reproducibility
5Using NVIDIA GPU (CUDA)
6  GPU: NVIDIA RTX 4090
7  Memory: 24.0 GB
8Loading FD001 datasets...
9  Training samples: 17,731
10  Test samples: 100
11  Input features: 15
12  Sequence length: 30
13Model Architecture:
14  Total parameters: 3,547,139
15  Trainable parameters: 3,547,139
16AMNL weights: 0.5/0.5
17Scheduler: ReduceLROnPlateau
18  Factor: 0.5, Patience: 30, Min LR: 5e-6
19Early stopping patience: 80 epochs
20EMA weight tracking enabled (decay=0.999)
21Mixed precision training enabled (FP16)
22Gradient accumulation: 2 steps
23Effective batch size: 512
24Starting training for 500 epochs...
25
26Epoch [  1/500] [WARMUP] | Loss: 1.2345 | RMSE: 35.67 | NASA: 2456.2 | LR: 0.000100
27Epoch [  2/500] [WARMUP] | Loss: 0.9876 | RMSE: 28.45 | NASA: 1823.1 | LR: 0.000200
28...
29Epoch [ 87/500] | Loss: 0.1234 | RMSE: 12.81 | NASA: 245.7 | LR: 0.000500
30  New best model! RMSE: 12.81
31...
32Early stopping triggered at epoch 167
33Best RMSE was 12.45 at epoch 142
34
35============================================================
36Final FD001 Results:
37============================================================
38RUL Prediction:
39  RMSE (last-cycle): 12.45
40  RMSE (all-cycles): 14.23
41  NASA Score: 238.4
42Best epoch: 142
43Model saved to models/nasa_cmapss/FD001_amnl_seed42.pth