Fix

README.md

@@ -0,0 +1,16 @@
+---
+title: Fault Classification PMU
+emoji: ⚡️
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: "4.44.1"
+app_file: app.py
+pinned: false
+---
+
+# Fault Classification for PMU and PV Systems
+
+This Space hosts the Gradio front end used to retrain and serve fault classification models for transmission lines and grid-connected photovoltaic systems. It loads pre-trained Keras models and feature scalers, accepts bulk CSV uploads for continued training, and exposes interactive inference utilities for high-frequency PMU measurements.
+
+Refer to `app.py` for the interface definition and to `fault_classification_pmu.py` for the training pipeline that supports CNN-LSTM, TCN, and SVM architectures.

app.py

@@ -10,10 +10,15 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
+
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "-1")
+os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "2")
+os.environ.setdefault("TF_ENABLE_ONEDNN_OPTS", "0")
+
 import re
-import socket
 from pathlib import Path
-from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import gradio as gr
 import joblib
@@ -22,29 +27,16 @@ import pandas as pd
 from huggingface_hub import hf_hub_download
 from tensorflow.keras.models import load_model
 
-# Reduce TensorFlow log verbosity
-os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "2")
+from fault_classification_pmu import (
+    DEFAULT_FEATURE_COLUMNS as TRAINING_DEFAULT_FEATURE_COLUMNS,
+    LABEL_GUESS_CANDIDATES as TRAINING_LABEL_GUESSES,
+    train_from_dataframe,
+)
 
 # --------------------------------------------------------------------------------------
 # Configuration
 # --------------------------------------------------------------------------------------
-DEFAULT_FEATURE_COLUMNS: List[str] = [
-    "[325] UPMU_SUB22:FREQ",
-    "[326] UPMU_SUB22:DFDT",
-    "[327] UPMU_SUB22:FLAG",
-    "[328] UPMU_SUB22-L1:MAG",
-    "[329] UPMU_SUB22-L1:ANG",
-    "[330] UPMU_SUB22-L2:MAG",
-    "[331] UPMU_SUB22-L2:ANG",
-    "[332] UPMU_SUB22-L3:MAG",
-    "[333] UPMU_SUB22-L3:ANG",
-    "[334] UPMU_SUB22-C1:MAG",
-    "[335] UPMU_SUB22-C1:ANG",
-    "[336] UPMU_SUB22-C2:MAG",
-    "[337] UPMU_SUB22-C2:ANG",
-    "[338] UPMU_SUB22-C3:MAG",
-    "[339] UPMU_SUB22-C3:ANG",
-]
+DEFAULT_FEATURE_COLUMNS: List[str] = list(TRAINING_DEFAULT_FEATURE_COLUMNS)
 DEFAULT_SEQUENCE_LENGTH = 32
 DEFAULT_STRIDE = 4
 
@@ -70,23 +62,35 @@ def download_from_hub(filename: str) -> Optional[Path]:
         return None
     try:
         print(f"Downloading {filename} from {HUB_REPO} ...")
+        # Add timeout to prevent hanging
         path = hf_hub_download(repo_id=HUB_REPO, filename=filename)
         print("Downloaded", path)
         return Path(path)
     except Exception as exc:  # pragma: no cover - logging convenience
         print("Failed to download", filename, "from", HUB_REPO, ":", exc)
+        print("Continuing without pre-trained model...")
         return None
 
 
 def resolve_artifact(local_name: str, env_var: str, hub_filename: str) -> Optional[Path]:
+    print(f"Resolving artifact: {local_name}, env: {env_var}, hub: {hub_filename}")
     candidates = [Path(local_name)] if local_name else []
     env_value = os.environ.get(env_var)
     if env_value:
         candidates.append(Path(env_value))
+
     for candidate in candidates:
         if candidate and candidate.exists():
+            print(f"Found local artifact: {candidate}")
             return candidate
-    return download_from_hub(hub_filename)
+
+    print(f"No local artifacts found, checking hub...")
+    # Only try to download if we have a hub repo configured
+    if HUB_REPO:
+        return download_from_hub(hub_filename)
+    else:
+        print("No HUB_REPO configured, skipping download")
+        return None
 
 
 def load_metadata(path: Optional[Path]) -> Dict:
@@ -98,11 +102,62 @@ def load_metadata(path: Optional[Path]) -> Dict:
     return {}
 
 
-def try_load_model(path: Optional[Path]):
+def try_load_scaler(path: Optional[Path]):
     if not path:
         return None
     try:
-        model = load_model(path)
+        scaler = joblib.load(path)
+        print("Loaded scaler from", path)
+        return scaler
+    except Exception as exc:
+        print("Failed to load scaler", path, exc)
+        return None
+
+
+# Initialize paths with error handling
+print("Starting application initialization...")
+try:
+    MODEL_PATH = resolve_artifact(LOCAL_MODEL_FILE, ENV_MODEL_PATH, HUB_MODEL_FILENAME)
+    print(f"Model path resolved: {MODEL_PATH}")
+except Exception as e:
+    print(f"Model path resolution failed: {e}")
+    MODEL_PATH = None
+
+try:
+    SCALER_PATH = resolve_artifact(LOCAL_SCALER_FILE, ENV_SCALER_PATH, HUB_SCALER_FILENAME)
+    print(f"Scaler path resolved: {SCALER_PATH}")
+except Exception as e:
+    print(f"Scaler path resolution failed: {e}")
+    SCALER_PATH = None
+
+try:
+    METADATA_PATH = resolve_artifact(LOCAL_METADATA_FILE, ENV_METADATA_PATH, HUB_METADATA_FILENAME)
+    print(f"Metadata path resolved: {METADATA_PATH}")
+except Exception as e:
+    print(f"Metadata path resolution failed: {e}")
+    METADATA_PATH = None
+
+try:
+    METADATA = load_metadata(METADATA_PATH)
+    print(f"Metadata loaded: {len(METADATA)} entries")
+except Exception as e:
+    print(f"Metadata loading failed: {e}")
+    METADATA = {}
+
+# Queuing configuration
+QUEUE_MAX_SIZE = 32
+# Apply a small per-event concurrency limit to avoid relying on the deprecated
+# ``concurrency_count`` parameter when enabling Gradio's request queue.
+EVENT_CONCURRENCY_LIMIT = 2
+
+def try_load_model(path: Optional[Path], model_type: str, model_format: str):
+    if not path:
+        return None
+    try:
+        if model_type == "svm" or model_format == "joblib":
+            model = joblib.load(path)
+        else:
+            model = load_model(path)
         print("Loaded model from", path)
         return model
     except Exception as exc:  # pragma: no cover - runtime diagnostics
@@ -110,34 +165,360 @@ def try_load_model(path: Optional[Path]):
         return None
 
 
-def try_load_scaler(path: Optional[Path]):
-    if not path:
-        return None
+FEATURE_COLUMNS: List[str] = list(DEFAULT_FEATURE_COLUMNS)
+LABEL_CLASSES: List[str] = []
+LABEL_COLUMN: str = "Fault"
+SEQUENCE_LENGTH: int = DEFAULT_SEQUENCE_LENGTH
+DEFAULT_WINDOW_STRIDE: int = DEFAULT_STRIDE
+MODEL_TYPE: str = "cnn_lstm"
+MODEL_FORMAT: str = "keras"
+
+MODEL_FILENAME_BY_TYPE: Dict[str, str] = {
+    "cnn_lstm": LOCAL_MODEL_FILE,
+    "tcn": "pmu_tcn_model.keras",
+    "svm": "pmu_svm_model.joblib",
+}
+
+REQUIRED_PMU_COLUMNS: Tuple[str, ...] = tuple(DEFAULT_FEATURE_COLUMNS)
+TRAINING_UPLOAD_DIR = Path(os.environ.get("PMU_TRAINING_UPLOAD_DIR", "training_uploads"))
+TRAINING_UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _normalise_header(name: str) -> str:
+    return str(name).strip().lower()
+
+
+def guess_label_from_columns(columns: Sequence[str], preferred: Optional[str] = None) -> Optional[str]:
+    if not columns:
+        return preferred
+
+    lookup = {_normalise_header(col): str(col) for col in columns}
+
+    if preferred:
+        preferred_stripped = preferred.strip()
+        for col in columns:
+            if str(col).strip() == preferred_stripped:
+                return str(col)
+        preferred_norm = _normalise_header(preferred)
+        if preferred_norm in lookup:
+            return lookup[preferred_norm]
+
+    for guess in TRAINING_LABEL_GUESSES:
+        guess_norm = _normalise_header(guess)
+        if guess_norm in lookup:
+            return lookup[guess_norm]
+
+    for col in columns:
+        if _normalise_header(col).startswith("fault"):
+            return str(col)
+
+    return str(columns[0])
+
+
+def summarise_training_files(paths: Sequence[str], notes: Sequence[str]) -> str:
+    lines = [Path(path).name for path in paths]
+    lines.extend(notes)
+    return "\n".join(lines) if lines else "No training files selected."
+
+
+def read_training_status(status_file_path: str) -> str:
+    """Read the current training status from file."""
     try:
-        scaler = joblib.load(path)
-        print("Loaded scaler from", path)
-        return scaler
-    except Exception as exc:
-        print("Failed to load scaler", path, exc)
+        if Path(status_file_path).exists():
+            with open(status_file_path, 'r') as f:
+                return f.read().strip()
+    except Exception:
+        pass
+    return "Training status unavailable"
+
+
+def _persist_uploaded_file(file_obj) -> Optional[Path]:
+    if file_obj is None:
         return None
 
+    if isinstance(file_obj, (str, Path)):
+        source = Path(file_obj)
+        original_name = source.name
+    else:
+        source = Path(getattr(file_obj, "name", "") or getattr(file_obj, "path", ""))
+        original_name = getattr(file_obj, "orig_name", source.name) or source.name
+    if not source or not source.exists():
+        return None
+
+    original_name = Path(original_name).name or source.name
+
+    base_path = Path(original_name)
+    destination = TRAINING_UPLOAD_DIR / base_path.name
+    counter = 1
+    while destination.exists():
+        suffix = base_path.suffix or ".csv"
+        destination = TRAINING_UPLOAD_DIR / f"{base_path.stem}_{counter}{suffix}"
+        counter += 1
+
+    shutil.copy2(source, destination)
+    return destination
+
+
+def append_training_files(new_files, existing_paths: Sequence[str], current_label: str):
+    if isinstance(existing_paths, (str, Path)):
+        paths: List[str] = [str(existing_paths)]
+    elif existing_paths is None:
+        paths = []
+    else:
+        paths = list(existing_paths)
+    if new_files:
+        for file in new_files:
+            persisted = _persist_uploaded_file(file)
+            if persisted is None:
+                continue
+            path_str = str(persisted)
+            if path_str not in paths:
+                paths.append(path_str)
+
+    valid_paths: List[str] = []
+    notes: List[str] = []
+    columns_map: Dict[str, str] = {}
+    for path in paths:
+        try:
+            df = load_measurement_csv(path)
+        except Exception as exc:  # pragma: no cover - user file diagnostics
+            notes.append(f"⚠️ Skipped {Path(path).name}: {exc}")
+            try:
+                Path(path).unlink(missing_ok=True)
+            except Exception:
+                pass
+            continue
+        valid_paths.append(path)
+        for col in df.columns:
+            columns_map[_normalise_header(col)] = str(col)
+
+    paths = valid_paths
+    summary = summarise_training_files(paths, notes)
+    column_choices = sorted(columns_map.values())
+    preferred = current_label or LABEL_COLUMN
+    guessed = guess_label_from_columns(column_choices, preferred)
+    dropdown_choices = column_choices if column_choices else [preferred or LABEL_COLUMN]
+    dropdown_value = guessed or preferred or LABEL_COLUMN
 
