Enhance Gradio app with integrated threshold diagnosis, trend detection, and anomaly analysis features. Added file loading functionality, improved data processing, and refined UI components for better user experience.

app.py

@@ -1,12 +1,21 @@
-# 統合版 Gradio アプリ (Tab1=閾値診断, Tab2=傾向検出, Tab3=予兆解析)
+# 統合版 Gradio アプリ (閾値診断 + 傾向検出 + 予兆解析)
 import gradio as gr
 import pandas as pd
 import numpy as np
-from sklearn.linear_model import LinearRegression
 import json
 import os
+from sklearn.linear_model import LinearRegression
+
+# --- 共通ユーティリティ ---
+def convert_value(v):
+    if hasattr(v, "item"):
+        return v.item()
+    if isinstance(v, (np.integer, int)):
+        return int(v)
+    if isinstance(v, (np.floating, float)):
+        return float(v)
+    return v
 
-# ========= 共通ユーティリティ =========
 def normalize(s):
     return str(s).replace("\u3000", " ").replace("\n", "").replace("\r", "").strip()
 
@@ -21,255 +30,315 @@ def find_matching_column(df, col_id, item_name, process_name):
     ]
     return candidates[0] if candidates else None
 
-# ========= 閾値診断 =========
-def diagnose_process_range(csv_file, excel_file, process_name, datetime_str, window_minutes):
+# --- グローバル変数（全タブで共有） ---
+df = None
+thresholds_df = None
+lag_matrix = None
+
+# --- ファイル読み込み ---
+def load_files(csv_file, excel_file, lag_file):
+    global df, thresholds_df, lag_matrix
     try:
-        df = pd.read_csv(csv_file.name, header=[0,1,2])
-        ts = df.iloc[:,0]
+        df = pd.read_csv(csv_file.name, header=[0, 1, 2])
+        timestamp_col = pd.to_datetime(df.iloc[:, 0], errors="coerce")
         df = df.drop(df.columns[0], axis=1)
-        df.insert(0,"timestamp", pd.to_datetime(ts, errors="coerce"))
+        df.insert(0, "timestamp", timestamp_col)
+
+        # MultiIndex → 文字列化
+        def col_to_str(col):
+            return "_".join([str(c) for c in col if c]) if isinstance(col, tuple) else str(col)
+
+        df.columns = [
+            "timestamp" if (isinstance(c, str) and c == "timestamp") else col_to_str(c)
+            for c in df.columns
+        ]
 
         thresholds_df = pd.read_excel(excel_file.name)
-        thresholds_df["Important"] = thresholds_df["Important"].astype(str).str.upper().map({"TRUE":True,"FALSE":False})
-        for col in ["LL","L","H","HH"]:
+        thresholds_df["Important"] = thresholds_df["Important"].astype(str).str.upper().map({"TRUE": True, "FALSE": False})
+        for col in ["LL", "L", "H", "HH"]:
             if col in thresholds_df.columns:
                 thresholds_df[col] = pd.to_numeric(thresholds_df[col], errors="coerce")
+
+        lag_matrix = pd.read_excel(lag_file.name, index_col=0)
+
+        return "✅ ファイル読み込み成功"
     except Exception as e:
-        return None,None,None,f"❌ 入力エラー: {e}",None
+        return f"❌ ファイル読み込み失敗: {e}"
+
+# --- Tab1: 閾値診断 ---
+def judge_status(value, ll, l, h, hh):
+    if pd.notna(ll) and value < ll:
+        return "LOW-LOW"
+    elif pd.notna(l) and value < l:
+        return "LOW"
+    elif pd.notna(hh) and value > hh:
+        return "HIGH-HIGH"
+    elif pd.notna(h) and value > h:
+        return "HIGH"
+    else:
+        return "OK"
 
+def diagnose_process_range(process_name, datetime_str, window_minutes):
+    global df, thresholds_df
+    if df is None or thresholds_df is None:
+        return None, None, None, "⚠ ファイル未読み込み", None
     try:
         target_time = pd.to_datetime(datetime_str)
