generate_data.py

"""
Synthetic Data Generator: Industrial Equipment Sensor Anomaly Detection

Generates realistic multivariate sensor data from a simulated manufacturing
plant with 5 equipment units. Embeds 4 distinct anomaly types at ~4% rate
with realistic noise, missing values, temporal correlations, and concept drift.

Reproducible with fixed random seeds.
"""

import numpy as np
import pandas as pd
from datetime import datetime, timedelta

SEED = 42
np.random.seed(SEED)

# ============================================================
# Configuration
# ============================================================
N_EQUIPMENT = 5
EQUIPMENT_IDS = [f"EQ-{str(i).zfill(3)}" for i in range(1, N_EQUIPMENT + 1)]
START_DATE = datetime(2024, 1, 1)
READINGS_PER_EQUIPMENT = 10000  # 1-min intervals => ~7 days each
TOTAL_ROWS = N_EQUIPMENT * READINGS_PER_EQUIPMENT  # 50,000
ANOMALY_RATE_TARGET = 0.04  # ~4%

# Sensor baseline profiles per equipment (slightly different characteristics)
EQUIPMENT_PROFILES = {
    "EQ-001": {"temp_base": 72, "vib_base": 0.15, "press_base": 150, "rpm_base": 3000, "flow_base": 45},
    "EQ-002": {"temp_base": 68, "vib_base": 0.12, "press_base": 155, "rpm_base": 3200, "flow_base": 48},
    "EQ-003": {"temp_base": 75, "vib_base": 0.18, "press_base": 145, "rpm_base": 2800, "flow_base": 42},
    "EQ-004": {"temp_base": 70, "vib_base": 0.14, "press_base": 152, "rpm_base": 3100, "flow_base": 46},
    "EQ-005": {"temp_base": 73, "vib_base": 0.16, "press_base": 148, "rpm_base": 2900, "flow_base": 44},
}

# Operating modes with transition probabilities
OPERATING_MODES = ["startup", "normal", "high_load", "cooldown", "idle"]
MODE_DURATION_RANGE = {
    "startup": (15, 45),
    "normal": (120, 480),
    "high_load": (30, 180),
    "cooldown": (20, 60),
    "idle": (30, 120),
}
MODE_MULTIPLIERS = {
    "startup": {"temp": 0.85, "vib": 1.3, "press": 0.9, "rpm": 0.7, "flow": 0.6},
    "normal": {"temp": 1.0, "vib": 1.0, "press": 1.0, "rpm": 1.0, "flow": 1.0},
    "high_load": {"temp": 1.25, "vib": 1.5, "press": 1.15, "rpm": 1.2, "flow": 1.3},
    "cooldown": {"temp": 0.9, "vib": 0.8, "press": 0.95, "rpm": 0.5, "flow": 0.4},
    "idle": {"temp": 0.7, "vib": 0.3, "press": 0.85, "rpm": 0.1, "flow": 0.05},
}

# Anomaly type definitions
# Type 1: Thermal runaway (gradual temperature escalation over 15-40 min)
# Type 2: Bearing degradation (vibration increases + high-freq noise)
# Type 3: Pressure leak (slow pressure drop with flow compensation)
# Type 4: Sensor malfunction (one sensor gives erratic readings - NOT real failure)
ANOMALY_TYPES = ["thermal_runaway", "bearing_degradation", "pressure_leak", "sensor_malfunction"]


def generate_operating_mode_sequence(n_steps, rng):
    """Generate a realistic sequence of operating modes."""
    modes = []
    current_mode = "startup"
    steps_remaining = rng.integers(*MODE_DURATION_RANGE[current_mode])

    for _ in range(n_steps):
        modes.append(current_mode)
        steps_remaining -= 1
        if steps_remaining <= 0:
            # Transition logic
            if current_mode == "startup":
                current_mode = "normal"
            elif current_mode == "normal":
                current_mode = rng.choice(["normal", "high_load", "cooldown"], p=[0.6, 0.3, 0.1])
            elif current_mode == "high_load":
                current_mode = rng.choice(["normal", "high_load", "cooldown"], p=[0.4, 0.3, 0.3])
            elif current_mode == "cooldown":
                current_mode = rng.choice(["idle", "normal", "startup"], p=[0.4, 0.4, 0.2])
            elif current_mode == "idle":
                current_mode = rng.choice(["startup", "idle"], p=[0.7, 0.3])
            steps_remaining = rng.integers(*MODE_DURATION_RANGE[current_mode])

    return modes


