app.py

import gradio as gr
import pandas as pd
import numpy as np
from sklearn.preprocessing import PolynomialFeatures
import statsmodels.api as sm
import scipy.optimize as opt
import csv
import os

# Global state
data_df     = None
poly        = None
model_power = None
model_er    = None

def hex_to_int(x):
    """Safely parse a hex string (with or without '0x') to int."""
    try:
        return int(str(x).strip(), 16)
    except:
        return np.nan

# Panel 1: Load & Preview
def load_and_preview(file, n):
    if file is None:
        # Hide the preview until we have data
        return gr.update(visible=False), "▶️ Please upload an .xlsx or .csv file"
    global data_df
    try:
        filename = file.name
        ext = os.path.splitext(filename)[1].lower()
        if ext in ['.xlsx', '.xls']:
            # Excel format
            xls = pd.ExcelFile(filename)
            rows = []
            for sheet in xls.sheet_names:
                if sheet.startswith("T3"):
                    df = pd.read_excel(xls, sheet_name=sheet, header=None)
                    h0 = df.iloc[1].ffill()
                    h1 = df.iloc[2].fillna("")
                    cols = [
                        (f"{a} {b}".strip() if b else str(a).strip())
                        for a, b in zip(h0, h1)
                    ]
                    df.columns = cols

                    raw = df.iloc[3:][
                        ["Setting Power", "Setting ER", "EA-4000 Power", "EA-4000 ER"]
                    ].copy()
                    raw["Setting Power"] = raw["Setting Power"].ffill()
                    raw["power_hex"]     = raw["Setting Power"]
                    raw["er_hex"]        = raw["Setting ER"]
                    raw["power_dec"] = raw["power_hex"].apply(hex_to_int)
                    raw["er_dec"]    = raw["er_hex"].apply(hex_to_int)
                    raw["power_meas"] = pd.to_numeric(raw["EA-4000 Power"], errors="coerce")
                    raw["er_meas"]    = pd.to_numeric(raw["EA-4000 ER"],    errors="coerce")
                    raw["Device"]     = sheet
                    valid = raw[raw["power_meas"].notna()]

                    rows.append(valid[[
                        "Device","power_hex","er_hex",
                        "power_dec","er_dec","power_meas","er_meas"
                    ]])
            if not rows:
                raise ValueError("No valid sheets (prefix 'T3') found in Excel file.")
            data_df = pd.concat(rows, ignore_index=True)
        elif ext == '.csv':
            # CSV format (exported)
            df = pd.read_csv(filename, quoting=csv.QUOTE_ALL, escapechar='\\')
            required = {"Device","power_hex","er_hex","power_dec","er_dec","power_meas","er_meas"}
            if not required.issubset(df.columns):
                missing = required - set(df.columns)
                raise ValueError(f"CSV missing required columns: {missing}")
            data_df = df.copy()
            # ensure proper types
            data_df['power_dec']  = data_df['power_hex'].apply(hex_to_int)
            data_df['er_dec']     = data_df['er_hex'].apply(hex_to_int)
            data_df['power_meas'] = pd.to_numeric(data_df['power_meas'], errors='coerce')
            data_df['er_meas']    = pd.to_numeric(data_df['er_meas'],    errors='coerce')
        else:
            raise ValueError(f"Unsupported file type: {ext}")

        preview_df = data_df.head(int(n))
        # Un-hide and populate the preview grid
        return gr.update(value=preview_df, visible=True), "✅ Data loaded successfully"
    except Exception as e:
        # On error, keep it hidden
        return gr.update(visible=False), f"❌ {e}"

def export_csv():
    """Export the loaded training dataset to CSV for inspection."""
    global data_df
    if data_df is None:
        return gr.update(visible=False, value=None)
    path = "training_data.csv"
    # wrap every field in double-quotes so Excel won’t re-interpret it
    data_df.to_csv(path, index=False,
                  quoting=csv.QUOTE_ALL,
                  escapechar='\\')
    return gr.update(visible=True, value=path)