-    except:
-        return None,None,None,f"⚠ 無効な日時 {datetime_str}",None
+    except Exception:
+        return None, None, None, "⚠ 日時が不正です", None
 
     start_time = target_time - pd.Timedelta(minutes=window_minutes)
-    df_window = df[(df["timestamp"]>=start_time)&(df["timestamp"]<=target_time)]
+    df_window = df[(df["timestamp"] >= start_time) & (df["timestamp"] <= target_time)]
     if df_window.empty:
-        return None,None,None,"⚠ 指定範囲にデータなし",None
+        return None, None, None, "⚠ 指定範囲にデータなし", None
 
-    proc_thresholds = thresholds_df[thresholds_df["ProcessNo_ProcessName"]==process_name]
+    proc_thresholds = thresholds_df[thresholds_df["ProcessNo_ProcessName"] == process_name]
     if proc_thresholds.empty:
-        return None,None,None,f"⚠ {process_name} の閾値なし",None
-
-    all_results=[]
-    for _,row in df_window.iterrows():
-        for _,thr in proc_thresholds.iterrows():
-            col_tuple=(thr["ColumnID"],thr["ItemName"],thr["ProcessNo_ProcessName"])
-            if col_tuple not in df.columns: continue
-            value=row[col_tuple]
-            status="OK"
-            if pd.notna(thr.get("LL")) and value<thr["LL"]: status="LOW-LOW"
-            elif pd.notna(thr.get("L")) and value<thr["L"]: status="LOW"
-            elif pd.notna(thr.get("HH")) and value>thr["HH"]: status="HIGH-HIGH"
-            elif pd.notna(thr.get("H")) and value>thr["H"]: status="HIGH"
+        return None, None, None, f"⚠ {process_name} の閾値なし", None
+
+    all_results = []
+    for _, row in df_window.iterrows():
+        for _, thr in proc_thresholds.iterrows():
+            col_tuple = f"{thr['ColumnID']}_{thr['ItemName']}_{thr['ProcessNo_ProcessName']}"
+            if col_tuple not in df.columns:
+                continue
+            value = row[col_tuple]
+            status = judge_status(value, thr.get("LL"), thr.get("L"), thr.get("H"), thr.get("HH"))
             all_results.append({
-                "ItemName":thr["ItemName"],"判定":status,
-                "重要項目":bool(thr.get("Important",False))
+                "ItemName": thr["ItemName"],
+                "判定": status,
+                "重要項目": bool(thr.get("Important", False)),
+                "時刻": str(row["timestamp"])
             })
 
