Upload factorynet_loader.py with huggingface_hub

factorynet_loader.py

@@ -0,0 +1,186 @@
+"""
+FactoryNet Loader - Easy access to hackathon datasets.
+
+Usage:
+    from factorynet_loader import load_factorynet
+
+    # Load AURSAD data
+    df, metadata = load_factorynet("aursad")
+
+    # Get specific columns
+    setpoints = df[[c for c in df.columns if c.startswith("setpoint_")]]
+    efforts = df[[c for c in df.columns if c.startswith("effort_")]]
+    feedback = df[[c for c in df.columns if c.startswith("feedback_")]]
+"""
+
+import pandas as pd
+import json
+from pathlib import Path
+from typing import Tuple, List, Optional, Dict
+import numpy as np
+
+try:
+    from datasets import load_dataset
+    HF_AVAILABLE = True
+except ImportError:
+    HF_AVAILABLE = False
+
+
+# HuggingFace repo
+HF_REPO = "forgis/factorynet-hackathon"
+
+
+def load_factorynet(
+    dataset: str = "aursad",
+    split: str = "train",
+    from_hf: bool = True,
+    local_path: Optional[Path] = None,
+) -> Tuple[pd.DataFrame, List[Dict]]:
+    """
+    Load FactoryNet dataset.
+
+    Args:
+        dataset: "aursad" or "voraus"
+        split: "train" (full data) or future splits
+        from_hf: If True, load from HuggingFace Hub
+        local_path: Local path override
+
+    Returns:
+        df: DataFrame with time series
+        metadata: List of episode metadata dicts
+    """
+    if from_hf and HF_AVAILABLE:
+        return _load_from_hf(dataset, split)
+    elif local_path:
+        return _load_from_local(local_path, dataset)
+    else:
+        raise ValueError("Either set from_hf=True or provide local_path")
+
+
+def _load_from_hf(dataset: str, split: str) -> Tuple[pd.DataFrame, List[Dict]]:
+    """Load from HuggingFace Hub."""
+    ds = load_dataset(HF_REPO, data_dir=dataset, split=split)
+    df = ds.to_pandas()
+
+    # Try to load metadata
+    try:
+        from huggingface_hub import hf_hub_download
+        meta_file = hf_hub_download(
+            repo_id=HF_REPO,
+            filename=f"{dataset}/{dataset}_metadata.json",
+            repo_type="dataset"
+        )
+        with open(meta_file) as f:
+            metadata = json.load(f)
+    except:
+        metadata = []
+
+    return df, metadata
+
+
+def _load_from_local(local_path: Path, dataset: str) -> Tuple[pd.DataFrame, List[Dict]]:
+    """Load from local files."""
+    local_path = Path(local_path)
+
+    # Find parquet file
+    parquet_files = list(local_path.glob(f"**/*{dataset}*factorynet*.parquet"))
+    if not parquet_files:
+        parquet_files = list(local_path.glob("**/*.parquet"))
+
+    if not parquet_files:
+        raise FileNotFoundError(f"No parquet files found in {local_path}")
+
+    df = pd.read_parquet(parquet_files[0])
+
+    # Load metadata
+    meta_files = list(local_path.glob(f"**/*{dataset}*metadata*.json"))
+    if meta_files:
+        with open(meta_files[0]) as f:
+            metadata = json.load(f)
+    else:
+        metadata = []
+
+    return df, metadata
+
+
+def get_episode(df: pd.DataFrame, episode_id: str) -> pd.DataFrame:
+    """Extract a single episode from the dataset."""
+    return df[df["episode_id"] == episode_id].copy()
+
+
+def get_episodes_by_fault(df: pd.DataFrame, metadata: List[Dict], fault_type: str) -> pd.DataFrame:
+    """Get all episodes of a specific fault type."""
+    fault_episodes = [m["episode_id"] for m in metadata if m.get("fault_type") == fault_type]
+    return df[df["episode_id"].isin(fault_episodes)].copy()
+
+
+def extract_features(df: pd.DataFrame, window_size: int = 100) -> np.ndarray:
+    """
+    Extract basic features for anomaly detection.
+
+    Returns array of shape (n_windows, n_features).
+    """
+    # Get signal columns
+    signal_cols = [c for c in df.columns if any(
+        c.startswith(p) for p in ["setpoint_", "effort_", "feedback_"]
+    )]
+
+    data = df[signal_cols].values
+
+    # Sliding window features
+    n_windows = len(data) // window_size
+    features = []
+
+    for i in range(n_windows):
+        window = data[i * window_size : (i + 1) * window_size]
+        # Basic stats per column
+        feat = np.concatenate([
+            window.mean(axis=0),    # Mean
+            window.std(axis=0),     # Std
+            window.max(axis=0),     # Max
+            window.min(axis=0),     # Min
+            np.abs(np.diff(window, axis=0)).mean(axis=0),  # Mean absolute diff
+        ])
+        features.append(feat)
+
+    return np.array(features)
+
+
+def compute_causal_residual(df: pd.DataFrame, axis: int = 0) -> pd.Series:
+    """
+    Compute causal residual: effort that can't be explained by setpoint.
+
+    High residual = anomaly (effort without command, or command without effort).
+    """
+    setpoint = df[f"setpoint_pos_{axis}"]
+    effort = df[f"effort_torque_{axis}"] if f"effort_torque_{axis}" in df.columns else df[f"effort_current_{axis}"]
+
+    # Simple approach: effort should correlate with setpoint change
+    setpoint_diff = setpoint.diff().abs()
+    effort_normalized = (effort - effort.mean()) / effort.std()
+
+    # Residual: effort that doesn't match setpoint activity
+    residual = effort_normalized - setpoint_diff / (setpoint_diff.max() + 1e-6)
+
+    return residual
+
+
+# Quick test
+if __name__ == "__main__":
+    print("Testing FactoryNet loader...")
+
+    # Try local load
+    try:
+        df, meta = load_factorynet("aursad", from_hf=False,
+                                    local_path=Path(__file__).parent.parent / "output" / "aursad_real")
+        print(f"Loaded {len(df)} rows, {len(df.columns)} columns")
+        print(f"Metadata for {len(meta)} episodes")
+        print(f"Columns: {df.columns.tolist()[:10]}...")
+
+        # Test feature extraction
+        features = extract_features(df)
+        print(f"Extracted features: {features.shape}")
+
+    except Exception as e:
+        print(f"Local load failed: {e}")
+        print("Try: pip install datasets && load with from_hf=True")