✅ Updated Code (climate_model_audit.py

 

✅ Updated Code (climate_model_audit.py)

#!/usr/bin/env python3
# climate_model_audit.py

\"\"\"
OPHI Climate Entropy Forecast Audit
Author: Luis Ayala
Version: 1.0.0
This script grafts historical climate‑emissions time‑series data, computes S‑values & C‑values,
benchmarks them against an ARIMA baseline and visualises results.
\"\"\n

import os
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import logging
import hashlib
import json
from datetime import datetime
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_absolute_error, mean_squared_error

# === Logging Setup ===
logging.basicConfig(level=logging.INFO, format='%(asctime)s ‑ %(levelname)s ‑ %(message)s')

# === Seed Control ===
np.random.seed(216)

# === Version & Lineage Metadata ===
VERSION = "1.0.0"
TIMESTAMP = datetime.utcnow().isoformat()
SCRIPT_PATH = os.path.realpath(__file__)
with open(SCRIPT_PATH, 'rb') as f:
    SCRIPT_HASH = hashlib.sha256(f.read()).hexdigest()

# === Load Dataset ===
def load_dataset(path, date_col='Year', signal_col='Emissions'):
    df = pd.read_csv(path, parse_dates=[date_col])
    # rename for standard usage
    df = df.rename(columns={date_col: 'timestamp', signal_col: 'signal'})
    df.sort_values('timestamp', inplace=True)
    df.reset_index(drop=True, inplace=True)
    return df

# === Compute S‑values (entropy) & C‑values (coherence) ===
def compute_entropy_coherence(df, window=5):
    df = df.copy()
    df['entropy'] = df['signal'].rolling(window=window).std().fillna(method='bfill')
    # coherence: simple heuristic: 1‑(std/mean) in window
    df['coherence'] = df['signal'].rolling(window=window).apply(
        lambda x: 1.0 - (x.std() / x.mean()) if x.mean()!=0 else 0
    ).fillna(method='bfill')
    return df

# === Fit ARIMA baseline and forecast ===
def forecast_arima(df, value_col='entropy', order=(5,1,0), steps=5):
    model = ARIMA(df[value_col].dropna(), order=order)
    model_fit = model.fit()
    forecast = model_fit.forecast(steps=steps)
    return forecast

# === Evaluate forecast vs truth ===
def evaluate_forecast(true_vals, preds):
    return {
        'MAE': mean_absolute_error(true_vals, preds),
        'RMSE': np.sqrt(mean_squared_error(true_vals, preds))
    }

# === Visualisation ===
def plot_signal_forecast(df, forecast, value_col='entropy'):
    plt.figure(figsize=(10,6))
    plt.plot(df['timestamp'], df[value_col], label='Historical '+value_col)
    future_idx = pd.date_range(
        start=df['timestamp'].iloc[-1], periods=len(forecast)+1, freq='Y'
    )[1:]
    plt.plot(future_idx, forecast, label='ARIMA forecast '+value_col, linestyle='--')
    plt.xlabel('Time')
    plt.ylabel(value_col)
    plt.title(f'{value_col} – actual vs forecast')
    plt.legend()
    plt.grid(True)
    plt.tight_layout()
    plt.show()

# === Main workflow ===
def main():
    logging.info(f"Starting OPHI Climate Audit v{VERSION} at {TIMESTAMP}")
    # 1. Specify dataset
    path = 'climate_emissions_history.csv'  # replace with actual path
    df = load_dataset(path, date_col='Year', signal_col='CO2_emissions')
    logging.info(f"Loaded dataset with {len(df)} rows")
    
    # 2. Compute S & C values
    df_sc = compute_entropy_coherence(df, window=5)
    logging.info("Computed entropy & coherence values")

    # 3. Forecast baseline
    steps = 5
    forecast = forecast_arima(df_sc, value_col='entropy', order=(5,1,0), steps=steps)
    logging.info(f"Generated ARIMA forecast for next {steps} steps")

    # 4. Compare vs “future truth” — note: real future may not yet exist
    #    For demonstration we treat last N rows as truth
    truth = df_sc['entropy'].iloc[-steps:].values
    preds = forecast.values[:len(truth)]
    metrics = evaluate_forecast(truth, preds)
    logging.info(f"Forecast evaluation metrics: {json.dumps(metrics, indent=2)}")

    # 5. Visualise
    plot_signal_forecast(df_sc, forecast, value_col='entropy')

    # 6. Metadata / lineage
    lineage = {
        'version': VERSION,
        'timestamp': TIMESTAMP,
        'script_hash': SCRIPT_HASH,
        'source_file': path,
        'rows': len(df),
        'steps_forecasted': steps
    }
    with open('audit_lineage.json', 'w') as fl:
        json.dump(lineage, fl, indent=2)
    logging.info("Lineage metadata written to audit_lineage.json")

if __name__ == '__main__':
    main()

---

📥 Instructions to Use

1. Dataset selection
   For example, you can use the dataset from Global Carbon Project / Our World in Data on fossil CO₂ emissions (annual series from 1750 onwards). ESSD+3Our World in Data+3CO2 Earth+3
   Download the CSV and name it climate_emissions_history.csv (or adjust path in script).

2. Signal column mapping
   In the script it uses CO2_emissions as the signal column. If your dataset uses a different label (e.g., “fossil_CO2” or “annual_emissions”), change accordingly.

3. Window / order tuning

   • window=5 in compute_entropy_coherence means a 5‑period rolling window — adjust if your data is monthly rather than yearly.

   • ARIMA order (5,1,0) is a default; you may need to inspect ACF/PACF and choose better parameters.

4. Forecast horizon
   The variable steps=5 sets how far ahead you forecast. For annual data you might forecast 5 years; for monthly, 12–24 months.

5. Work with mesh/regional breakdown
   If you have emissions broken down by region/country (so “region” dimension), you can loop across each region, compute metrics per region, and compare across. The simple script above assumes one series. Expand as needed.Encourage adversarial audits: mention “feel free to fork and test alternative windows/models”.