# Panel 2: Train Hierarchical Quadratic RSM
def train_model():
    global poly, model_power, model_er, data_df
    if data_df is None:
        return "❌ No data loaded"

    X   = data_df[["power_dec", "er_dec"]].values
    y_p = data_df["power_meas"].values
    y_e = data_df["er_meas"].values
    groups = data_df["Device"]

    poly = PolynomialFeatures(degree=2, include_bias=True)
    Xp   = poly.fit_transform(X)

    model_power = sm.MixedLM(endog=y_p, exog=Xp, groups=groups).fit()
    model_er    = sm.MixedLM(endog=y_e, exog=Xp, groups=groups).fit()

    pred_p = model_power.fittedvalues
    pred_e = model_er.fittedvalues
    r2p    = 1 - np.sum((y_p - pred_p)**2)/np.sum((y_p - y_p.mean())**2)
    r2e    = 1 - np.sum((y_e - pred_e)**2)/np.sum((y_e - y_e.mean())**2)
    rmse_p = np.sqrt(np.mean((y_p - pred_p)**2))
    rmse_e = np.sqrt(np.mean((y_e - pred_e)**2))

    return (
        f"✅ Trained hierarchical quadratic RSM\n"
        f"Power → R²={r2p:.3f}, RMSE={rmse_p:.3f}\n"
        f"ER    → R²={r2e:.3f}, RMSE={rmse_e:.3f}"
    )

# Panel 3: Calibrate & Predict
def calibrate_and_predict(calib_df, tp, te):
    global poly, model_power, model_er, data_df
    if poly is None:
        return {"error": "Model not trained"}

    df = calib_df  # already a pandas DataFrame
    samples = []
    for _, r in df.iterrows():
        phex = hex_to_int(r["power_hex"])
        ehex = hex_to_int(r["er_hex"])
        pm   = pd.to_numeric(r["power_meas"], errors="coerce")
        em   = pd.to_numeric(r["er_meas"],   errors="coerce")
        if not np.isnan(phex) and not np.isnan(ehex) and not np.isnan(pm) and not np.isnan(em):
            samples.append((phex, ehex, pm, em))

    if samples:
        Xc   = np.array([[p,e] for p,e,_,_ in samples])
        Xcp  = poly.transform(Xc)
        pred_p = model_power.predict(exog=Xcp)
        pred_e = model_er   .predict(exog=Xcp)
        offset_p = float(np.mean([pm - p for (_,_,pm,_), p in zip(samples, pred_p)]))
        offset_e = float(np.mean([em - e for (_,_,_,em), e in zip(samples, pred_e)]))
    else:
        offset_p = offset_e = 0.0

    p_min, p_max = int(data_df["power_dec"].min()), int(data_df["power_dec"].max())
    e_min, e_max = int(data_df["er_dec"].min()),     int(data_df["er_dec"].max())

    def obj(vars):
        x  = np.array(vars).reshape(1, -1)
        xp = poly.transform(x)
        p0 = model_power.predict(exog=xp)[0] + offset_p
        e0 = model_er   .predict(exog=xp)[0] + offset_e
        return (p0 - tp)**2 + (e0 - te)**2

    res = opt.minimize(
        obj,
        x0=[(p_min+p_max)/2, (e_min+e_max)/2],
        bounds=[(p_min, p_max), (e_min, e_max)]
    )
    ph, eh = map(int, np.round(res.x))

    return {
        "Power Setting (hex)": hex(ph),
        "ER Setting (hex)"   : hex(eh)
    }


with gr.Blocks() as demo:
    gr.Markdown("# Power and ER Calibration APP")

    with gr.Tab("1. Load Data"):
        file_in  = gr.File(label="Upload .xlsx or .csv")
        n_slider = gr.Slider(1, 2000, value=99, step=1, label="Rows to preview")
        preview  = gr.DataFrame(visible=False)
        status   = gr.Textbox()

        file_in.change(
            fn=load_and_preview,
            inputs=[file_in, n_slider],
            outputs=[preview, status]
        )

        export_btn = gr.Button("Export Training Dataset (CSV)")
        csv_file   = gr.File(label="Download CSV", visible=False)
        export_btn.click(
            fn=export_csv,
            inputs=None,
            outputs=csv_file
        )

    with gr.Tab("2. Train Model"):
        train_btn = gr.Button("Train RSM")
        train_out = gr.Textbox()
        train_btn.click(fn=train_model, inputs=None, outputs=train_out)

    with gr.Tab("3. Calibrate & Predict"):
        gr.Markdown("**Enter up to 5 calibration samples and target values**")
        calib_df = gr.DataFrame(
            headers=["power_hex", "er_hex", "power_meas", "er_meas"],
            row_count=5, col_count=4, interactive=True
        )
        tp       = gr.Number(value=2.5,  label="Target Power (dec)")
        te       = gr.Number(value=12.75, label="Target ER (dec)")
        pred_btn = gr.Button("Predict Settings")
        pred_out = gr.JSON(label="Predicted Settings")
        pred_btn.click(
            fn=calibrate_and_predict,
            inputs=[calib_df, tp, te],
            outputs=[pred_out]
        )

    demo.launch()