-    # 集計
-    total=len(all_results)
-    status_counts=pd.Series([r["判定"] for r in all_results]).value_counts().reindex(["LOW-LOW","LOW","OK","HIGH","HIGH-HIGH"],fill_value=0)
-    ratio=(status_counts/total*100).round(1)
-    result_df_all=pd.DataFrame({"状態":status_counts.index,"件数":status_counts.values,"割合(%)":ratio.values})
-
-    imp=[r for r in all_results if r["重要項目"]]
-    if imp:
-        total_imp=len(imp)
-        c=pd.Series([r["判定"] for r in imp]).value_counts().reindex(["LOW-LOW","LOW","OK","HIGH","HIGH-HIGH"],fill_value=0)
-        ratio_imp=(c/total_imp*100).round(1)
-        result_df_imp=pd.DataFrame({"状態":c.index,"件数":c.values,"割合(%)":ratio_imp.values})
-    else:
-        result_df_imp=pd.DataFrame(columns=["状態","件数","割合(%)"])
-        ratio_imp=pd.Series(dtype=float)
-
-    per_item=[]
-    for item in [r["ItemName"] for r in imp]:
-        item_results=[r for r in imp if r["ItemName"]==item]
-        c=pd.Series([r["判定"] for r in item_results]).value_counts().reindex(["LOW-LOW","LOW","OK","HIGH","HIGH-HIGH"],fill_value=0)
-        ratio_item=(c/len(item_results)*100).round(1)
-        for s,v,r in zip(c.index,c.values,ratio_item.values):
-            per_item.append({"ItemName":item,"状態":s,"件数":v,"割合(%)":r})
-    result_df_imp_items=pd.DataFrame(per_item)
-
-    summary=f"✅ {process_name} の診断完了\n[全項目] "+ " / ".join([f"{s}:{r:.1f}%" for s,r in ratio.items()]) +"\n[重要項目全体] "+(" / ".join([f"{s}:{r:.1f}%" for s,r in ratio_imp.items()]) if not result_df_imp.empty else "対象なし")
-
-    json_data={"集計結果":{"全項目割合":ratio.to_dict(),"重要項目全体割合":ratio_imp.to_dict(),"重要項目ごと割合":per_item}}
-    result_json=json.dumps(json_data, ensure_ascii=False, indent=2)
-
-    return result_df_all,result_df_imp,result_df_imp_items,summary,result_json
-
-# ========= 傾向検出 =========
-def detect_trends_with_forecast(csv_file, excel_file, process_name, datetime_str, window_minutes, forecast_minutes):
-    try:
-        df = pd.read_csv(csv_file.name, header=[0,1,2])
-        ts=df.iloc[:,0]; df=df.drop(df.columns[0],axis=1); df.insert(0,"timestamp",pd.to_datetime(ts,errors="coerce"))
-        thresholds_df=pd.read_excel(excel_file.name)
-        thresholds_df["Important"]=thresholds_df["Important"].astype(str).str.upper().map({"TRUE":True,"FALSE":False})
-        for col in ["LL","L","H","HH"]:
-            if col in thresholds_df.columns: thresholds_df[col]=pd.to_numeric(thresholds_df[col], errors="coerce")
-    except Exception as e:
-        return None,f"❌ 入力エラー: {e}",None
-
-    target_time=pd.to_datetime(datetime_str)
-    start_time=target_time-pd.Timedelta(minutes=window_minutes)
-    df_window=df[(df["timestamp"]>=start_time)&(df["timestamp"]<=target_time)]
-    if df_window.empty: return None,"⚠ データなし",None
-
-    interval=df_window["timestamp"].diff().median()
-    if pd.isna(interval): return None,"⚠ サンプリング間隔不明",None
-    interval_minutes=interval.total_seconds()/60
-
-    proc_thresholds=thresholds_df[(thresholds_df["ProcessNo_ProcessName"]==process_name)&(thresholds_df["Important"]==True)]
-    if proc_thresholds.empty: return None,f"⚠ {process_name} の重要項目なし",None
-
-    results=[]
-    for _,thr in proc_thresholds.iterrows():
-        col=(thr["ColumnID"],thr["ItemName"],thr["ProcessNo_ProcessName"])
-        if col not in df.columns: continue
-        series=df_window[col].dropna()
-        if len(series)<3: continue
-
-        x=np.arange(len(series)).reshape(-1,1); y=series.values.reshape(-1,1)
-        model=LinearRegression().fit(x,y); slope=model.coef_[0][0]
-        last_val=series.iloc[-1]
-        forecast_steps=int(forecast_minutes/interval_minutes)
-        forecast_val=model.predict([[len(series)+forecast_steps]])[0][0]
-        forecast_time=target_time+pd.Timedelta(minutes=forecast_minutes)
-
-        status="安定"
-        if slope<0 and pd.notna(thr.get("LL")):
-            if last_val>thr["LL"]: status="LL接近下降傾向"
-            elif last_val<=thr["LL"]: status="LL逸脱下降傾向"
-        if slope>0 and pd.notna(thr.get("HH")):
-            if last_val<thr["HH"]: status="HH接近上昇傾向"
-            elif last_val>=thr["HH"]: status="HH逸脱上昇傾向"
-
-        forecast_status="安定"
-        if pd.notna(thr.get("LL")) and forecast_val<=thr["LL"]: forecast_status="LL逸脱予測"
-        elif pd.notna(thr.get("HH")) and forecast_val>=thr["HH"]: forecast_status="HH逸脱予測"
-
-        results.append({"ItemName":thr["ItemName"],"傾向":status,"傾き":round(slope,4),
-                        "最終値":round(float(last_val),3),"予測値":round(float(forecast_val),3),
-                        "予測時刻":str(forecast_time),"予測傾向":forecast_status})
-    result_df=pd.DataFrame(results)
-    return result_df,"✅ 傾向検出＋未来予測完了",json.dumps(results, ensure_ascii=False, indent=2)
-
-# ========= 予兆解析 =========
-def forecast_process_with_lag(csv_file, excel_file, lag_excel_file, process_name, datetime_str, forecast_minutes):
-    try:
-        df=pd.read_csv(csv_file.name, header=[0,1,2])
-        ts=df.iloc[:,0]; df=df.drop(df.columns[0],axis=1); df.insert(0,"timestamp",pd.to_datetime(ts,errors="coerce"))
-        df.columns=["timestamp" if (isinstance(c,str) and c=="timestamp") else "_".join([str(x) for x in c if x]) for c in df.columns]
-
-        thresholds_df=pd.read_excel(excel_file.name)
-        thresholds_df["Important"]=thresholds_df["Important"].astype(str).str.upper().map({"TRUE":True,"FALSE":False})
-        for col in ["LL","L","H","HH"]:
-            if col in thresholds_df.columns: thresholds_df[col]=pd.to_numeric(thresholds_df[col], errors="coerce")
-
-        lag_matrix=pd.read_excel(lag_excel_file.name, index_col=0)
-    except Exception as e:
-        return None,f"❌ 入力エラー: {e}",None
-
-    target_time=pd.to_datetime(datetime_str)
-    forecast_time=target_time+pd.Timedelta(minutes=forecast_minutes)
-
-    proc_thresholds=thresholds_df[(thresholds_df["ProcessNo_ProcessName"]==process_name)&(thresholds_df["Important"]==True)]
-    if proc_thresholds.empty: return None,f"⚠ {process_name} に重要項目なし",None
-    if process_name not in lag_matrix.index: return None,f"⚠ ラグ表に {process_name} の行なし",None
+    total = len(all_results)
+    status_counts = pd.Series([r["判定"] for r in all_results]).value_counts().reindex(
+        ["LOW-LOW", "LOW", "OK", "HIGH", "HIGH-HIGH"], fill_value=0)
+    status_ratio = (status_counts / total * 100).round(1)
 