-MODEL_PATH = resolve_artifact(LOCAL_MODEL_FILE, ENV_MODEL_PATH, HUB_MODEL_FILENAME)
-SCALER_PATH = resolve_artifact(LOCAL_SCALER_FILE, ENV_SCALER_PATH, HUB_SCALER_FILENAME)
-METADATA_PATH = resolve_artifact(LOCAL_METADATA_FILE, ENV_METADATA_PATH, HUB_METADATA_FILENAME)
+    return paths, summary, gr.update(choices=dropdown_choices, value=dropdown_value)
 
-MODEL = try_load_model(MODEL_PATH)
-SCALER = try_load_scaler(SCALER_PATH)
-METADATA = load_metadata(METADATA_PATH)
 
-FEATURE_COLUMNS: List[str] = METADATA.get("feature_columns", DEFAULT_FEATURE_COLUMNS)
-LABEL_CLASSES: List[str] = [str(label) for label in METADATA.get("label_classes", [])]
-LABEL_COLUMN: str = METADATA.get("label_column", "Fault")
-SEQUENCE_LENGTH: int = int(METADATA.get("sequence_length", DEFAULT_SEQUENCE_LENGTH))
-DEFAULT_WINDOW_STRIDE: int = int(METADATA.get("stride", DEFAULT_STRIDE))
+def clear_training_files():
+    default_label = LABEL_COLUMN or "Fault"
+    for cached_file in TRAINING_UPLOAD_DIR.glob("*"):
+        try:
+            if cached_file.is_file():
+                cached_file.unlink(missing_ok=True)
+        except Exception:
+            pass
+    return (
+        [],
+        "No training files selected.",
+        gr.update(choices=[default_label], value=default_label),
+        gr.update(value=None),
+    )
+
+PROJECT_OVERVIEW_MD = """
+## Project Overview
+
+This project focuses on classifying faults in electrical transmission lines and
+grid-connected photovoltaic (PV) systems by combining ensemble learning
+techniques with deep neural architectures.
+
+## Datasets
+
+### Transmission Line Fault Dataset
+- 134,406 samples collected from Phasor Measurement Units (PMUs)
+- 14 monitored channels covering currents, voltages, magnitudes, frequency, and phase angles
+- Labels span symmetrical and asymmetrical faults: NF, L-G, LL, LL-G, LLL, and LLL-G
+- Time span: 0 to 5.7 seconds with high-frequency sampling
+
+### Grid-Connected PV System Fault Dataset
+- 2,163,480 samples from 16 experimental scenarios
+- 14 features including PV array measurements (Ipv, Vpv, Vdc), three-phase currents/voltages, aggregate magnitudes (Iabc, Vabc), and frequency indicators (If, Vf)
+- Captures array, inverter, grid anomaly, feedback sensor, and MPPT controller faults at 9.9989 μs sampling intervals
+
+## Data Format Quick Reference
+
+Each measurement file may be comma or tab separated and typically exposes the
+following ordered columns:
+
+1. `Timestamp`
+2. `[325] UPMU_SUB22:FREQ` – system frequency (Hz)
+3. `[326] UPMU_SUB22:DFDT` – frequency rate-of-change
+4. `[327] UPMU_SUB22:FLAG` – PMU status flag
+5. `[328] UPMU_SUB22-L1:MAG` – phase A voltage magnitude
+6. `[329] UPMU_SUB22-L1:ANG` – phase A voltage angle
+7. `[330] UPMU_SUB22-L2:MAG` – phase B voltage magnitude
+8. `[331] UPMU_SUB22-L2:ANG` – phase B voltage angle
+9. `[332] UPMU_SUB22-L3:MAG` – phase C voltage magnitude
+10. `[333] UPMU_SUB22-L3:ANG` – phase C voltage angle
+11. `[334] UPMU_SUB22-C1:MAG` – phase A current magnitude
+12. `[335] UPMU_SUB22-C1:ANG` – phase A current angle
+13. `[336] UPMU_SUB22-C2:MAG` – phase B current magnitude
+14. `[337] UPMU_SUB22-C2:ANG` – phase B current angle
+15. `[338] UPMU_SUB22-C3:MAG` – phase C current magnitude
+16. `[339] UPMU_SUB22-C3:ANG` – phase C current angle
+
+Upload as many hourly CSV exports as needed—the training tab concatenates them
+before building sliding windows.
+
+## Models Developed
+
+1. **Support Vector Machine (SVM)** – provides the classical machine learning baseline with balanced accuracy across both datasets (85% PMU / 83% PV).
+2. **CNN-LSTM** – couples convolutional feature extraction with temporal memory, achieving 92% PMU / 89% PV accuracy.
+3. **Temporal Convolutional Network (TCN)** – leverages dilated convolutions for long-range context and delivers the best trade-off between accuracy and training time (94% PMU / 91% PV).
+
+## Results Summary
+
+- **Transmission Line Fault Classification**: SVM 85%, CNN-LSTM 92%, TCN 94%
+- **PV System Fault Classification**: SVM 83%, CNN-LSTM 89%, TCN 91%
+
+Use the **Inference** tab to score new PMU/PV windows and the **Training** tab to
+fine-tune or retrain any of the supported models directly within Hugging Face
+Spaces. The logs panel will surface TensorBoard archives whenever deep-learning
+models are trained.
+"""
+
 
-if MODEL is not None and not LABEL_CLASSES:
-    LABEL_CLASSES = [str(i) for i in range(MODEL.output_shape[-1])]
+def load_measurement_csv(path: str) -> pd.DataFrame:
+    """Read a PMU/PV measurement file with flexible separators and column mapping."""
+
+    try:
+        df = pd.read_csv(path, sep=None, engine="python", encoding="utf-8-sig")
+    except Exception:
+        df = None
+        for separator in ("\t", ",", ";"):
+            try:
+                df = pd.read_csv(path, sep=separator, engine="python", encoding="utf-8-sig")
+                break
+            except Exception:
+                df = None
+        if df is None:
+            raise
+
+    # Clean column names
+    df.columns = [str(col).strip() for col in df.columns]
+
+    print(f"Loaded CSV with {len(df)} rows and {len(df.columns)} columns")
+    print(f"Columns: {list(df.columns)}")
+    print(f"Data shape: {df.shape}")
+
+    # Check if we have enough data for training
+    if len(df) < 100:
+        print(f"Warning: Only {len(df)} rows of data. Recommend at least 1000 rows for effective training.")
+
+    # Check for label column
+    has_label = any(col.lower() in ['fault', 'label', 'class', 'target'] for col in df.columns)
+    if not has_label:
+        print("Warning: No label column found. Adding dummy 'Fault' column with value 'Normal' for all samples.")
+        df['Fault'] = 'Normal'  # Add dummy label for training
+
+    # Create column mapping - map similar column names to expected format
+    column_mapping = {}
+    expected_cols = list(REQUIRED_PMU_COLUMNS)
+
+    # If we have at least the right number of numeric columns after Timestamp, use positional mapping
+    if "Timestamp" in df.columns:
+        numeric_cols = [col for col in df.columns if col != "Timestamp"]
+        if len(numeric_cols) >= len(expected_cols):
+            # Map by position (after Timestamp)
+            for i, expected_col in enumerate(expected_cols):
+                if i < len(numeric_cols):
+                    column_mapping[numeric_cols[i]] = expected_col
+
+            # Rename columns to match expected format
+            df = df.rename(columns=column_mapping)
+
+    # Check if we have the required columns after mapping
+    missing = [col for col in REQUIRED_PMU_COLUMNS if col not in df.columns]
+    if missing:
+        # If still missing, try a more flexible approach
+        available_numeric = df.select_dtypes(include=[np.number]).columns.tolist()
+        if len(available_numeric) >= len(expected_cols):
+            # Use the first N numeric columns
+            for i, expected_col in enumerate(expected_cols):
+                if i < len(available_numeric):
+                    if available_numeric[i] not in df.columns:
+                        continue
+                    df = df.rename(columns={available_numeric[i]: expected_col})
+
+            # Recheck missing columns
+            missing = [col for col in REQUIRED_PMU_COLUMNS if col not in df.columns]
+
+    if missing:
+        missing_str = ", ".join(missing)
+        available_str = ", ".join(df.columns.tolist())
+        raise ValueError(
+            f"Missing required PMU feature columns: {missing_str}. "
+            f"Available columns: {available_str}. "
+            "Please ensure your CSV has the correct format with Timestamp followed by PMU measurements."
+        )
+
+    return df
+
+
+def apply_metadata(metadata: Dict[str, Any]) -> None:
+    global FEATURE_COLUMNS, LABEL_CLASSES, LABEL_COLUMN, SEQUENCE_LENGTH, DEFAULT_WINDOW_STRIDE, MODEL_TYPE, MODEL_FORMAT
+    FEATURE_COLUMNS = [str(col) for col in metadata.get("feature_columns", DEFAULT_FEATURE_COLUMNS)]
+    LABEL_CLASSES = [str(label) for label in metadata.get("label_classes", [])]
+    LABEL_COLUMN = str(metadata.get("label_column", "Fault"))
+    SEQUENCE_LENGTH = int(metadata.get("sequence_length", DEFAULT_SEQUENCE_LENGTH))
+    DEFAULT_WINDOW_STRIDE = int(metadata.get("stride", DEFAULT_STRIDE))
+    MODEL_TYPE = str(metadata.get("model_type", "cnn_lstm")).lower()
+    MODEL_FORMAT = str(
+        metadata.get("model_format", "joblib" if MODEL_TYPE == "svm" else "keras")
+    ).lower()
+
+
+apply_metadata(METADATA)
+
+def sync_label_classes_from_model(model: Optional[object]) -> None:
+    global LABEL_CLASSES
+    if model is None:
+        return
+    if hasattr(model, "classes_"):
+        LABEL_CLASSES = [str(label) for label in getattr(model, "classes_")]
+    elif not LABEL_CLASSES and hasattr(model, "output_shape"):
+        LABEL_CLASSES = [str(i) for i in range(int(model.output_shape[-1]))]
+
+
+# Load model and scaler with error handling
+print("Loading model and scaler...")
+try:
+    MODEL = try_load_model(MODEL_PATH, MODEL_TYPE, MODEL_FORMAT)
+    print(f"Model loaded: {MODEL is not None}")
+except Exception as e:
+    print(f"Model loading failed: {e}")
+    MODEL = None
+
+try:
+    SCALER = try_load_scaler(SCALER_PATH)
+    print(f"Scaler loaded: {SCALER is not None}")
+except Exception as e:
+    print(f"Scaler loading failed: {e}")
+    SCALER = None
+
+try:
+    sync_label_classes_from_model(MODEL)
+    print("Label classes synchronized")
+except Exception as e:
+    print(f"Label sync failed: {e}")
+
+print("Application initialization completed.")
+print(f"Ready to start Gradio interface. Model available: {MODEL is not None}, Scaler available: {SCALER is not None}")
+
+
+def refresh_artifacts(model_path: Path, scaler_path: Path, metadata_path: Path) -> None:
+    global MODEL_PATH, SCALER_PATH, METADATA_PATH, MODEL, SCALER, METADATA
+    MODEL_PATH = model_path
+    SCALER_PATH = scaler_path
+    METADATA_PATH = metadata_path
+    METADATA = load_metadata(metadata_path)
+    apply_metadata(METADATA)
+    MODEL = try_load_model(model_path, MODEL_TYPE, MODEL_FORMAT)
+    SCALER = try_load_scaler(scaler_path)
+    sync_label_classes_from_model(MODEL)
 
 # --------------------------------------------------------------------------------------
 # Pre-processing helpers