def generate_base_sensor_data(n_steps, profile, modes, rng):
    """Generate correlated base sensor readings with mode-dependent behavior."""
    t = np.arange(n_steps)

    # Slow ambient drift (diurnal cycle ~1440 min)
    ambient_cycle = 3.0 * np.sin(2 * np.pi * t / 1440) + 0.5 * np.sin(2 * np.pi * t / 720)

    # Equipment age effect (very subtle degradation over time)
    age_factor = 1.0 + 0.0001 * t

    temp_mult = np.array([MODE_MULTIPLIERS[m]["temp"] for m in modes])
    vib_mult = np.array([MODE_MULTIPLIERS[m]["vib"] for m in modes])
    press_mult = np.array([MODE_MULTIPLIERS[m]["press"] for m in modes])
    rpm_mult = np.array([MODE_MULTIPLIERS[m]["rpm"] for m in modes])
    flow_mult = np.array([MODE_MULTIPLIERS[m]["flow"] for m in modes])

    # Core sensors (correlated via physics)
    temp_base = profile["temp_base"] * temp_mult * age_factor + ambient_cycle
    vib_base = profile["vib_base"] * vib_mult * age_factor
    press_base = profile["press_base"] * press_mult
    rpm_base = profile["rpm_base"] * rpm_mult
    flow_base = profile["flow_base"] * flow_mult

    # Add realistic sensor noise
    temp = temp_base + rng.normal(0, 0.8, n_steps)
    vibration = vib_base + rng.normal(0, 0.01, n_steps)
    pressure = press_base + rng.normal(0, 1.5, n_steps)
    rpm = rpm_base + rng.normal(0, 15, n_steps)
    flow_rate = flow_base + rng.normal(0, 0.8, n_steps)

    # Derived/correlated sensors
    # Power consumption correlates with RPM and load
    power = 0.012 * rpm + 0.3 * flow_rate + rng.normal(0, 0.5, n_steps)
    # Coolant temperature lags behind main temp
    coolant_temp = np.convolve(temp, np.ones(10) / 10, mode='same') - 5 + rng.normal(0, 0.3, n_steps)
    # Acoustic level correlates with vibration and RPM
    acoustic_db = 40 + 80 * vibration + 0.005 * rpm + rng.normal(0, 1.0, n_steps)
    # Oil viscosity inversely related to temperature
    oil_viscosity = 100 - 0.4 * temp + rng.normal(0, 0.5, n_steps)
    # Humidity (mostly ambient, weakly correlated)
    humidity = 45 + 10 * np.sin(2 * np.pi * t / 1440 + 1.5) + rng.normal(0, 2, n_steps)

    return {
        "temperature_c": temp,
        "vibration_mm_s": np.clip(vibration, 0, None),
        "pressure_kpa": pressure,
        "motor_rpm": np.clip(rpm, 0, None),
        "flow_rate_lpm": np.clip(flow_rate, 0, None),
        "power_consumption_kw": np.clip(power, 0, None),
        "coolant_temp_c": coolant_temp,
        "acoustic_level_db": np.clip(acoustic_db, 20, 120),
        "oil_viscosity_cst": np.clip(oil_viscosity, 10, 150),
        "humidity_pct": np.clip(humidity, 10, 95),
        "ambient_temp_c": 22 + ambient_cycle + rng.normal(0, 0.3, n_steps),
    }