-    lag_row=lag_matrix.loc[process_name].dropna(); lag_row=lag_row[lag_row>0]
-    if lag_row.empty: return None,f"⚠ 正のラグなし",None
+    result_df_all = pd.DataFrame({"状態": status_counts.index, "件数": status_counts.values, "割合(%)": status_ratio.values})
 
-    results=[]
-    for _,thr in proc_thresholds.iterrows():
-        y_col=find_matching_column(df,thr["ColumnID"],thr["ItemName"],thr["ProcessNo_ProcessName"])
-        if y_col is None: continue
-
-        df_window=df[df["timestamp"]<=target_time].copy()
-        df_window=df_window[df_window["timestamp"]>=target_time-pd.Timedelta(hours=24)]
-        if df_window.empty: continue
+    important_results = [r for r in all_results if r["重要項目"]]
+    if important_results:
+        total_imp = len(important_results)
+        status_counts_imp = pd.Series([r["判定"] for r in important_results]).value_counts().reindex(
+            ["LOW-LOW", "LOW", "OK", "HIGH", "HIGH-HIGH"], fill_value=0)
+        status_ratio_imp = (status_counts_imp / total_imp * 100).round(1)
+        result_df_imp = pd.DataFrame({"状態": status_counts_imp.index, "件数": status_counts_imp.values, "割合(%)": status_ratio_imp.values})
+    else:
+        result_df_imp = pd.DataFrame(columns=["状態", "件数", "割合(%)"])
+        status_ratio_imp = pd.Series(dtype=float)
+
+    result_json = json.dumps({
+        "集計結果": {
+            "全項目割合": {k: convert_value(v) for k, v in status_ratio.to_dict().items()},
+            "重要項目全体割合": {k: convert_value(v) for k, v in status_ratio_imp.to_dict().items()} if not result_df_imp.empty else {}
+        }
+    }, ensure_ascii=False, indent=2)
+
+    summary = f"✅ {process_name} の診断完了（{start_time} ～ {target_time}）"
+    return result_df_all, result_df_imp, None, summary, result_json
+
+# --- Tab2: 傾向検出 ---
+def detect_trends_with_forecast(process_name, datetime_str, window_minutes, forecast_minutes):
+    global df, thresholds_df
+    if df is None or thresholds_df is None:
+        return None, "⚠ ファイル未読み込み", None
+    target_time = pd.to_datetime(datetime_str)
+    start_time = target_time - pd.Timedelta(minutes=window_minutes)
+    df_window = df[(df["timestamp"] >= start_time) & (df["timestamp"] <= target_time)]
+    if df_window.empty:
+        return None, "⚠ データなし", None
 