@@ -146,8 +527,11 @@ if MODEL is not None and not LABEL_CLASSES:
 def ensure_ready():
     if MODEL is None or SCALER is None:
         raise RuntimeError(
-            "模型或特征缩放器未加载。请将 pmu_cnn_lstm_model.keras 和 pmu_feature_scaler.pkl "
-            "上传到 Space，或设置相关的 Hugging Face Hub 配置。"
+            "The model and feature scaler are not available. Upload the trained model "
+            "(for example `pmu_cnn_lstm_model.keras`, `pmu_tcn_model.keras`, or `pmu_svm_model.joblib`), "
+            "the feature scaler (`pmu_feature_scaler.pkl`), and the metadata JSON (`pmu_metadata.json`) to the Space root "
+            "or configure the Hugging Face Hub environment variables so the artifacts can be downloaded "
+            "automatically."
         )
 
 
@@ -155,7 +539,7 @@ def parse_text_features(text: str) -> np.ndarray:
     cleaned = re.sub(r"[;\n\t]+", ",", text.strip())
     arr = np.fromstring(cleaned, sep=",")
     if arr.size == 0:
-        raise ValueError("未解析到任何特征值，请输入以逗号分隔的数字。")
+        raise ValueError("No feature values were parsed. Please enter comma-separated numbers.")
     return arr.astype(np.float32)
 
 
@@ -171,7 +555,8 @@ def apply_scaler(sequences: np.ndarray) -> np.ndarray:
 def make_sliding_windows(data: np.ndarray, sequence_length: int, stride: int) -> np.ndarray:
     if data.shape[0] < sequence_length:
         raise ValueError(
-            f"数据行数 ({data.shape[0]}) 小于序列长度 ({sequence_length})，无法创建窗口。"
+            f"The dataset contains {data.shape[0]} rows which is less than the requested sequence "
+            f"length {sequence_length}. Provide more samples or reduce the sequence length."
         )
     windows = [data[start : start + sequence_length] for start in range(0, data.shape[0] - sequence_length + 1, stride)]
     return np.stack(windows)
