| from __future__ import annotations |
|
|
| import json |
| from pathlib import Path |
|
|
| import gradio as gr |
| import lightgbm as lgb |
| import numpy as np |
| import pandas as pd |
| import plotly.graph_objects as go |
| import torch |
|
|
| from model import GRUFraudModel |
|
|
| ASSETS = Path(__file__).parent / "assets" |
|
|
| with open(ASSETS / "config.json", encoding="utf-8") as f: |
| CFG = json.load(f) |
|
|
| SEQ_LEN = CFG["seq_len"] |
| N_NUMERIC = CFG["n_numeric"] |
| N_FEAT = N_NUMERIC - 1 |
| THR_GRU = CFG["threshold_gru"] |
| THR_LGB = CFG["threshold_lgb"] |
|
|
| _w = np.load(ASSETS / "demo_windows.npz") |
| WIN_NUM = _w["win_num"] |
| WIN_CAT = _w["win_cat"] |
|
|
| META = pd.read_csv(ASSETS / "demo_meta.csv") |
| DISPLAY = pd.read_csv(ASSETS / "demo_display.csv") |
|
|
| _s = np.load(ASSETS / "test_scores.npz") |
| S_GRU = _s["gru"].astype(np.float64) |
| S_LGB = _s["lgb"].astype(np.float64) |
| Y_TEST = _s["y"].astype(np.float64) |
| AMT_TEST = _s["amt"].astype(np.float64) |
|
|
| N_TEST = len(Y_TEST) |
| N_FRAUD = int(Y_TEST.sum()) |
| TOTAL_FRAUD_AMT = float((Y_TEST * AMT_TEST).sum()) |
|
|
| GRU = GRUFraudModel(n_numeric=N_NUMERIC, n_categories=CFG["n_categories"]) |
| GRU.load_state_dict(torch.load(ASSETS / "gru.pth", map_location="cpu", weights_only=True)) |
| GRU.eval() |
| torch.set_num_threads(2) |
|
|
| BOOSTER = lgb.Booster(model_file=str(ASSETS / "lightgbm.txt")) |
|
|
| RNG = np.random.default_rng() |
|
|
|
|
| def score_gru(sample_id: int) -> float: |
| with torch.no_grad(): |
| logit = GRU( |
| torch.from_numpy(WIN_NUM[sample_id : sample_id + 1]), |
| torch.from_numpy(WIN_CAT[sample_id : sample_id + 1]), |
| ) |
| return float(torch.sigmoid(logit).item()) |
|
|
|
|
| def score_lgb(sample_id: int) -> float: |
| flat = np.concatenate( |
| [ |
| WIN_NUM[sample_id, -1, :N_FEAT].astype(np.float64), |
| [float(WIN_CAT[sample_id, -1])], |
| ] |
| ).reshape(1, -1) |
| return float(BOOSTER.predict(flat)[0]) |
|
|
|
|
| def _cumulative(scores: np.ndarray) -> dict: |
| order = np.argsort(-scores, kind="stable") |
| ys = Y_TEST[order] |
| return { |
| "s_desc": scores[order], |
| "tp": np.concatenate([[0.0], np.cumsum(ys)]), |
| "famt": np.concatenate([[0.0], np.cumsum(ys * AMT_TEST[order])]), |
| } |
|
|
|
|
| CUM = {"GRU": _cumulative(S_GRU), "LightGBM": _cumulative(S_LGB)} |
| K_AXIS = np.arange(N_TEST + 1, dtype=np.float64) |
|
|
|
|
| def cost_curve(model: str, review_cost: float) -> np.ndarray: |
| c = CUM[model] |
| return review_cost * (K_AXIS - c["tp"]) + (TOTAL_FRAUD_AMT - c["famt"]) |
|
|
|
|
| def optimal_threshold(model: str, review_cost: float) -> tuple[float, float]: |
| curve = cost_curve(model, review_cost) |
| k = int(np.argmin(curve)) |
| thr = 1.0 if k == 0 else float(CUM[model]["s_desc"][k - 1]) |
| return thr, float(curve[k]) |
|
|
|
|
| def confusion_at(model: str, threshold: float, review_cost: float) -> dict: |
| c = CUM[model] |
| k = int(np.searchsorted(-c["s_desc"], -threshold, side="right")) |
| tp = float(c["tp"][k]) |
| fp = k - tp |
| fn = N_FRAUD - tp |
| tn = N_TEST - k - fn |
| cost = review_cost * fp + (TOTAL_FRAUD_AMT - float(c["famt"][k])) |
| return { |
| "alerts": k, |
| "tp": int(tp), |
| "fp": int(fp), |
| "fn": int(fn), |
| "tn": int(tn), |
| "cost": cost, |
| "recall": tp / N_FRAUD if N_FRAUD else 0.0, |
| "precision": tp / k if k else 0.0, |
| "alert_rate": k / N_TEST, |
| } |
|
|
|
|
| def _history_table(sample_id: int) -> str: |
| rows = DISPLAY[DISPLAY.sample_id == sample_id].sort_values("position") |
| body = [] |
| for _, r in rows.iterrows(): |
| cls = "target" if bool(r.is_target) else "" |
| gap = "first seen" if r.hours_since_prev >= 719 else f"{r.hours_since_prev:,.1f} h" |
| body.append( |
| f"<tr class='{cls}'>" |
| f"<td>{r.timestamp}</td>" |
| f"<td class='num'>${r.amount:,.2f}</td>" |
| f"<td>{r.category}</td>" |
| f"<td class='num'>{r.distance_km:,.0f} km</td>" |
| f"<td class='num'>{gap}</td>" |
| f"<td class='num'>{r.amt_vs_card_mean:,.2f}x</td>" |
| f"</tr>" |
| ) |
| return ( |
| "<div class='tablewrap'><table class='hist'>" |
| "<thead><tr><th>Timestamp</th><th>Amount</th><th>Category</th>" |
| "<th>Distance</th><th>Since previous</th><th>vs card average</th></tr></thead>" |
| f"<tbody>{''.join(body)}</tbody></table></div>" |
| "<p class='caption'>The highlighted row is the transaction being scored. " |
| "The rows above it are the context the GRU reads.</p>" |
| ) |
|
|
|
|
| def _score_panel(name: str, prob: float, threshold: float, subtitle: str) -> str: |
| flagged = prob >= threshold |
| pct = prob * 100 |
| tone = "flag" if flagged else "clear" |
| verdict = "FLAG FOR REVIEW" if flagged else "ALLOW" |
| return ( |
| f"<div class='scorecard {tone}'>" |
| f"<div class='sc-name'>{name}</div>" |
| f"<div class='sc-sub'>{subtitle}</div>" |
| f"<div class='sc-prob'>{pct:.1f}<span>%</span></div>" |
| f"<div class='sc-bar'><div class='sc-fill' style='width:{min(pct, 100):.1f}%'></div>" |
| f"<div class='sc-thr' style='left:{threshold * 100:.1f}%'></div></div>" |
| f"<div class='sc-verdict'>{verdict}</div>" |
| f"<div class='sc-thrlab'>threshold {threshold:.3f}</div>" |
| f"</div>" |
| ) |
|
|
|
|
| def _outcome_banner(is_fraud: int, p_gru: float, p_lgb: float) -> str: |
| gru_flag = p_gru >= THR_GRU |
| lgb_flag = p_lgb >= THR_LGB |
| truth = "FRAUDULENT" if is_fraud else "LEGITIMATE" |
|
|
| if is_fraud and gru_flag and not lgb_flag: |
| tone, msg = "good", "The sequence model caught it. The flat model did not." |
| elif is_fraud and gru_flag: |
| tone, msg = "good", "Both models caught it." |
| elif is_fraud and not gru_flag: |
| tone, msg = "bad", "Both models missed this one. It is one of the 31 the GRU lets through." |
| elif not is_fraud and gru_flag: |
| tone, msg = "warn", "A false alarm. This costs a review, not a chargeback." |
| else: |
| tone, msg = "good", "Correctly cleared, with no analyst time spent." |
|
|
| return ( |
| f"<div class='banner {tone}'>" |
| f"<span class='b-label'>Ground truth</span>" |
| f"<span class='b-truth'>{truth}</span>" |
| f"<span class='b-msg'>{msg}</span></div>" |
| ) |
|
|
|
|
| def load_case(scenario: str): |
| pool = META[META.scenario == scenario] |
| if pool.empty: |
| pool = META |
| row = pool.iloc[int(RNG.integers(len(pool)))] |
| sid = int(row.sample_id) |
|
|
| p_gru = score_gru(sid) |
| p_lgb = score_lgb(sid) |
|
|
| header = ( |
| f"<div class='caseheader'>" |
| f"<div><span class='ch-label'>Card</span><span class='ch-val'>{row.card}</span></div>" |
| f"<div><span class='ch-label'>Transaction</span>" |
| f"<span class='ch-val'>${row.amount:,.2f}</span></div>" |
| f"<div><span class='ch-label'>History available</span>" |
| f"<span class='ch-val'>{int(row.history_length)} of {SEQ_LEN} steps</span></div>" |
| f"</div>" |
| ) |
| panels = ( |
| "<div class='panelrow'>" |
| + _score_panel("GRU", p_gru, THR_GRU, "reads the last 10 transactions") |
| + _score_panel("LightGBM", p_lgb, THR_LGB, "reads this transaction only") |
| + "</div>" |
| ) |
| banner = _outcome_banner(int(row.is_fraud), p_gru, p_lgb) |
| return header, _history_table(sid), panels, banner |
|
|
|
|
| def _metric_tile(label: str, value: str, sub: str = "") -> str: |
| return ( |
| f"<div class='tile'><div class='t-label'>{label}</div>" |
| f"<div class='t-value'>{value}</div><div class='t-sub'>{sub}</div></div>" |
| ) |
|
|
|
|
| def _style_fig(fig: go.Figure) -> go.Figure: |
| fig.update_layout( |
| paper_bgcolor="rgba(0,0,0,0)", |
| plot_bgcolor="rgba(0,0,0,0)", |
| font=dict(color="#94a3b8", size=12), |
| legend=dict(orientation="h", yanchor="bottom", y=1.0, x=0), |
| margin=dict(l=68, r=20, t=34, b=50), |
| ) |
| grid = "rgba(148,163,184,0.20)" |
| line = "rgba(148,163,184,0.35)" |
| fig.update_xaxes(gridcolor=grid, zerolinecolor=line, linecolor=line) |
| fig.update_yaxes(gridcolor=grid, zerolinecolor=line, linecolor=line) |
| return fig |
|
|
|
|
| def explore(review_cost: float, threshold: float): |
| gru = confusion_at("GRU", threshold, review_cost) |
| opt_thr, opt_cost = optimal_threshold("GRU", review_cost) |
| opt_thr_l, opt_cost_l = optimal_threshold("LightGBM", review_cost) |
| naive = confusion_at("GRU", 0.5, review_cost) |
|
|
| tiles = ( |
| "<div class='tilehead'>GRU, at your chosen threshold</div>" |
| "<div class='tilerow'>" |
| + _metric_tile("Alerts raised", f"{gru['alerts']:,}", |
| f"{gru['alert_rate'] * 100:.2f}% of transactions") |
| + _metric_tile("Fraud caught", f"{gru['tp']:,}", |
| f"{gru['recall'] * 100:.1f}% recall") |
| + _metric_tile("Fraud missed", f"{gru['fn']:,}", "escaped review") |
| + _metric_tile("False alarms", f"{gru['fp']:,}", |
| f"{gru['precision'] * 100:.1f}% precision") |
| + _metric_tile("Total cost", f"${gru['cost']:,.0f}", |
| f"vs ${naive['cost']:,.0f} at threshold 0.5") |
| + "</div>" |
| + f"<div class='optnote'>At ${review_cost:,.2f} per review, each model's own cost " |
| f"minimising threshold is <b>{opt_thr:.3f}</b> for the GRU " |
| f"(<b>${opt_cost:,.0f}</b>) and <b>{opt_thr_l:.3f}</b> for LightGBM " |
| f"(<b>${opt_cost_l:,.0f}</b>). Sequence context is worth " |
| f"<b>${opt_cost_l - opt_cost:,.0f}</b>.</div>" |
| ) |
|
|
| fig = go.Figure() |
| for name, colour in (("GRU", "#4f46e5"), ("LightGBM", "#f59e0b")): |
| curve = cost_curve(name, review_cost) |
| s = CUM[name]["s_desc"] |
| step = max(1, len(s) // 1500) |
| fig.add_trace( |
| go.Scatter( |
| x=s[::step], y=curve[1:][::step], mode="lines", name=name, |
| line=dict(color=colour, width=2), |
| hovertemplate="threshold %{x:.3f}<br>cost $%{y:,.0f}<extra></extra>", |
| ) |
| ) |
| fig.add_vline(x=threshold, line_dash="dash", line_color="#94a3b8", |
| annotation_text="your threshold", annotation_position="top") |
| fig.add_trace( |
| go.Scatter(x=[opt_thr], y=[opt_cost], mode="markers", name="GRU optimum", |
| marker=dict(color="#4f46e5", size=12, symbol="circle"), |
| hovertemplate="optimum %{x:.3f}<br>$%{y:,.0f}<extra></extra>") |
| ) |
| fig.update_layout( |
| yaxis_type="log", |
| xaxis_title="Decision threshold", |
| yaxis_title="Total cost, dollars (log scale)", |
| height=420, |
| hovermode="x unified", |
| ) |
| fig.update_yaxes(dtick=1, tickprefix="$", tickformat="~s") |
| return tiles, _style_fig(fig) |
|
|
|
|
| def snap_to_optimal(review_cost: float): |
| thr, _ = optimal_threshold("GRU", review_cost) |
| return thr |
|
|
|
|
| def pr_figure() -> go.Figure: |
| fig = go.Figure() |
| for name, colour in (("GRU", "#4f46e5"), ("LightGBM", "#f59e0b")): |
| c = CUM[name] |
| k = np.arange(1, N_TEST + 1) |
| recall = c["tp"][1:] / N_FRAUD |
| precision = c["tp"][1:] / k |
| step = max(1, N_TEST // 2000) |
| fig.add_trace( |
| go.Scatter(x=recall[::step], y=precision[::step], mode="lines", name=name, |
| line=dict(color=colour, width=2))) |
| fig.add_hline(y=N_FRAUD / N_TEST, line_dash="dot", line_color="#94a3b8", |
| annotation_text="random classifier") |
| fig.update_layout( |
| xaxis_title="Recall", yaxis_title="Precision", |
| yaxis_range=[0, 1.02], height=400, |
| ) |
| return _style_fig(fig) |
|
|
|
|
| M = CFG["metrics"] |
| ABOUT = f""" |
| ### What this is |
| |
| Most credit card fraud models score each transaction in isolation. But fraud is a |
| behavioural signal: what matters is that *this card* has never behaved this way before. |
| This model builds a per card sequence of recent transactions and feeds it to a GRU. |
| |
| The comparison is against a LightGBM model given the **identical features** for the |
| transaction being scored, but no sequence context. That isolates what the sequence adds. |
| |
| ### Results on the held out time period |
| |
| {CFG['n_test']:,} transactions, {CFG['n_fraud']:,} fraudulent ({CFG['n_fraud'] / CFG['n_test'] * 100:.3f} percent). |
| |
| | Model | PR-AUC | ROC-AUC | Recall @ 0.1% | Recall @ 1% | |
| |---|---|---|---|---| |
| | **GRU (sequence)** | **{M['gru']['pr_auc']:.4f}** | {M['gru']['roc_auc']:.4f} | {M['gru']['recall_at_0.001']:.3f} | **{M['gru']['recall_at_0.01']:.3f}** | |
| | LightGBM (no sequence) | {M['lightgbm']['pr_auc']:.4f} | {M['lightgbm']['roc_auc']:.4f} | {M['lightgbm']['recall_at_0.001']:.3f} | {M['lightgbm']['recall_at_0.01']:.3f} | |
| | Logistic regression | {M['logreg']['pr_auc']:.4f} | {M['logreg']['roc_auc']:.4f} | {M['logreg']['recall_at_0.001']:.3f} | {M['logreg']['recall_at_0.01']:.3f} | |
| |
| Accuracy is deliberately absent. Predicting "legitimate" for every transaction scores |
| **{CFG['trivial_accuracy'] * 100:.3f} percent** while catching nothing. |
| |
| ### How it was built |
| |
| - **Chronological split by timestamp.** Every test row is strictly later than every training row. |
| - **Causal features only.** A card's average spend is an expanding mean over prior rows, so a |
| transaction never contributes to its own baseline. |
| - **Windows sliced on demand.** One flat array per split rather than materialising 1.29M |
| sequences, which keeps the whole thing inside 16 GB. |
| - **Trained on CPU.** 22,577 parameters, 4 epochs, 7.1 minutes on a laptop with no GPU. |
| |
| ### Honest limits |
| |
| The data is simulated (Sparkov), and rule generated fraud is far more learnable than the |
| adversarial kind, so a PR-AUC of 0.965 is not a production number. The cost minimising |
| threshold is also selected on the test set, which makes those dollar figures optimistic. |
| Both points are covered in more detail in the repository. |
| |
| [Full code, methodology and limitations on GitHub](https://github.com/adwitiyashukla/DL-based-sequential-fraud-detection) |
| """ |
|
|
| CSS = """ |
| .gradio-container { max-width: 1180px !important; } |
| #hero { padding: 4px 0 2px 0; } |
| #hero h1 { font-size: 2rem; font-weight: 700; margin: 0 0 6px 0; letter-spacing: -0.02em; |
| color: var(--body-text-color); } |
| #hero p { color: var(--body-text-color-subdued); margin: 0; font-size: 1.02rem; } |
| |
| .caseheader { display:flex; gap:34px; padding:14px 18px; |
| background: var(--background-fill-secondary); |
| border:1px solid var(--border-color-primary); border-radius:10px; |
| margin-bottom:6px; flex-wrap:wrap; } |
| .caseheader > div { display:flex; flex-direction:column; } |
| .ch-label { font-size:0.7rem; text-transform:uppercase; letter-spacing:0.07em; |
| color: var(--body-text-color-subdued); } |
| .ch-val { font-size:1.12rem; font-weight:650; color: var(--body-text-color); } |
| |
| .tablewrap { overflow-x:auto; border:1px solid var(--border-color-primary); border-radius:10px; } |
| table.hist { width:100%; border-collapse:collapse; font-size:0.87rem; } |
| table.hist th { background: var(--background-fill-secondary); text-align:left; |
| padding:9px 11px; font-weight:600; color: var(--body-text-color-subdued); |
| border-bottom:1px solid var(--border-color-primary); white-space:nowrap; |
| font-size:0.78rem; text-transform:uppercase; letter-spacing:0.04em; } |
| table.hist td { padding:8px 11px; border-bottom:1px solid var(--border-color-primary); |
| color: var(--body-text-color); white-space:nowrap; } |
| table.hist td.num { text-align:right; font-variant-numeric:tabular-nums; } |
| table.hist tr.target td { background: rgba(99,102,241,0.18); font-weight:700; } |
| .caption { color: var(--body-text-color-subdued); font-size:0.8rem; margin:7px 2px 0 2px; } |
| |
| .panelrow { display:flex; gap:16px; flex-wrap:wrap; } |
| .scorecard { flex:1; min-width:250px; border:1px solid var(--border-color-primary); |
| border-radius:12px; padding:16px 18px; background: var(--background-fill-primary); } |
| .scorecard.flag { border-color: rgba(239,68,68,0.45); background: rgba(239,68,68,0.09); } |
| .scorecard.clear { border-color: rgba(34,197,94,0.45); background: rgba(34,197,94,0.09); } |
| .sc-name { font-size:1.02rem; font-weight:700; color: var(--body-text-color); } |
| .sc-sub { font-size:0.78rem; color: var(--body-text-color-subdued); margin-bottom:10px; } |
| .sc-prob { font-size:2.5rem; font-weight:700; line-height:1; color: var(--body-text-color); |
| font-variant-numeric:tabular-nums; } |
| .sc-prob span { font-size:1.1rem; color: var(--body-text-color-subdued); margin-left:2px; } |
| .sc-bar { position:relative; height:8px; background: rgba(148,163,184,0.30); |
| border-radius:4px; margin:12px 0 10px 0; } |
| .sc-fill { position:absolute; height:100%; border-radius:4px; background:#6366f1; } |
| .scorecard.flag .sc-fill { background:#ef4444; } |
| .scorecard.clear .sc-fill { background:#22c55e; } |
| .sc-thr { position:absolute; top:-3px; width:2px; height:14px; background: var(--body-text-color); } |
| .sc-verdict { font-size:0.82rem; font-weight:700; letter-spacing:0.06em; } |
| .scorecard.flag .sc-verdict { color:#ef4444; } |
| .scorecard.clear .sc-verdict { color:#22c55e; } |
| .sc-thrlab { font-size:0.72rem; color: var(--body-text-color-subdued); margin-top:3px; } |
| |
| .banner { display:flex; align-items:center; gap:14px; padding:13px 18px; border-radius:10px; |
| margin-top:4px; flex-wrap:wrap; } |
| .banner.good { background: rgba(34,197,94,0.10); border:1px solid rgba(34,197,94,0.40); } |
| .banner.bad { background: rgba(239,68,68,0.10); border:1px solid rgba(239,68,68,0.40); } |
| .banner.warn { background: rgba(245,158,11,0.12); border:1px solid rgba(245,158,11,0.40); } |
| .b-label { font-size:0.7rem; text-transform:uppercase; letter-spacing:0.07em; |
| color: var(--body-text-color-subdued); } |
| .b-truth { font-weight:750; font-size:0.95rem; letter-spacing:0.03em; |
| color: var(--body-text-color); } |
| .b-msg { color: var(--body-text-color); opacity:0.85; font-size:0.9rem; } |
| |
| .tilehead { font-size:0.72rem; text-transform:uppercase; letter-spacing:0.07em; |
| color: var(--body-text-color-subdued); margin:2px 2px 7px 2px; } |
| .tilerow { display:flex; gap:12px; flex-wrap:wrap; margin-bottom:10px; } |
| .tile { flex:1; min-width:150px; border:1px solid var(--border-color-primary); |
| border-radius:10px; padding:13px 15px; background: var(--background-fill-primary); } |
| .t-label { font-size:0.7rem; text-transform:uppercase; letter-spacing:0.07em; |
| color: var(--body-text-color-subdued); } |
| .t-value { font-size:1.6rem; font-weight:700; color: var(--body-text-color); |
| font-variant-numeric:tabular-nums; line-height:1.2; } |
| .t-sub { font-size:0.76rem; color: var(--body-text-color-subdued); } |
| .optnote { padding:12px 16px; background: rgba(99,102,241,0.12); |
| border:1px solid rgba(99,102,241,0.40); border-radius:10px; |
| color: var(--body-text-color); font-size:0.92rem; } |
| """ |
|
|
| THEME = gr.themes.Base( |
| primary_hue=gr.themes.colors.indigo, |
| secondary_hue=gr.themes.colors.slate, |
| neutral_hue=gr.themes.colors.slate, |
| ) |
|
|
| with gr.Blocks(title="Sequential Fraud Detection") as demo: |
| gr.HTML( |
| "<div id='hero'><h1>Sequential Fraud Detection</h1>" |
| "<p>A GRU reads each card's last 10 transactions. A LightGBM baseline sees the same " |
| "features without the sequence. Every score below is computed live.</p></div>" |
| ) |
|
|
| with gr.Tabs(): |
| with gr.Tab("Score a transaction"): |
| with gr.Row(): |
| scenario = gr.Dropdown( |
| choices=CFG["scenario_order"], |
| value=CFG["scenario_order"][0], |
| label="Pick a scenario", |
| scale=3, |
| ) |
| shuffle = gr.Button("Load another case", variant="primary", scale=1) |
|
|
| case_header = gr.HTML() |
| history = gr.HTML() |
| panels = gr.HTML() |
| banner = gr.HTML() |
|
|
| scenario.change(load_case, scenario, [case_header, history, panels, banner]) |
| shuffle.click(load_case, scenario, [case_header, history, panels, banner]) |
| demo.load(load_case, scenario, [case_header, history, panels, banner]) |
|
|
| with gr.Tab("Cost explorer"): |
| gr.Markdown( |
| "A missed fraud costs the full transaction amount. A false positive costs a " |
| "manual review. Move the inputs and watch where the optimum goes: as reviews " |
| "get more expensive, the threshold rises and you alert less." |
| ) |
| with gr.Row(): |
| review_cost = gr.Slider(1, 50, value=CFG["default_review_cost"], step=0.5, |
| label="Cost of one manual review ($)") |
| threshold = gr.Slider(0.0, 1.0, value=THR_GRU, step=0.001, |
| label="Decision threshold") |
| snap = gr.Button("Snap to the cost minimising threshold") |
|
|
| tiles = gr.HTML() |
| cost_plot = gr.Plot(show_label=False) |
|
|
| for control in (review_cost, threshold): |
| control.change(explore, [review_cost, threshold], [tiles, cost_plot]) |
| snap.click(snap_to_optimal, review_cost, threshold) |
| demo.load(explore, [review_cost, threshold], [tiles, cost_plot]) |
|
|
| with gr.Tab("How it works"): |
| gr.Markdown(ABOUT) |
| gr.Plot(pr_figure(), show_label=False) |
|
|
|
|
| if __name__ == "__main__": |
| ids = META.sample_id.values[:25] |
| d_gru = max(abs(score_gru(int(i)) - float(META.score_gru[i])) for i in ids) |
| d_lgb = max(abs(score_lgb(int(i)) - float(META.score_lgb[i])) for i in ids) |
| print(f"[check] max score drift GRU {d_gru:.2e} LightGBM {d_lgb:.2e}") |
|
|
| demo.launch(theme=THEME, css=CSS) |
|
|