-        try: base_df=df_window[["timestamp",y_col]].rename(columns={y_col:"y"})
-        except: continue
+    interval = df_window["timestamp"].diff().median()
+    if pd.isna(interval):
+        return None, "⚠ サンプリング間隔検出失敗", None
+    interval_minutes = interval.total_seconds() / 60
 
-        merged_df=base_df.copy()
-        for up_proc,lag_min in lag_row.items():
-            up_cols=[c for c in df.columns if isinstance(c,str) and up_proc in c]
+    proc_thresholds = thresholds_df[(thresholds_df["ProcessNo_ProcessName"] == process_name) & (thresholds_df["Important"] == True)]
+    if proc_thresholds.empty:
+        return None, f"⚠ {process_name} の重要項目なし", None
+
+    results = []
+    for _, thr in proc_thresholds.iterrows():
+        col_tuple = f"{thr['ColumnID']}_{thr['ItemName']}_{thr['ProcessNo_ProcessName']}"
+        if col_tuple not in df.columns:
+            continue
+        series = df_window[col_tuple].dropna()
+        if len(series) < 3:
+            continue
+        x = np.arange(len(series)).reshape(-1, 1)
+        y = series.values.reshape(-1, 1)
+        model = LinearRegression().fit(x, y)
+        slope = model.coef_[0][0]
+        last_val = series.iloc[-1]
+
+        forecast_steps = int(forecast_minutes / interval_minutes)
+        forecast_val = model.predict([[len(series) + forecast_steps]])[0][0]
+        forecast_time = target_time + pd.Timedelta(minutes=forecast_minutes)
+
+        risk = "安定"
+        if pd.notna(thr.get("LL")) and forecast_val <= thr["LL"]:
+            risk = "LL逸脱予測"
+        elif pd.notna(thr.get("HH")) and forecast_val >= thr["HH"]:
+            risk = "HH逸脱予測"
+
+        results.append({
+            "ItemName": thr["ItemName"],
+            "傾き": round(float(slope), 4),
+            "最終値": round(float(last_val), 3),
+            "予測値": round(float(forecast_val), 3),
+            "予測時刻": str(forecast_time),
+            "予測リスク": risk
+        })
+
+    result_df = pd.DataFrame(results)
+    result_json = json.dumps(results, ensure_ascii=False, indent=2)
+    return result_df, "✅ 傾向検出完了", result_json
+
+# --- Tab3: 予兆解析 ---
+def forecast_process_with_lag(process_name, datetime_str, forecast_minutes):
+    global df, thresholds_df, lag_matrix
+    if df is None or thresholds_df is None or lag_matrix is None:
+        return None, "⚠ ファイル未読み込み", None
+    target_time = pd.to_datetime(datetime_str)
+    forecast_time = target_time + pd.Timedelta(minutes=forecast_minutes)
+
+    proc_thresholds = thresholds_df[(thresholds_df["ProcessNo_ProcessName"] == process_name) & (thresholds_df["Important"] == True)]
+    if proc_thresholds.empty:
+        return None, f"⚠ {process_name} の重要項目なし", None
+
+    if process_name not in lag_matrix.index:
+        return None, f"⚠ {process_name} のラグ行なし", None
+
+    lag_row = lag_matrix.loc[process_name].dropna()
+    lag_row = lag_row[lag_row > 0]
+    if lag_row.empty:
+        return None, f"⚠ {process_name} に正のラグなし", None
+
+    results = []
+    for _, thr in proc_thresholds.iterrows():
+        y_col = find_matching_column(df, thr["ColumnID"], thr["ItemName"], thr["ProcessNo_ProcessName"])
+        if y_col is None:
+            continue
+        df_window = df[df["timestamp"] <= target_time].copy()
+        df_window = df_window[df_window["timestamp"] >= target_time - pd.Timedelta(hours=24)]
+        if df_window.empty:
+            continue
+        base_df = df_window[["timestamp", y_col]].rename(columns={y_col: "y"})
+        merged_df = base_df.copy()
+        for up_proc, lag_min in lag_row.items():
+            up_cols = [c for c in df.columns if isinstance(c, str) and up_proc in c]
             for x_col in up_cols:
-                try:
-                    shifted=df_window.loc[:,["timestamp",x_col]].copy()
-                    shifted["timestamp"]=shifted["timestamp"]+pd.Timedelta(minutes=lag_min)
-                    shifted=shifted.rename(columns={x_col:f"{x_col}_lag{lag_min}"})
-                    merged_df=pd.merge_asof(merged_df.sort_values("timestamp"), shifted.sort_values("timestamp"), on="timestamp", direction="nearest")
-                except: continue
-
-        X_all=merged_df.drop(columns=["timestamp","y"], errors="ignore").values
-        Y_all=merged_df["y"].values
-        if X_all.shape[1]==0 or len(Y_all)<5: continue
-
-        model=LinearRegression().fit(X_all,Y_all)
-        X_pred=[]
-        for up_proc,lag_min in lag_row.items():
-            up_cols=[c for c in df.columns if isinstance(c,str) and up_proc in c]
+                shifted = df_window.loc[:, ["timestamp", x_col]].copy()
+                shifted["timestamp"] = shifted["timestamp"] + pd.Timedelta(minutes=lag_min)
+                shifted = shifted.rename(columns={x_col: f"{x_col}_lag{lag_min}"})
+                merged_df = pd.merge_asof(
+                    merged_df.sort_values("timestamp"),
+                    shifted.sort_values("timestamp"),
+                    on="timestamp",
+                    direction="nearest"
+                )
+        X_all = merged_df.drop(columns=["timestamp", "y"], errors="ignore").values
+        Y_all = merged_df["y"].values
+        if X_all.shape[1] == 0 or len(Y_all) < 5:
+            continue
+        model = LinearRegression().fit(X_all, Y_all)
+
+        X_pred = []
+        for up_proc, lag_min in lag_row.items():
+            up_cols = [c for c in df.columns if isinstance(c, str) and up_proc in c]
             for x_col in up_cols:
-                try:
-                    ref_time=forecast_time-pd.Timedelta(minutes=lag_min)
-                    idx=(df["timestamp"]-ref_time).abs().idxmin()
-                    X_pred.append(df.loc[idx,x_col])
-                except: continue
-        if not X_pred: continue
-
-        pred_val=model.predict([X_pred])[0]
-        ll,l,h,hh=thr.get("LL"),thr.get("L"),thr.get("H"),thr.get("HH")
-        risk="OK"
-        if pd.notna(ll) and pred_val<=ll: risk="LOW-LOW"
-        elif pd.notna(l) and pred_val<=l: risk="LOW"
-        elif pd.notna(hh) and pred_val>=hh: risk="HIGH-HIGH"
-        elif pd.notna(h) and pred_val>=h: risk="HIGH"
-
-        results.append({"ItemName":thr["ItemName"],"予測値":round(float(pred_val),3),
-                        "予測時刻":str(forecast_time),"予測リスク":risk,
-                        "使用上流工程数":len(lag_row)})
-    result_df=pd.DataFrame(results)
-    return result_df,f"✅ {process_name} の予兆解析完了",json.dumps(results, ensure_ascii=False, indent=2)
-
-# ========= Gradio UI =========
-with gr.Blocks(css="body {overflow-y: scroll;}") as demo:
-    gr.Markdown("## 統合アプリ (閾値診断 + 傾向検出 + 予兆解析)")
+                ref_time = forecast_time - pd.Timedelta(minutes=lag_min)
+                idx = (df["timestamp"] - ref_time).abs().idxmin()
+                X_pred.append(df.loc[idx, x_col])
+        if not X_pred:
+            continue
+
+        pred_val = model.predict([X_pred])[0]
+
+        risk = "OK"
+        if pd.notna(thr.get("LL")) and pred_val <= thr["LL"]:
+            risk = "LOW-LOW"
+        elif pd.notna(thr.get("L")) and pred_val <= thr["L"]:
+            risk = "LOW"
+        elif pd.notna(thr.get("HH")) and pred_val >= thr["HH"]:
+            risk = "HIGH-HIGH"
+        elif pd.notna(thr.get("H")) and pred_val >= thr["H"]:
+            risk = "HIGH"
+
+        results.append({
+            "ItemName": thr["ItemName"],
+            "予測値": round(float(pred_val), 3),
+            "予測時刻": str(forecast_time),
+            "予測リスク": risk
+        })
+
+    result_df = pd.DataFrame(results)
+    result_json = json.dumps(results, ensure_ascii=False, indent=2)
+    return result_df, f"✅ {process_name} の予兆解析完了", result_json
+
+# --- Gradio UI ---
+with gr.Blocks(css=".gradio-container {overflow: auto !important;}") as demo:
+    gr.Markdown("## 統合トレンド解析アプリ (MCP対応)")
 
     with gr.Row():
-        csv_input=gr.File(label="CSVファイル", file_types=[".csv"], type="filepath")
-        excel_input=gr.File(label="Excel閾値", file_types=[".xlsx"], type="filepath")
-        lag_excel_input=gr.File(label="ラグ表(予兆解析用)", file_types=[".xlsx"], type="filepath")
+        csv_input = gr.File(label="CSVファイル", file_types=[".csv"], type="filepath")
+        excel_input = gr.File(label="Excel閾値ファイル", file_types=[".xlsx"], type="filepath")
+        lag_input = gr.File(label="ラグファイル", file_types=[".xlsx"], type="filepath")
+        load_btn = gr.Button("ファイル読み込み")
+        load_status = gr.Textbox(label="読み込み結果")
 
     with gr.Tabs():
         with gr.Tab("閾値診断"):
-            pname=gr.Textbox(label="プロセス名", value="E018-A012_除害RO")
-            dtime=gr.Textbox(label="診断基準日時", value="2025/8/1 1:05")
-            wmin=gr.Number(label="さかのぼる時間幅(分)", value=60)
-            run=gr.Button("診断実行")
-            out1=gr.Dataframe(); out2=gr.Dataframe(); out3=gr.Dataframe()
-            summ=gr.Textbox(); jout=gr.Json()
-            run.click(diagnose_process_range, [csv_input,excel_input,pname,dtime,wmin], [out1,out2,out3,summ,jout])
+            process_name1 = gr.Textbox(label="プロセス名")
+            datetime_str1 = gr.Textbox(label="診断基準日時")
+            window_minutes1 = gr.Number(label="さかのぼる時間幅（分）", value=60)
+            run_btn1 = gr.Button("診断実行")
+            result_df_all = gr.Dataframe(label="全項目の状態集計")
+            result_df_imp = gr.Dataframe(label="重要項目全体の状態集計")
+            summary_output = gr.Textbox(label="サマリー")
+            json_output = gr.Json(label="JSON集計結果")
+            run_btn1.click(
+                diagnose_process_range,
+                inputs=[process_name1, datetime_str1, window_minutes1],
+                outputs=[result_df_all, result_df_imp, None, summary_output, json_output]
+            )
 
         with gr.Tab("傾向検出"):
