Create app.py

app.py

@@ -0,0 +1,503 @@
+import numpy as np
+import pandas as pd
+from sklearn.cluster import KMeans
+import torch
+from torch import nn
+from torch.utils.data import TensorDataset, DataLoader
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# -------------------------------------------------------
+# 1. Load dataset (Facebook Metrics of Cosmetic Brand)
+# -------------------------------------------------------
+DATA_PATH = "dataset_Facebook.csv"  # semicolon-separated file
+
+df = pd.read_csv(DATA_PATH, sep=";")
+df = df.fillna(0)
+
+# Rename important columns if needed
+df = df.rename(columns={
+    "Page total likes": "page_likes",
+    "Lifetime Post Total Impressions": "impressions",
+    "Lifetime Engaged Users": "engaged_users",
+    "comment": "comments",
+    "like": "likes",
+    "share": "shares"
+})
+
+# Fallback if some names are missing in your copy
+for col in ["comments", "likes", "shares"]:
+    if col not in df.columns:
+        df[col] = 0
+
+# -------------------------------------------------------
+# 2. Real behavioural features from dataset
+# -------------------------------------------------------
+
+engagement = df["comments"] + df["likes"] + df["shares"]
+
+impressions = df["impressions"].replace(0, 1)
+interaction_rate = df["engaged_users"] / impressions
+
+def minmax(x):
+    x = np.asarray(x, dtype=float)
+    return (x - x.min()) / (x.max() - x.min() + 1e-8)
+
+eng_norm = minmax(engagement)
+interaction_norm = minmax(interaction_rate)
+
+# Trust-like base: higher interaction => more trusted
+trust_base = interaction_norm.copy()
+
+# Suspicious: high impressions but low engagement
+imp_norm = minmax(df["impressions"])
+suspicious_score = imp_norm * (1.0 - trust_base)
+susp_norm = minmax(suspicious_score)
+
+# Activity regularity: posts around midday more "regular"
+if "Post Hour" in df.columns:
+    post_hour = df["Post Hour"]
+else:
+    post_hour = pd.Series([12] * len(df))  # default midday if missing
+
+activity_reg = 1.0 - (np.abs(post_hour - 12) / 12.0).clip(0, 1)
+act_norm = minmax(activity_reg)
+
+# -------------------------------------------------------
+# 3. Synthetic FRR & MFR
+# -------------------------------------------------------
+
+rng = np.random.default_rng(42)
+
+# Friend requests sent (more for engaged posts)
+base_sent = rng.poisson(lam=3 + 20 * eng_norm)
+sent_requests = np.maximum(base_sent, 1)
+
+# Acceptance probability depends on trust_base (0.2 to 0.9)
+accepted_prob = 0.2 + 0.7 * trust_base
+accepted_prob = np.clip(accepted_prob, 0.0, 1.0)
+accepted_requests = rng.binomial(sent_requests, accepted_prob)
+friend_request_ratio = accepted_requests / (sent_requests + 1e-8)
+frr_norm = minmax(friend_request_ratio)
+
+# Synthetic total friends
+total_friends = rng.integers(low=50, high=2000, size=len(df))
+
+# Mutual friends probability depends on trust_base
+mutual_prob = 0.1 + 0.6 * trust_base
+mutual_prob = np.clip(mutual_prob, 0.0, 1.0)
+mutual_friends = rng.binomial(total_friends, mutual_prob)
+mutual_friends_ratio = mutual_friends / (total_friends + 1e-8)
+mfr_norm = minmax(mutual_friends_ratio)
+
+friends_norm = minmax(total_friends)
+
+# -------------------------------------------------------
+# 4. Build S, T, B scores
+# -------------------------------------------------------
+
+# S: social / structural (FRR, MFR, friends)
+S_score = (frr_norm + mfr_norm + friends_norm) / 3.0
+
+# T: trust (trust_base, FRR, inverse suspiciousness)
+T_score = (trust_base + frr_norm + (1.0 - susp_norm)) / 3.0
+
+# B: behaviour (engagement, regularity, suspiciousness)
+B_score = (eng_norm + act_norm + susp_norm) / 3.0
+
+# -------------------------------------------------------
+# 5. Fused features with variance-based weights
+# -------------------------------------------------------
+
+varS = np.var(S_score)
+varT = np.var(T_score)
+varB = np.var(B_score)
+den = varS + varT + varB + 1e-8
+wS, wT, wB = varS / den, varT / den, varB / den
+
+F = np.vstack([
+    wS * S_score,
+    wT * T_score,
+    wB * B_score
+]).T  # shape (N, 3)
+
+# -------------------------------------------------------
+# 6. Unsupervised clustering -> pseudo labels
+# -------------------------------------------------------
+
+kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
+cluster_raw = kmeans.fit_predict(F)
+
+cluster_means = []
+for c in range(3):
+    cluster_means.append((c, T_score[cluster_raw == c].mean()))
+cluster_means_sorted = sorted(cluster_means, key=lambda x: x[1])
+
+label_map = {
+    cluster_means_sorted[0][0]: 2,  # lowest trust => Intruder
+    cluster_means_sorted[1][0]: 1,  # mid => Under Observation
+    cluster_means_sorted[2][0]: 0   # highest => Trusted
+}
+
+cluster_labels = np.array([label_map[c] for c in cluster_raw], dtype=int)
+
+label_names = {
+    0: "Trusted",
+    1: "Under Observation",
+    2: "Intruder"
+}
+
+status_counts = np.bincount(cluster_labels, minlength=3)
+
+def make_status_bar_plot():
+    fig, ax = plt.subplots()
+    labels = ["Trusted", "Under Observation", "Intruder"]
+    ax.bar(labels, status_counts)
+    ax.set_ylabel("Number of posts")
+    ax.set_title("Global distribution of statuses (on dataset)")
+    fig.tight_layout()
+    return fig
+
+# -------------------------------------------------------
+# 7. Train MLP on fused features
+# -------------------------------------------------------
+
+X = torch.tensor(F, dtype=torch.float32)
+y = torch.tensor(cluster_labels, dtype=torch.long)
+
+dataset = TensorDataset(X, y)
+loader = DataLoader(dataset, batch_size=64, shuffle=True)
+
+class MLPClassifier(nn.Module):
+    def __init__(self, in_dim, hidden_dim=32, num_classes=3):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, num_classes)
+        )
+    def forward(self, x):
+        return self.net(x)
+
+model = MLPClassifier(in_dim=3)
+criterion = nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
+
+for epoch in range(20):
+    model.train()
+    total_loss = 0.0
+    for xb, yb in loader:
+        optimizer.zero_grad()
+        logits = model(xb)
+        loss = criterion(logits, yb)
+        loss.backward()
+        optimizer.step()
+        total_loss += loss.item() * xb.size(0)
+
+model.eval()
+with torch.no_grad():
+    preds = model(X).argmax(dim=1)
+    acc = (preds == y).float().mean().item()
+print(f"Training accuracy vs pseudo-labels: {acc:.3f}")
+
+def predict_from_fused(S_val, T_val, B_val):
+    vec3 = np.array([wS * S_val, wT * T_val, wB * B_val], dtype=np.float32)
+    x = torch.tensor(vec3.reshape(1, -1), dtype=torch.float32)
+    model.eval()
+    with torch.no_grad():
+        logits = model(x)
+        probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
+        pred = int(np.argmax(probs))
+    return pred, probs
+
+eng_min = engagement.min()
+eng_max = engagement.max()
+
+# -------------------------------------------------------
+# 8. Build S, T, B from UI inputs
+# -------------------------------------------------------
+
+def build_scores_from_user_input(
+    engagement_input,
+    suspicious_input,
+    activity_input,
+    frr_input,
+    mfr_input
+):
+    eng_norm_ui = (engagement_input - eng_min) / (eng_max - eng_min + 1e-8)
+    eng_norm_ui = float(np.clip(eng_norm_ui, 0.0, 1.0))
+
+    susp_norm_ui = float(np.clip(suspicious_input, 0.0, 1.0))
+    act_norm_ui = float(np.clip(activity_input, 0.0, 1.0))
+    frr_norm_ui = float(np.clip(frr_input, 0.0, 1.0))
+    mfr_norm_ui = float(np.clip(mfr_input, 0.0, 1.0))
+
+    friends_norm_ui = 0.5  # fixed average friends
+
+    trust_norm_ui = (eng_norm_ui + (1.0 - susp_norm_ui)) / 2.0
+
+    S_ui = (frr_norm_ui + mfr_norm_ui + friends_norm_ui) / 3.0
+    T_ui = (trust_norm_ui + frr_norm_ui + (1.0 - susp_norm_ui)) / 3.0
+    B_ui = (eng_norm_ui + act_norm_ui + susp_norm_ui) / 3.0
+
+    return S_ui, T_ui, B_ui, eng_norm_ui, susp_norm_ui, act_norm_ui
+
+# -------------------------------------------------------
+# 9. Timeline helpers (T1–T5)
+# -------------------------------------------------------
+
+def make_timeline_plot(timeline_state):
+    fig, ax = plt.subplots()
+    if not timeline_state:
+        ax.text(0.5, 0.5, "No timeline yet", ha="center", va="center")
+        ax.set_axis_off()
+        fig.tight_layout()
+        return fig
+
+    steps = [i + 1 for i in range(len(timeline_state))]
+    trusted = [e["probs"][0] for e in timeline_state]
+    obs = [e["probs"][1] for e in timeline_state]
+    intr = [e["probs"][2] for e in timeline_state]
+
+    ax.plot(steps, trusted, marker="o", label="Trusted")
+    ax.plot(steps, obs, marker="o", label="Under Observation")
+    ax.plot(steps, intr, marker="o", label="Intruder")
+
+    ax.set_xticks(steps)
+    ax.set_xlabel("Time step (T1–T5)")
+    ax.set_ylabel("Probability")
+    ax.set_ylim(0, 1)
+    ax.set_title("User status probabilities over time")
+    ax.legend()
+    fig.tight_layout()
+    return fig
+
+def simulate_week(
+    engagement_input,
+    suspicious_input,
+    activity_input,
+    frr_input,
+    mfr_input,
+    timeline_state
+):
+    if timeline_state is None:
+        timeline_state = []
+
+    S_ui, T_ui, B_ui, eng_n, susp_n, act_n = build_scores_from_user_input(
+        engagement_input,
+        suspicious_input,
+        activity_input,
+        frr_input,
+        mfr_input
+    )
+
+    pred, probs = predict_from_fused(S_ui, T_ui, B_ui)
+    status = label_names[pred]
+
+    if len(timeline_state) >= 5:
+        timeline_state = timeline_state[1:]  # keep only last 4
+    timeline_state.append({
+        "status": status,
+        "probs": probs.tolist(),
+        "S": float(S_ui),
+        "T": float(T_ui),
+        "B": float(B_ui)
+    })
+
+    step_num = len(timeline_state)
+
+    # Current step summary
+    lines = []
+    lines.append(f"### Current Week: T{step_num}")
+    lines.append(f"**Predicted Status:** **{status}**")
+    lines.append("")
+    lines.append("**Probabilities:**")
+    lines.append(f"- Trusted: {probs[0]:.2f}")
+    lines.append(f"- Under Observation: {probs[1]:.2f}")
+    lines.append(f"- Intruder: {probs[2]:.2f}")
+    lines.append("")
+    lines.append("**Aggregated scores (0–1):**")
+    lines.append(f"- S (Social / Structural): `{S_ui:.2f}`")
+    lines.append(f"- T (Trust): `{T_ui:.2f}`")
+    lines.append(f"- B (Behaviour): `{B_ui:.2f}`")
+    lines.append("")
+    lines.append("**Inputs (normalized):**")
+    lines.append(f"- Engagement: `{eng_n:.2f}`")
+    lines.append(f"- Suspiciousness: `{susp_n:.2f}`")
+    lines.append(f"- Activity regularity: `{act_n:.2f}`")
+
+    current_md = "\n".join(lines)
+
+    # Timeline text
+    tl_lines = ["## Timeline (T1–T5)"]
+    for i, entry in enumerate(timeline_state):
+        p = entry["probs"]
+        tl_lines.append(
+            f"- **T{i+1}**: {entry['status']} | "
+            f"Trusted={p[0]:.2f}, Obs={p[1]:.2f}, Intruder={p[2]:.2f}"
+        )
+    timeline_md = "\n".join(tl_lines)
+
+    tl_fig = make_timeline_plot(timeline_state)
+
+    return current_md, timeline_md, tl_fig, timeline_state
+
+def reset_timeline():
+    empty_fig = make_timeline_plot([])
+    return (
+        "Timeline reset. Adjust sliders and click **Next week (T+1)** to start from T1.",
+        "## Timeline (T1–T5)\n(No entries yet)",
+        empty_fig,
+        []
+    )
+
+# -------------------------------------------------------
+# 10. Example table: real Trusted / Intruder-like samples
+# -------------------------------------------------------
+
+def build_example_table(n_per_class=5):
+    rows = []
+    for lbl in [0, 2]:  # 0 = Trusted, 2 = Intruder
+        idxs = np.where(cluster_labels == lbl)[0]
+        if len(idxs) == 0:
+            continue
+        sel = rng.choice(idxs, size=min(n_per_class, len(idxs)), replace=False)
+        tmp = pd.DataFrame({
+            "Status": [label_names[lbl]] * len(sel),
+            "Comments": df["comments"].values[sel],
+            "Likes": df["likes"].values[sel],
+            "Shares": df["shares"].values[sel],
+            "Engagement": engagement.values[sel],
+            "S_score": S_score[sel],
+            "T_score": T_score[sel],
+            "B_score": B_score[sel]
+        })
+        rows.append(tmp)
+    if rows:
+        return pd.concat(rows, ignore_index=True)
+    else:
+        return pd.DataFrame(columns=[
+            "Status", "Comments", "Likes", "Shares", "Engagement",
+            "S_score", "T_score", "B_score"
+        ])
+
+examples_df = build_example_table()
+
+def refresh_examples():
+    return build_example_table()
+
+# Precompute global status plot
+global_status_fig = make_status_bar_plot()
+
+# -------------------------------------------------------
+# 11. Gradio app
+# -------------------------------------------------------
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Trust-Based Intrusion Detection Demo (Facebook Cosmetic Brand Metrics)")
+    gr.Markdown(
+        "This app is trained on the **Facebook Metrics of a Cosmetic Brand** dataset.\n\n"
+        "- Real post metrics (comments, likes, shares, impressions, engaged users) are used to derive\n"
+        "  engagement, suspiciousness, and trust-like scores.\n"
+        "- Two social features – **Friend Request Ratio (FRR)** and **Mutual Friends Ratio (MFR)** –\n"
+        "  are generated synthetically but consistently with behaviour.\n\n"
+        "Use the sliders to change user behaviour. Each click on **Next week (T+1)** simulates\n"
+        "the same user at a new time step T1..T5, so you can see how their status changes over time."
+    )
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Behaviour Inputs")
+            engagement_slider = gr.Slider(
+                minimum=float(eng_min),
+                maximum=float(eng_max),
+                value=float((eng_min + eng_max) / 2.0),
+                step=10.0,
+                label="Engagement level (comments + likes + shares)"
+            )
+            suspicious_slider = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.2,
+                step=0.01,
+                label="Suspiciousness (0 = clean, 1 = very suspicious)"
+            )
+            activity_slider = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.7,
+                step=0.01,
+                label="Activity regularity (1 = very regular, 0 = random)"
+            )
+            frr_slider = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.8,
+                step=0.01,
+                label="Friend Request Ratio (accepted / sent)"
+            )
+            mfr_slider = gr.Slider(
+                minimum=0.0,
+                maximum=1.0,
+                value=0.6,
+                step=0.01,
+                label="Mutual Friends Ratio"
+            )
+
+            next_button = gr.Button("Next week (T+1)")
+            reset_button = gr.Button("Reset timeline")
+
+        with gr.Column():
+            current_box = gr.Markdown(
+                "Current week status will appear here after you click **Next week (T+1)**."
+            )
+            timeline_box = gr.Markdown(
+                "## Timeline (T1–T5)\n(No entries yet)"
+            )
+            timeline_plot = gr.Plot(
+                value=make_timeline_plot([]),
+                label="Timeline probabilities (T1–T5)"
+            )
+
+    gr.Markdown("### Global Status Distribution on Real Dataset")
+    status_plot = gr.Plot(value=global_status_fig)
+
+    gr.Markdown("### Example Posts (Real Trusted vs Intruder-like)")
+    examples_table = gr.Dataframe(
+        value=examples_df,
+        label="Sample posts from dataset",
+        interactive=False
+    )
+    refresh_button = gr.Button("Refresh examples")
+
+    timeline_state = gr.State([])
+
+    next_button.click(
+        fn=simulate_week,
+        inputs=[
+            engagement_slider,
+            suspicious_slider,
+            activity_slider,
+            frr_slider,
+            mfr_slider,
+            timeline_state
+        ],
+        outputs=[current_box, timeline_box, timeline_plot, timeline_state]
+    )
+
+    reset_button.click(
+        fn=reset_timeline,
+        inputs=None,
+        outputs=[current_box, timeline_box, timeline_plot, timeline_state]
+    )
+
+    refresh_button.click(
+        fn=refresh_examples,
+        inputs=None,
+        outputs=[examples_table]
+    )
+
+if __name__ == "__main__":
+    demo.launch()