@@ -204,7 +589,8 @@ def dataframe_to_sequences(
     if sequence_length == 1 and array.shape[1] == n_features:
         return array.reshape(array.shape[0], 1, n_features)
     raise ValueError(
-        "CSV 列与预期特征不匹配。请包含完整的 PMU 特征列，或提供整形后的窗口数据。"
+        "CSV columns do not match the expected feature layout. Include the full PMU feature set "
+        "or provide pre-shaped sliding window data."
     )
 
 
@@ -248,10 +634,18 @@ def probabilities_to_json(probabilities: np.ndarray) -> List[Dict[str, object]]:
 def predict_sequences(sequences: np.ndarray) -> Tuple[str, pd.DataFrame, List[Dict[str, object]]]:
     ensure_ready()
     sequences = apply_scaler(sequences.astype(np.float32))
-    probs = MODEL.predict(sequences, verbose=0)
+    if MODEL_TYPE == "svm":
+        flattened = sequences.reshape(sequences.shape[0], -1)
+        if hasattr(MODEL, "predict_proba"):
+            probs = MODEL.predict_proba(flattened)
+        else:
+            raise RuntimeError("Loaded SVM model does not expose predict_proba. Retrain with probability=True.")
+    else:
+        probs = MODEL.predict(sequences, verbose=0)
     table = format_predictions(probs)
     json_probs = probabilities_to_json(probs)
-    status = f"共生成 {len(sequences)} 个窗口，模型输出维度 {probs.shape[1]}."
+    architecture = MODEL_TYPE.replace("_", "-").upper()
+    status = f"Generated {len(sequences)} windows. {architecture} model output dimension: {probs.shape[1]}."
     return status, table, json_probs
 
 
@@ -260,21 +654,23 @@ def predict_from_text(text: str, sequence_length: int) -> Tuple[str, pd.DataFram
     n_features = len(FEATURE_COLUMNS)
     if arr.size % n_features != 0:
         raise ValueError(
-            f"输入特征数量 {arr.size} 不是特征维度 {n_features} 的整数倍。请按照 {n_features} 个特征为一组输入。"
+            f"The number of values ({arr.size}) is not a multiple of the feature dimension "
+            f"({n_features}). Provide values in groups of {n_features}."
         )
     timesteps = arr.size // n_features
     if timesteps != sequence_length:
         raise ValueError(
-            f"检测到 {timesteps} 个时间步，与当前设置的序列长度 {sequence_length} 不一致。"
+            f"Detected {timesteps} timesteps which does not match the configured sequence length "
+            f"({sequence_length})."
         )
     sequences = arr.reshape(1, sequence_length, n_features)
     status, table, probs = predict_sequences(sequences)
-    status = f"单窗口预测完成。{status}"
+    status = f"Single window prediction complete. {status}"
     return status, table, probs
 
 
 def predict_from_csv(file_obj, sequence_length: int, stride: int) -> Tuple[str, pd.DataFrame, List[Dict[str, object]]]:
-    df = pd.read_csv(file_obj.name)
+    df = load_measurement_csv(file_obj.name)
     sequences = dataframe_to_sequences(
         df,
         sequence_length=sequence_length,
@@ -282,82 +678,497 @@ def predict_from_csv(file_obj, sequence_length: int, stride: int) -> Tuple[str,
         feature_columns=FEATURE_COLUMNS,
     )
     status, table, probs = predict_sequences(sequences)
-    status = f"CSV 处理完成，生成 {len(sequences)} 个窗口。{status}"
+    status = f"CSV processed successfully. Generated {len(sequences)} windows. {status}"
     return status, table, probs
 
 
+# --------------------------------------------------------------------------------------
+# Training helpers
+# --------------------------------------------------------------------------------------
+
+
+def classification_report_to_dataframe(report: Dict[str, Any]) -> pd.DataFrame:
+    rows: List[Dict[str, Any]] = []
+    for label, metrics in report.items():
+        if isinstance(metrics, dict):
+            row = {"label": label}
+            for key, value in metrics.items():
+                if key == "support":
+                    row[key] = int(value)
+                else:
+                    row[key] = round(float(value), 4)
+            rows.append(row)
+        else:
+            rows.append({"label": label, "accuracy": round(float(metrics), 4)})
+    return pd.DataFrame(rows)
+
+
+def confusion_matrix_to_dataframe(confusion: Sequence[Sequence[float]], labels: Sequence[str]) -> pd.DataFrame:
+    if not confusion:
+        return pd.DataFrame()
+    df = pd.DataFrame(confusion, index=list(labels), columns=list(labels))
+    df.index.name = "True Label"
+    df.columns.name = "Predicted Label"
+    return df
+
+
 # --------------------------------------------------------------------------------------
 # Gradio interface
 # --------------------------------------------------------------------------------------
 
 def build_interface() -> gr.Blocks:
-    with gr.Blocks(title="Fault Classification - PMU Data") as demo:
-        gr.Markdown("# Fault Classification (PMU 数据)")
+    theme = gr.themes.Soft(primary_hue="sky", secondary_hue="blue", neutral_hue="gray").set(
+        body_background_fill="#1f1f1f",
+        body_text_color="#f5f5f5",
+        block_background_fill="#262626",
+        block_border_color="#333333",
+        button_primary_background_fill="#5ac8fa",
+        button_primary_background_fill_hover="#48b5eb",
+        button_primary_border_color="#38bdf8",
+        button_primary_text_color="#0f172a",
+        button_secondary_background_fill="#3f3f46",
+        button_secondary_text_color="#f5f5f5",
+    )
+    with gr.Blocks(title="Fault Classification - PMU Data", theme=theme) as demo:
+        gr.Markdown("# Fault Classification for PMU & PV Data")
+        gr.Markdown(
+            "🖥️ TensorFlow is locked to CPU execution so the Space can run without CUDA drivers."
+        )
         if MODEL is None or SCALER is None:
             gr.Markdown(
-                "⚠️ **模型或缩放器未准备好。** 上传 `pmu_cnn_lstm_model.keras`、"
-                "`pmu_feature_scaler.pkl` 与 `pmu_metadata.json` 至 Space 根目录，或配置环境变量以从 Hugging Face Hub 自动下载。"
+                "⚠️ **Artifacts Missing** — Upload `pmu_cnn_lstm_model.keras`, "
+                "`pmu_feature_scaler.pkl`, and `pmu_metadata.json` to enable inference, "
+                "or configure the Hugging Face Hub environment variables so they can be downloaded."
             )
         else:
+            class_count = len(LABEL_CLASSES) if LABEL_CLASSES else "unknown"
             gr.Markdown(
-                "模型、特征缩放器与元数据均已加载。可以上传原始 PMU CSV 数据，或粘贴单个时间窗口的特征向量进行推理。"
+                f"Loaded a **{MODEL_TYPE.upper()}** model ({MODEL_FORMAT.upper()}) with "
+                f"{len(FEATURE_COLUMNS)} features, sequence length **{SEQUENCE_LENGTH}**, and "
+                f"{class_count} target classes. Use the tabs below to run inference or fine-tune "
+                "the model with your own CSV files."
             )
 
-        with gr.Accordion("特征说明", open=False):
+        with gr.Accordion("Feature Reference", open=False):
             gr.Markdown(
-                f"输入窗口按以下特征顺序排列 (每个时间步共 {len(FEATURE_COLUMNS)} 个特征):\n"
+                f"Each time window expects **{len(FEATURE_COLUMNS)} features** ordered as follows:\n"
                 + "\n".join(f"- {name}" for name in FEATURE_COLUMNS)
             )
             gr.Markdown(
-                f"训练时使用的窗口长度默认为 **{SEQUENCE_LENGTH}**，滑动步长默认为 **{DEFAULT_WINDOW_STRIDE}**。"
-            )
-
-        with gr.Row():
-            file_in = gr.File(label="上传 PMU CSV", file_types=[".csv"])
-            text_in = gr.Textbox(
-                lines=4,
-                label="或粘贴单个窗口的逗号分隔特征",
-                placeholder="49.97772,1.215825E-38,...",
-            )
-
-        with gr.Row():
-            sequence_length_input = gr.Slider(
-                minimum=1,
-                maximum=max(1, SEQUENCE_LENGTH * 2),
-                step=1,
-                value=SEQUENCE_LENGTH,
-                label="序列长度 (timesteps)",
+                f"Default training parameters: **sequence length = {SEQUENCE_LENGTH}**, "
+                f"**stride = {DEFAULT_WINDOW_STRIDE}**. Adjust them in the tabs as needed."
             )
-            stride_input = gr.Slider(
-                minimum=1,
-                maximum=max(1, SEQUENCE_LENGTH),
-                step=1,
-                value=max(1, DEFAULT_WINDOW_STRIDE),
-                label="CSV 滑动窗口步长",
-            )
-
-        predict_btn = gr.Button("执行预测", variant="primary")
-        status_out = gr.Textbox(label="状态", interactive=False)
-        table_out = gr.Dataframe(headers=["window", "predicted_label", "confidence", "top3"], label="预测结果", interactive=False)
-        probs_out = gr.JSON(label="各窗口概率分布")
 
-        def _run_prediction(file_obj, text, sequence_length, stride):
-            sequence_length = int(sequence_length)
-            stride = int(stride)
-            try:
-                if file_obj is not None:
-                    return predict_from_csv(file_obj, sequence_length, stride)
-                if text and text.strip():
-                    return predict_from_text(text, sequence_length)
-                return "请上传 CSV 或输入文本特征。", pd.DataFrame(), []
-            except Exception as exc:
-                return f"预测失败: {exc}", pd.DataFrame(), []
-
-        predict_btn.click(
-            _run_prediction,
-            inputs=[file_in, text_in, sequence_length_input, stride_input],
-            outputs=[status_out, table_out, probs_out],
-        )
+        with gr.Tabs():
+            with gr.Tab("Overview"):
+                gr.Markdown(PROJECT_OVERVIEW_MD)
+            with gr.Tab("Inference"):
+                gr.Markdown("## Run Inference")
+                with gr.Row():
+                    file_in = gr.File(label="Upload PMU CSV", file_types=[".csv"])
+                    text_in = gr.Textbox(
+                        lines=4,
+                        label="Or paste a single window (comma separated)",
+                        placeholder="49.97772,1.215825E-38,...",
+                    )
+
+                with gr.Row():
+                    sequence_length_input = gr.Slider(
+                        minimum=1,
+                        maximum=max(1, SEQUENCE_LENGTH * 2),
+                        step=1,
+                        value=SEQUENCE_LENGTH,
+                        label="Sequence length (timesteps)",
+                    )
+                    stride_input = gr.Slider(
+                        minimum=1,
+                        maximum=max(1, SEQUENCE_LENGTH),
+                        step=1,
+                        value=max(1, DEFAULT_WINDOW_STRIDE),
+                        label="CSV window stride",
+                    )
+
+                predict_btn = gr.Button("🚀 Run Inference", variant="primary")
+                status_out = gr.Textbox(label="Status", interactive=False)
+                table_out = gr.Dataframe(
+                    headers=["window", "predicted_label", "confidence", "top3"],
+                    label="Predictions",
+                    interactive=False,
+                )
+                probs_out = gr.JSON(label="Per-window probabilities")
+
+                def _run_prediction(file_obj, text, sequence_length, stride):
+                    sequence_length = int(sequence_length)
+                    stride = int(stride)
+                    try:
+                        if file_obj is not None:
+                            return predict_from_csv(file_obj, sequence_length, stride)
+                        if text and text.strip():
+                            return predict_from_text(text, sequence_length)
+                        return "Please upload a CSV file or provide feature values.", pd.DataFrame(), []
+                    except Exception as exc:
+                        return f"Prediction failed: {exc}", pd.DataFrame(), []
+
+                predict_btn.click(
+                    _run_prediction,
+                    inputs=[file_in, text_in, sequence_length_input, stride_input],
+                    outputs=[status_out, table_out, probs_out],
+                    concurrency_limit=EVENT_CONCURRENCY_LIMIT,
+                )
+
+            with gr.Tab("Training"):
+                gr.Markdown("## Train or Fine-tune the Model")
+                gr.Markdown(
+                    "Upload one or more PMU CSV files to create a combined training dataset. "
+                    "The files will be concatenated in upload order before generating sliding windows."
+                )
+
+                training_files_state = gr.State([])
+                with gr.Row():
+                    training_file_drop = gr.Files(
+                        label="Drag and drop PMU training CSVs",
+                        file_types=[".csv"],
+                        file_count="multiple",
+                        type="filepath",
+                    )
+                    with gr.Column(scale=1, min_width=180):
+                        training_upload = gr.UploadButton(
+                            "📂 Add training CSVs",
+                            file_types=[".csv"],
+                            file_count="multiple",
+                            type="filepath",
+                            variant="primary",
+                        )
+                        clear_training = gr.Button("Clear list", variant="secondary")
+
+                training_files_summary = gr.Textbox(
+                    label="Selected training CSVs",
+                    value="No training files selected.",
+                    lines=4,
+                    interactive=False,
+                )
+
+                with gr.Row():
+                    label_input = gr.Dropdown(
+                        value=LABEL_COLUMN,
+                        choices=[LABEL_COLUMN],
+                        allow_custom_value=True,
+                        label="Label column name",
+                    )
+                    model_selector = gr.Radio(
+                        choices=["CNN-LSTM", "TCN", "SVM"],
+                        value=(
+                            "TCN"
+                            if MODEL_TYPE == "tcn"
+                            else ("SVM" if MODEL_TYPE == "svm" else "CNN-LSTM")
+                        ),
+                        label="Model architecture",
+                    )
+                    sequence_length_train = gr.Slider(
+                        minimum=4,
+                        maximum=max(32, SEQUENCE_LENGTH * 2),
+                        step=1,
+                        value=SEQUENCE_LENGTH,
+                        label="Sequence length",
+                    )
+                    stride_train = gr.Slider(
+                        minimum=1,
+                        maximum=max(32, SEQUENCE_LENGTH * 2),
+                        step=1,
+                        value=max(1, DEFAULT_WINDOW_STRIDE),
+                        label="Stride",
+                    )
+
+                model_default = (
+                    str(MODEL_PATH)
+                    if MODEL_PATH
+                    else MODEL_FILENAME_BY_TYPE.get(MODEL_TYPE, LOCAL_MODEL_FILE)
+                )
+
+                with gr.Row():
+                    validation_train = gr.Slider(
+                        minimum=0.05,
+                        maximum=0.4,
+                        step=0.05,
+                        value=0.2,
+                        label="Validation split",
+                    )
+                    batch_train = gr.Slider(
+                        minimum=32,
+                        maximum=512,
+                        step=32,
+                        value=128,
+                        label="Batch size",
+                    )
+                    epochs_train = gr.Slider(
+                        minimum=5,
+                        maximum=100,
+                        step=5,
+                        value=50,
+                        label="Epochs",
+                    )
+
+                with gr.Row():
+                    model_name = gr.Textbox(value=model_default, label="Model output filename")
+                    scaler_name = gr.Textbox(
+                        value=str(SCALER_PATH or LOCAL_SCALER_FILE),
+                        label="Scaler output filename",
+                    )
+                    metadata_name = gr.Textbox(
+                        value=str(METADATA_PATH or LOCAL_METADATA_FILE),
+                        label="Metadata output filename",
+                    )
+
+                tensorboard_toggle = gr.Checkbox(
+                    value=True,
+                    label="Enable TensorBoard logging (creates downloadable archive)",
+                )
+
+                def _suggest_model_filename(choice: str, current_value: str):
+                    choice_key = (choice or "cnn_lstm").lower().replace("-", "_")
+                    suggested = MODEL_FILENAME_BY_TYPE.get(choice_key, LOCAL_MODEL_FILE)
+                    known_defaults = {Path(name).name for name in MODEL_FILENAME_BY_TYPE.values()}
+                    current_name = Path(current_value).name if current_value else ""
+                    if current_name and current_name not in known_defaults:
+                        return gr.update()
+                    return gr.update(value=suggested)
+
+                model_selector.change(
+                    _suggest_model_filename,
+                    inputs=[model_selector, model_name],
+                    outputs=model_name,
+                )
+
+                with gr.Row():
+                    train_button = gr.Button("🛠️ Start Training", variant="primary")
+                    progress_button = gr.Button("📊 Check Progress", variant="secondary")
+
+                # Training status display
+                training_status = gr.Textbox(label="Training Status", interactive=False)
+                report_output = gr.Dataframe(label="Classification report", interactive=False)
+                history_output = gr.JSON(label="Training history")
+                confusion_output = gr.Dataframe(label="Confusion matrix", interactive=False)
+                tensorboard_file = gr.File(
+                    label="TensorBoard logs (.zip)",
+                    interactive=False,
+                )
+
+                # Message area at the bottom for progress updates
+                with gr.Accordion("📋 Progress Messages", open=True):
+                    progress_messages = gr.Textbox(
+                        label="Training Messages",
+                        lines=8,
+                        max_lines=20,
+                        interactive=False,
+                        autoscroll=True,
+                        placeholder="Click 'Check Progress' to see training updates..."
+                    )
+                    with gr.Row():
+                        gr.Button("🗑️ Clear Messages", variant="secondary").click(
+                            lambda: "",
+                            outputs=[progress_messages]
+                        )
+
+                def _run_training(
+                    file_paths,
+                    label_column,
+                    model_choice,
+                    sequence_length,
+                    stride,
+                    validation_split,
+                    batch_size,
+                    epochs,
+                    model_filename,
+                    scaler_filename,
+                    metadata_filename,
+                    enable_tensorboard,
+                ):
+                    try:
+                        # Create status file path for progress tracking
+                        status_file = Path(model_filename).parent / "training_status.txt"
+
+                        # Initialize status
+                        with open(status_file, 'w') as f:
+                            f.write("Starting training setup...")
+
+                        if not file_paths:
+                            raise ValueError("Add at least one training CSV via the uploader before starting.")
+
+                        with open(status_file, 'w') as f:
+                            f.write("Loading and validating CSV files...")
+
+                        available_paths = [path for path in file_paths if Path(path).exists()]
+                        missing_paths = [Path(path).name for path in file_paths if not Path(path).exists()]
+                        if not available_paths:
+                            raise ValueError("None of the referenced CSV files are available. Please upload them again.")
+
+                        dfs = [load_measurement_csv(path) for path in available_paths]
+                        combined = pd.concat(dfs, ignore_index=True)
+
+                        # Validate data size and provide recommendations
+                        total_samples = len(combined)
+                        if total_samples < 100:
+                            print(f"Warning: Only {total_samples} samples. Recommend at least 1000 for good results.")
+                            print("Automatically switching to SVM for small dataset compatibility.")
+                            if model_choice in ["cnn_lstm", "tcn"]:
+                                model_choice = "svm"
+                                print(f"Model type changed to SVM for better small dataset performance.")
+                        if total_samples < 10:
+                            raise ValueError(f"Insufficient data: {total_samples} samples. Need at least 10 samples for training.")
+
+                        label_column = (label_column or LABEL_COLUMN).strip()
+                        if not label_column:
+                            raise ValueError("Label column name cannot be empty.")
+
+                        model_choice = (model_choice or "CNN-LSTM").lower().replace("-", "_")
+                        if model_choice not in {"cnn_lstm", "tcn", "svm"}:
+                            raise ValueError("Select CNN-LSTM, TCN, or SVM for the model architecture.")
+
+                        with open(status_file, 'w') as f:
+                            f.write(f"Starting {model_choice.upper()} training with {len(combined)} samples...")
+
+                        # Start training
+                        result = train_from_dataframe(
+                            combined,
+                            label_column=label_column,
+                            feature_columns=None,
+                            sequence_length=int(sequence_length),
+                            stride=int(stride),
+                            validation_split=float(validation_split),
+                            batch_size=int(batch_size),
+                            epochs=int(epochs),
+                            model_type=model_choice,
+                            model_path=Path(model_filename),
+                            scaler_path=Path(scaler_filename),
+                            metadata_path=Path(metadata_filename),
+                            enable_tensorboard=bool(enable_tensorboard),
+                        )
+
+                        refresh_artifacts(
+                            Path(result["model_path"]),
+                            Path(result["scaler_path"]),
+                            Path(result["metadata_path"]),
+                        )
+
+                        report_df = classification_report_to_dataframe(result["classification_report"])
+                        confusion_df = confusion_matrix_to_dataframe(result["confusion_matrix"], result["class_names"])
+                        tensorboard_dir = result.get("tensorboard_log_dir")
+                        tensorboard_zip = result.get("tensorboard_zip_path")
+
+                        architecture = result["model_type"].replace("_", "-").upper()
+                        status = (
+                            f"Training complete using a {architecture} architecture. "
+                            f"{result['num_sequences']} windows derived from "
+                            f"{result['num_samples']} rows across {len(available_paths)} file(s)."
+                            f" Artifacts saved to:"
+                            f"\n• Model: {result['model_path']}\n"
+                            f"• Scaler: {result['scaler_path']}\n"
+                            f"• Metadata: {result['metadata_path']}"
+                        )
+
+                        status += f"\nLabel column used: {result.get('label_column', label_column)}"
+
+                        if tensorboard_dir:
+                            status += (
+                                f"\nTensorBoard logs directory: {tensorboard_dir}"
+                                f"\nRun `tensorboard --logdir \"{tensorboard_dir}\"` to inspect the training curves."
+                                "\nDownload the archive below to explore the run offline."
+                            )
+
+                        if missing_paths:
+                            skipped = ", ".join(missing_paths)
+                            status = f"⚠️ Skipped missing files: {skipped}\n" + status
+
+                        return (
+                            status,
+                            report_df,
+                            result["history"],
+                            confusion_df,
+                            tensorboard_zip,
+                            gr.update(value=result.get("label_column", label_column)),
+                        )
+                    except Exception as exc:
+                        return (
+                            f"Training failed: {exc}",
+                            pd.DataFrame(),
+                            {},
+                            pd.DataFrame(),
+                            None,
+                            gr.update(),
+                        )
+
+                def _check_progress(model_filename, current_messages):
+                    """Check training progress by reading status file and accumulate messages."""
+                    status_file = Path(model_filename).parent / "training_status.txt"
+                    status_message = read_training_status(str(status_file))
+
+                    # Add timestamp to the message
+                    from datetime import datetime
+                    timestamp = datetime.now().strftime("%H:%M:%S")
+                    new_message = f"[{timestamp}] {status_message}"
+
+                    # Accumulate messages, keeping last 50 lines to prevent overflow
+                    if current_messages:
+                        lines = current_messages.split('\n')
+                        lines.append(new_message)
+                        # Keep only last 50 lines
+                        if len(lines) > 50:
+                            lines = lines[-50:]
+                        accumulated_messages = '\n'.join(lines)
+                    else:
+                        accumulated_messages = new_message
+
+                    return accumulated_messages
+
+                train_button.click(
+                    _run_training,
+                    inputs=[
+                        training_files_state,
+                        label_input,
+                        model_selector,
+                        sequence_length_train,
+                        stride_train,
+                        validation_train,
+                        batch_train,
+                        epochs_train,
+                        model_name,
+                        scaler_name,
+                        metadata_name,
+                        tensorboard_toggle,
+                    ],
+                    outputs=[
+                        training_status,
+                        report_output,
+                        history_output,
+                        confusion_output,
+                        tensorboard_file,
+                        label_input,
+                    ],
+                    concurrency_limit=EVENT_CONCURRENCY_LIMIT,
+                )
+
+                progress_button.click(
+                    _check_progress,
+                    inputs=[model_name, progress_messages],
+                    outputs=[progress_messages],
+                )
+
+                training_upload.upload(
+                    append_training_files,
+                    inputs=[training_upload, training_files_state, label_input],
+                    outputs=[training_files_state, training_files_summary, label_input],
+                    concurrency_limit=EVENT_CONCURRENCY_LIMIT,
+                )
+                training_file_drop.upload(
+                    append_training_files,
+                    inputs=[training_file_drop, training_files_state, label_input],
+                    outputs=[training_files_state, training_files_summary, label_input],
+                    concurrency_limit=EVENT_CONCURRENCY_LIMIT,
+                )
+                clear_training.click(
+                    clear_training_files,
+                    outputs=[training_files_state, training_files_summary, label_input, training_file_drop],
+                )
 
     return demo
 
@@ -366,33 +1177,58 @@ def build_interface() -> gr.Blocks:
 # Launch helpers
 # --------------------------------------------------------------------------------------
 
-def find_free_port() -> int:
-    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(("", 0))
-        return s.getsockname()[1]
-
-
-def choose_port() -> Optional[int]:
-    for env_var in ("GRADIO_SERVER_PORT", "PORT"):
+def resolve_server_port() -> int:
+    for env_var in ("PORT", "GRADIO_SERVER_PORT"):
         value = os.environ.get(env_var)
         if value:
             try:
                 return int(value)
             except ValueError:
-                pass
-    return find_free_port()
+                print(f"Ignoring invalid port value from {env_var}: {value}")
+    return 7860
 
 
 def main():
-    demo = build_interface()
+    print("Building Gradio interface...")
+    try:
+        demo = build_interface()
+        print("Interface built successfully")
+    except Exception as e:
+        print(f"Failed to build interface: {e}")
+        import traceback
+        traceback.print_exc()
+        return
+
+    print("Setting up queue...")
     try:
-        port = choose_port()
+        demo.queue(max_size=QUEUE_MAX_SIZE)
+        print("Queue configured")
+    except Exception as e:
+        print(f"Failed to configure queue: {e}")
+
+    try:
+        port = resolve_server_port()
         print(f"Launching Gradio app on port {port}")
-        demo.launch(server_name="0.0.0.0", server_port=port)
+        demo.launch(server_name="0.0.0.0", server_port=port, show_error=True)
     except OSError as exc:
         print("Failed to launch on requested port:", exc)
-        demo.launch()
+        try:
+            demo.launch(server_name="0.0.0.0", show_error=True)
+        except Exception as e:
+            print(f"Failed to launch completely: {e}")
+    except Exception as e:
+        print(f"Unexpected launch error: {e}")
+        import traceback
+        traceback.print_exc()
 
 
 if __name__ == "__main__":
+    print("="*50)
+    print("PMU Fault Classification App Starting")
+    print(f"Python version: {os.sys.version}")
+    print(f"Working directory: {os.getcwd()}")
+    print(f"HUB_REPO: {HUB_REPO}")
+    print(f"Model available: {MODEL is not None}")
+    print(f"Scaler available: {SCALER is not None}")
+    print("="*50)
     main()

fault_classification_pmu.py

@@ -1,17 +1,19 @@
-"""Fault classification training utilities for PMU data.
+"""Fault classification training utilities for PMU and PV datasets.
 
-This module trains a CNN-LSTM model on high-frequency PMU measurements to
-classify transmission line faults.  It implements a full training pipeline
-including preprocessing, sequence generation, model definition, evaluation,
-and artifact export so the resulting model can be served via the Gradio app
-in this repository or on Hugging Face Spaces.
+This module trains deep learning models on high-frequency PMU measurements and
+supports classical machine learning baselines so the resulting artefacts can be
+served via the Gradio app in this repository or on Hugging Face Spaces.  It
+implements a full training pipeline including preprocessing, sequence
+generation, model definition (CNN-LSTM, Temporal Convolutional Network, or
+Support Vector Machine), evaluation, and export of deployment metadata.
 
 Example
 -------
 python fault_classification_pmu.py \
     --data-path data/Fault_Classification_PMU_Data.csv \
     --label-column FaultType \
-    --model-out pmu_cnn_lstm_model.keras \
+    --model-type tcn \
+    --model-out pmu_tcn_model.keras \
     --scaler-out pmu_feature_scaler.pkl \
     --metadata-out pmu_metadata.json
 
@@ -22,24 +24,200 @@ via the ``--feature-columns`` argument.  Data is automatically standardised
 and windowed to create temporal sequences that feed into the neural network.
 
 The exported metadata JSON file contains the feature ordering, label names,
-sequence length, and stride.  The Gradio front-end consumes this file to
-replicate the same preprocessing steps during inference.
+sequence length, stride, and chosen architecture.  The Gradio front-end
+consumes this file to replicate the same preprocessing steps during inference.
 """
 from __future__ import annotations
 
 import argparse
 import json
+import os
+import shutil
+from datetime import datetime
 from pathlib import Path
-from typing import List, Sequence, Tuple
+from typing import Dict, List, Optional, Sequence, Tuple
+
+import math
+
+os.environ.setdefault("CUDA_VISIBLE_DEVICES", "-1")
+os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "2")
+os.environ.setdefault("TF_ENABLE_ONEDNN_OPTS", "0")
 
 import joblib
 import numpy as np
 import pandas as pd
-from sklearn.metrics import classification_report, confusion_matrix
+from pandas.api.types import is_numeric_dtype
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.svm import SVC
 from tensorflow.keras import callbacks, layers, models, optimizers
 
+
+
+class ProgressCallback(callbacks.Callback):
+    """Custom callback to provide training progress updates."""
+
+    def __init__(
+        self,
+        total_epochs,
+        status_file_path=None,
+        *,
+        status_update_interval: float = 10.0,
+        batch_log_frequency: int = 10,
+    ):
+        super().__init__()
+        self.total_epochs = total_epochs
+        self.status_file_path = status_file_path
+        self.status_update_interval = max(1.0, float(status_update_interval))
+        self.batch_log_frequency = max(1, int(batch_log_frequency))
+        self.current_epoch = 0
+        self.train_start_time: Optional[float] = None
+        self.last_status_report: Optional[float] = None
+        self.total_batches_per_epoch = 0
+        self.batches_seen = 0
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+    def _now(self) -> float:
+        import time
+
+        return time.perf_counter()
+
+    def _training_elapsed(self, now: Optional[float] = None) -> float:
+        if self.train_start_time is None:
+            return 0.0
+        if now is None:
+            now = self._now()
+        return max(0.0, now - self.train_start_time)
+
+    def _report_status(self, message: str, *, force: bool = False) -> None:
+        now = self._now()
+        if not force and self.last_status_report is not None:
+            if now - self.last_status_report < self.status_update_interval:
+                return
+
+        print(message, flush=True)
+
+        if self.status_file_path:
+            try:
+                with open(self.status_file_path, "w") as f:
+                    f.write(message)
+            except Exception:
+                # Silently ignore status file failures; progress should still stream to stdout
+                pass
+
+        self.last_status_report = now
+
+    # ------------------------------------------------------------------
+    # Keras callback overrides
+    # ------------------------------------------------------------------
+    def on_train_begin(self, logs=None):
+        params = self.params or {}
+        steps = params.get("steps") or params.get("steps_per_epoch")
+        if steps:
+            self.total_batches_per_epoch = int(steps)
+        else:
+            samples = params.get("samples")
+            batch_size = params.get("batch_size") or 0
+            if samples and batch_size:
+                self.total_batches_per_epoch = math.ceil(samples / batch_size)
+            else:
+                self.total_batches_per_epoch = 0
+
+        self.batches_seen = 0
+        self.last_status_report = None
+        self.train_start_time = self._now()
+
+    def on_epoch_begin(self, epoch, logs=None):
+        import time
+
+        now = self._now()
+        if self.train_start_time is None:
+            self.train_start_time = now
+
+        self.current_epoch = epoch + 1
+        self.batches_seen = 0
+
+        progress_pct = (self.current_epoch / self.total_epochs) * 100
+        elapsed_time = self._training_elapsed(now)
+        status_msg = (
+            f"Training epoch {self.current_epoch}/{self.total_epochs} "
+            f"({progress_pct:.1f}%) - {elapsed_time:.1f}s elapsed"
+        )
+        self._report_status(status_msg, force=True)
+
+        if self.current_epoch == 1:
+            wall_clock = time.strftime("%H:%M:%S")
+            print(f"Starting first epoch at {wall_clock}", flush=True)
+
+    def on_batch_begin(self, batch, logs=None):
+        if self.current_epoch == 1 and batch % self.batch_log_frequency == 0:
+            elapsed = self._training_elapsed()
+            print(f"Epoch {self.current_epoch}, Batch {batch} started - {elapsed:.1f}s elapsed", flush=True)
+
+    def on_batch_end(self, batch, logs=None):
+        self.batches_seen = batch + 1
+
+        if self.current_epoch == 1 and batch % self.batch_log_frequency == 0:
+            logs = logs or {}
+            loss = logs.get("loss", 0)
+            elapsed = self._training_elapsed()
+            print(
+                f"Epoch {self.current_epoch}, Batch {batch} completed - Loss: {loss:.4f}, {elapsed:.1f}s elapsed",
+                flush=True,
+            )
+
+        total_batches = self.total_batches_per_epoch or 0
+        if not total_batches:
+            params = self.params or {}
+            total_batches = (
+                params.get("steps")
+                or params.get("steps_per_epoch")
+                or 0
+            )
+
+        if total_batches:
+            epoch_fraction = min(1.0, (batch + 1) / total_batches)
+        else:
+            epoch_fraction = 0.0
+
+        overall_progress = (
+            (self.current_epoch - 1 + epoch_fraction) / self.total_epochs * 100
+        )
+        elapsed_time = self._training_elapsed()
+        status_msg = (
+            f"Epoch {self.current_epoch}/{self.total_epochs} - Batch {batch + 1}/{total_batches or '?'} "
+            f"({overall_progress:.1f}%) - {elapsed_time:.1f}s elapsed"
+        )
+        self._report_status(status_msg)
+
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+        loss = logs.get("loss", 0)
+        val_loss = logs.get("val_loss", 0)
+        accuracy = logs.get("accuracy", logs.get("acc", 0))
+        val_accuracy = logs.get("val_accuracy", logs.get("val_acc", 0))
+        _ = epoch  # Suppress unused variable warning
+
+        elapsed_time = self._training_elapsed()
+        status_msg = (
+            f"Epoch {self.current_epoch}/{self.total_epochs} completed - "
+            f"Loss: {loss:.4f}, Val Loss: {val_loss:.4f}, "
+            f"Acc: {accuracy:.4f}, Val Acc: {val_accuracy:.4f} - {elapsed_time:.1f}s total"
+        )
+        self._report_status(status_msg, force=True)
+
+    def on_train_end(self, logs=None):
+        total_elapsed = self._training_elapsed()
+        final_message = (
+            f"Training finished after {self.total_epochs} epoch(s) - "
+            f"{total_elapsed:.1f}s total elapsed"
+        )
+        self._report_status(final_message, force=True)
+
+
 # Default PMU feature set as described in the user provided table.  Timestamp is
 # intentionally omitted because it is not a model input feature.
 DEFAULT_FEATURE_COLUMNS: List[str] = [
@@ -60,6 +238,47 @@ DEFAULT_FEATURE_COLUMNS: List[str] = [
     "[339] UPMU_SUB22-C3:ANG",
 ]
 
+LABEL_GUESS_CANDIDATES: Tuple[str, ...] = ("Fault", "FaultType", "Label", "Target", "Class")
+
+
+def _normalise_column_name(name: str) -> str:
+    return str(name).strip().lower()
+
+
+def _resolve_label_column(df: pd.DataFrame, requested: str) -> str:
+    columns = [str(col) for col in df.columns]
+    if not columns:
+        raise ValueError("Provided dataframe does not contain any columns.")
+
+    requested = str(requested or "").strip()
+    if requested and requested in df.columns:
+        return requested
+
+    if requested:
+        for col in df.columns:
+            if str(col).strip() == requested:
+                return str(col)
+        lowered = requested.lower()
+        lowered_map = {_normalise_column_name(col): str(col) for col in df.columns}
+        if lowered in lowered_map:
+            return lowered_map[lowered]
+
+    lowered_map = {_normalise_column_name(col): str(col) for col in df.columns}
+    for guess in LABEL_GUESS_CANDIDATES:
+        key = guess.lower()
+        if key in lowered_map:
+            return lowered_map[key]
+
+    for col in reversed(df.columns):
+        if not is_numeric_dtype(df[col]):
+            return str(col)
+
+    available = ", ".join(columns)
+    raise ValueError(
+        f"Label column '{requested or ' '}' not found in provided dataframe. "
+        f"Available columns: {available}"
+    )
+
 
 def _resolve_features(df: pd.DataFrame, feature_columns: Sequence[str] | None, label_column: str) -> List[str]:
     if feature_columns:
@@ -85,7 +304,7 @@ def load_dataset(
     *,
     feature_columns: Sequence[str] | None,
     label_column: str,
-) -> Tuple[np.ndarray, np.ndarray, List[str]]:
+) -> Tuple[np.ndarray, np.ndarray, List[str], str]:
     """Load the dataset from CSV.
 
     Parameters
@@ -105,15 +324,32 @@ def load_dataset(
         1-D array of label strings.
     columns: list[str]
         Actual feature ordering used.
+    resolved_label: str
+        The column name that supplied the labels.
     """
-    df = pd.read_csv(csv_path)
-    if label_column not in df.columns:
-        raise ValueError(f"Label column '{label_column}' not found in {csv_path}")
+    df = pd.read_csv(csv_path, sep=None, engine="python")
+    resolved_label = _resolve_label_column(df, label_column)
+
+    columns = _resolve_features(df, feature_columns, resolved_label)
+    features = df[columns].astype(np.float32).values
+    labels = df[resolved_label].astype(str).values
+    return features, labels, columns, resolved_label
+
+
+def load_dataset_from_dataframe(
+    df: pd.DataFrame,
+    *,
+    feature_columns: Sequence[str] | None,
+    label_column: str,
+) -> Tuple[np.ndarray, np.ndarray, List[str], str]:
+    """Load dataset arrays directly from a DataFrame."""
 
-    columns = _resolve_features(df, feature_columns, label_column)
+    resolved_label = _resolve_label_column(df, label_column)
+
+    columns = _resolve_features(df, feature_columns, resolved_label)
     features = df[columns].astype(np.float32).values
-    labels = df[label_column].astype(str).values
-    return features, labels, columns
+    labels = df[resolved_label].astype(str).values
+    return features, labels, columns, resolved_label
 
 
 def create_sequences(
@@ -175,6 +411,56 @@ def build_cnn_lstm(
     return model
 
 
+def build_tcn(
+    input_shape: Tuple[int, int],
+    num_classes: int,
+    *,
+    filters: int = 64,
+    kernel_size: int = 3,
+    dilations: Sequence[int] = (1, 2, 4, 8),
+    dropout: float = 0.2,
+) -> models.Model:
+    """Construct a lightweight Temporal Convolutional Network."""
+
+    inputs = layers.Input(shape=input_shape)
+    x = inputs
+    for dilation in dilations:
+        residual = x
+        x = layers.Conv1D(
+            filters,
+            kernel_size,
+            padding="causal",
+            activation="relu",
+            dilation_rate=dilation,
+        )(x)
+        x = layers.BatchNormalization()(x)
+        x = layers.Dropout(dropout)(x)
+        x = layers.Conv1D(
+            filters,
+            kernel_size,
+            padding="causal",
+            activation="relu",
+            dilation_rate=dilation,
+        )(x)
+        x = layers.BatchNormalization()(x)
+        if residual.shape[-1] != filters:
+            residual = layers.Conv1D(filters, 1, padding="same")(residual)
+        x = layers.Add()([x, residual])
+        x = layers.Activation("relu")(x)
+
+    x = layers.GlobalAveragePooling1D()(x)
+    x = layers.Dropout(dropout)(x)
+    outputs = layers.Dense(num_classes, activation="softmax")(x)
+
+    model = models.Model(inputs, outputs)
+    model.compile(
+        optimizer=optimizers.Adam(learning_rate=1e-3),
+        loss="sparse_categorical_crossentropy",
+        metrics=["accuracy"],
+    )
+    return model
+
+
 def train_model(
     sequences: np.ndarray,
     labels: np.ndarray,
@@ -182,40 +468,216 @@ def train_model(
     validation_split: float,
     batch_size: int,
     epochs: int,
-) -> Tuple[models.Model, LabelEncoder, dict]:
-    """Train the CNN-LSTM model and return training history and validation outputs."""
-    label_encoder = LabelEncoder()
-    y = label_encoder.fit_transform(labels)
-
-    X_train, X_val, y_train, y_val = train_test_split(
-        sequences, y, test_size=validation_split, stratify=y, random_state=42
-    )
+    model_type: str = "cnn_lstm",
+    tensorboard_log_dir: Optional[Path] = None,
+    status_file_path: Optional[Path] = None,
+) -> Tuple[object, LabelEncoder, Dict[str, object]]:
+    """Train a sequence model and return training history and validation outputs."""
 
-    model = build_cnn_lstm(input_shape=sequences.shape[1:], num_classes=len(label_encoder.classes_))
+    model_type = model_type.lower().strip()
+    if model_type not in {"cnn_lstm", "tcn", "svm"}:
+        raise ValueError("model_type must be either 'cnn_lstm', 'tcn', or 'svm'")
 
-    callbacks_list = [
-        callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5, patience=5, min_lr=1e-5),
-        callbacks.EarlyStopping(monitor="val_loss", patience=10, restore_best_weights=True),
-    ]
+    # Handle status file for progress tracking
+    status_file = status_file_path if status_file_path else None
 
-    history = model.fit(
-        X_train,
-        y_train,
-        validation_data=(X_val, y_val),
-        epochs=epochs,
-        batch_size=batch_size,
-        callbacks=callbacks_list,
-        verbose=2,
-    )
+    label_encoder = LabelEncoder()
+    y = label_encoder.fit_transform(labels)
 
-    y_pred = model.predict(X_val, verbose=0).argmax(axis=1)
-    metrics = {
-        "history": history.history,
+    if model_type == "svm":
+        features = sequences.reshape(sequences.shape[0], -1)
+    else:
+        features = sequences
+
+    tb_dir: Optional[str] = None
+    if model_type != "svm" and tensorboard_log_dir is not None:
+        tensorboard_log_dir.mkdir(parents=True, exist_ok=True)
+        tb_dir = str(tensorboard_log_dir.resolve())
+    else:
+        tensorboard_log_dir = None
+
+    # Check if we can use stratification (each class needs at least 2 samples)
+    unique_labels, label_counts = np.unique(y, return_counts=True)
+    min_samples_per_class = np.min(label_counts)
+
+    print(f"Label distribution: {dict(zip(unique_labels, label_counts))}")
+    print(f"Minimum samples per class: {min_samples_per_class}")
+    print(f"Total sequences: {len(sequences)}, Features per sequence: {sequences.shape[1:]}")
+
+    # Check for potential memory issues
+    import sys
+    data_size_mb = sequences.nbytes / (1024 * 1024)
+    print(f"Data size: {data_size_mb:.2f} MB")
+    if data_size_mb > 1000:  # > 1GB
+        print("Warning: Large dataset detected. Consider reducing batch size or sequence length.")
+
+    # Validate data ranges
+    if np.any(np.isnan(sequences)) or np.any(np.isinf(sequences)):
+        print("Warning: NaN or Inf values detected in sequences")
+        sequences = np.nan_to_num(sequences, nan=0.0, posinf=1e6, neginf=-1e6)
+
+    # Use stratification only if each class has at least 2 samples
+    if min_samples_per_class >= 2:
+        X_train, X_val, y_train, y_val = train_test_split(
+            features, y, test_size=validation_split, stratify=y, random_state=42
+        )
+    else:
+        print(f"Warning: Some classes have only {min_samples_per_class} sample(s). Using simple random split instead of stratified split.")
+
+        # If validation split would result in empty validation set for some classes,
+        # reduce validation split or use a minimum number of samples
+        total_samples = len(y)
+        if validation_split * total_samples < len(unique_labels):
+            # Ensure at least one sample per class in validation if possible
+            adjusted_split = max(0.1, len(unique_labels) / total_samples)
+            adjusted_split = min(adjusted_split, 0.3)  # Cap at 30%
+            print(f"Adjusting validation split from {validation_split} to {adjusted_split}")
+            validation_split = adjusted_split
+
+        X_train, X_val, y_train, y_val = train_test_split(
+            features, y, test_size=validation_split, random_state=42
+        )
+
+    if model_type == "cnn_lstm":
+        print("Building CNN-LSTM model...")
+
+        # Optimize model for large datasets
+        if len(sequences) > 100000:
+            print("Using lightweight CNN-LSTM for large dataset")
+            model = build_cnn_lstm(
+                input_shape=sequences.shape[1:],
+                num_classes=len(label_encoder.classes_),
+                conv_filters=64,  # Reduce from 128
+                lstm_units=64,    # Reduce from 128
+                dropout=0.2       # Reduce dropout
+            )
+        else:
+            model = build_cnn_lstm(
+                input_shape=sequences.shape[1:], num_classes=len(label_encoder.classes_)
+            )
+        print(f"CNN-LSTM model built. Input shape: {sequences.shape[1:]}, Classes: {len(label_encoder.classes_)}")
+        print(f"Model parameters: {model.count_params():,}")
+
+        # Adjust callbacks for dataset size
+        if len(sequences) > 100000:
+            callbacks_list = [
+                ProgressCallback(total_epochs=epochs, status_file_path=str(status_file) if status_file else None),
+                callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5, patience=2, min_lr=1e-5),
+                callbacks.EarlyStopping(monitor="val_loss", patience=3, restore_best_weights=True),  # More aggressive
+            ]
+            print("Using aggressive callbacks for large dataset")
+        else:
+            callbacks_list = [
+                ProgressCallback(total_epochs=epochs, status_file_path=str(status_file) if status_file else None),
+                callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5, patience=3, min_lr=1e-5),
+                callbacks.EarlyStopping(monitor="val_loss", patience=6, restore_best_weights=True),
+            ]
+        if tensorboard_log_dir is not None:
+            callbacks_list.insert(-2, callbacks.TensorBoard(log_dir=tb_dir, histogram_freq=0, write_graph=False))  # Reduce TensorBoard overhead
+
+        print(f"Starting CNN-LSTM training with {len(X_train)} training samples, {len(X_val)} validation samples")
+        print(f"Batch size: {batch_size}, Epochs: {epochs}")
+
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write(f"CNN-LSTM training started - {len(X_train)} train, {len(X_val)} val samples, batch_size={batch_size}")
+
+        history = model.fit(
+            X_train,
+            y_train,
+            validation_data=(X_val, y_val),
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks_list,
+            verbose=2,
+        )
+
+        print("CNN-LSTM training completed, starting prediction...")
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write("CNN-LSTM training completed, evaluating model...")
+
+        print(f"Making predictions on {len(X_val)} validation samples...")
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write(f"Making predictions on {len(X_val)} validation samples...")
+        y_pred = model.predict(X_val, verbose=0).argmax(axis=1)
+        print("Predictions completed")
+        training_history: Dict[str, object] = history.history
+    elif model_type == "tcn":
+        print("Building TCN model...")
+        model = build_tcn(input_shape=sequences.shape[1:], num_classes=len(label_encoder.classes_))
+        print(f"TCN model built. Input shape: {sequences.shape[1:]}, Classes: {len(label_encoder.classes_)}")
+
+        callbacks_list = [
+            ProgressCallback(total_epochs=epochs, status_file_path=str(status_file) if status_file else None),
+            callbacks.ReduceLROnPlateau(monitor="val_loss", factor=0.5, patience=3, min_lr=1e-5),
+            callbacks.EarlyStopping(monitor="val_loss", patience=6, restore_best_weights=True),
+        ]
+        if tensorboard_log_dir is not None:
+            callbacks_list.insert(-2, callbacks.TensorBoard(log_dir=tb_dir, histogram_freq=0, write_graph=False))  # Reduce TensorBoard overhead
+
+        print(f"Starting TCN training with {len(X_train)} training samples, {len(X_val)} validation samples")
+        print(f"Batch size: {batch_size}, Epochs: {epochs}")
+
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write(f"TCN training started - {len(X_train)} train, {len(X_val)} val samples, batch_size={batch_size}")
+
+        history = model.fit(
+            X_train,
+            y_train,
+            validation_data=(X_val, y_val),
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks_list,
+            verbose=2,
+        )
+
+        print("TCN training completed, starting prediction...")
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write("TCN training completed, evaluating model...")
+
+        print(f"Making TCN predictions on {len(X_val)} validation samples...")
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write(f"Making TCN predictions on {len(X_val)} validation samples...")
+        y_pred = model.predict(X_val, verbose=0).argmax(axis=1)
+        print("TCN predictions completed")
+        training_history = history.history
+    else:  # svm
+        print("Training SVM model...", flush=True)
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write("Training SVM model...")
+
+        model = SVC(kernel="rbf", probability=True, class_weight="balanced")
+        model.fit(X_train, y_train)
+
+        print("SVM training completed. Evaluating...", flush=True)
+        if status_file:
+            with open(status_file, 'w') as f:
+                f.write("SVM training completed. Evaluating...")
+
+        y_pred = model.predict(X_val)
+        training_history = {
+            "train_accuracy": float(model.score(X_train, y_train)),
+            "val_accuracy": float(accuracy_score(y_val, y_pred)),
+        }
+
+    cm = confusion_matrix(y_val, y_pred)
+    metrics: Dict[str, object] = {
+        "history": training_history,
         "validation": {
             "y_true": y_val,
             "y_pred": y_pred,
             "class_names": label_encoder.classes_.tolist(),
+            "confusion_matrix": cm,
         },
+        "model_type": model_type,
+        "input_shape": list(sequences.shape[1:]),
+        "tensorboard_log_dir": tb_dir,
     }
     return model, label_encoder, metrics
 
@@ -230,7 +692,7 @@ def standardise_sequences(sequences: np.ndarray) -> Tuple[np.ndarray, StandardSc
 
 def export_artifacts(
     *,
-    model: models.Model,
+    model: object,
     scaler: StandardScaler,
     label_encoder: LabelEncoder,
     feature_columns: Sequence[str],
@@ -246,9 +708,21 @@ def export_artifacts(
     model_path.parent.mkdir(parents=True, exist_ok=True)
     scaler_path.parent.mkdir(parents=True, exist_ok=True)
     metadata_path.parent.mkdir(parents=True, exist_ok=True)
-    model.save(model_path)
+    model_type = str(metrics.get("model_type", "cnn_lstm"))
+    if model_type == "svm":
+        joblib.dump(model, model_path)
+    else:
+        model.save(model_path)
     joblib.dump(scaler, scaler_path)
 
+    validation = metrics["validation"]
+    report_dict = classification_report(
+        validation["y_true"],
+        validation["y_pred"],
+        target_names=label_encoder.classes_,
+        output_dict=True,
+    )
+
     metadata = {
         "feature_columns": list(feature_columns),
         "label_classes": label_encoder.classes_.tolist(),
@@ -258,28 +732,184 @@ def export_artifacts(
         "model_path": str(model_path),
         "scaler_path": str(scaler_path),
         "training_history": metrics["history"],
-        "classification_report": classification_report(
-            metrics["validation"]["y_true"], metrics["validation"]["y_pred"], target_names=label_encoder.classes_
-        ),
-        "confusion_matrix": metrics["validation"].get("confusion_matrix")
-        if metrics["validation"].get("confusion_matrix") is not None
-        else None,
+        "classification_report": report_dict,
+        "model_type": model_type,
+        "model_format": "joblib" if model_type == "svm" else "keras",
+        "input_shape": metrics.get("input_shape"),
+        "tensorboard_log_dir": metrics.get("tensorboard_log_dir"),
     }
-    # Add confusion matrix lazily to avoid recomputation.
-    if metadata["confusion_matrix"] is None:
-        cm = confusion_matrix(metrics["validation"]["y_true"], metrics["validation"]["y_pred"])
-        metadata["confusion_matrix"] = cm.tolist()
+    confusion = validation.get("confusion_matrix")
+    if confusion is None:
+        confusion = confusion_matrix(validation["y_true"], validation["y_pred"])
+    metadata["confusion_matrix"] = np.asarray(confusion).tolist()
 
     metadata_path.write_text(json.dumps(metadata, indent=2))
 
 
+def train_from_dataframe(
+    df: pd.DataFrame,
+    *,
+    label_column: str,
+    feature_columns: Sequence[str] | None = None,
+    sequence_length: int = 32,
+    stride: int = 4,
+    validation_split: float = 0.2,
+    batch_size: int = 128,
+    epochs: int = 50,
+    model_type: str = "cnn_lstm",
+    model_path: Path | str = "pmu_cnn_lstm_model.keras",
+    scaler_path: Path | str = "pmu_feature_scaler.pkl",
+    metadata_path: Path | str = "pmu_metadata.json",
+    enable_tensorboard: bool = True,
+    tensorboard_root: Path | str | None = None,
+) -> dict:
+    """Train a PMU fault classification model using an in-memory dataframe."""
+
+    model_path = Path(model_path)
+    scaler_path = Path(scaler_path)
+    metadata_path = Path(metadata_path)
+
+    # Create status file for progress tracking
+    status_file = model_path.parent / "training_status.txt"
+    print(f"Training progress will be written to: {status_file}")
+
+    tensorboard_log_dir: Optional[Path] = None
+    if enable_tensorboard and model_type.lower() != "svm":
+        base_dir = Path(tensorboard_root) if tensorboard_root is not None else Path("tensorboard_runs")
+        timestamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
+        tensorboard_log_dir = base_dir / f"run-{timestamp}"
+
+    features, labels, used_columns, resolved_label = load_dataset_from_dataframe(
+        df, feature_columns=feature_columns, label_column=label_column
+    )
+
+    print(f"Input data: {len(features)} samples")
+    print(f"Creating sequences with length={sequence_length}, stride={stride}")
+
+    sequences, seq_labels = create_sequences(
+        features,
+        labels,
+        sequence_length=sequence_length,
+        stride=stride,
+    )
+
+    print(f"Generated {len(sequences)} sequences")
+
+    # Validate sequence count and adjust parameters if necessary
+    if len(sequences) < 10:
+        raise ValueError(
+            f"Only {len(sequences)} sequences generated. Need at least 10 for training. "
+            f"Try reducing sequence_length (currently {sequence_length}) or stride (currently {stride}), "
+            "or provide more data."
+        )
+
+    # If very few sequences, recommend SVM instead of deep learning
+    if len(sequences) < 100 and model_type in ['cnn_lstm', 'tcn']:
+        print(f"Warning: Only {len(sequences)} sequences available. Consider using SVM for small datasets.")
+
+    sequences, scaler = standardise_sequences(sequences)
+
+    # Adjust training parameters based on data size
+    original_batch_size = batch_size
+    original_epochs = epochs
+    original_validation_split = validation_split
+
+    # Handle large datasets (>100K sequences) - optimize for memory and speed
+    if len(sequences) > 100000:
+        print(f"Large dataset detected ({len(sequences)} sequences). Optimizing parameters...")
+        batch_size = min(batch_size * 2, 512)  # Increase batch size for efficiency
+        epochs = min(epochs, 30)  # Reduce epochs for large datasets
+        print(f"Adjusted parameters for large dataset:")
+        print(f"  Batch size: {original_batch_size} -> {batch_size}")
+        print(f"  Epochs: {original_epochs} -> {epochs}")
+
+        # Force garbage collection
+        import gc
+        gc.collect()
+
+    elif len(sequences) < 100:
+        # For very small datasets
+        batch_size = max(min(batch_size, len(sequences) // 4), 4)  # Ensure batch_size >= 4
+        epochs = min(epochs, 20)  # Reduce epochs to prevent overfitting
+        validation_split = min(validation_split, 0.3)  # Reduce validation split
+        print(f"Adjusted parameters for small dataset:")
+        print(f"  Batch size: {original_batch_size} -> {batch_size}")
+        print(f"  Epochs: {original_epochs} -> {epochs}")
+        print(f"  Validation split: {original_validation_split} -> {validation_split}")
+
+    model, label_encoder, metrics = train_model(
+        sequences,
+        seq_labels,
+        validation_split=validation_split,
+        batch_size=batch_size,
+        epochs=epochs,
+        model_type=model_type,
+        tensorboard_log_dir=tensorboard_log_dir,
+        status_file_path=status_file,
+    )
+
+    export_artifacts(
+        model=model,
+        scaler=scaler,
+        label_encoder=label_encoder,
+        feature_columns=used_columns,
+        label_column=resolved_label,
+        sequence_length=sequence_length,
+        stride=stride,
+        model_path=model_path,
+        scaler_path=scaler_path,
+        metadata_path=metadata_path,
+        metrics=metrics,
+    )
+
+    tensorboard_zip_path: Optional[str] = None
+    if tensorboard_log_dir and tensorboard_log_dir.exists():
+        try:
+            tensorboard_zip_path = shutil.make_archive(
+                base_name=str(tensorboard_log_dir.parent / tensorboard_log_dir.name),
+                format="zip",
+                root_dir=str(tensorboard_log_dir.parent),
+                base_dir=tensorboard_log_dir.name,
+            )
+            tensorboard_zip_path = str(Path(tensorboard_zip_path).resolve())
+        except Exception:
+            tensorboard_zip_path = None
+
+    report_dict = classification_report(
+        metrics["validation"]["y_true"],
+        metrics["validation"]["y_pred"],
+        target_names=metrics["validation"]["class_names"],
+        output_dict=True,
+    )
+    confusion = metrics["validation"].get("confusion_matrix")
+    if confusion is None:
+        confusion = confusion_matrix(metrics["validation"]["y_true"], metrics["validation"]["y_pred"])
+
+    return {
+        "num_samples": int(df.shape[0]),
+        "num_sequences": int(sequences.shape[0]),
+        "feature_columns": used_columns,
+        "class_names": label_encoder.classes_.tolist(),
+        "model_path": str(model_path.resolve()),
+        "scaler_path": str(scaler_path.resolve()),
+        "metadata_path": str(metadata_path.resolve()),
+        "history": metrics["history"],
+        "model_type": metrics.get("model_type", model_type),
+        "classification_report": report_dict,
+        "confusion_matrix": np.asarray(confusion).tolist(),
+        "tensorboard_log_dir": metrics.get("tensorboard_log_dir"),
+        "tensorboard_zip_path": tensorboard_zip_path,
+        "label_column": resolved_label,
+    }
+
+
 def run_training(args: argparse.Namespace) -> None:
     csv_path = Path(args.data_path)
     model_out = Path(args.model_out)
     scaler_out = Path(args.scaler_out)
     metadata_out = Path(args.metadata_out)
 
-    features, labels, feature_columns = load_dataset(
+    features, labels, feature_columns, resolved_label = load_dataset(
         csv_path, feature_columns=args.feature_columns, label_column=args.label_column
     )
 
@@ -291,12 +921,21 @@ def run_training(args: argparse.Namespace) -> None:
     )
 
     sequences, scaler = standardise_sequences(sequences)
+    tensorboard_log_dir: Optional[Path] = None
+    if args.tensorboard and args.model_type != "svm":
+        if args.tensorboard_log_dir:
+            tensorboard_log_dir = Path(args.tensorboard_log_dir)
+        else:
+            tensorboard_log_dir = Path("tensorboard_runs") / datetime.utcnow().strftime("%Y%m%d-%H%M%S")
     model, label_encoder, metrics = train_model(
         sequences,
         seq_labels,
         validation_split=args.validation_split,
         batch_size=args.batch_size,
         epochs=args.epochs,
+        model_type=args.model_type,
+        tensorboard_log_dir=tensorboard_log_dir,
+        status_file_path=None,  # No status file for CLI usage
     )
 
     export_artifacts(
@@ -304,7 +943,7 @@ def run_training(args: argparse.Namespace) -> None:
         scaler=scaler,
         label_encoder=label_encoder,
         feature_columns=feature_columns,
-        label_column=args.label_column,
+        label_column=resolved_label,
         sequence_length=args.sequence_length,
         stride=args.stride,
         model_path=model_out,
@@ -314,6 +953,7 @@ def run_training(args: argparse.Namespace) -> None:
     )
 
     print("Training complete")
+    print(f"Model architecture  : {args.model_type}")
     print(f"Model saved to       : {model_out}")
     print(f"Scaler saved to      : {scaler_out}")
     print(f"Metadata saved to    : {metadata_out}")
@@ -322,10 +962,14 @@ def run_training(args: argparse.Namespace) -> None:
         metrics["validation"]["y_true"], metrics["validation"]["y_pred"], target_names=metrics["validation"]["class_names"]
     )
     print(report)
+    if metrics.get("tensorboard_log_dir"):
+        tb_dir = metrics["tensorboard_log_dir"]
+        print(f"TensorBoard logs written to: {tb_dir}")
+        print(f"Launch TensorBoard with: tensorboard --logdir \"{tb_dir}\"")
 
 
 def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Train a CNN-LSTM model for PMU fault classification")
+    parser = argparse.ArgumentParser(description="Train a sequence model for PMU fault classification")
     parser.add_argument("--data-path", required=True, help="Path to Fault_Classification_PMU_Data CSV")
     parser.add_argument(
         "--label-column",
@@ -343,9 +987,27 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
     parser.add_argument("--validation-split", type=float, default=0.2, help="Validation set fraction")
     parser.add_argument("--batch-size", type=int, default=128, help="Training batch size")
     parser.add_argument("--epochs", type=int, default=50, help="Maximum number of training epochs")
+    parser.add_argument(
+        "--model-type",
+        choices=["cnn_lstm", "tcn", "svm"],
+        default="cnn_lstm",
+        help="Model architecture to train (choices: cnn_lstm, tcn, svm)",
+    )
     parser.add_argument("--model-out", default="pmu_cnn_lstm_model.keras", help="Path to save trained Keras model")
     parser.add_argument("--scaler-out", default="pmu_feature_scaler.pkl", help="Path to save fitted StandardScaler")
     parser.add_argument("--metadata-out", default="pmu_metadata.json", help="Path to save metadata JSON")
+    parser.add_argument(
+        "--tensorboard-log-dir",
+        default=None,
+        help="Optional directory to write TensorBoard logs (defaults to tensorboard_runs/<timestamp>)",
+    )
+    parser.add_argument(
+        "--no-tensorboard",
+        dest="tensorboard",
+        action="store_false",
+        help="Disable TensorBoard logging for neural network models",
+    )
+    parser.set_defaults(tensorboard=True)
     return parser.parse_args(argv)
 
 

requirements.txt

@@ -1,4 +1,4 @@
-gradio>=3.0
+gradio>=4.44,<5
 tensorflow>=2.6
 numpy
 pandas