-            pname2=gr.Textbox(label="プロセス名", value="E018-A012_除害RO")
-            dtime2=gr.Textbox(label="基準日時", value="2025/8/1 1:05")
-            wmin2=gr.Number(label="さかのぼる時間幅(分)", value=60)
-            fmin2=gr.Number(label="予測時間幅(分)", value=60)
-            run2=gr.Button("傾向検出実行")
-            outt=gr.Dataframe(); sumt=gr.Textbox(); joutt=gr.Json()
-            run2.click(detect_trends_with_forecast, [csv_input,excel_input,pname2,dtime2,wmin2,fmin2],[outt,sumt,joutt])
+            process_name2 = gr.Textbox(label="プロセス名")
+            datetime_str2 = gr.Textbox(label="基準日時")
+            window_minutes2 = gr.Number(label="過去の時間幅（分）", value=60)
+            forecast_minutes2 = gr.Number(label="未来予測時間幅（分）", value=60)
+            run_btn2 = gr.Button("傾向検出実行")
+            result_df2 = gr.Dataframe(label="傾向＋予測結果")
+            summary_output2 = gr.Textbox(label="サマリー")
+            json_output2 = gr.Json(label="JSON結果")
+            run_btn2.click(
+                detect_trends_with_forecast,
+                inputs=[process_name2, datetime_str2, window_minutes2, forecast_minutes2],
+                outputs=[result_df2, summary_output2, json_output2]
+            )
 
         with gr.Tab("予兆解析"):
-            pname3=gr.Textbox(label="プロセス名", value="E018-A012_除害RO")
-            dtime3=gr.Textbox(label="基準日時", value="2025/8/2 0:05")
-            fmin3=gr.Number(label="予測時間幅(分)", value=60)
-            run3=gr.Button("予兆解析実行")
-            outy=gr.Dataframe(); sumy=gr.Textbox(); jouty=gr.Json()
-            run3.click(forecast_process_with_lag, [csv_input,excel_input,lag_excel_input,pname3,dtime3,fmin3],[outy,sumy,jouty])
-
-if __name__=="__main__":
-    if os.getenv("USE_MCP","0")=="1": demo.launch(mcp_server=True)
-    else: demo.launch(server_name="0.0.0.0", share=False)
+            process_name3 = gr.Textbox(label="プロセス名")
+            datetime_str3 = gr.Textbox(label="基準日時")
+            forecast_minutes3 = gr.Number(label="未来予測時間幅（分）", value=60)
+            run_btn3 = gr.Button("予兆解析実行")
+            result_df3 = gr.Dataframe(label="予兆解析結果")
+            summary_output3 = gr.Textbox(label="サマリー")
+            json_output3 = gr.Json(label="JSON結果")
+            run_btn3.click(
+                forecast_process_with_lag,
+                inputs=[process_name3, datetime_str3, forecast_minutes3],
+                outputs=[result_df3, summary_output3, json_output3]
+            )
+
+    load_btn.click(load_files, inputs=[csv_input, excel_input, lag_input], outputs=[load_status])
+
+if __name__ == "__main__":
+    use_mcp = os.getenv("USE_MCP", "0") == "1"
+    if use_mcp:
+        demo.launch(mcp_server=True)
+    else:
+        demo.launch(server_name="0.0.0.0", share=False)