Delete Maginet_inference

Maginet_inference/.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

Maginet_inference/Dockerfile

@@ -1,30 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first for better caching
-COPY requirements.txt .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application files
-COPY . .
-
-# Create necessary directories
-RUN mkdir -p uploads results
-
-# Expose port
-EXPOSE 7860
-
-# Set environment variables
-ENV PYTHONPATH=/app
-ENV FLASK_APP=app.py
-
-# Run the application
-CMD ["python", "app.py"] 

Maginet_inference/README.md

@@ -1,57 +0,0 @@
----
-title: Vessel Trajectory Inference
-emoji: 🚢
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-license: mit
----
-
-# 🚢 Vessel Trajectory Inference
-
-Advanced zero-shot vessel trajectory prediction using LSTM with Attention and Residual connections.
-
-## Features
-
-- **Real-time Inference**: Upload CSV data and get instant predictions
-- **Interactive UI**: Modern web interface with progress tracking
-- **Error Analysis**: Comprehensive error metrics and distribution visualization
-- **Download Results**: Export predictions as CSV with detailed analysis
-
-## Model Details
-
-- **Architecture**: LSTMWithAttentionWithResid (7 layers, 250 hidden units)  
-- **Training Data**: Atlantic Ocean vessel trajectories
-- **Sequence Length**: 12 time steps
-- **Forecast Horizon**: 1 time step ahead
-- **Input Features**: latitude/longitude velocities, positions, time features
-
-## Required Data Format
-
-Your CSV file should contain these columns:
-- `segment` - vessel trajectory segment ID
-- `latitude_velocity_km` - latitude velocity in km/h
-- `longitude_velocity_km` - longitude velocity in km/h  
-- `latitude_degrees` - latitude position
-- `longitude_degrees` - longitude position
-- `time_difference_hours` - time between observations
-- `time_scalar` or `datetime` - temporal reference
-
-## Usage
-
-1. Upload your preprocessed vessel trajectory CSV
-2. (Optional) Upload custom model (.pth) or normalization (.json) files
-3. Click "Start Inference" to begin prediction
-4. View real-time progress and error statistics
-5. Download results CSV with predictions and analysis
-
-## Performance
-
-- Mean prediction error: ~2-5 km (varies by dataset)
-- Processing speed: ~1000 predictions/second on CPU
-- Supports files up to 500MB
-
-## Citation
-
-If you use this model, please cite the original research on vessel trajectory prediction using LSTM networks with attention mechanisms. 

Maginet_inference/app.py