def inject_anomalies(sensors, modes, n_steps, rng):
    """Inject 4 types of anomalies into sensor data."""
    is_anomaly = np.zeros(n_steps, dtype=int)
    anomaly_type = np.full(n_steps, "normal", dtype=object)

    # Calculate how many anomaly windows we need
    target_anomaly_count = int(n_steps * ANOMALY_RATE_TARGET)
    injected = 0

    # Track used indices to avoid overlap
    used = np.zeros(n_steps, dtype=bool)

    # Type 1: Thermal runaway (gradual, 15-40 min windows)
    n_thermal = int(target_anomaly_count * 0.30)
    thermal_injected = 0
    attempts = 0
    while thermal_injected < n_thermal and attempts < 500:
        attempts += 1
        window_len = rng.integers(15, 41)
        start = rng.integers(100, n_steps - window_len - 10)
        if used[start:start + window_len].any():
            continue
        # Only inject during normal or high_load (realistic)
        if modes[start] not in ("normal", "high_load"):
            continue

        ramp = np.linspace(0, 1, window_len) ** 1.5  # Accelerating ramp
        magnitude = rng.uniform(15, 35)

        sensors["temperature_c"][start:start + window_len] += magnitude * ramp
        # Correlated: coolant also rises but lagged
        lag = min(5, window_len // 3)
        sensors["coolant_temp_c"][start + lag:start + window_len] += magnitude * 0.6 * ramp[:window_len - lag]
        # Oil viscosity drops as temperature rises
        sensors["oil_viscosity_cst"][start:start + window_len] -= magnitude * 0.3 * ramp
        # Power increases slightly
        sensors["power_consumption_kw"][start:start + window_len] += 2 * ramp

        is_anomaly[start:start + window_len] = 1
        anomaly_type[start:start + window_len] = "thermal_runaway"
        used[start:start + window_len] = True
        thermal_injected += window_len

    # Type 2: Bearing degradation (vibration spikes, 5-20 min)
    n_bearing = int(target_anomaly_count * 0.25)
    bearing_injected = 0
    attempts = 0
    while bearing_injected < n_bearing and attempts < 500:
        attempts += 1
        window_len = rng.integers(5, 21)
        start = rng.integers(100, n_steps - window_len - 10)
        if used[start:start + window_len].any():
            continue

        # Vibration increases with high-frequency noise
        vib_increase = rng.uniform(0.3, 0.8)
        noise_amp = rng.uniform(0.05, 0.15)
        sensors["vibration_mm_s"][start:start + window_len] += vib_increase + noise_amp * rng.standard_normal(window_len)
        # Acoustic level increases proportionally
        sensors["acoustic_level_db"][start:start + window_len] += 15 + 5 * rng.standard_normal(window_len)
        # Slight RPM fluctuation
        sensors["motor_rpm"][start:start + window_len] += rng.normal(0, 30, window_len)

        is_anomaly[start:start + window_len] = 1
        anomaly_type[start:start + window_len] = "bearing_degradation"
        used[start:start + window_len] = True
        bearing_injected += window_len

    # Type 3: Pressure leak (subtle, slow, 20-60 min)
    n_pressure = int(target_anomaly_count * 0.25)
    pressure_injected = 0
    attempts = 0
    while pressure_injected < n_pressure and attempts < 500:
        attempts += 1
        window_len = rng.integers(20, 61)
        start = rng.integers(100, n_steps - window_len - 10)
        if used[start:start + window_len].any():
            continue
        if modes[start] not in ("normal", "high_load"):
            continue

        ramp = np.linspace(0, 1, window_len)
        pressure_drop = rng.uniform(8, 25)

        sensors["pressure_kpa"][start:start + window_len] -= pressure_drop * ramp
        # Flow rate compensates (system tries to maintain)
        sensors["flow_rate_lpm"][start:start + window_len] += 3 * ramp
        # Power increases as pump works harder
        sensors["power_consumption_kw"][start:start + window_len] += 1.5 * ramp

        is_anomaly[start:start + window_len] = 1
        anomaly_type[start:start + window_len] = "pressure_leak"
        used[start:start + window_len] = True
        pressure_injected += window_len

    # Type 4: Sensor malfunction (erratic readings on ONE sensor - THIS IS A TRAP)
    # These look like anomalies but are just sensor failures, NOT equipment failures
    # A smart model should learn to distinguish these
    n_sensor_mal = int(target_anomaly_count * 0.20)
    sensor_mal_injected = 0
    attempts = 0
    while sensor_mal_injected < n_sensor_mal and attempts < 500:
        attempts += 1
        window_len = rng.integers(10, 30)
        start = rng.integers(100, n_steps - window_len - 10)
        if used[start:start + window_len].any():
            continue

        # Pick a random sensor to malfunction
        target_sensor = rng.choice([
            "temperature_c", "vibration_mm_s", "pressure_kpa", "motor_rpm"
        ])

        # Sensor gives erratic readings (not physically consistent)
        original = sensors[target_sensor][start:start + window_len].copy()
        noise_scale = np.std(sensors[target_sensor]) * rng.uniform(2, 5)

        # Random spikes and drops (uncorrelated with other sensors)
        erratic = original + noise_scale * rng.standard_normal(window_len)
        # Sometimes stuck at a value
        if rng.random() > 0.5:
            stuck_start = rng.integers(0, max(1, window_len // 2))
            stuck_len = rng.integers(3, min(10, window_len - stuck_start))
            erratic[stuck_start:stuck_start + stuck_len] = original[stuck_start]

        sensors[target_sensor][start:start + window_len] = erratic

        # Key distinction: OTHER correlated sensors remain normal!
        # This is how an agent should detect it's a sensor issue, not equipment
        is_anomaly[start:start + window_len] = 1
        anomaly_type[start:start + window_len] = "sensor_malfunction"
        used[start:start + window_len] = True
        sensor_mal_injected += window_len

    return is_anomaly, anomaly_type


def add_missing_values(df, rng):
    """Add realistic missing value patterns."""
    n = len(df)
    sensor_cols = [
        "temperature_c", "vibration_mm_s", "pressure_kpa", "motor_rpm",
        "flow_rate_lpm", "power_consumption_kw", "coolant_temp_c",
        "acoustic_level_db", "oil_viscosity_cst", "humidity_pct"
    ]

    # Random sporadic missing (~1-2% per sensor)
    for col in sensor_cols:
        mask = rng.random(n) < rng.uniform(0.008, 0.025)
        df.loc[mask, col] = np.nan

    # Block missing (simulating sensor outages, 5-15 min blocks)
    n_blocks = rng.integers(15, 30)
    for _ in range(n_blocks):
        block_sensor = rng.choice(sensor_cols)
        block_start = rng.integers(0, n - 20)
        block_len = rng.integers(5, 16)
        df.loc[block_start:block_start + block_len, block_sensor] = np.nan

    # Correlated missing: when one sensor drops, nearby sensors sometimes drop too
    for col in sensor_cols[:5]:
        missing_idx = df[df[col].isna()].index
        for idx in missing_idx:
            if rng.random() < 0.15:  # 15% chance of correlated dropout
                neighbor = rng.choice([c for c in sensor_cols if c != col])
                if idx in df.index:
                    df.loc[idx, neighbor] = np.nan

    return df


def add_concept_drift(sensors, n_steps, rng):
    """Add subtle concept drift — baseline shifts partway through."""
    drift_point = rng.integers(n_steps // 3, 2 * n_steps // 3)
    drift_ramp = np.zeros(n_steps)
    ramp_len = rng.integers(500, 1500)
    end_point = min(drift_point + ramp_len, n_steps)
    drift_ramp[drift_point:end_point] = np.linspace(0, 1, end_point - drift_point)
    drift_ramp[end_point:] = 1.0

    # Subtle baseline shift in temperature and pressure
    sensors["temperature_c"] += drift_ramp * rng.uniform(1.5, 3.5)
    sensors["pressure_kpa"] -= drift_ramp * rng.uniform(1.0, 3.0)

    return sensors


def generate_equipment_data(eq_id, profile, rng):
    """Generate complete data for one equipment unit."""
    n = READINGS_PER_EQUIPMENT

    # Timestamps
    timestamps = [START_DATE + timedelta(minutes=i) for i in range(n)]

    # Operating modes
    modes = generate_operating_mode_sequence(n, rng)

    # Base sensor data
    sensors = generate_base_sensor_data(n, profile, modes, rng)

    # Add concept drift
    sensors = add_concept_drift(sensors, n, rng)

    # Inject anomalies
    is_anomaly, anomaly_type = inject_anomalies(sensors, modes, n, rng)

    # Equipment metadata
    equipment_age_hours = np.arange(n) / 60 + rng.uniform(500, 5000)
    last_maintenance_hours = np.zeros(n)
    maintenance_interval = rng.integers(2000, 4000)
    last_maint = 0
    for i in range(n):
        if (i - last_maint) > maintenance_interval:
            last_maint = i
            maintenance_interval = rng.integers(2000, 4000)
        last_maintenance_hours[i] = (i - last_maint) / 60

    # Build dataframe
    data = {
        "timestamp": timestamps,
        "equipment_id": eq_id,
        "operating_mode": modes,
        **sensors,
        "equipment_age_hours": np.round(equipment_age_hours, 1),
        "hours_since_maintenance": np.round(last_maintenance_hours, 1),
        "is_anomaly": is_anomaly,
        "anomaly_type": anomaly_type,
    }

    return pd.DataFrame(data)


def add_leakage_features(df, rng):
    """
    Add features that look useful but contain target leakage.
    These should be identified and removed by a careful agent.
    """
    n = len(df)

    # Leakage 1: rolling_anomaly_rate — computed from future labels
    # This is a rolling mean of is_anomaly with centered window (uses future data)
    df["rolling_anomaly_rate"] = (
        df.groupby("equipment_id")["is_anomaly"]
        .transform(lambda x: x.rolling(60, center=True, min_periods=1).mean())
    )
    # Add small noise to disguise it
    df["rolling_anomaly_rate"] += rng.normal(0, 0.005, n)
    df["rolling_anomaly_rate"] = df["rolling_anomaly_rate"].clip(0, 1)

    # Leakage 2: maintenance_priority_score — assigned AFTER anomaly detected
    # Higher scores for rows that are actually anomalies (post-hoc label)
    df["maintenance_priority_score"] = rng.uniform(0, 30, n)
    anomaly_mask = df["is_anomaly"] == 1
    df.loc[anomaly_mask, "maintenance_priority_score"] += rng.uniform(20, 50, anomaly_mask.sum())

    # Leakage 3: alert_code — categorical that's derived from anomaly_type
    def map_alert(atype):
        if atype == "normal":
            return rng.choice(["NONE", "TEMP_WARN", "VIB_WARN"], p=[0.92, 0.04, 0.04])
        elif atype == "thermal_runaway":
            return rng.choice(["TEMP_WARN", "TEMP_CRIT"], p=[0.3, 0.7])
        elif atype == "bearing_degradation":
            return rng.choice(["VIB_WARN", "VIB_CRIT"], p=[0.4, 0.6])
        elif atype == "pressure_leak":
            return rng.choice(["PRESS_WARN", "PRESS_CRIT"], p=[0.5, 0.5])
        elif atype == "sensor_malfunction":
            return rng.choice(["SENSOR_ERR", "NONE"], p=[0.6, 0.4])
        return "NONE"

    df["alert_code"] = df["anomaly_type"].apply(map_alert)

    return df


def main():
    rng = np.random.default_rng(SEED)

    all_data = []
    for eq_id, profile in EQUIPMENT_PROFILES.items():
        print(f"Generating data for {eq_id}...")
        eq_rng = np.random.default_rng(rng.integers(0, 2**31))
        eq_data = generate_equipment_data(eq_id, profile, eq_rng)
        all_data.append(eq_data)

    df = pd.concat(all_data, ignore_index=True)

    # Sort by timestamp, then equipment_id
    df = df.sort_values(["timestamp", "equipment_id"]).reset_index(drop=True)

    # Add unique row IDs
    df.insert(0, "reading_id", [f"R{str(i).zfill(6)}" for i in range(len(df))])

    # Add leakage features (trap for naive agents)
    df = add_leakage_features(df, rng)

    # Add missing values
    df = add_missing_values(df, rng)

    # Print stats
    print(f"\nDataset shape: {df.shape}")
    print(f"Anomaly rate: {df['is_anomaly'].mean():.4f}")
    print(f"Anomaly type distribution:")
    print(df["anomaly_type"].value_counts())
    print(f"\nMissing values per column:")
    print(df.isnull().sum()[df.isnull().sum() > 0])

    # Save raw data
    df.to_csv("/home/claude/data.csv", index=False)
    print(f"\nSaved to /home/claude/data.csv")

    return df


if __name__ == "__main__":
    df = main()