@@ -1,819 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import json
-import time
-import numpy as np
-import pandas as pd
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torch.utils.data import TensorDataset, DataLoader
-from tqdm import tqdm
-from flask import Flask, render_template, request, jsonify, send_file
-from flask_socketio import SocketIO, emit
-import tempfile
-import threading
-from pathlib import Path
-from werkzeug.utils import secure_filename
-
-app = Flask(__name__)
-app.config['SECRET_KEY'] = 'your-secret-key-here'
-app.config['UPLOAD_FOLDER'] = 'uploads'
-app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500MB max file size
-socketio = SocketIO(app, cors_allowed_origins="*")
-
-# Ensure upload directory exists
-os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
-
-# Global variables for progress tracking
-current_progress = {'step': 'idle', 'progress': 0, 'details': ''}
-
-########################################
-#          MODEL DEFINITION            #
-########################################
-
-class LSTMWithAttentionWithResid(nn.Module):
-    def __init__(self, in_dim, hidden_dim, forecast_horizon, n_layers=10, dropout=0.2):
-        super(LSTMWithAttentionWithResid, self).__init__()
-        self.hidden_dim = hidden_dim
-        self.forecast_horizon = forecast_horizon
- 
-        # Embedding layer
-        self.embedding = nn.Linear(in_dim, hidden_dim)
- 
-        # LSTM layers
-        self.lstm = nn.LSTM(
-            hidden_dim, hidden_dim, num_layers=n_layers, dropout=dropout, batch_first=True
-        )
- 
-        # Layer normalization after residual connection
-        self.layer_norm = nn.LayerNorm(hidden_dim)
- 
-        # Attention mechanism
-        self.attention = nn.Linear(hidden_dim, hidden_dim)
-        self.context_vector = nn.Linear(hidden_dim, 1, bias=False)  # Linear layer for scoring
- 
-        # Fully connected layer to map attention context to output
-        self.fc = nn.Linear(hidden_dim, forecast_horizon * 2)
- 
-    def forward(self, x):
-        # x: [batch_size, seq_len, in_dim]
- 
-        # Pass through embedding layer
-        x_embed = self.embedding(x)  # [batch_size, seq_len, hidden_dim]
- 
-        # Pass through LSTM
-        lstm_output, (hidden, cell) = self.lstm(x_embed)  # [batch_size, seq_len, hidden_dim]
- 
-        # Add residual connection (out-of-place)
-        lstm_output = lstm_output + x_embed  # [batch_size, seq_len, hidden_dim]
- 
-        # Apply layer normalization
-        lstm_output = self.layer_norm(lstm_output)  # [batch_size, seq_len, hidden_dim]
- 
-        # Compute attention scores
-        attention_weights = torch.tanh(self.attention(lstm_output))  # [batch_size, seq_len, hidden_dim]
-        attention_scores = self.context_vector(attention_weights).squeeze(-1)  # [batch_size, seq_len]
- 
-        # Apply softmax to normalize scores
-        attention_weights = F.softmax(attention_scores, dim=1)  # [batch_size, seq_len]
- 
-        # Compute the context vector as a weighted sum of LSTM outputs
-        context_vector = torch.bmm(
-            attention_weights.unsqueeze(1), lstm_output
-        )  # [batch_size, 1, hidden_dim]
-        context_vector = context_vector.squeeze(1)  # [batch_size, hidden_dim]
- 
-        # Pass context vector through fully connected layer for forecasting
-        output = self.fc(context_vector)  # [batch_size, forecast_horizon * 2]
- 
-        # Reshape output to match the expected shape
-        output = output.view(-1, self.forecast_horizon, 2)  # [batch_size, forecast_horizon, 2]
- 
-        return output
-
-########################################
-#         UTILITY FUNCTIONS            #
-########################################
-
-def update_progress(step, progress, details=""):
-    """Update global progress state"""
-    global current_progress
-    current_progress = {
-        'step': step,
-        'progress': progress,
-        'details': details
-    }
-    socketio.emit('progress_update', current_progress)
-
-def create_sequences_grouped_by_segment_lat_long_veloc(df_scaled, seq_len=12, forecast_horizon=1, features_to_scale=None):
-    """
-    For each segment, creates overlapping sequences of length seq_len.
-    Returns:
-      - Xs: input sequences,
-      - ys: target outputs (future latitude and longitude velocities),
-      - segments: corresponding segment IDs,
-      - last_positions: last known positions from each sequence.
-    """
-    update_progress('Creating sequences', 10, f'Processing {len(df_scaled)} data points...')
-    
-    Xs, ys, segments, last_positions = [], [], [], []
-    
-    if features_to_scale is None:
-        # CRITICAL: Match YOUR EXACT inference logic (segment first, then removed)
-        features_to_scale = [
-            "segment",                    # Index 0 - will be removed before model
-            "latitude_velocity_km",       # Index 1 -> 0 after segment removal
-            "longitude_velocity_km",      # Index 2 -> 1 after segment removal  
-            "latitude_degrees",           # Index 3 -> 2 after segment removal
-            "longitude_degrees",          # Index 4 -> 3 after segment removal
-            "time_difference_hours",      # Index 5 -> 4 after segment removal
-            "time_scalar"                 # Index 6 -> 5 after segment removal
-        ]
-    
-    # Verify all required features exist
-    missing_features = [f for f in features_to_scale if f not in df_scaled.columns]
-    if missing_features:
-        raise ValueError(f"Missing required features: {missing_features}")
-    
-    grouped = df_scaled.groupby('segment')
-    total_segments = len(grouped)
-    
-    for i, (segment_id, group) in enumerate(grouped):
-        group = group.reset_index(drop=True)
-        L = len(group)
-        
-        # Progress update
-        if i % max(1, total_segments // 20) == 0:
-            progress = 10 + (i / total_segments) * 30  # 10-40% range
-            update_progress('Creating sequences', progress, 
-                          f'Processing segment {i+1}/{total_segments}')
-        
-        if L >= seq_len + forecast_horizon:
-            for j in range(L - seq_len - forecast_horizon + 1):
-                # Get sequence features
-                seq = group.iloc[j:(j+seq_len)][features_to_scale].to_numpy()
-                
-                # Get future time scalar for the forecast horizon
-                future_time = group['time_scalar'].iloc[j + seq_len + forecast_horizon - 1]
-                future_time_feature = np.full((seq_len, 1), future_time)
-                
-                # Augment sequence with future time
-                seq_aug = np.hstack((seq, future_time_feature))
-                Xs.append(seq_aug)
-                
-                # Target: future velocity
-                target = group[['latitude_velocity_km', 'longitude_velocity_km']].iloc[j + seq_len + forecast_horizon - 1].to_numpy()
-                ys.append(target)
-                
-                segments.append(segment_id)
-                
-                # Last known position
-                last_pos = group[['latitude_degrees', 'longitude_degrees']].iloc[j + seq_len - 1].to_numpy()
-                last_positions.append(last_pos)
-    
-    return (np.array(Xs, dtype=np.float32),
-            np.array(ys, dtype=np.float32),
-            np.array(segments),
-            np.array(last_positions, dtype=np.float32))
-
-def load_normalization_params(json_path):
-    """Load normalization parameters from JSON file"""
-    with open(json_path, "r") as f:
-        normalization_params = json.load(f)
-    return normalization_params["feature_mins"], normalization_params["feature_maxs"]
-
-def minmax_denormalize(scaled_series, feature_min, feature_max):
-    """Denormalize data using min-max scaling"""
-    return scaled_series * (feature_max - feature_min) + feature_min
-
-########################################
-#         INFERENCE PIPELINE           #
-########################################
-
-def run_inference_pipeline(csv_file_path, model_path, normalization_path):
-    """Complete inference pipeline following Final_inference_maginet.py logic"""
-    
-    try:
-        # Step 1: Load and validate data
-        update_progress('Loading data', 5, 'Reading CSV file...')
-        
-        # Enhanced CSV parsing with error handling
-        try:
-            # Determine separator by reading first few lines
-            with open(csv_file_path, 'r') as f:
-                first_line = f.readline()
-                separator = ';' if ';' in first_line else ','
-            
-            # Try reading with detected separator
-            df = pd.read_csv(csv_file_path, sep=separator, on_bad_lines='skip')
-            update_progress('Loading data', 8, f'Loaded {len(df)} rows with separator "{separator}"')
-            
-            # Debug: Print actual column names
-            print(f"🔍 CSV COLUMNS FOUND: {list(df.columns)}")
-            update_progress('Loading data', 8.5, f'Columns: {list(df.columns)}')
-            
-        except Exception as e:
-            print(f"❌ CSV PARSING ERROR: {e}")
-            # Try alternative parsing methods
-            try:
-                df = pd.read_csv(csv_file_path, sep=',', on_bad_lines='skip')
-                update_progress('Loading data', 8, f'Loaded {len(df)} rows with comma separator (fallback)')
-                print(f"🔍 CSV COLUMNS FOUND (fallback): {list(df.columns)}")
-            except Exception as e2:
-                try:
-                    df = pd.read_csv(csv_file_path, sep=';', on_bad_lines='skip')
-                    update_progress('Loading data', 8, f'Loaded {len(df)} rows with semicolon separator (fallback)')
-                    print(f"🔍 CSV COLUMNS FOUND (fallback): {list(df.columns)}")
-                except Exception as e3:
-                    raise ValueError(f"Could not parse CSV file. Tried multiple separators. Errors: {e}, {e2}, {e3}")
-        
-        # CRITICAL: Create time_scalar (was missing from inference dataset!)
-        if 'time_scalar' not in df.columns:
-            if 'datetime' in df.columns:
-                # Convert datetime to time_scalar (preferred method)
-                df['datetime'] = pd.to_datetime(df['datetime'], errors='coerce')
-                reference_date = pd.Timestamp('2023-01-01')
-                df['time_scalar'] = ((df['datetime'] - reference_date) / pd.Timedelta(days=1)).round(8)
-                update_progress('Loading data', 9, 'Created time_scalar from datetime column')
-            elif 'time_decimal' in df.columns:
-                # Use time_decimal directly as time_scalar (alternative method)
-                df['time_scalar'] = df['time_decimal'].copy()
-                update_progress('Loading data', 9, 'Created time_scalar from time_decimal column')
-            elif all(col in df.columns for col in ['day', 'month', 'time_decimal']):
-                # Create datetime from components and then time_scalar
-                df['year'] = df.get('year', 2024)  # Default year if not present
-                df['datetime'] = pd.to_datetime(df[['year', 'month', 'day']], errors='coerce')
-                df['datetime'] += pd.to_timedelta(df['time_decimal'], unit='h')
-                reference_date = pd.Timestamp('2023-01-01')
-                df['time_scalar'] = ((df['datetime'] - reference_date) / pd.Timedelta(days=1)).round(8)
-                update_progress('Loading data', 9, 'Created time_scalar from day/month/time_decimal')
-            else:
-                # Create a simple sequential time_scalar based on row order
-                df['time_scalar'] = df.index / len(df)
-                update_progress('Loading data', 9, 'Created sequential time_scalar')
-        
-        # Validate required columns with detailed error reporting
-        required_columns = [
-            'segment', 'latitude_velocity_km', 'longitude_velocity_km',
-            'latitude_degrees', 'longitude_degrees', 'time_difference_hours', 'time_scalar'
-        ]
-        
-        print(f"🔍 REQUIRED COLUMNS: {required_columns}")
-        print(f"🔍 ACTUAL COLUMNS: {list(df.columns)}")
-        
-        missing_columns = [col for col in required_columns if col not in df.columns]
-        if missing_columns:
-            available_cols = list(df.columns)
-            error_msg = f"""
-❌ COLUMN VALIDATION ERROR:
-   Missing required columns: {missing_columns}
-   Available columns: {available_cols}
-   
-   Column mapping suggestions:
-   - Check for extra spaces or different naming
-   - Verify CSV file format and encoding
-   - Ensure time_scalar column exists or can be created
-"""
-            print(error_msg)
-            raise ValueError(f"Missing required columns: {missing_columns}. Available: {available_cols}")
-        
-        # CRITICAL: Apply the SAME data filtering as training/notebook
-        update_progress('Filtering data', 10, 'Applying quality filters...')
-        original_count = len(df)
-        
-        # 1. Calculate speed column if missing (CRITICAL!)
-        if 'speed_km_h' not in df.columns:
-            df['speed_km_h'] = np.sqrt(df['latitude_velocity_km']**2 + df['longitude_velocity_km']**2)
-            update_progress('Filtering data', 10.5, 'Calculated speed_km_h column')
-        
-        # 2. Speed filtering - EXACTLY like training
-        df = df[(df['speed_km_h'] >= 2) & (df['speed_km_h'] <= 60)].copy()
-        update_progress('Filtering data', 11, f'Speed filter: {original_count} -> {len(df)} rows')
-        
-        # 3. Velocity filtering - CRITICAL for performance!
-        velocity_mask = (
-            (np.abs(df['latitude_velocity_km']) <= 100) &
-            (np.abs(df['longitude_velocity_km']) <= 100) &
-            (df['time_difference_hours'] > 0) &
-            (df['time_difference_hours'] <= 24)  # Max 24 hours between points
-        )
-        df = df[velocity_mask].copy()
-        update_progress('Filtering data', 12, f'Velocity filter: -> {len(df)} rows')
-        
-        # 4. Segment length filtering - Remove segments with < 20 points
-        segment_counts = df['segment'].value_counts()
-        segments_to_remove = segment_counts[segment_counts < 20].index
-        before_segment_filter = len(df)
-        df = df[~df['segment'].isin(segments_to_remove)].copy()
-        update_progress('Filtering data', 13, f'Segment filter: {before_segment_filter} -> {len(df)} rows')
-        
-        # 5. Remove NaN and infinite values
-        df = df.dropna().copy()
-        numeric_cols = ['latitude_velocity_km', 'longitude_velocity_km', 'time_difference_hours']
-        for col in numeric_cols:
-            if col in df.columns:
-                df = df[~np.isinf(df[col])].copy()
-        
-        # DEBUGGING: Add detailed filtering statistics
-        filtered_count = len(df)
-        filter_percent = ((original_count - filtered_count) / original_count) * 100
-        update_progress('Filtering data', 14, f'Final filtered data: {filtered_count} rows ({original_count - filtered_count} removed = {filter_percent:.1f}%)')
-        
-        # Debug info for analysis
-        print(f"🔍 FILTERING SUMMARY:")
-        print(f"   Original: {original_count:,} rows")
-        print(f"   Final: {filtered_count:,} rows")
-        print(f"   Removed: {original_count - filtered_count:,} ({filter_percent:.1f}%)")
-        
-        if len(df) == 0:
-            raise ValueError("No data remaining after quality filtering. Check your input data quality.")
-        
-        # Step 2: Load normalization parameters
-        update_progress('Loading normalization', 12, 'Loading normalization parameters...')
-        feature_mins, feature_maxs = load_normalization_params(normalization_path)
-        
-        # Step 2.5: CRITICAL - Normalize the test data (missing step causing 3373km error!)
-        update_progress('Normalizing data', 15, 'Applying normalization to test data...')
-        features_to_normalize = ['latitude_velocity_km', 'longitude_velocity_km',
-                               'latitude_degrees', 'longitude_degrees',
-                               'time_difference_hours', 'time_scalar']
-        
-        for feature in features_to_normalize:
-            if feature in df.columns and feature in feature_mins:
-                min_val = feature_mins[feature]
-                max_val = feature_maxs[feature]
-                rng = max_val - min_val if max_val != min_val else 1
-                df[feature] = (df[feature] - min_val) / rng
-                update_progress('Normalizing data', 18, f'Normalized {feature}')
-        
-        # Step 3: Create sequences
-        SEQ_LENGTH = 12
-        FORECAST_HORIZON = 1
-        
-        X_test, y_test, test_segments, last_known_positions_scaled = create_sequences_grouped_by_segment_lat_long_veloc(
-            df, seq_len=SEQ_LENGTH, forecast_horizon=FORECAST_HORIZON
-        )
-        
-        update_progress('Preparing model', 45, f'Created {len(X_test)} sequences')
-        
-        if len(X_test) == 0:
-            raise ValueError("No valid sequences could be created. Check your data and sequence length requirements.")
-        
-        # Step 4: Prepare data for model
-        device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        X_test_tensor = torch.from_numpy(X_test).float().to(device)
-        y_test_tensor = torch.from_numpy(y_test).float().to(device)
-        test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
-        test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
-        
-        # Step 5: Load model
-        update_progress('Loading model', 50, 'Loading trained model...')
-        
-        # CRITICAL: Model expects 6 features (segment removed) + 1 future_time = 7 total
-        in_dim = X_test.shape[2] - 1  # Remove segment column dimension
-        # CRITICAL: Match the exact model architecture from Atlantic model weights
-        hidden_dim = 250  # From best_model.pth
-        n_layers = 7      # From best_model.pth (CRITICAL: not 10!)
-        dropout = 0.2
-        
-        model = LSTMWithAttentionWithResid(
-            in_dim, hidden_dim, FORECAST_HORIZON, 
-            n_layers=n_layers, dropout=dropout
-        ).to(device)
-        
-        model.load_state_dict(torch.load(model_path, map_location=device))
-        model.eval()
-        
-        # Step 6: Run inference
-        update_progress('Running inference', 60, 'Making predictions...')
-        
-        # CRITICAL: Extract features batch-by-batch like your notebook
-        all_preds = []
-        segments_extracted = []
-        time_scalars_extracted = []
-        time_diff_hours_extracted = []
-        
-        with torch.no_grad():
-            for i, batch in enumerate(test_loader):
-                x_batch, _ = batch
-                
-                # CRITICAL: Extract features exactly like your notebook
-                segment_batch = x_batch[:, 0, 0].cpu().numpy()  # Take segment from first time step
-                time_scalar_batch = x_batch[:, -1, 6].cpu().numpy()  # LAST timestep, index 6 = time_scalar
-                time_diff_hours_batch = x_batch[:, 0, 5].cpu().numpy()  # First timestep, index 5
-                
-                segments_extracted.extend(segment_batch)
-                time_scalars_extracted.extend(time_scalar_batch)
-                time_diff_hours_extracted.extend(time_diff_hours_batch)
-                
-                # Remove segment column before model input
-                x_batch_no_segment = x_batch[:, :, 1:]  # Remove segment (index 0) but keep all other features
-                preds = model(x_batch_no_segment)
-                all_preds.append(preds.cpu().numpy())
-                
-                # Progress update
-                progress = 60 + (i / len(test_loader)) * 20  # 60-80% range
-                update_progress('Running inference', progress, 
-                              f'Processing batch {i+1}/{len(test_loader)}')
-        
-        all_preds = np.concatenate(all_preds, axis=0)
-        
-        # Step 7: Process results
-        update_progress('Processing results', 80, 'Processing predictions...')
-        
-        # CRITICAL: Reshape predictions exactly like your notebook
-        yhat = torch.from_numpy(all_preds)
-        yhat = yhat.view(-1, 2)  # Reshape to [batch_size, 2] - EXACTLY like your notebook
-        
-        # Extract predictions exactly like your notebook
-        predicted_lat_vel = yhat[:, 0].numpy()  # Predicted lat velocity
-        predicted_lon_vel = yhat[:, 1].numpy()  # Predicted lon velocity
-        
-        # Extract actual values exactly like your notebook
-        y_real = y_test_tensor.cpu()
-        actual_lat_vel = y_real[:, 0].numpy()  # Actual lat velocity
-        actual_lon_vel = y_real[:, 1].numpy()  # Actual lon velocity
-        
-        # CRITICAL: Use extracted features from batches (matching your notebook exactly)
-        # Ensure all arrays have consistent length
-        num_samples = len(predicted_lat_vel)
-        segments_extracted = segments_extracted[:num_samples]
-        time_scalars_extracted = time_scalars_extracted[:num_samples]
-        time_diff_hours_extracted = time_diff_hours_extracted[:num_samples]
-        last_known_positions_scaled = last_known_positions_scaled[:num_samples]
-        
-        # Create results dataframe exactly like your notebook
-        results_df = pd.DataFrame({
-            'segment': segments_extracted,              # From batch extraction
-            'time_difference_hours': time_diff_hours_extracted,  # From batch extraction (first timestep)
-            'Time Scalar': time_scalars_extracted,      # From batch extraction (LAST timestep)
-            'Last Known Latitude': [pos[0] for pos in last_known_positions_scaled],
-            'Last Known Longitude': [pos[1] for pos in last_known_positions_scaled],
-            'predicted_lat_km': predicted_lat_vel,
-            'predicted_lon_km': predicted_lon_vel,
-            'actual_lat_km': actual_lat_vel,
-            'actual_lon_km': actual_lon_vel
-        })
-        
-        # Step 8: Denormalize results
-        update_progress('Denormalizing results', 85, 'Converting to real units...')
-        
-        # Column to feature mapping (COMPLETE mapping for all denormalizable columns)
-        column_to_feature = {
-            "predicted_lat_km": "latitude_velocity_km",
-            "predicted_lon_km": "longitude_velocity_km",
-            "actual_lat_km": "latitude_velocity_km",
-            "actual_lon_km": "longitude_velocity_km",
-            "Last Known Latitude": "latitude_degrees",
-            "Last Known Longitude": "longitude_degrees",
-            "time_difference_hours": "time_difference_hours",
-            "Time Scalar": "time_scalar"
-        }
-        
-        # Denormalize relevant columns
-        for col, feat in column_to_feature.items():
-            if col in results_df.columns and feat in feature_mins:
-                fmin = feature_mins[feat]
-                fmax = feature_maxs[feat]
-                results_df[col + "_unscaled"] = minmax_denormalize(results_df[col], fmin, fmax)
-                update_progress('Denormalizing results', 85, f'Denormalized {col}')
-        
-        # Ensure all required _unscaled columns exist
-        required_unscaled_cols = [
-            'predicted_lat_km_unscaled', 'predicted_lon_km_unscaled',
-            'actual_lat_km_unscaled', 'actual_lon_km_unscaled',
-            'Last Known Latitude_unscaled', 'Last Known Longitude_unscaled',
-            'time_difference_hours_unscaled'
-        ]
-        
-        for col in required_unscaled_cols:
-            if col not in results_df.columns:
-                base_col = col.replace('_unscaled', '')
-                if base_col in results_df.columns:
-                    # If base column exists but wasn't denormalized, copy it
-                    results_df[col] = results_df[base_col]
-                    update_progress('Denormalizing results', 87, f'Created missing {col}')
-                else:
-                    results_df[col] = 0.0
-                    update_progress('Denormalizing results', 87, f'Defaulted missing {col} to 0')
-        
-        # ---------------------------
-        # NEW: Clip predicted velocities to realistic physical bounds to avoid huge errors
-        # ---------------------------
-        VELOCITY_RANGE_KM_H = (-100, 100)  # Same limits used during input filtering
-        results_df["predicted_lat_km_unscaled"] = results_df["predicted_lat_km_unscaled"].clip(*VELOCITY_RANGE_KM_H)
-        results_df["predicted_lon_km_unscaled"] = results_df["predicted_lon_km_unscaled"].clip(*VELOCITY_RANGE_KM_H)
-        update_progress('Denormalizing results', 88, 'Clipped predicted velocities to realistic range')
-
-        # Step 9: Calculate final positions and errors (EXACT column structure matching your notebook)
-        update_progress('Calculating errors', 90, 'Computing prediction errors...')
-        
-        # Compute displacement components (in km)
-        results_df["pred_final_lat_km_component"] = (
-            results_df["predicted_lat_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        )
-        results_df["pred_final_lon_km_component"] = (
-            results_df["predicted_lon_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        )
-        results_df["actual_final_lat_km_component"] = (
-            results_df["actual_lat_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        )
-        results_df["actual_final_lon_km_component"] = (
-            results_df["actual_lon_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        )
-        
-        # Calculate total displacement magnitudes (MISSING COLUMNS!)
-        results_df["pred_final_km"] = np.sqrt(
-            results_df["pred_final_lat_km_component"]**2 + results_df["pred_final_lon_km_component"]**2
-        )
-        results_df["actual_final_km"] = np.sqrt(
-            results_df["actual_final_lat_km_component"]**2 + results_df["actual_final_lon_km_component"]**2
-        )
-        
-        # Calculate Euclidean distance error (in km)
-        results_df["error_km"] = np.sqrt(
-            (results_df["pred_final_lat_km_component"] - results_df["actual_final_lat_km_component"])**2 +
-            (results_df["pred_final_lon_km_component"] - results_df["actual_final_lon_km_component"])**2
-        )
-        
-        # Compute final positions in degrees
-        km_per_deg_lat = 111  # approximate conversion for latitude
-        results_df["pred_final_lat_deg"] = results_df["Last Known Latitude_unscaled"] + (
-            results_df["predicted_lat_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        ) / km_per_deg_lat
-        results_df["actual_final_lat_deg"] = results_df["Last Known Latitude_unscaled"] + (
-            results_df["actual_lat_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        ) / km_per_deg_lat
-        
-        # Account for longitude scaling by latitude
-        results_df["Last_Known_Lat_rad"] = np.deg2rad(results_df["Last Known Latitude_unscaled"])
-        results_df["pred_final_lon_deg"] = results_df["Last Known Longitude_unscaled"] + (
-            results_df["predicted_lon_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        ) / (km_per_deg_lat * np.cos(results_df["Last_Known_Lat_rad"]))
-        results_df["actual_final_lon_deg"] = results_df["Last Known Longitude_unscaled"] + (
-            results_df["actual_lon_km_unscaled"] * results_df["time_difference_hours_unscaled"]
-        ) / (km_per_deg_lat * np.cos(results_df["Last_Known_Lat_rad"]))
-        
-        # Step 10: Reorder columns to match your EXACT specification
-        update_progress('Finalizing results', 93, 'Reordering columns to match notebook format...')
-        
-        # EXACT column order as specified by user
-        column_order = [
-            'segment', 'time_difference_hours', 'Time Scalar', 'Last Known Latitude', 'Last Known Longitude',
-            'predicted_lat_km', 'predicted_lon_km', 'actual_lat_km', 'actual_lon_km',
-            'predicted_lat_km_unscaled', 'predicted_lon_km_unscaled', 'actual_lat_km_unscaled', 'actual_lon_km_unscaled',
-            'Last Known Latitude_unscaled', 'Last Known Longitude_unscaled', 'time_difference_hours_unscaled',
-            'pred_final_km', 'actual_final_km',
-            'pred_final_lat_km_component', 'pred_final_lon_km_component', 
-            'actual_final_lat_km_component', 'actual_final_lon_km_component',
-            'error_km', 'pred_final_lat_deg', 'actual_final_lat_deg', 'Last_Known_Lat_rad',
-            'pred_final_lon_deg', 'actual_final_lon_deg'
-        ]
-        
-        # Validate all required columns exist - add missing ones with defaults if needed
-        missing_columns = [col for col in column_order if col not in results_df.columns]
-        if missing_columns:
-            update_progress('Finalizing results', 94, f'Adding missing columns: {missing_columns}')
-            for col in missing_columns:
-                # Add default values for any missing columns
-                if '_unscaled' in col:
-                    # For unscaled columns, try to find the original scaled column
-                    base_col = col.replace('_unscaled', '')
-                    if base_col in results_df.columns and base_col in column_to_feature:
-                        # Use the same denormalization process
-                        feat = column_to_feature[base_col]
-                        if feat in feature_mins:
-                            fmin = feature_mins[feat]
-                            fmax = feature_maxs[feat]
-                            results_df[col] = minmax_denormalize(results_df[base_col], fmin, fmax)
-                        else:
-                            results_df[col] = results_df[base_col]  # No denormalization available
-                    else:
-                        results_df[col] = 0.0  # Default to 0
-                else:
-                    results_df[col] = 0.0  # Default to 0 for any other missing columns
-        
-        # Reorder columns to match exact specification
-        results_df = results_df[column_order]
-        
-        # Step 11: Save results
-        update_progress('Saving results', 95, 'Saving inference results...')
-        
-        # Create results directory
-        results_dir = Path('results/inference_atlantic')
-        results_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Save to results directory
-        timestamp = pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')
-        results_file = results_dir / f'inference_results_{timestamp}.csv'
-        results_df.to_csv(results_file, index=False)
-        
-        # Also save to temporary file for compatibility
-        output_file = tempfile.NamedTemporaryFile(
-            mode='w', suffix='_inference_results.csv', delete=False
-        )
-        results_df.to_csv(output_file.name, index=False)
-        
-        # CRITICAL: Calculate SAME regression metrics as your notebook
-        # Convert predictions and actuals to tensors for metric calculation
-        yhat_tensor = torch.from_numpy(np.column_stack([predicted_lat_vel, predicted_lon_vel])).float()
-        y_real_tensor = torch.from_numpy(np.column_stack([actual_lat_vel, actual_lon_vel])).float()
-        
-        # Calculate regression metrics exactly like your notebook
-        def calc_metrics_like_notebook(preds, labels):
-            """Calculate metrics exactly like your notebook's calc_metrics function"""
-            EPS = 1e-8
-            mse = torch.mean((preds - labels) ** 2)
-            mae = torch.mean(torch.abs(preds - labels))
-            rmse = torch.sqrt(mse)
-            mape = torch.mean(torch.abs((preds - labels) / (labels + EPS))) * 100  # Convert to percentage
-            rse = torch.sum((preds - labels) ** 2) / torch.sum((labels + EPS) ** 2)
-            return rse.item(), mae.item(), mse.item(), mape.item(), rmse.item()
-        
-        # Calculate regression metrics on velocity predictions
-        rse, mae, mse, mape, rmse = calc_metrics_like_notebook(yhat_tensor, y_real_tensor)
-        
-        # Calculate summary statistics
-        error_stats = {
-            # Distance-based metrics (web app specific)
-            'mean_error_km': float(results_df["error_km"].mean()),
-            'median_error_km': float(results_df["error_km"].median()),
-            'std_error_km': float(results_df["error_km"].std()),
-            'min_error_km': float(results_df["error_km"].min()),
-            'max_error_km': float(results_df["error_km"].max()),
-            
-            # Regression metrics (matching your notebook)
-            'rse': rse,
-            'mae': mae,
-            'mse': mse,
-            'mape': mape,
-            'rmse': rmse,
-            
-            # General stats
-            'total_predictions': len(results_df),
-            'total_segments': len(results_df['segment'].unique()),
-            'columns_generated': list(results_df.columns),
-            'total_columns': len(results_df.columns)
-        }
-        
-        # NEW: Create histogram of error distribution (30 bins by default)
-        hist_counts, bin_edges = np.histogram(results_df["error_km"], bins=30)
-        histogram_data = {
-            'bins': bin_edges.tolist(),
-            'counts': hist_counts.tolist()
-        }
-        
-        update_progress('Complete', 100, 
-                       f'✅ Inference complete! Distance: {error_stats["mean_error_km"]:.2f} km | MAE: {error_stats["mae"]:.2f} | MAPE: {error_stats["mape"]:.2f}%')
-        
-        # Emit inference_complete with full statistics and histogram for the frontend chart
-        try:
-            socketio.emit('inference_complete', {
-                'success': True,
-                'stats': error_stats,
-                'histogram': histogram_data
-            })
-        except Exception:
-            pass  # In case we are in CLI context without SocketIO
-        
-        return {
-            'success': True,
-            'results_file': output_file.name,
-            'stats': error_stats,
-            'histogram': histogram_data,
-            'message': f'Successfully processed {len(results_df)} predictions'
-        }
-        
-    except Exception as e:
-        error_msg = f"Error during inference: {str(e)}"
-        update_progress('Error', 0, error_msg)
-        return {
-            'success': False,
-            'error': error_msg
-        }
-
-########################################
-#            WEB ROUTES                #
-########################################
-
-@app.route('/')
-def index():
-    return render_template('vessel_inference.html')
-
-@app.route('/upload', methods=['POST'])
-def upload_file():
-    try:
-        # Check if files were uploaded
-        if 'csv_file' not in request.files:
-            return jsonify({'success': False, 'error': 'No CSV file uploaded'})
-        
-        csv_file = request.files['csv_file']
-        if csv_file.filename == '':
-            return jsonify({'success': False, 'error': 'No CSV file selected'})
-        
-        # Default model and normalization files
-        model_path = 'best_model.pth'
-        normalization_path = 'normalization_params_1_atlanttic_regular_intervals_with_lat_lon_velocity_and_time_difference_filter_outlier_segment_min_20_points.json'
-        
-        # Check for optional uploads
-        if 'model_file' in request.files and request.files['model_file'].filename != '':
-            model_file = request.files['model_file']
-            model_filename = secure_filename(model_file.filename)
-            model_path = os.path.join(app.config['UPLOAD_FOLDER'], model_filename)
-            model_file.save(model_path)
-        
-        if 'normalization_file' in request.files and request.files['normalization_file'].filename != '':
-            norm_file = request.files['normalization_file']
-            norm_filename = secure_filename(norm_file.filename)
-            normalization_path = os.path.join(app.config['UPLOAD_FOLDER'], norm_filename)
-            norm_file.save(normalization_path)
-        
-        # Check if required files exist
-        if not os.path.exists(model_path):
-            return jsonify({'success': False, 'error': f'Model file not found: {model_path}'})
-        
-        if not os.path.exists(normalization_path):
-            return jsonify({'success': False, 'error': f'Normalization file not found: {normalization_path}'})
-        
-        # Save CSV file
-        csv_filename = secure_filename(csv_file.filename)
-        csv_path = os.path.join(app.config['UPLOAD_FOLDER'], csv_filename)
-        csv_file.save(csv_path)
-        
-        # Start inference in background thread
-        def run_inference_background():
-            return run_inference_pipeline(csv_path, model_path, normalization_path)
-        
-        thread = threading.Thread(target=run_inference_background)
-        thread.start()
-        
-        return jsonify({'success': True, 'message': 'Files uploaded successfully. Inference started.'})
-        
-    except Exception as e:
-        return jsonify({'success': False, 'error': str(e)})
-
-@app.route('/progress')
-def get_progress():
-    return jsonify(current_progress)
-
-@app.route('/download_results')
-def download_results():
-    # Find the most recent results file
-    upload_dir = app.config['UPLOAD_FOLDER']
-    temp_dir = tempfile.gettempdir()
-    
-    # Look for results files in both directories
-    for directory in [upload_dir, temp_dir]:
-        if os.path.exists(directory):
-            files = [f for f in os.listdir(directory) if f.endswith('_inference_results.csv')]
-            if files:
-                latest_file = max(files, key=lambda x: os.path.getctime(os.path.join(directory, x)))
-                return send_file(
-                    os.path.join(directory, latest_file),
-                    as_attachment=True,
-                    download_name='vessel_inference_results.csv'
-                )
-    
-    return jsonify({'error': 'No results file found'}), 404
-
-########################################
-#           SOCKETIO EVENTS            #
-########################################
-
-@socketio.on('connect')
-def handle_connect():
-    emit('progress_update', current_progress)
-
-@socketio.on('start_inference')
-def handle_start_inference(data):
-    """Handle inference request via WebSocket"""
-    try:
-        csv_path = data.get('csv_path')
-        model_path = data.get('model_path', 'best_model.pth')
-        norm_path = data.get('normalization_path', 'normalization_params_1_atlanttic_regular_intervals_with_lat_lon_velocity_and_time_difference_filter_outlier_segment_min_20_points.json')
-        
-        def run_inference_background():
-            result = run_inference_pipeline(csv_path, model_path, norm_path)
-            emit('inference_complete', result)
-        
-        thread = threading.Thread(target=run_inference_background)
-        thread.start()
-        
-    except Exception as e:
-        emit('inference_complete', {'success': False, 'error': str(e)})
-
-if __name__ == '__main__':
-    print("🚢 Vessel Trajectory Inference Web App")
-    print("📊 Using Final_inference_maginet.py logic")
-    
-    # Get port from environment variable (Hugging Face Spaces uses 7860)
-    port = int(os.environ.get('PORT', 7860))
-    print(f"🌐 Starting server at http://0.0.0.0:{port}")
-    print("📝 Make sure you have:")
-    print("   - best_model.pth")
-    print("   - normalization_params_1_atlanttic_regular_intervals_...json")
-    print("   - Your test dataset CSV")
-    
-    socketio.run(app, host='0.0.0.0', port=port, debug=False) 

Maginet_inference/requirements.txt

@@ -1,13 +0,0 @@
-# Core ML and Data Processing
-torch>=1.9.0,<2.1.0
-pandas>=1.3.0,<2.1.0
-numpy>=1.21.0,<1.25.0
-tqdm>=4.62.0
-
-# Web Interface
-flask>=2.0.0,<3.0.0
-flask-socketio>=5.1.0,<6.0.0
-werkzeug>=2.0.0,<3.0.0
-
-# Additional utilities
-pathlib 

Maginet_inference/templates/vessel_inference.html

@@ -1,681 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>🚢 Vessel Trajectory Inference</title>
-    <script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>
-    <!-- Chart.js for error distribution plot -->
-    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chart.umd.min.js"></script>
-    <style>
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-
-        body {
-            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-            min-height: 100vh;
-            padding: 20px;
-        }
-
-        .container {
-            max-width: 900px;
-            margin: 0 auto;
-            background: white;
-            border-radius: 15px;
-            box-shadow: 0 20px 40px rgba(0,0,0,0.1);
-            overflow: hidden;
-        }
-
-        .header {
-            background: linear-gradient(135deg, #2c3e50 0%, #3498db 100%);
-            color: white;
-            padding: 30px;
-            text-align: center;
-        }
-
-        .header h1 {
-            font-size: 2.5rem;
-            margin-bottom: 10px;
-            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
-        }
-
-        .header p {
-            font-size: 1.1rem;
-            opacity: 0.9;
-            margin-bottom: 5px;
-        }
-
-        .subtitle {
-            font-size: 0.95rem !important;
-            font-style: italic;
-            opacity: 0.8 !important;
-        }
-
-        .content {
-            padding: 40px;
-        }
-
-        .data-format-info {
-            background: #e8f4fd;
-            border: 2px solid #3498db;
-            border-radius: 10px;
-            padding: 20px;
-            margin-bottom: 30px;
-        }
-
-        .data-format-info h3 {
-            color: #2c3e50;
-            margin-bottom: 15px;
-            font-size: 1.3rem;
-        }
-
-        .required-columns {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-            gap: 10px;
-            margin-top: 15px;
-        }
-
-        .column-item {
-            background: white;
-            padding: 10px;
-            border-radius: 5px;
-            border-left: 4px solid #3498db;
-            font-family: 'Courier New', monospace;
-            font-size: 0.9rem;
-        }
-
-        .upload-section {
-            margin-bottom: 30px;
-        }
-
-        .upload-section h3 {
-            color: #2c3e50;
-            margin-bottom: 15px;
-            font-size: 1.3rem;
-        }
-
-        .file-upload {
-            border: 2px dashed #3498db;
-            border-radius: 10px;
-            padding: 30px;
-            text-align: center;
-            background: #f8f9fa;
-            margin-bottom: 20px;
-            transition: all 0.3s ease;
-        }
-
-        .file-upload:hover {
-            border-color: #2980b9;
-            background: #e8f4fd;
-        }
-
-        .file-upload input[type="file"] {
-            display: none;
-        }
-
-        .file-upload label {
-            display: block;
-            cursor: pointer;
-            font-size: 1.1rem;
-            color: #2c3e50;
-        }
-
-        .file-upload .upload-icon {
-            font-size: 3rem;
-            margin-bottom: 10px;
-            color: #3498db;
-        }
-
-        .file-info {
-            margin-top: 10px;
-            padding: 10px;
-            background: #d4edda;
-            border-radius: 5px;
-            border: 1px solid #c3e6cb;
-            display: none;
-        }
-
-        .optional-uploads {
-            display: grid;
-            grid-template-columns: 1fr 1fr;
-            gap: 20px;
-            margin-top: 20px;
-        }
-
-        .optional-upload {
-            border: 1px solid #dee2e6;
-            border-radius: 8px;
-            padding: 20px;
-            background: #f8f9fa;
-        }
-
-        .optional-upload h4 {
-            color: #495057;
-            margin-bottom: 10px;
-            font-size: 1rem;
-        }
-
-        .optional-upload input[type="file"] {
-            width: 100%;
-            padding: 8px;
-            border: 1px solid #ced4da;
-            border-radius: 4px;
-            font-size: 0.9rem;
-        }
-
-        .btn {
-            background: linear-gradient(135deg, #3498db 0%, #2980b9 100%);
-            color: white;
-            border: none;
-            padding: 15px 30px;
-            font-size: 1.1rem;
-            border-radius: 8px;
-            cursor: pointer;
-            transition: all 0.3s ease;
-            width: 100%;
-            margin-top: 20px;
-        }
-
-        .btn:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 5px 15px rgba(52, 152, 219, 0.4);
-        }
-
-        .btn:disabled {
-            background: #95a5a6;
-            cursor: not-allowed;
-            transform: none;
-            box-shadow: none;
-        }
-
-        .progress-container {
-            display: none;
-            margin-top: 30px;
-            padding: 20px;
-            background: #f8f9fa;
-            border-radius: 10px;
-            border: 1px solid #dee2e6;
-        }
-
-        .progress-bar {
-            width: 100%;
-            height: 25px;
-            background: #e9ecef;
-            border-radius: 15px;
-            overflow: hidden;
-            margin-bottom: 15px;
-        }
-
-        .progress-fill {
-            height: 100%;
-            background: linear-gradient(90deg, #3498db, #2ecc71);
-            width: 0%;
-            transition: width 0.3s ease;
-            border-radius: 15px;
-        }
-
-        .progress-text {
-            text-align: center;
-            font-weight: bold;
-            color: #2c3e50;
-            margin-bottom: 10px;
-        }
-
-        .progress-details {
-            text-align: center;
-            color: #7f8c8d;
-            font-size: 0.9rem;
-        }
-
-        .results-container {
-            display: none;
-            margin-top: 30px;
-            padding: 20px;
-            background: #d4edda;
-            border-radius: 10px;
-            border: 1px solid #c3e6cb;
-        }
-
-        .results-stats {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-            gap: 15px;
-            margin-bottom: 20px;
-        }
-
-        .stat-item {
-            background: white;
-            padding: 15px;
-            border-radius: 8px;
-            text-align: center;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-
-        .stat-value {
-            font-size: 1.5rem;
-            font-weight: bold;
-            color: #2c3e50;
-        }
-
-        .stat-label {
-            font-size: 0.9rem;
-            color: #7f8c8d;
-            margin-top: 5px;
-        }
-
-        .download-btn {
-            background: linear-gradient(135deg, #27ae60 0%, #229954 100%);
-            margin-top: 0;
-        }
-
-        .download-btn:hover {
-            box-shadow: 0 5px 15px rgba(39, 174, 96, 0.4);
-        }
-
-        .error-container {
-            display: none;
-            margin-top: 20px;
-            padding: 20px;
-            background: #f8d7da;
-            border-radius: 10px;
-            border: 1px solid #f5c6cb;
-            color: #721c24;
-        }
-
-        .model-info {
-            background: #fff3cd;
-            border: 1px solid #ffeaa7;
-            border-radius: 8px;
-            padding: 15px;
-            margin-bottom: 20px;
-        }
-
-        .model-info h4 {
-            color: #856404;
-            margin-bottom: 10px;
-        }
-
-        .model-info ul {
-            margin-left: 20px;
-            color: #856404;
-        }
-
-        @media (max-width: 768px) {
-            .container {
-                margin: 10px;
-                border-radius: 10px;
-            }
-
-            .header {
-                padding: 20px;
-            }
-
-            .header h1 {
-                font-size: 2rem;
-            }
-
-            .content {
-                padding: 20px;
-            }
-
-            .optional-uploads {
-                grid-template-columns: 1fr;
-            }
-
-            .results-stats {
-                grid-template-columns: 1fr;
-            }
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1>🚢 Vessel Trajectory Inference</h1>
-            <p>Vessel trajectory prediction using our model logic</p>
-            <p class="subtitle">Upload your preprocessed dataset with segments and velocity features</p>
-        </div>
-
-        <div class="content">
-            <!-- Data Format Information -->
-            <div class="data-format-info">
-                <h3>📋 Required Data Format</h3>
-                <p>Your CSV file should contain the following columns (automatically detects ';' or ',' separator):</p>
-                <div class="required-columns">
-                    <div class="column-item">segment</div>
-                    <div class="column-item">latitude_velocity_km</div>
-                    <div class="column-item">longitude_velocity_km</div>
-                    <div class="column-item">latitude_degrees</div>
-                    <div class="column-item">longitude_degrees</div>
-                    <div class="column-item">time_difference_hours</div>
-                    <div class="column-item">time_scalar (or datetime)</div>
-                </div>
-                <p style="margin-top: 15px; font-style: italic; color: #495057;">
-                    ✅ Your data format is supported! The app will automatically create time_scalar from datetime/time_decimal if needed.
-                </p>
-            </div>
-
-            <!-- Model Information -->
-            <div class="model-info">
-                <h4>🤖 Default Model Configuration</h4>
-                <ul>
-                    <li><strong>Model:</strong> LSTMWithAttentionWithResid (7 layers, 250 hidden units)</li>
-                    <li><strong>Training:</strong> Atlantic Ocean vessel trajectories</li>
-                    <li><strong>Normalization:</strong> Atlantic dataset parameters</li>
-                    <li><strong>Sequence Length:</strong> 12 time steps</li>
-                    <li><strong>Forecast Horizon:</strong> 1 time step</li>
-                </ul>
-            </div>
-
-            <!-- File Upload Section -->
-            <div class="upload-section">
-                <h3>📁 Upload Files</h3>
-                
-                <!-- Main CSV Upload -->
-                <div class="file-upload" onclick="document.getElementById('csv_file').click()">
-                    <div class="upload-icon">📊</div>
-                    <label for="csv_file">
-                        <strong>Select Your Inference Dataset (CSV)</strong><br>
-                        Click here or drag and drop your CSV file
-                    </label>
-                    <input type="file" id="csv_file" accept=".csv" onchange="handleFileSelect(this, 'csv')">
-                    <div id="csv_file_info" class="file-info"></div>
-                </div>
-
-                <!-- Optional Uploads -->
-                <div class="optional-uploads">
-                    <div class="optional-upload">
-                        <h4>🧠 Custom Model (Optional)</h4>
-                        <input type="file" id="model_file" accept=".pth,.pt" onchange="handleFileSelect(this, 'model')">
-                        <small>Default: best_model.pth</small>
-                    </div>
-                    
-                    <div class="optional-upload">
-                        <h4>⚙️ Custom Normalization (Optional)</h4>
-                        <input type="file" id="normalization_file" accept=".json" onchange="handleFileSelect(this, 'norm')">
-                        <small>Default: Atlantic dataset parameters</small>
-                    </div>
-                </div>
-            </div>
-
-            <!-- Submit Button -->
-            <button class="btn" id="submit_btn" onclick="startInference()" disabled>
-                🚀 Start Inference
-            </button>
-
-            <!-- Progress Container -->
-            <div class="progress-container" id="progress_container">
-                <div class="progress-text" id="progress_text">Initializing...</div>
-                <div class="progress-bar">
-                    <div class="progress-fill" id="progress_fill"></div>
-                </div>
-                <div class="progress-details" id="progress_details">Please wait...</div>
-            </div>
-
-            <!-- Results Container -->
-            <div class="results-container" id="results_container">
-                <h3>📈 Inference Results</h3>
-                <div class="results-stats" id="results_stats">
-                    <!-- Stats will be populated dynamically -->
-                </div>
-                <button class="btn download-btn" onclick="downloadResults()">
-                    💾 Download Results CSV
-                </button>
-
-                <!-- Error Distribution Chart -->
-                <div style="margin-top:30px;">
-                    <canvas id="errorChart" height="220"></canvas>
-                </div>
-            </div>
-
-            <!-- Error Container -->
-            <div class="error-container" id="error_container">
-                <h3>❌ Error</h3>
-                <p id="error_message"></p>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        const socket = io();
-        let inferenceInProgress = false;
-
-        // File selection handlers
-        function handleFileSelect(input, type) {
-            const file = input.files[0];
-            if (file) {
-                const infoDiv = document.getElementById(input.id + '_info');
-                if (infoDiv) {
-                    infoDiv.style.display = 'block';
-                    infoDiv.innerHTML = `📁 Selected: ${file.name} (${(file.size / 1024 / 1024).toFixed(2)} MB)`;
-                }
-                
-                // Enable submit button if CSV is selected
-                if (type === 'csv') {
-                    document.getElementById('submit_btn').disabled = false;
-                }
-            }
-        }
-
-        // Start inference
-        function startInference() {
-            if (inferenceInProgress) return;
-
-            const csvFile = document.getElementById('csv_file').files[0];
-            if (!csvFile) {
-                alert('Please select a CSV file first!');
-                return;
-            }
-
-            inferenceInProgress = true;
-            document.getElementById('submit_btn').disabled = true;
-            document.getElementById('progress_container').style.display = 'block';
-            document.getElementById('results_container').style.display = 'none';
-            document.getElementById('error_container').style.display = 'none';
-
-            // Prepare form data
-            const formData = new FormData();
-            formData.append('csv_file', csvFile);
-            
-            const modelFile = document.getElementById('model_file').files[0];
-            if (modelFile) {
-                formData.append('model_file', modelFile);
-            }
-            
-            const normFile = document.getElementById('normalization_file').files[0];
-            if (normFile) {
-                formData.append('normalization_file', normFile);
-            }
-
-            // Upload files and start inference
-            fetch('/upload', {
-                method: 'POST',
-                body: formData
-            })
-            .then(response => response.json())
-            .then(data => {
-                if (!data.success) {
-                    showError(data.error);
-                    resetUI();
-                }
-            })
-            .catch(error => {
-                showError('Upload failed: ' + error.message);
-                resetUI();
-            });
-        }
-
-        // Download results
-        function downloadResults() {
-            window.location.href = '/download_results';
-        }
-
-        // Show error
-        function showError(message) {
-            document.getElementById('error_container').style.display = 'block';
-            document.getElementById('error_message').textContent = message;
-            document.getElementById('progress_container').style.display = 'none';
-        }
-
-        // Reset UI
-        function resetUI() {
-            inferenceInProgress = false;
-            document.getElementById('submit_btn').disabled = !document.getElementById('csv_file').files[0];
-            document.getElementById('progress_container').style.display = 'none';
-        }
-
-        // Show results
-        function showResults(stats, histogram) {
-            const resultsStats = document.getElementById('results_stats');
-            resultsStats.innerHTML = `
-                <div class="stat-item">
-                    <div class="stat-value">${stats.mean_error_km.toFixed(2)} km</div>
-                    <div class="stat-label">Mean Error</div>
-                </div>
-                <div class="stat-item">
-                    <div class="stat-value">${stats.median_error_km.toFixed(2)} km</div>
-                    <div class="stat-label">Median Error</div>
-                </div>
-                <div class="stat-item">
-                    <div class="stat-value">${stats.total_predictions.toLocaleString()}</div>
-                    <div class="stat-label">Total Predictions</div>
-                </div>
-                <div class="stat-item">
-                    <div class="stat-value">${stats.total_segments}</div>
-                    <div class="stat-label">Segments Processed</div>
-                </div>
-                <div class="stat-item">
-                    <div class="stat-value">${stats.min_error_km.toFixed(2)} km</div>
-                    <div class="stat-label">Min Error</div>
-                </div>
-                <div class="stat-item">
-                    <div class="stat-value">${stats.max_error_km.toFixed(2)} km</div>
-                    <div class="stat-label">Max Error</div>
-                </div>
-            `;
-            
-            // Render error distribution histogram if data provided
-            if (histogram && histogram.bins && histogram.counts) {
-                renderErrorChart(histogram);
-            }
-            document.getElementById('results_container').style.display = 'block';
-            document.getElementById('progress_container').style.display = 'none';
-            resetUI();
-        }
-
-        // Chart.js rendering function
-        let errorChartInstance = null;
-        function renderErrorChart(histogram) {
-            const ctx = document.getElementById('errorChart').getContext('2d');
-            // Prepare labels as mid-points of bins
-            const labels = [];
-            for (let i = 0; i < histogram.bins.length - 1; i++) {
-                const mid = (histogram.bins[i] + histogram.bins[i + 1]) / 2;
-                labels.push(mid.toFixed(1));
-            }
-            // Destroy previous chart if it exists (for multiple runs)
-            if (errorChartInstance) {
-                errorChartInstance.destroy();
-            }
-            errorChartInstance = new Chart(ctx, {
-                type: 'bar',
-                data: {
-                    labels: labels,
-                    datasets: [{
-                        label: 'Error (km) distribution',
-                        data: histogram.counts,
-                        backgroundColor: 'rgba(52, 152, 219, 0.5)',
-                        borderColor: 'rgba(41, 128, 185, 1)',
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    scales: {
-                        x: {
-                            title: {
-                                display: true,
-                                text: 'Error (km)'
-                            }
-                        },
-                        y: {
-                            beginAtZero: true,
-                            title: {
-                                display: true,
-                                text: 'Count'
-                            }
-                        }
-                    }
-                }
-            });
-        }
-
-        // Socket event handlers
-        socket.on('progress_update', function(data) {
-            document.getElementById('progress_text').textContent = data.step;
-            document.getElementById('progress_fill').style.width = data.progress + '%';
-            document.getElementById('progress_details').textContent = data.details;
-
-            if (data.step === 'Complete') {
-                // Results will be shown via the inference_complete event
-            } else if (data.step === 'Error') {
-                showError(data.details);
-                resetUI();
-            }
-        });
-
-        socket.on('inference_complete', function(data) {
-            if (data.success) {
-                showResults(data.stats, data.histogram);
-            } else {
-                showError(data.error);
-                resetUI();
-            }
-        });
-
-        // Drag and drop functionality
-        ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
-            document.addEventListener(eventName, preventDefaults, false);
-        });
-
-        function preventDefaults(e) {
-            e.preventDefault();
-            e.stopPropagation();
-        }
-
-        ['dragenter', 'dragover'].forEach(eventName => {
-            document.querySelector('.file-upload').addEventListener(eventName, highlight, false);
-        });
-
-        ['dragleave', 'drop'].forEach(eventName => {
-            document.querySelector('.file-upload').addEventListener(eventName, unhighlight, false);
-        });
-
-        function highlight(e) {
-            e.currentTarget.style.borderColor = '#2980b9';
-            e.currentTarget.style.background = '#e8f4fd';
-        }
-
-        function unhighlight(e) {
-            e.currentTarget.style.borderColor = '#3498db';
-            e.currentTarget.style.background = '#f8f9fa';
-        }
-
-        document.querySelector('.file-upload').addEventListener('drop', handleDrop, false);
-
-        function handleDrop(e) {
-            const dt = e.dataTransfer;
-            const files = dt.files;
-            
-            if (files.length > 0) {
-                document.getElementById('csv_file').files = files;
-                handleFileSelect(document.getElementById('csv_file'), 'csv');
-            }
-        }
-    </script>
-</body>
-</html>