From d93627e3e65caf80cbe61a39366656a247793ba4 Mon Sep 17 00:00:00 2001
From: Kumkum Goyal <145197845+kum-kum1234@users.noreply.github.com>
Date: Thu, 4 Dec 2025 21:36:29 +0530
Subject: [PATCH 1/6] Add files via upload

---
 app.py | 491 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 491 insertions(+)
 create mode 100644 app.py

diff --git a/app.py b/app.py
new file mode 100644
index 0000000..b453d5d
--- /dev/null
+++ b/app.py
@@ -0,0 +1,491 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import joblib
+import plotly.graph_objects as go
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score,
+    confusion_matrix, roc_curve, auc
+)
+
+# -----------------------------------------------------------
+# PAGE CONFIG
+# -----------------------------------------------------------
+st.set_page_config(page_title="SentinelNet IDS", layout="wide")
+
+# -----------------------------------------------------------
+# CSS THEME
+# -----------------------------------------------------------
+st.markdown("""
+<style>
+
+body {
+    background-color: #060A19;
+    color: #E8ECF2;
+    font-family: 'Segoe UI', sans-serif;
+}
+
+/* Glowing Header */
+h1 {
+    color: #7EC8FF !important;
+    text-shadow: 0 0 12px #1E90FF;
+    animation: glowPulse 2.5s infinite alternate;
+}
+
+@keyframes glowPulse {
+    from { text-shadow: 0 0 4px #1E90FF; }
+    to   { text-shadow: 0 0 18px #61DBFB; }
+}
+
+/* Section Titles */
+h2, h3, h4 {
+    color: #9BD1FF !important;
+    text-shadow: 0 0 6px #2271B3;
+}
+
+/* Main container */
+.block-container {
+    background-color: #0B1027;
+    padding: 2rem;
+    border-radius: 16px;
+    box-shadow: 0 0 20px #12172E;
+}
+
+/* Buttons */
+.stButton>button {
+    background-color: #1E90FF !important;
+    color: white !important;
+    border-radius: 12px !important;
+    padding: 0.7rem 1.4rem !important;
+    font-size: 1rem;
+    box-shadow: 0 0 10px #1E90FF;
+    transition: 0.2s ease-in-out;
+}
+.stButton>button:hover {
+    background-color: #5AB3FF !important;
+    box-shadow: 0 0 18px #61DBFB;
+}
+
+/* Table stylings */
+thead tr th {
+    background-color: #1A2038 !important;
+    color: #A6CEFF !important;
+}
+tbody tr {
+    background-color: #10162E !important;
+    color: #D6E4FF !important;
+}
+
+/* Metrics glowing cards */
+[data-testid="stMetric"] {
+    background-color: #151B36;
+    padding: 1rem;
+    border-radius: 12px;
+    border: 1px solid #1E90FF33;
+    box-shadow: 0 0 12px #1E90FF33;
+}
+
+</style>
+""", unsafe_allow_html=True)
+
+# -----------------------------------------------------------
+# CONFIG
+# -----------------------------------------------------------
+MODELS_DIR = "models"
+
+# Binary model files (your existing names)
+BINARY_MODEL_FILES = {
+    "Logistic Regression": "nslkdd_binary_logistic_regression.pkl",
+    "Decision Tree": "nslkdd_binary_decision_tree_classifier.pkl",
+    "Random Forest": "nslkdd_binary_random_forest.pkl",
+    "Gradient Boosting": "nslkdd_binary_gradient_boosting.pkl",
+    "KNN": "nslkdd_binary_knn.pkl",
+    "SVM (RBF)": "nslkdd_binary_svm__rbf_.pkl",
+    "XGBoost": "nslkdd_binary_xgboost.pkl"
+}
+
+# Multiclass model files (5-class: dos, normal, probe, r2l, u2r)
+MULTI_MODEL_FILES = {
+    "Decision Tree": "nslkdd_multi_decision_tree.pkl",
+    "Random Forest": "nslkdd_multi_random_forest.pkl",
+    "Extra Trees": "nslkdd_multi_extra_trees.pkl",
+    "Naive Bayes": "nslkdd_multi_naive_bayes.pkl",
+    "Logistic Regression": "nslkdd_multi_logistic_regression.pkl"
+}
+
+# Load scalers + feature lists
+binary_scaler = joblib.load(f"{MODELS_DIR}/nslkdd_scaler.pkl")
+binary_features = [str(c) for c in joblib.load(f"{MODELS_DIR}/nslkdd_binary_features.pkl")]
+
+multi_scaler = joblib.load(f"{MODELS_DIR}/nslkdd_multi_scaler.pkl")
+multi_features = [str(c) for c in joblib.load(f"{MODELS_DIR}/nslkdd_multi_features.pkl")]
+
+LABEL_COL = 41
+DIFFICULTY_COL = 42
+
+# NSL-KDD column names (43-col)
+NSL_COLUMNS = [
+    'duration','protocol_type','service','flag','src_bytes','dst_bytes','land',
+    'wrong_fragment','urgent','hot','num_failed_logins','logged_in',
+    'num_compromised','root_shell','su_attempted','num_root','num_file_creations',
+    'num_shells','num_access_files','num_outbound_cmds','is_host_login',
+    'is_guest_login','count','srv_count','serror_rate','srv_serror_rate',
+    'rerror_rate','srv_rerror_rate','same_srv_rate','diff_srv_rate',
+    'srv_diff_host_rate','dst_host_count','dst_host_srv_count',
+    'dst_host_same_srv_rate','dst_host_diff_srv_rate','dst_host_same_src_port_rate',
+    'dst_host_srv_diff_host_rate','dst_host_serror_rate','dst_host_srv_serror_rate',
+    'dst_host_rerror_rate','dst_host_srv_rerror_rate','label','difficulty'
+]
+
+# -----------------------------------------------------------
+# Multiclass mapping (supports both numeric + string labels)
+# -----------------------------------------------------------
+
+# String attack → 5-class
+dos_attacks = [
+    "back","land","neptune","pod","smurf","teardrop",
+    "mailbomb","processtable","udpstorm","apache2","worm"
+]
+probe_attacks = [
+    "satan","ipsweep","nmap","portsweep","mscan","saint"
+]
+r2l_attacks = [
+    "guess_passwd","ftp_write","imap","phf","multihop","warezmaster",
+    "warezclient","spy","xlock","xsnoop","snmpguess","snmpgetattack",
+    "httptunnel","sendmail","named"
+]
+u2r_attacks = [
+    "buffer_overflow","loadmodule","rootkit","perl","sqlattack","xterm","ps"
+]
+
+def map_string_label(v: str):
+    v = str(v).strip().lower().replace(".", "")
+    if v == "normal":
+        return "normal"
+    if v in dos_attacks:
+        return "dos"
+    if v in probe_attacks:
+        return "probe"
+    if v in r2l_attacks:
+        return "r2l"
+    if v in u2r_attacks:
+        return "u2r"
+    return "unknown"
+
+# Old NSL numeric → 5-class
+numeric_to_5class = {
+    0:"normal", 14:"normal", 16:"normal", 21:"normal",
+
+    # DOS
+    1:"dos", 2:"dos", 3:"dos", 4:"dos", 5:"dos",
+    6:"dos", 7:"dos", 8:"dos", 9:"dos", 10:"dos",
+    15:"dos", 18:"dos", 34:"dos",
+
+    # PROBE
+    11:"probe", 12:"probe", 13:"probe", 17:"probe",
+    22:"probe", 23:"probe", 24:"probe", 27:"probe",
+    33:"probe", 36:"probe", 37:"probe", 39:"probe",
+
+    # R2L
+    19:"r2l", 20:"r2l", 26:"r2l", 38:"r2l", 35:"r2l",
+
+    # U2R
+    25:"u2r", 28:"u2r", 29:"u2r", 30:"u2r",
+    31:"u2r", 32:"u2r"
+}
+
+# 0..4 encoding → 5-class (NSL-KDD 5-class version)
+INT_TO_CLASS = {
+    0: "normal",
+    1: "dos",
+    2: "probe",
+    3: "r2l",
+    4: "u2r"
+}
+
+def to_main_class(label):
+    """
+    Convert ANY label format into one of:
+    'dos', 'normal', 'probe', 'r2l', 'u2r', or 'unknown'.
+
+    Handles:
+    - 0..4 numeric (5-class NSL)
+    - NSL original numeric IDs (0,1,2,...,39)
+    - String attack names: 'neptune', 'smurf', 'normal', etc.
+    """
+    s = str(label).strip().lower()
+
+    # numeric style
+    if s.isdigit():
+        n = int(s)
+        if n in INT_TO_CLASS:
+            return INT_TO_CLASS[n]
+        if n in numeric_to_5class:
+            return numeric_to_5class[n]
+        return "unknown"
+
+    # string attack / normal
+    return map_string_label(s)
+
+MULTI_CLASSES = ["dos", "normal", "probe", "r2l", "u2r"]
+MULTI_CLASS_TO_ID = {c: i for i, c in enumerate(MULTI_CLASSES)}
+
+# -----------------------------------------------------------
+# PREPROCESS: BINARY
+# -----------------------------------------------------------
+def preprocess_binary(df_raw: pd.DataFrame):
+    """
+    Preprocessing for binary models (KDDTrain+/KDDTest+ style):
+    - label at col 41
+    - optional difficulty at col 42
+    - sparse dummies to avoid memory issues
+    """
+    df = df_raw.copy()
+
+    # labels from column 41
+    y_raw = df.iloc[:, LABEL_COL].astype(str)
+
+    # drop label + optional difficulty
+    df = df.drop(columns=[LABEL_COL], errors="ignore")
+    if df.shape[1] > DIFFICULTY_COL:
+        df = df.drop(columns=[DIFFICULTY_COL], errors="ignore")
+
+    df.columns = df.columns.astype(str)
+
+    # encode categorical with SPARSE dummies
+    cat_cols = df.select_dtypes(include="object").columns.tolist()
+    df_encoded = pd.get_dummies(
+        df,
+        columns=cat_cols,
+        drop_first=True,
+        sparse=True
+    )
+    df_encoded.columns = df_encoded.columns.astype(str)
+
+    # ensure all training features exist
+    for col in binary_features:
+        if col not in df_encoded.columns:
+            df_encoded[col] = 0
+
+    # keep only features used during training
+    df_encoded = df_encoded[binary_features].astype(float)
+
+    # scale
+    X_scaled = binary_scaler.transform(df_encoded)
+
+    return X_scaled, y_raw, df_raw
+
+# -----------------------------------------------------------
+# PREPROCESS: MULTICLASS (NO get_dummies)
+# -----------------------------------------------------------
+def preprocess_multiclass(df_raw: pd.DataFrame):
+    """
+    Preprocessing for NSLKDDTest.csv (5-class numeric labels 0..4):
+    - 42 or 43 columns
+    - label column is numeric 0..4
+    - output labels as strings: dos, normal, probe, r2l, u2r
+    """
+    df = df_raw.copy()
+
+    # Fix shape: if 42 cols, add dummy difficulty
+    if df.shape[1] == 42:
+        df[42] = 0
+    elif df.shape[1] != 43:
+        raise ValueError(f"Expected 42 or 43 columns, got {df.shape[1]}")
+
+    # Proper column names
+    df.columns = NSL_COLUMNS
+
+    # Remove accidental header row
+    if not str(df.loc[0, "duration"]).replace(".", "", 1).isdigit():
+        df = df.iloc[1:].reset_index(drop=True)
+
+    # ---- LABELS: numeric 0..4 → 5-class strings ----
+    y_raw_numeric = (
+    df["label"]
+    .astype(str)
+    .str.replace(".0", "", regex=False)
+    .astype(int)
+)
+
+    y_labels = y_raw_numeric.map(INT_TO_CLASS)   # normal/dos/probe/r2l/u2r
+
+    # ---- FEATURES ----
+    cat_cols = ["protocol_type", "service", "flag"]
+    drop_cols = cat_cols + ["label", "difficulty"]
+    numeric_cols = [c for c in df.columns if c not in drop_cols]
+
+    numeric_part = df[numeric_cols].apply(pd.to_numeric, errors="coerce").fillna(0.0)
+
+    # Manual one-hot encoding based ONLY on training feature list
+    df_cat = pd.DataFrame(index=df.index)
+
+    for col in cat_cols:
+        prefix = col + "_"
+        available_features = [f for f in multi_features if f.startswith(prefix)]
+        values = df[col].astype(str)
+
+        for feat in available_features:
+            cat_value = feat[len(prefix):]
+            df_cat[feat] = (values == cat_value).astype(int)
+
+    full = pd.concat([numeric_part, df_cat], axis=1)
+
+    # Ensure all model features exist
+    for col in multi_features:
+        if col not in full.columns:
+            full[col] = 0
+
+    full = full[multi_features].astype(float)
+
+    # Scale
+    X_scaled = multi_scaler.transform(full)
+
+    # Return X + string labels
+    return X_scaled, y_labels.values, df
+# -----------------------------------------------------------
+# UI
+# -----------------------------------------------------------
+st.markdown(
+    "<h1 style='text-align:center;'>⚡ SentinelNet IDS — Binary + Multiclass ⚡</h1>",
+    unsafe_allow_html=True
+)
+
+uploaded = st.file_uploader("Upload NSL-KDD / KDD CSV file", type=["csv"])
+
+mode = st.sidebar.selectbox(
+    "Select Task",
+    ["Binary Classification", "Multiclass Classification"]
+)
+
+if uploaded is not None:
+    # clean read, no python engine nonsense
+    df_raw = pd.read_csv(
+        uploaded,
+        header=None,
+        low_memory=False
+    )
+
+    st.success(f"Loaded: {uploaded.name} | Shape: {df_raw.shape}")
+    st.dataframe(df_raw.head(10), width="stretch")
+
+    st.subheader("⚙ Classification Mode")
+    mode = st.radio(
+        "Select Mode:",
+        ["Binary Classification", "Multiclass Classification"],
+        horizontal=True
+    )
+
+    # -------------------------- BINARY -------------------------
+    if mode == "Binary Classification":
+        X, y_raw, base_df = preprocess_binary(df_raw)
+        y_true = np.array([0 if v.lower() == "normal" else 1 for v in y_raw])
+
+        model_name = st.selectbox("Select Binary Model", list(BINARY_MODEL_FILES.keys()))
+        model = joblib.load(f"{MODELS_DIR}/{BINARY_MODEL_FILES[model_name]}")
+
+        y_pred = model.predict(X)
+        try:
+            y_score = model.predict_proba(X)[:, 1]
+        except Exception:
+            y_score = None
+
+        acc = accuracy_score(y_true, y_pred)
+        prec = precision_score(y_true, y_pred, zero_division=0)
+        rec = recall_score(y_true, y_pred, zero_division=0)
+        f1 = f1_score(y_true, y_pred, zero_division=0)
+
+        st.subheader("📊 Binary Metrics")
+        c1, c2, c3, c4 = st.columns(4)
+        c1.metric("Accuracy", f"{acc*100:.2f}%")
+        c2.metric("Precision", f"{prec*100:.2f}%")
+        c3.metric("Recall", f"{rec*100:.2f}%")
+        c4.metric("F1 Score", f"{f1*100:.2f}%")
+
+        cm = confusion_matrix(y_true, y_pred)
+        fig = go.Figure(go.Heatmap(
+            z=cm,
+            x=["normal", "attack"],
+            y=["normal", "attack"],
+            colorscale="Blues",
+            text=cm,
+            texttemplate="%{text}"
+        ))
+        fig.update_layout(title="Confusion Matrix — Binary")
+        st.plotly_chart(fig, width="stretch")
+
+        if y_score is not None:
+            fpr, tpr, _ = roc_curve(y_true, y_score)
+            auc_val = auc(fpr, tpr)
+            roc_fig = go.Figure()
+            roc_fig.add_trace(go.Scatter(x=fpr, y=tpr, mode="lines",
+                                         name=f"AUC={auc_val:.3f}"))
+            roc_fig.add_trace(go.Scatter(x=[0, 1], y=[0, 1], mode="lines",
+                                         line=dict(dash="dash")))
+            roc_fig.update_layout(title="ROC Curve — Binary",
+                                  xaxis_title="FPR", yaxis_title="TPR")
+            st.plotly_chart(roc_fig, width="stretch")
+
+    # -------------------------- MULTICLASS -------------------------
+    # -------------------------- MULTICLASS -------------------------
+    if mode == "Multiclass Classification":
+        X, y_true, df_named = preprocess_multiclass(df_raw)  # y_true are strings
+
+        model_name = st.selectbox("Select Multiclass Model", list(MULTI_MODEL_FILES.keys()))
+        model = joblib.load(f"{MODELS_DIR}/{MULTI_MODEL_FILES[model_name]}")
+
+        # model predictions (normally 0..4 integers)
+        raw_pred = model.predict(X)
+
+        # Map predictions to 5-class strings
+        y_pred = []
+        for v in raw_pred:
+            if isinstance(v, (int, np.integer, np.int64, np.int32)):
+                y_pred.append(INT_TO_CLASS.get(int(v), "unknown"))
+            else:
+                # if model somehow outputs string labels (rare), just pass through
+                y_pred.append(str(v).lower())
+
+        y_pred = np.array(y_pred)
+
+        # We expect no 'unknown' for NSLKDDTest; but just in case:
+        valid_mask = y_pred != "unknown"
+        y_true_valid = y_true[valid_mask]
+        y_pred_valid = y_pred[valid_mask]
+
+        if len(y_true_valid) == 0:
+            st.error("All predictions mapped to 'unknown'. Cannot compute metrics.")
+        else:
+            # METRICS
+            acc = accuracy_score(y_true_valid, y_pred_valid)
+            prec = precision_score(y_true_valid, y_pred_valid,
+                                   average="weighted", zero_division=0)
+            rec = recall_score(y_true_valid, y_pred_valid,
+                               average="weighted", zero_division=0)
+            f1 = f1_score(y_true_valid, y_pred_valid,
+                          average="weighted", zero_division=0)
+
+            st.subheader("📊 Multiclass Metrics (5-class)")
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Accuracy", f"{acc*100:.2f}%")
+            c2.metric("Precision", f"{prec*100:.2f}%")
+            c3.metric("Recall", f"{rec*100:.2f}%")
+            c4.metric("F1 Score", f"{f1*100:.2f}%")
+
+            # CONFUSION MATRIX in fixed class order
+            cm = confusion_matrix(
+                y_true_valid,
+                y_pred_valid,
+                labels=MULTI_CLASSES
+            )
+
+            fig = go.Figure(go.Heatmap(
+                z=cm,
+                x=MULTI_CLASSES,
+                y=MULTI_CLASSES,
+                colorscale="Blues",
+                text=cm,
+                texttemplate="%{text}"
+            ))
+            fig.update_layout(title="Confusion Matrix — Multiclass (5-Class)")
+            st.plotly_chart(fig, use_container_width=True)

From b392c5beee3915a4c25d67e5fb604e00fe184704 Mon Sep 17 00:00:00 2001
From: Kumkum Goyal <145197845+kum-kum1234@users.noreply.github.com>
Date: Thu, 4 Dec 2025 21:37:01 +0530
Subject: [PATCH 2/6] Add files via upload

---
 main.py | 253 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 253 insertions(+)

diff --git a/main.py b/main.py
index e69de29..ed89b6f 100644
--- a/main.py
+++ b/main.py
@@ -0,0 +1,253 @@
+import pandas as pd
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split
+from sklearn.impute import SimpleImputer
+from sklearn.preprocessing import StandardScaler
+from imblearn.over_sampling import SMOTE
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report
+from sklearn.ensemble import RandomForestClassifier
+from xgboost import XGBClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import LinearSVC
+import warnings
+warnings.filterwarnings("ignore")
+
+path = r"C://Users//S Rakshita//Desktop//SENITNELNET//SentinelNet_Oct_Batch//KDDTrain+.csv"
+test_path = r"C://Users//S Rakshita//Desktop//SENITNELNET//SentinelNet_Oct_Batch//KDDTest+.csv"
+output_path = r"C://Users//S Rakshita//Desktop//SENITNELNET//SentinelNet_Oct_Batch//modified_data.csv"
+
+df = pd.read_csv(path)
+print("Before deleting column:")
+print(df.head())
+
+if 'labels' in df.columns:
+    target_col = 'labels'
+    y = df[target_col]
+    df = df.drop(target_col, axis=1)
+else:
+    target_col = df.columns[-1]
+    y = df[target_col]
+    df = df.drop(target_col, axis=1)
+
+print("\nAfter deleting column:")
+print(df.head())
+
+print("\nTail (last 5 rows):")
+print(df.tail())
+
+print("\nInfo:")
+print(df.info())
+
+print("\nDescribe:")
+print(df.describe())
+
+print("\nMissing values per column:")
+print(df.isnull().sum())
+
+df_onecol = pd.read_csv(path, usecols=[0])
+print("\nLoaded 1 column only:")
+print(df_onecol.head())
+
+df_multicol = pd.read_csv(path, usecols=[0, 1, 2])
+print("\nLoaded multiple columns:")
+print(df_multicol.head())
+
+df["new_col"] = range(1, len(df) + 1)
+print("\nAfter adding new column:")
+print(df.head())
+
+first_col = df.columns[0]
+df_filtered = df[df[first_col] > 10]
+print(f"\nFiltered rows where {first_col} > 10:")
+print(df_filtered.head())
+
+output_dir = os.path.dirname(output_path)
+if not os.path.exists(output_dir):
+    os.makedirs(output_dir)
+
+df.to_csv(output_path, index=False)
+print(f"\nModified data stored successfully at: {output_path}")
+
+
+numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns
+'''
+df[numeric_cols].hist(figsize=(12, 10), bins=30, edgecolor='black')
+plt.suptitle("Histogram of Numeric Columns", fontsize=16)
+plt.show()
+
+plt.figure(figsize=(10, 8))
+sns.heatmap(df.corr(numeric_only=True), annot=False, cmap="coolwarm", linewidths=0.5)
+plt.title("Correlation Heatmap", fontsize=16)
+plt.show()
+
+for col in numeric_cols:
+    plt.figure(figsize=(6, 3))
+    sns.boxplot(x=df[col], color='lightblue')
+    plt.title(f"Boxplot of {col}")
+    plt.show()
+
+sns.pairplot(df.sample(min(200, len(df))), diag_kind='kde')
+plt.suptitle("Pairplot of Numeric Columns", y=1.02)
+plt.show()
+
+categorical_cols = df.select_dtypes(include=['object']).columns
+for col in categorical_cols:
+    plt.figure(figsize=(6, 3))
+    df[col].value_counts().plot(kind='bar')
+    plt.title(f"Bar Chart of {col}")
+    plt.xlabel(col)
+    plt.ylabel("Count")
+    plt.show()
+
+for col in categorical_cols:
+    plt.figure(figsize=(5, 5))
+    df[col].value_counts().plot.pie(autopct='%1.1f%%', startangle=90)
+    plt.title(f"Distribution of {col}")
+    plt.ylabel('')
+    plt.tight_layout()
+    plt.show()
+
+plt.figure(figsize=(10, 5))
+sns.heatmap(df.isnull(), cbar=False, cmap='viridis')
+plt.title("Missing Values Heatmap", fontsize=16)
+plt.show()
+'''
+
+df_encoded = pd.get_dummies(df, drop_first=True)
+print("\nEncoded dataset shape:", df_encoded.shape)
+
+try:
+    df_test = pd.read_csv(test_path)
+    print("\nTest dataset loaded:", df_test.shape)
+    df_test_encoded = pd.get_dummies(df_test, drop_first=True)
+    missing_cols = set(df_encoded.columns) - set(df_test_encoded.columns)
+    for col in missing_cols:
+        df_test_encoded[col] = 0
+    df_test_encoded = df_test_encoded[df_encoded.columns]
+    print("\nColumn consistency maintained between train and test datasets.")
+except FileNotFoundError:
+    print("\nTest dataset not found.")
+
+encoded_output = r"C://Users//S Rakshita//Desktop//SENITNELNET//SentinelNet_Oct_Batch//encoded_data.csv"
+df_encoded.to_csv(encoded_output, index=False)
+print(f"\nEncoded dataset saved to: {encoded_output}")
+
+
+print("\n--- Data Preprocessing Steps ---")
+
+print("\nPerforming Train-Test Split...")
+X_train, X_test, y_train, y_test = train_test_split(
+    df_encoded, y, test_size=0.2, random_state=42, stratify=y
+)
+print("Train shape:", X_train.shape)
+print("Test shape:", X_test.shape)
+
+print("\nApplying SimpleImputer (strategy='mean') on numeric columns...")
+imputer = SimpleImputer(strategy='mean')
+X_train[numeric_cols] = imputer.fit_transform(X_train[numeric_cols])
+X_test[numeric_cols] = imputer.transform(X_test[numeric_cols])
+print("Missing values handled successfully!")
+
+print("\nApplying SMOTE to balance the dataset...")
+smote = SMOTE(random_state=42)
+X_train_resampled, y_train_resampled = smote.fit_resample(X_train, y_train)
+print("After SMOTE: X_train =", X_train_resampled.shape, ", y_train =", y_train_resampled.shape)
+
+print("\nApplying StandardScaler on numeric features...")
+scaler = StandardScaler()
+X_train_resampled[numeric_cols] = scaler.fit_transform(X_train_resampled[numeric_cols])
+X_test[numeric_cols] = scaler.transform(X_test[numeric_cols])
+print("Standardization completed successfully!")
+
+print("\n--- OPTIMIZED MODEL TRAINING PIPELINE (NO FREEZE) ---")
+
+
+models = {
+    "Logistic Regression": LogisticRegression(
+        max_iter=500,
+        solver='saga',
+        penalty='l2',
+        n_jobs=-1,
+        random_state=42
+    ),
+    "Random Forest": RandomForestClassifier(
+        n_estimators=80,
+        max_depth=20,
+        n_jobs=-1,
+        random_state=42
+    ),
+    "XGBoost": XGBClassifier(
+        n_estimators=120,
+        learning_rate=0.1,
+        max_depth=6,
+        subsample=0.8,
+        colsample_bytree=0.8,
+        random_state=42,
+        tree_method='approx',
+        eval_metric='mlogloss'
+    ),
+    "Linear SVM": LinearSVC(
+        max_iter=5000,
+        dual=False,
+        random_state=42
+    ),
+    "KNN": KNeighborsClassifier(
+        n_neighbors=3,
+        weights='distance',
+        algorithm='auto',
+        n_jobs=-1
+    )
+}
+
+training_metrics = {}
+testing_metrics = {}
+
+def get_metrics(model, X, y):
+    preds = model.predict(X)
+    return {
+        "Accuracy": accuracy_score(y, preds),
+        "Precision": precision_score(y, preds, average="weighted", zero_division=0),
+        "Recall": recall_score(y, preds, average="weighted", zero_division=0),
+        "F1-Score": f1_score(y, preds, average="weighted", zero_division=0)
+    }
+
+for name, model in models.items():
+    print(f"\nTraining {name}...")
+    model.fit(X_train_resampled, y_train_resampled)
+
+    print(f"Evaluating Training Performance...")
+    training_metrics[name] = get_metrics(model, X_train_resampled, y_train_resampled)
+
+    print(f"Evaluating Testing Performance...")
+    testing_metrics[name] = get_metrics(model, X_test, y_test)
+
+    print(f"\n{name} Training Metrics:")
+    print(training_metrics[name])
+
+    print(f"\n{name} Testing Metrics:")
+    print(testing_metrics[name])
+
+    print("\nConfusion Matrix:")
+    print(confusion_matrix(y_test, model.predict(X_test)))
+
+    print("\nClassification Report:")
+    print(classification_report(y_test, model.predict(X_test), zero_division=0))
+
+train_df = pd.DataFrame(training_metrics).T
+test_df = pd.DataFrame(testing_metrics).T
+
+print(train_df)
+print(test_df)
+
+model_results_path = r"C://Users//S Rakshita//Desktop//SENITNELNET//SentinelNet_Oct_Batch//model_metrics.csv"
+combined_df = pd.concat(
+    [train_df.add_suffix("_train"), test_df.add_suffix("_test")], axis=1
+)
+combined_df.to_csv(model_results_path)
+
+print(f"\nModel metrics saved to: {model_results_path}")

From 6a176422d94ad20d312f3eac4645921894c8bcdc Mon Sep 17 00:00:00 2001
From: Kumkum Goyal <145197845+kum-kum1234@users.noreply.github.com>
Date: Thu, 4 Dec 2025 21:37:24 +0530
Subject: [PATCH 3/6] Add files via upload

---
 binaryclassify.ipynb | 1031 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1031 insertions(+)
 create mode 100644 binaryclassify.ipynb

diff --git a/binaryclassify.ipynb b/binaryclassify.ipynb
new file mode 100644
index 0000000..2a3153f
--- /dev/null
+++ b/binaryclassify.ipynb
@@ -0,0 +1,1031 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "725b9a64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report\n",
+    "from sklearn.linear_model import LogisticRegression, LinearRegression, SGDRegressor\n",
+    "from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor\n",
+    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n",
+    "from sklearn.neighbors import KNeighborsClassifier\n",
+    "from sklearn.svm import SVC\n",
+    "from xgboost import XGBClassifier\n",
+    "from sklearn.preprocessing import StandardScaler\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "40da4b59",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train shape: (22543, 43)\n",
+      "Test shape: (125973, 43)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>0</th>\n",
+       "      <th>1</th>\n",
+       "      <th>2</th>\n",
+       "      <th>3</th>\n",
+       "      <th>4</th>\n",
+       "      <th>5</th>\n",
+       "      <th>6</th>\n",
+       "      <th>7</th>\n",
+       "      <th>8</th>\n",
+       "      <th>9</th>\n",
+       "      <th>...</th>\n",
+       "      <th>33</th>\n",
+       "      <th>34</th>\n",
+       "      <th>35</th>\n",
+       "      <th>36</th>\n",
+       "      <th>37</th>\n",
+       "      <th>38</th>\n",
+       "      <th>39</th>\n",
+       "      <th>40</th>\n",
+       "      <th>41</th>\n",
+       "      <th>42</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>tcp</td>\n",
+       "      <td>private</td>\n",
+       "      <td>REJ</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.04</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>neptune</td>\n",
+       "      <td>21</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0</td>\n",
+       "      <td>tcp</td>\n",
+       "      <td>private</td>\n",
+       "      <td>REJ</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>neptune</td>\n",
+       "      <td>21</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>tcp</td>\n",
+       "      <td>ftp_data</td>\n",
+       "      <td>SF</td>\n",
+       "      <td>12983</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.61</td>\n",
+       "      <td>0.04</td>\n",
+       "      <td>0.61</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>normal</td>\n",
+       "      <td>21</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0</td>\n",
+       "      <td>icmp</td>\n",
+       "      <td>eco_i</td>\n",
+       "      <td>SF</td>\n",
+       "      <td>20</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.28</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>saint</td>\n",
+       "      <td>15</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1</td>\n",
+       "      <td>tcp</td>\n",
+       "      <td>telnet</td>\n",
+       "      <td>RSTO</td>\n",
+       "      <td>0</td>\n",
+       "      <td>15</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.31</td>\n",
+       "      <td>0.17</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.83</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>mscan</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 43 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   0     1         2     3      4   5   6   7   8   9   ...    33    34    35  \\\n",
+       "0   0   tcp   private   REJ      0   0   0   0   0   0  ...  0.04  0.06  0.00   \n",
+       "1   0   tcp   private   REJ      0   0   0   0   0   0  ...  0.00  0.06  0.00   \n",
+       "2   2   tcp  ftp_data    SF  12983   0   0   0   0   0  ...  0.61  0.04  0.61   \n",
+       "3   0  icmp     eco_i    SF     20   0   0   0   0   0  ...  1.00  0.00  1.00   \n",
+       "4   1   tcp    telnet  RSTO      0  15   0   0   0   0  ...  0.31  0.17  0.03   \n",
+       "\n",
+       "     36   37   38    39    40       41  42  \n",
+       "0  0.00  0.0  0.0  1.00  1.00  neptune  21  \n",
+       "1  0.00  0.0  0.0  1.00  1.00  neptune  21  \n",
+       "2  0.02  0.0  0.0  0.00  0.00   normal  21  \n",
+       "3  0.28  0.0  0.0  0.00  0.00    saint  15  \n",
+       "4  0.02  0.0  0.0  0.83  0.71    mscan  11  \n",
+       "\n",
+       "[5 rows x 43 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_df = pd.read_csv(\"KDDTest+.csv\",header=None)\n",
+    "test_df = pd.read_csv(\"KDDTrain+.csv\",header=None)\n",
+    "print(\"Train shape:\", train_df.shape)\n",
+    "print(\"Test shape:\", test_df.shape)\n",
+    "train_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d4ae61c3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "e73ef376",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "label_col = 41\n",
+    "\n",
+    "train_df[label_col] = train_df[label_col].astype(str).str.strip().str.lower()\n",
+    "test_df[label_col]  = test_df[label_col].astype(str).str.strip().str.lower()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "97b77b0a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_df[\"attack_binary\"] = (train_df[label_col] != \"normal\").astype(int)\n",
+    "test_df[\"attack_binary\"]  = (test_df[label_col] != \"normal\").astype(int)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9c172c94",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "attack_binary\n",
+      "1    12833\n",
+      "0     9710\n",
+      "Name: count, dtype: int64\n",
+      "attack_binary\n",
+      "0    67343\n",
+      "1    58630\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(train_df[\"attack_binary\"].value_counts())\n",
+    "print(test_df[\"attack_binary\"].value_counts())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "5412a5fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train = train_df.drop(columns=[label_col, \"attack_binary\"])\n",
+    "y_train = train_df[\"attack_binary\"]\n",
+    "\n",
+    "X_test  = test_df.drop(columns=[label_col, \"attack_binary\"])\n",
+    "y_test  = test_df[\"attack_binary\"]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d16e404e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cat_cols = X_train.select_dtypes(include=['object']).columns\n",
+    "X_train = pd.get_dummies(X_train, columns=cat_cols, drop_first=True)\n",
+    "X_test  = pd.get_dummies(X_test,  columns=cat_cols, drop_first=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "30bb83b1",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "AttributeError",
+     "evalue": "'numpy.ndarray' object has no attribute 'columns'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[12], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m missing_cols \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mset\u001b[39m(\u001b[43mX_train\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m) \u001b[38;5;241m-\u001b[39m \u001b[38;5;28mset\u001b[39m(X_test\u001b[38;5;241m.\u001b[39mcolumns)\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m col \u001b[38;5;129;01min\u001b[39;00m missing_cols:\n\u001b[0;32m      3\u001b[0m     X_test[col] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n",
+      "\u001b[1;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'columns'"
+     ]
+    }
+   ],
+   "source": [
+    "missing_cols = set(X_train.columns) - set(X_test.columns)\n",
+    "for col in missing_cols:\n",
+    "    X_test[col] = 0\n",
+    "\n",
+    "extra_cols = set(X_test.columns) - set(X_train.columns)\n",
+    "X_test.drop(columns=extra_cols, inplace=True)\n",
+    "\n",
+    "X_test = X_test[X_train.columns]\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fe96ff0c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Column names fixed! Ready for scaling.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Ensure DataFrame form\n",
+    "X_train = pd.DataFrame(X_train)\n",
+    "X_test  = pd.DataFrame(X_test)\n",
+    "\n",
+    "# Convert all feature names to string\n",
+    "X_train.columns = X_train.columns.astype(str)\n",
+    "X_test.columns  = X_test.columns.astype(str)\n",
+    "\n",
+    "print(\"Column names fixed! Ready for scaling.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "07820a26",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Scaler saved successfully!\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.preprocessing import StandardScaler\n",
+    "scaler = StandardScaler()\n",
+    "\n",
+    "X_train = scaler.fit_transform(X_train)\n",
+    "X_test  = scaler.transform(X_test)\n",
+    "import joblib\n",
+    "joblib.dump(scaler, \"models/nslkdd_scaler.pkl\")\n",
+    "print(\"Scaler saved successfully!\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "574149d4",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "06fb39dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "models = {\n",
+    "    \"Logistic Regression\": LogisticRegression(\n",
+    "        max_iter=1000,\n",
+    "        random_state=42\n",
+    "    ),\n",
+    "\n",
+    "    \"Decision Tree Classifier\": DecisionTreeClassifier(\n",
+    "        random_state=42\n",
+    "    ),\n",
+    "\n",
+    "    \"Random Forest\": RandomForestClassifier(\n",
+    "        n_estimators=200,\n",
+    "        random_state=42\n",
+    "    ),\n",
+    "\n",
+    "    \"Gradient Boosting\": GradientBoostingClassifier(\n",
+    "        n_estimators=200,\n",
+    "        random_state=42\n",
+    "    ),\n",
+    "\n",
+    "    \"XGBoost\": XGBClassifier(\n",
+    "        n_estimators=200,\n",
+    "        eval_metric=\"logloss\",\n",
+    "        random_state=42\n",
+    "    ),\n",
+    "\n",
+    "    \"KNN\": KNeighborsClassifier(\n",
+    "        n_neighbors=5\n",
+    "    ),\n",
+    "\n",
+    "    \"SVM (RBF)\": SVC(\n",
+    "        kernel=\"rbf\",\n",
+    "        probability=True,\n",
+    "        random_state=42\n",
+    "    )\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "b934e4db",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Logistic Regression\n",
+      "\n",
+      "\n",
+      "Decision Tree Classifier\n",
+      "\n",
+      "\n",
+      "Random Forest\n",
+      "\n",
+      "\n",
+      "Gradient Boosting\n",
+      "\n",
+      "\n",
+      "XGBoost\n",
+      "\n",
+      "\n",
+      "KNN\n",
+      "\n",
+      "\n",
+      "SVM (RBF)\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "results = {}\n",
+    "\n",
+    "for name, model in models.items():\n",
+    "    print(f\"{name}\")\n",
+    "    print(\"\\n\")\n",
+    "    \n",
+    "    model.fit(X_train, y_train)\n",
+    "    y_pred = model.predict(X_test)\n",
+    "    \n",
+    "    # Skip classification metrics if regression model\n",
+    "    if name in [\"Linear Regression (OLS)\", \"Gradient Descent (SGD)\", \"Decision Tree Regressor\"]:\n",
+    "        results[name] = {\n",
+    "            \"note\": \"Regression model – classification metrics not applicable\"\n",
+    "        }\n",
+    "        continue\n",
+    "    \n",
+    "    acc = accuracy_score(y_test, y_pred)\n",
+    "    prec = precision_score(y_test, y_pred)\n",
+    "    rec = recall_score(y_test, y_pred)\n",
+    "    f1 = f1_score(y_test, y_pred)\n",
+    "    cm = confusion_matrix(y_test, y_pred)\n",
+    "    report = classification_report(y_test, y_pred)\n",
+    "    \n",
+    "    results[name] = {\n",
+    "        \"accuracy\": acc,\n",
+    "        \"precision\": prec,\n",
+    "        \"recall\": rec,\n",
+    "        \"f1\": f1,\n",
+    "        \"confusion_matrix\": cm,\n",
+    "        \"report\": report\n",
+    "    }\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "c5e07a2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "MODEL RESULTS\n",
+      "\n",
+      "Logistic Regression\n",
+      "-------------------\n",
+      "Accuracy: 0.9320965603740484\n",
+      "Precision: 0.9078115838165353\n",
+      "Recall: 0.9506396042981409\n",
+      "F1-Score: 0.9287321080432573\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[61683  5660]\n",
+      " [ 2894 55736]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.96      0.92      0.94     67343\n",
+      "           1       0.91      0.95      0.93     58630\n",
+      "\n",
+      "    accuracy                           0.93    125973\n",
+      "   macro avg       0.93      0.93      0.93    125973\n",
+      "weighted avg       0.93      0.93      0.93    125973\n",
+      "\n",
+      "\n",
+      "\n",
+      "Decision Tree Classifier\n",
+      "------------------------\n",
+      "Accuracy: 0.9816547990442397\n",
+      "Precision: 0.9792372232338876\n",
+      "Recall: 0.9813917789527545\n",
+      "F1-Score: 0.9803133172614129\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[66123  1220]\n",
+      " [ 1091 57539]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.98      0.98      0.98     67343\n",
+      "           1       0.98      0.98      0.98     58630\n",
+      "\n",
+      "    accuracy                           0.98    125973\n",
+      "   macro avg       0.98      0.98      0.98    125973\n",
+      "weighted avg       0.98      0.98      0.98    125973\n",
+      "\n",
+      "\n",
+      "\n",
+      "Random Forest\n",
+      "-------------\n",
+      "Accuracy: 0.9589912124026577\n",
+      "Precision: 0.9358857291938429\n",
+      "Recall: 0.9789527545625106\n",
+      "F1-Score: 0.9569349272245286\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[63411  3932]\n",
+      " [ 1234 57396]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.98      0.94      0.96     67343\n",
+      "           1       0.94      0.98      0.96     58630\n",
+      "\n",
+      "    accuracy                           0.96    125973\n",
+      "   macro avg       0.96      0.96      0.96    125973\n",
+      "weighted avg       0.96      0.96      0.96    125973\n",
+      "\n",
+      "\n",
+      "\n",
+      "Gradient Boosting\n",
+      "-----------------\n",
+      "Accuracy: 0.960396275392346\n",
+      "Precision: 0.9268537233619276\n",
+      "Recall: 0.9932969469554835\n",
+      "F1-Score: 0.9589257634012004\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[62747  4596]\n",
+      " [  393 58237]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.99      0.93      0.96     67343\n",
+      "           1       0.93      0.99      0.96     58630\n",
+      "\n",
+      "    accuracy                           0.96    125973\n",
+      "   macro avg       0.96      0.96      0.96    125973\n",
+      "weighted avg       0.96      0.96      0.96    125973\n",
+      "\n",
+      "\n",
+      "\n",
+      "XGBoost\n",
+      "-------\n",
+      "Accuracy: 0.986243083835425\n",
+      "Precision: 0.9775722271651363\n",
+      "Recall: 0.9932287224970152\n",
+      "F1-Score: 0.9853382854338869\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[66007  1336]\n",
+      " [  397 58233]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.99      0.98      0.99     67343\n",
+      "           1       0.98      0.99      0.99     58630\n",
+      "\n",
+      "    accuracy                           0.99    125973\n",
+      "   macro avg       0.99      0.99      0.99    125973\n",
+      "weighted avg       0.99      0.99      0.99    125973\n",
+      "\n",
+      "\n",
+      "\n",
+      "KNN\n",
+      "---\n",
+      "Accuracy: 0.9373675311376247\n",
+      "Precision: 0.921218661796447\n",
+      "Recall: 0.9463585195292512\n",
+      "F1-Score: 0.9336193841494195\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[62598  4745]\n",
+      " [ 3145 55485]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.95      0.93      0.94     67343\n",
+      "           1       0.92      0.95      0.93     58630\n",
+      "\n",
+      "    accuracy                           0.94    125973\n",
+      "   macro avg       0.94      0.94      0.94    125973\n",
+      "weighted avg       0.94      0.94      0.94    125973\n",
+      "\n",
+      "\n",
+      "\n",
+      "SVM (RBF)\n",
+      "---------\n",
+      "Accuracy: 0.9493939177442785\n",
+      "Precision: 0.936980482012343\n",
+      "Recall: 0.9555347091932458\n",
+      "F1-Score: 0.9461666427407301\n",
+      "\n",
+      "Confusion Matrix:\n",
+      "[[63575  3768]\n",
+      " [ 2607 56023]]\n",
+      "\n",
+      "Classification Report:\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.96      0.94      0.95     67343\n",
+      "           1       0.94      0.96      0.95     58630\n",
+      "\n",
+      "    accuracy                           0.95    125973\n",
+      "   macro avg       0.95      0.95      0.95    125973\n",
+      "weighted avg       0.95      0.95      0.95    125973\n",
+      "\n",
+      "\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"\\nMODEL RESULTS\\n\")\n",
+    "\n",
+    "for name, metrics in results.items():\n",
+    "    print(name)\n",
+    "    print(\"-\" * len(name))\n",
+    "    \n",
+    "    if \"note\" in metrics:\n",
+    "        print(metrics[\"note\"])\n",
+    "        print()\n",
+    "        continue\n",
+    "    \n",
+    "    print(\"Accuracy:\", metrics[\"accuracy\"])\n",
+    "    print(\"Precision:\", metrics[\"precision\"])\n",
+    "    print(\"Recall:\", metrics[\"recall\"])\n",
+    "    print(\"F1-Score:\", metrics[\"f1\"])\n",
+    "    print(\"\\nConfusion Matrix:\")\n",
+    "    print(metrics[\"confusion_matrix\"])\n",
+    "    print(\"\\nClassification Report:\")\n",
+    "    print(metrics[\"report\"])\n",
+    "    print(\"\\n\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8043391c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def plot_cm(name):\n",
+    "    cm = results[name][\"confusion_matrix\"]\n",
+    "    sns.heatmap(cm, annot=True, fmt=\"d\", cmap=\"Blues\")\n",
+    "    plt.title(f\"Confusion Matrix - {name}\")\n",
+    "    plt.xlabel(\"Predicted\")\n",
+    "    plt.ylabel(\"Actual\")\n",
+    "    plt.show()\n",
+    "\n",
+    "for name in results:\n",
+    "    if \"confusion_matrix\" in results[name]:\n",
+    "        plot_cm(name)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d55f50b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"model_results_binary.txt\", \"w\") as f:\n",
+    "    f.write(\"MODELWISE SUMMARY (Binary Classification)\\n\")\n",
+    "    f.write(\"=\"*60 + \"\\n\\n\")\n",
+    "\n",
+    "    for name, r in results.items():\n",
+    "        f.write(f\"MODEL: {name}\\n\")\n",
+    "        f.write(\"=\"*40 + \"\\n\")\n",
+    "        if \"accuracy\" in r:\n",
+    "            f.write(f\"Accuracy: {r['accuracy']:.4f}\\n\")\n",
+    "            f.write(f\"Precision: {r['precision']:.4f}\\n\")\n",
+    "            f.write(f\"Recall: {r['recall']:.4f}\\n\")\n",
+    "            f.write(f\"F1 Score: {r['f1']:.4f}\\n\\n\")\n",
+    "            f.write(\"Confusion Matrix:\\n\")\n",
+    "            f.write(str(r[\"confusion_matrix\"]) + \"\\n\\n\")\n",
+    "            f.write(\"Classification Report:\\n\")\n",
+    "            f.write(r[\"report\"] + \"\\n\\n\")\n",
+    "        else:\n",
+    "            f.write(\"Regression model — metrics not applicable.\\n\\n\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "f3107d69",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "MODEL TRAINING SUMMARY\n",
+      "\n",
+      "                      Model  Train Acc  Test Acc  Precision    Recall  F1-Score       AUC\n",
+      "0       Logistic Regression        1.0  0.932097   0.907812  0.950640  0.928732  0.976638\n",
+      "1  Decision Tree Classifier        1.0  0.981655   0.979237  0.981392  0.980313  0.981638\n",
+      "2             Random Forest        1.0  0.958991   0.935886  0.978953  0.956935  0.996637\n",
+      "3         Gradient Boosting        1.0  0.960396   0.926854  0.993297  0.958926  0.995302\n",
+      "4                   XGBoost        1.0  0.986243   0.977572  0.993229  0.985338  0.999048\n",
+      "5                       KNN        1.0  0.937368   0.921219  0.946359  0.933619  0.975643\n",
+      "6                 SVM (RBF)        1.0  0.949394   0.936980  0.955535  0.946167  0.990514\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import roc_auc_score\n",
+    "summary_rows = []\n",
+    "\n",
+    "for name, m in results.items():\n",
+    "    if \"accuracy\" in m:\n",
+    "        auc = roc_auc_score(y_test, models[name].predict_proba(X_test)[:,1]) if hasattr(models[name], \"predict_proba\") else roc_auc_score(y_test, models[name].decision_function(X_test))\n",
+    "        summary_rows.append([name, 1.0000, m[\"accuracy\"], m[\"precision\"], m[\"recall\"], m[\"f1\"], auc])\n",
+    "\n",
+    "summary_df = pd.DataFrame(summary_rows, columns=[\"Model\", \"Train Acc\", \"Test Acc\", \"Precision\", \"Recall\", \"F1-Score\", \"AUC\"])\n",
+    "print(\"\\nMODEL TRAINING SUMMARY\\n\")\n",
+    "print(summary_df.to_string(index=True))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "48e59c06",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "==== ROC AUC SCORES ====\n",
+      "\n",
+      "Logistic Regression : AUC = 0.97664\n",
+      "Decision Tree Classifier : AUC = 0.98164\n",
+      "Random Forest : AUC = 0.99664\n",
+      "Gradient Boosting : AUC = 0.99530\n",
+      "XGBoost : AUC = 0.99905\n",
+      "KNN : AUC = 0.97564\n",
+      "SVM (RBF) : AUC = 0.99051\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjcsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvTLEjVAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqSZJREFUeJztnQeYE1UXhk822U7vHem9iiAgIiKiomAFQREbNlB+bKBSrNhFLNgFG0URFAFBpaMiKKBIlSIgvddtSeZ/vpNMmGSTbSS7y+73PgxJps+dbO43p9xjMwzDEEIIIYSQAkJUXp8AIYQQQkg4obghhBBCSIGC4oYQQgghBQqKG0IIIYQUKChuCCGEEFKgoLghhBBCSIGC4oYQQgghBQqKG0IIIYQUKChuCCGEEFKgoLghhJBssGDBArHZbPpqcuutt8o555yTb9tx/Pjxes7//vtvtrd98skndVtCziYobgiJcIdiTg6HQypXrqwd4c6dO4Nug2oon332mVx44YVSokQJSUhIkCZNmsjTTz8tJ0+eDHmsadOmyeWXXy5lypSRmJgYqVSpkvTs2VPmzZuXpXNNTk6W0aNHS5s2baR48eISFxcndevWlYEDB8rGjRulMIF2w/0aMmRI2Pd90UUX6b7r1KkTdPmPP/7o+75MmTIl7McnpLBAcUNIhIEwgWB59913VYB8/vnn0rFjRxUUVlwul9x4441yyy23+J6YX3/9dWnevLk89dRTcv7558vevXvTiaHbbrtNrr32Wl324IMP6nEGDBggW7Zskc6dO8svv/yS4fkdOHBALrjgAt22XLlyer5vv/22XH311TJ9+nRp3LixFBaOHTsm3333nVphJk6cqO0bbiAcN23aJMuWLUu37IsvvtDlhJAzBIUzCSHhZ9y4cegZjeXLl/vNHzJkiM6fPHmy3/xRo0bp/IcffjjdvqZPn25ERUUZl112md/8l19+Wbf53//+Z7jd7nTbffrpp8Zvv/2W4Xl269ZN9z1lypR0y5KTk42HHnrICAdpaWlGSkqKkZ/5+OOPjejoaGPevHnargsWLEi3zvz583UZXk369etnVK9ePdP9d+zY0WjUqJFRr149vWdWkpKSjGLFihnXXXed7v+rr74K+3dx69at2d525MiRui0hZxO03BCSy3To0EFfN2/e7JuXlJQkL7/8srqCnn/++XTbXHXVVdKvXz+ZPXu2LF261LcN1q1fv7688sorQeMi+vbtK61btw55Lr/99pvMnDlT7rjjDrnuuuvSLY+NjdV9W90qmAIJjDlBbAfOB9vC+lSrVi3d18qVK9U9B0tUIBs2bNBt3nrrLd+8I0eOyP/+9z+pWrWqbl+7dm158cUXxe12SySA5aRLly7SqVMnadCggX6OBL1795bJkyf7XQcsRqdOnVK3WDDQdrD8FStWTIoUKaJWOfO7YGXNmjVy8cUXS3x8vFSpUkWeffbZkO31/fff6/cxMTFRihYtKt26ddPtMwPuM1j74DrFudSrV08ef/zxbLUBIZGE4oaQXMYM6ixZsqRv3pIlS+Tw4cPSp08f7fyDYbqrZsyY4dvm0KFDuo3dbs/RucDtZIqgSDBu3Dh588035a677pJXX31VKlasqC65L7/8Mt266OxxHTfccIN+RkePdeHGw7W/8cYb0r59e3nsscfUhRZudu3aJfPnz1fhAfCKuJfU1NSwHwv3bPfu3X5ByRMmTFDBAtdgIBAcECF//vmnPProozJ8+HDZunWrCk0IVJM9e/aoMFu1apUMHTpUheGnn34qY8aMSbdPuEohZiBOIBixz7Vr16poySjwGOdy5ZVXSkpKirowcV+7d+8uP//8c1jahpCwkNemI0IKKqYr4KeffjL2799v7NixQ10/ZcuWNWJjY/Wzyeuvv67rTps2LeT+Dh06pOtce+21+nnMmDGZbpMZ11xzje7j8OHDWVofbhVMgQS6ZeD+wH7hZtm3b5/fuu+9954uW716td/8hg0bGhdffLHv8zPPPGMkJiYaGzdu9Ftv6NChht1uN7Zv326Ek1deecWIj483jh07pp9x3GDtGw63FGjVqpVxxx136Hu0f0xMjPHJJ5/49m91S1199dW6fPPmzb55u3btMooWLWpceOGFvnlwdWFbqysS7V+8eHE/t9Tx48eNEiVKGP379/c7vz179ui61vmBbqnRo0frZ3ynCcmv0HJDSIS55JJLpGzZsupauf7669UFAIsJXAYmx48f11e4BkJhLkPQq/U1o20yIxz7yAi4unDtVhD8DOsULDUmf//9t1oNevXq5Zv31VdfqbUCFi4EPZsT2hPB14sWLQrrucIFBUuG2RbIaDr33HMj5pqC9Wbq1KlqGYKFCFara665Jt16uNYffvhBA7xr1qzpmw8rGPYBC555H2fNmqWB51ZXJNr/pptuSudWgssP1ilr2+IckDEHC1Yo4IoC3377bcTcg4ScKRQ3hEQYZB6hM0EHdsUVV2gngvgRK2aHaoqcYAQKIMReZLZNZoRjHxlRo0aNdPOQrg73i9U1BaEDwQPhY/LPP/9ojBE6Z+sEcQP27dsX8rhHjx5VF405wX2XEevWrdOYFri9kMlkTnD7wA1oiodwgsw4nCfiXiCg4OoJJjL379+vLjrEtQSCuCAIjB07dujnbdu2BU0zD9wWbQsQmxPYvhBSGbUtBCja6c4775Ty5cvrdeBeUuiQ/ERw5z4hJGzgKbpVq1b6Hk/fiGnAEzcCaBHvYHZS4K+//tJ1goFloGHDhvqKQGKwevXqkNtkhnUfZqBzRiDgN1h6NKwLwUBQazDQISKFHbEhSHVH5wjBA+Fjgs4Swb2IMQkGgq9DMWjQIPnkk098nxG7Y41vCQRxPWDw4ME6BfL111/r+YYTWF4gnhCzgngVHCO3MIUI4m4qVKiQbnmouC/znsJqBusOgtEhQCFOIZQgjHIa/0VIOKG4ISQXwQ8/MpwQ9ImsIAR9AjPzBEGlTzzxRNAOAoGhAE/45jZw2WA8FmSq5KRTQRYWzgede1bEDY6H8XMCgcUgO0CM3X333T7XFAYKRKCwFWRYnThxwmepyQ4QRDfffLPfeYcCYg3tjnty3333pVv+zDPPqGUl3OIGQOTCAoJ7D6teMGBNwWCOEMOBrF+/XqKiotTlCapXr+6zylgJ3BZtCxC8nJP2xTEhRjG99tprMmrUKP3eQvDkZH+EhJ28DvohpLCNcwNat25tlC9fXsc2MXn22Wd1fYyDE8iMGTN0LJquXbv6zX/hhRd0G4xFE2ycm88++yzTcW4wdg72HSwwGePSWMe5wRg8CIa2BgmvWrVKtw8WUIxxeEJx1VVXGTVr1tTrRbBsYFDzk08+qfuYPXt2um2xLsbNCQeLFy/W42BMoGA899xzen07d+4Ma0AxOHLkiAbsTpgwwTcvVEAx2t06Tg2CfxGwnZOA4qNHj+q2OJ/U1NR052m9v4EBxQcPHky3/syZM3UdfE8JyQ9Q3BCSB+IGHReWvfPOO755TqfTN4AbOixkQ73//vvGLbfcop0rOkV0aFZcLpfRt29f3aZly5Y6ECAGosMrBBTm//LLLxmeJzqy5s2bGzabzejevbse98MPP1TRgQ4bwsNk7dq1ei4tWrQw3nrrLWPEiBFGuXLljCZNmmRb3Hz++ee6DjJ+IHQCOXnypF6Tw+Ew7rzzTm0rZDRBSCCLKlzZOvfcc49mXwXrtAGyunCer776atjFTTCCiZu///5br7ly5coqtl588UUVhhA8S5cu9cugKl26tFGyZEkVh2j/OnXqGE2bNk03iN8XX3yh97Jx48YqrJHF9sQTT+h3YcCAASHFzaBBg/T+Dxs2zPjggw/0fHBeVapUUbFGSH6A4oaQPBA3ECW1atXSCaLGOh/btW/fXp+s4+LitDN86qmnjBMnToQ8FlLML730UqNUqVIqBipWrGj06tUr6Ai7wTh16pQKh/POO88oUqSIChp0ivfff7+xadOmdKIEHSvWQUc4Z86ckKngGYkbpFwj9RrrYZ/BQMryY489ZtSuXVuPV6ZMGaNdu3Z6rsEsDtkF+4AY6NChQ4br1ahRQzv0vBI3YMWKFWq5w/1JSEgwOnXqFFS4/vXXX3ocfHcgOpBS/9FHHwUdoRjHwj5h2cH6+D7eeuutxu+//x5S3MydO9fo0aOHUalSJb0neO3du3e6lH1C8hIb/gu/s4sQQgghJG9gKjghhBBCChQUN4QQQggpUFDcEEIIIaRAQXFDCCGEkAIFxQ0hhBBCChQUN4QQQggpUBS68guoqbJr1y4tUIc6OYQQQgjJ/2DkGhT5rVSpkpYAyYhCJ24gbMw6LIQQQgg5u9ixY4dUqVIlw3UKnbiBxcZsnGLFiuX16RBCCCEkCxw7dkyNE2Y/nhGFTtyYrigIG4obQggh5OwiKyElDCgmhBBCSIGC4oYQQgghBQqKG0IIIYQUKChuCCGEEFKgoLghhBBCSIGC4oYQQgghBQqKG0IIIYQUKChuCCGEEFKgoLghhBBCSIGC4oYQQgghBYo8FTeLFi2Sq666Sit8Yjjlb775JtNtFixYIC1btpTY2FipXbu2jB8/PlfOlRBCCCFnB3kqbk6ePCnNmjWTt99+O0vrb926Vbp16yadOnWSVatWyf/+9z+58847Zc6cORE/V0IIIYScHeRp4czLL79cp6zy7rvvSo0aNeTVV1/Vzw0aNJAlS5bI6NGjpWvXrlKYMQxDxPPP896N94bgrc43zPeeV9/6lvduN1YQMVwuMZyu7J+DGOIynOJ0u8TtShOX4Ran4RLDcOf0ok6/4i3Oz8j+WZ0RxpntVts2u/sOvqNsrBypc8n+OaTf4syvI0ttYUSwPb1/U2eOkbv7OMPvck5OIcPv3JmehBGmCzHC+HdmhON8cvl7kY3Nfaem/YVT+wq3O00Mp1MM/d13iTMtVU4kp0lisQRp1eMqySvOqqrgv/76q1xyySV+8yBqYMEJRUpKik7Wkun5DYiKE4eSJflkmiQdTxOX0y2njqaIy2WI4Tbk8O6TEpMQreukJntER9LxVNm//bgkFI8RZ6pbnKn4YoXlFzdi2EWkuN0msVEiDpvnPUyHiVGY53mPyW7zvEb5XjOvAEsIISQviPZOpykvIgeT94r0yLs7claJmz179kj58mi20+AzBEtSUpLEx8en2+b555+Xp556SvILzjSXLJ/5r+zedET2bDkmUVE2FTM55dTR1DM/KcMtNq/Zx4iyS5Q7LUxPDyIxNpEy0XapHhctpRxRFCqEnCVk3eqSO0TECpiNo0X26EY+241xxvtww32Qh5xV4iYnPPbYY/Lggw/6PkMIVa1aNU/OZcvK/fL9e6v95rm8riBQpGSsRMfa5fjBZClVKVFcTkMtM0VLxsrxQ8lS7pxiqjliExxSskKiuDaukbRN/4jzz2XiXLtaotxOsZl+KDHkQFFD9pYQ+be8IWkOQ1IdIqnRNnGWKiJxJUtL0cQS4oiNk5ioaLElJnrex8aLIzZeouMSJNYeKzH2WIm1x6R7Hx0VIzFRDnEcjxL7CZGoU4bYUkRsyYbIEZcYx53iPpIm7mNpftcbVTRaHCVixBZjl6h4u9gcURJdIV7speLE5rDpZxtMN95XG8w35jw15ZyBFceyqc36IVv7CJMVKdh+bHlzLiH3YgvXudjCsx9bDvehbk23iNsp4nZ5XsV1+r3v1em/nuGyvGJe4DLPNobLKW4nLK5OSUtNk9S0FElJTpO01BRJTkuT5JQUSU5O0e3cTqccP5UijihD0tI828CU73Y55eipFLVqGm63d3Lpq+fhA5dvSBTOzzD0vU7ev3eb1+V8+np9F+9zP5uLxNBHGYu31yaGYRMcxW159Zvnfa/zrOvk9O+ogBNlM3SyWX62/N/bJCrK+4rPsFzrPJt3mee3z/M+yjfpPPO93Zxn986zS5Qd8+36HvOj7PbTn+0OnTzzzNdoiXJgXYdEOaLF5sD8aJ30vc6L0fXtOg/rx4gtOsa3LMoeI1ExmB/r2a8tSux2m5wTm7fy4qwSNxUqVJC9e/f6zcPnYsWKBbXaAGRVYcpr/pq/QxZP/kff44tbv11FqdWirBQvlyAxcXYVLPhiZvWJ6r/7Bkjy/Pm+m2jeyD9q22RJQ5v83jhW2la+QM4tf65cWLKOVEisIKXjSkux2GL65TsTkjcelhM/75SUrUfFSHXrD2RGETqOsvESV6ekJLapII5yCfoHSyKAr/N1BumQrfMsHXu25gUXA4YrzeN7x6szzdtZp4nb6Z3nOt2BeyZ08vDVe3z0utztFrfLfXqe77N3nrfDh+vVM88tbsSPufHZnDDP4+b1LEPHjfeeDtzsjNN11jpPQnbg5nauEB1+9lVpVjEdtWcfKsR8nfbpTt3TeXtezc789BTl69i1M9fOG5253TIP780OPKBDR8dqrqMduXee+YqOWd/j1eHtyDHfuwydta4f450XI1HRmOfp0HUddOrayXsEg2d/3vfeeRAaJO85q8RN27ZtZdasWX7zfvzxR52fnzlxOEV+nrJJ31eqU0KuuLeJxCb4+yizw76XXpYTXmED/rmyiSxOWSM/trBJs4rnSs96PeXVqhdJYnSihJvUHcflwMd/n55ht4mjZJzYi8VIVIJDbHEOfa/zSsVJTMVEiTqDa02HPslaOlezA87qvLB08unnne7g8RSPDtzTyXvmWTt2SwduLnMH6dTRKXuX6TxrB67z0BTe9QI68cAOPOS8LDyZB19fAtaN5I/52dvBq0XF5unMAV7Np3FgR6dseUq3ex7lxeGw6zK7t+PGe4fdLna/DtXs2E934Ok6c7OD9z2Nezpy7cC9nblvPbPztkyejj7q9D6956PHCuzYLRYDjzXhbL1npKCQp+LmxIkTsmmTp9M3U72R4l2qVCmpVq2aupR27twpn376qS6/55575K233pJHH31Ubr/9dpk3b558+eWXMnPmTMnPrF7wnz5xlq1WVK5+sEXmlgvNdgpuLnefOCGHvO3hbN9ERndzyfLj67QDuKtGdxlQo4fHdL1zpaXztTy9ZzTPTxAEdN5pbjm8rq4k7UPME34g06Rso0USHX8Az7Qe87zb27Hvd4l7t6dDT9ZO29upeztzjarX+d4ncLNT187bExjt69S18zaf4D1N48pKZ+03TzLuwL3zXHlmnjc78DCKwHyCdujo4L1P7Grl8M4zPAs9z/nez6kuT6ePdnV677XbFuW53zbMjxK3zSOozM8uXY5Xu7i8851i9y7zzMMr5pmf8QQeHR0tJ9NEYmKipXTROImOdkhCbLR23CkukcqlEiUmxiFxMdESC7O73Q6Tg5QrFi/xcdESHxMjsTEOXRYT7ZDEuBiJi42W+Nho3YYWSkIKqbj5/fffdcwaEzM2pl+/fjo43+7du2X79u2+5UgDh5AZPHiwjBkzRqpUqSIffvhhvk4Dh9l89cL/9H3j4gvF9vptGVsBNB4gdDDX8W3xIq6S+r5Ph7Uix20S73bLc/sPSpetb4kIpsw5kJwgyw5WlWSXI1PzfJyjjLQo1UcSo8votk53ivyyZ4Ic3LLLzyqQcQdfcDvwTNFOXN94Quy0s/d02NqpW17RcavIQoetnbe1I/d08GYHrp03OnHvPHTybrGL03a6E8d7zMP+rfvx7dsrDEzBYJ3v+Xx6u9MCA684rjof/MSGVYSEKybIEWWTYvHRUjTOIUViT0/4HB9jF7fTLWWLxErJhBipXa6Izk+IsUuswy7RdptE26N0inFEeed7LCaEkIKLzchvIfERBgHFxYsXl6NHj2qsTqRBADECie3RNrmtZB+JjTqV433hTq2fXEnfo5O88TGHXJ6UJoNOOKUyEq2jHPpkqa8287Nlnnf+3uN2mbJcJNk/1jcocfZEuazyHRJrjxenO1VWHZon206sE6eR9Swtnz9dfeRqm9eOz9OR4luIztnTqeMVnSc65iR9ireL07BJmtf9oR245WncnIdO3r/DDt5Bn+7YPZ1yyI49y9uGEgled00udqJ2uDZscG94JjS1+f7AiVSpWDzOEyHiPSfTcILgalN/qZVFF3pS8D3zTq/j2c4yP2D7tbuPSfOqJcQRBVeK59gQJ3iNj7ZLQqxDzzE5zSW1yhVRsRHjFR9YH+9TXW6pVCJeSiXGSPlicZIYY6cYIYRIdvrvsyrm5mwEwgbUaFRMYvd4hc1dC0SiokWiTAFit4iR0PMOjH1HRDyjOX/ZySGjLxotl1T3H/cnM3Zv2iBfPzdCUtJOSsXa9aRpl8t9QXrWyHp8tm91i+2PFLEhWjhKJPbGStKuxB1ygRnQ5/O3e6PysY3DIWlukV3HUnX6Y9thOZTklL92HpUt+07I8RRYpnIOnsorFY+XInEOfQI/ifF93IZUK5WgnaN2qhg3JzpK4qI9T+noWA+dTNV10GFjPX31BjKisz18KlXKFo3177j9On0cPb0IsHbw3n8h9+FZbpMUp0uvw3MOEHynhYl5PgCWBszHR11mBlt6RYt+9mZbeNajNYIQQgDFTQT52+uOAm26lBT5DI/XMSKVWuRofwc//1xf/ystUnPgw9kWNrs2rpOvR42U1KRTUqleQ7l26JMSm5Dgt47hMuTUH3vl+KKd4tzrHfzQESVlb28ksTVL+NZLc7ll+6FTsvtIsmzef0I27D0um/aekK0HT8r+46cHTQwGnuAhJPBkjk7+WLJTLqhdWp/S4VpIjLVLnMMusdF2FSAlEqIlIcYhxeOjtcMnhBBCMoLiJkKcPJoiCydu1PeNOlSSEp4wGY+4yQHHko/KqeTjgoT3ny+rIk/U75Ot7f9b97dMfeEpSUtOkioNG8s1Q0ZKtD1GnAeSxHUiVV/Tdp2UpLUHxXXEI05s0VESf1EVWVchTj5as1NS/twhCzfslxMpTjmenKbxORkJmCol46V66QR1OVzSoLw0rVJcyhWNk2LxDloZCCGERAyKmwjx59wdvvcX3lhX5JBnjBux5yygduq7D0mbZLekRNuk/8APJTob+9nx158yb8w7UtVRR6rWaSTVKjSWg2/8La7DycFjl2Pt8l+D4jI5JUlmzlurMRDBgMunaqkEOad0gtSrUFRqlS0iNcsWkaolPfESdJMQQgjJCyhuIsSuf47o60U31fMMzuf0umrs2R9Q8Lfdv0mbd3/W9466taRyyeqZbuM+lSZJaw7KoSVbxNiTKp3L3uRZ4BRJ3Xq6vpYtJkpccA3F2mSLzZBfk5PlG5SzWHXYtw4CUREkiviOjvXKauxKjTKJmqGiAcKEEEJIPoLiJgIgAe3grpP6HmUSFFdattxSae40+fvA37J011KZ8dsn8op3/jkPDg15TLiWUjYdUddSyuajWkXbE9iK9OA0SaheSmKqFRNH2QTZYbjk+x2H5Is1e+TgsfSZT/XKF5WL6peV7s0qScOKxWiFIYQQctZAcRMBDu06Kc4Ul1o1yp1T1DPT5RUQGbiTthzdIkv+WyK/7flNft/zu5xyerKrei89XdwgvnErObX6gBjJTnEeTtZSCKjHlLbnpBjeiuEmR9MOyLbja8VWM1YuefABcURHy+y/98hrP26Qf/adOL3PaLs0q1pcmlctKa1rlJRmVUpI6SJ5X7KCEEIIyQkUNxHg91n/6muluiXEEW33zHSZmUex6Swu87bPk/f+ek/WHcJIw6fpvCleOh6rLU32lBB7mwYSXbGR7H5+WegDY5yQasXkeOxhmTd3nBxLPSB127SXKx4YJP8cSJL/TVoq6/cc11XjoqOkQ52ycv25VaRTvXLMQiKEEFJgoLgJMy6nWzb9sU/f12hWxrLAdEtFS7IzWeNoFvy3QBbtWCT7kjzrO6Ic0qZCG2lbqa20nrxGYlbbJLb+lSLNLAdAkewy8WKkuCSufimxl4iVqDiHxJxTTKLLJciaxXNlzntv6Ih/DTt0klZ975VnZm2UCb9t18BgDIh20/nV5b6LakmJhJxlbhFCCCH5GYqbMLN7kyeQGDTuWMX33uVMlp/j4+TbmFOyaFIHSXYl+5ahwGWf+n3kloa3SJEkQ7ZcfqXE1L9JHPWb6HKb/ZjE1ispxTo1kegKiZqiHYxVc2bK3I8x0J9Ik85dZVv9y+WhVxfJKRTsEZH2tUvLW71bSslEihpCCCEFF4qbMLPHm4lUvXFpXybRyn0r5bnVb8iGCuVEJEVQZ7JCYgXpWKWjXFT1IjmvwnkS682i2nLjzRLb7G6xl6yhlaaLX1ZVinXuEPJ4GJBvw9IlsmbBXNm5fo3Oq9PpCvnE1kJ+nrVBP9evUFSGdWuo4obp2YQQQgo6FDdh5qR3ALyYOE+szcwtM2XoYk+GU1GXW7rbS0r3K9+XBqUapBMaSesOSHSd28VmjxbDnSJl7z5X4mqbo//5C5p//1whm5YvlX+W/yrOFG88j80mO6q2kze3VhOxHdLRfR/pWk/6d6jJlG1CCCGFBoqbMGP3lgewx9hlw6ENMvKXkfr5iuINZMhfP0qpWo1ESjdMt13q7v2y/71lEhVXTJwHNkqlp6+TmEqnyx2cOHxItvyxTDb9vlS2r14lLufpGk3RpcrLz1E15O/4OnLSXkTntalRSoZf2VAaVy4e7kskhBBC8jUUN2Em6bgn5Tu+pF0GzL1PUlwp0r5yexlVrKXYV80RcaSPd3G73bJr+FRxlGko7qTDIicXSHTF2+Xgf9vVOrP599+04KWVEuUrSq1WbeSPqGoy+u9UrYKNsWl6nldVrmhSQSoWR6EGQgghpPBBcRNmkk96LCrL9y2TvY69UrlIZXmxw4tiXzkh6CB+7tRU+bfnnRJTv79+PnJsiRzu1knmDb5bDu/e5bduhdp1pXar81XUJJavLI9M+Utm/LVbU6h6tqoiz13TROs4EUIIIYUZipswc/xgkr4uPjFXpITI4HMHS/HY4pZB/E6Lm+Nz58ruMWPEXfYywdw9JzfJwlNrRb5b61nV4ZBqjZtJLQiac1tLkVKldf6hk6ly/bu/yppdx8QeZZOnujeSm8/PvCQDIYQQUhiguAkzJ7wBxQeid0l0VLR0rtbZs8B5WtycOnZU/nz1Jdn82y9SrnpXaVjSk/L999GlEpuYKDVbnKeCpkbzlhITn+C3/yOnUuW2cctU2GDMmrE3nysd65YN92UQQgghZy0UN2EewC/NWwLhRMwRaV2xtQ7M51mYKoZbZP3SvfL9533EsNmkeuXW0rBke118IHGnXPzofVK5fiO12AQjOc0l/cYtlz//O6rCZvLdbRkwTAghhARAcROBNHDD5pZUR5KcX+F837LDi9fLni8rycbyO8SoUEqKuRxyXslLdFlC6wrS/NrQY9mYDPvmb/lzxxEpFueQz+5oQ2FDCCGEBIHiJgIuqdSYJDFshtQsUdNXP2rPxN/1vds7sN8FtW8Su8RpKYWS3Wtluu8xP/0jU/74T7D5G71bSLOqp9PECSGEEHIaipsw4vSWOYhNSdTXWiU8ouXotG986xRpXVNqHKgqRaWCFrosdWM9reqdEfPX75PRP23U949d3kAuqoeRjgkhhBASDOYNhxEz3mZf4nYpGlNUKiVWkpRNm2T344/rfJvdLY740tKs1EX6udgl1SSmStEM94kA4ge/XKXvUcG7/4UeaxAhhBBCgkPLTRhJPump/J0UfVzql6qv7/+9sbdvecXWR0RS20usPV5SE9Ok6IWnC2uG4sXZ6+XwqTSpWSZRnr26cThPlxBCCCmQUNyEOVsKpNlTpF7JepK2c5e4T5zQeaU7VRFnyT5SxF1BXIZLjjc8JbZMBtx7f9Fmmbhsh75/snsjiYv21KsihBBCSGjolgojzjSPuHHZnGq5OTp1qn6OqVFDijRtJ0lujztqzeElYiuesa5cuuWgjJq1Xt//75I6ciHHsiGEEEKyBMVNGNm18Yi+uqM84sa5f7+vmY/taanvjshOWXd0qdijo0PuB+PZDJq0Ut9f1aySDOpcJ5ynSQghhBRoKG7CiDM+WV+LpJWU6kYpOfLVV2JLLCexLe4TZ0opsckJWe9aqOs4YtIX0DT5Ye1e2XssRcoXi5Xnr20iNpsnfZwQQgghmUNxE0b2ndynr46KaZLy86/6Pq75zSLuomKzpUmp6Nck1eURQPbo4OLG7TbkrXn/6Psbzq0qRWIZFkUIIYRkB4qbMHIk+ai+Vi5aSVzHj0tU8SriKFsfRbulXJX3JN6+TJwuT1yOI4RbauHG/bJx7wkVNXd2qBHO0yOEEEIKBRQ3YSTNW/k7MSZRTv78i0RX89SNim9UWqLtu/S905tR5Qhhuflh7R5frE2JhNCuK0IIIYQEh+ImjDhd3hGKHbFiL1ZM7OUa6uf4JmVEXJ4xcFxOzzr2mPSWmzSXW35cu1ffX9qwfDhPjRBCCCk0UNyEEZcpbmJiJGXTXrEXrYjKUhJbu6SIy1N3yukVN8EsN3/9d1QOnEiVEgnRckGdMuE8NUIIIaTQQHETRtwuQ1/jY2Iluno7TwPHHRV7YnR6y00QcbNy+2F9bVW9pERnMsAfIYQQQoLDHjSMuD26ReKiY8WIqqzvY6p4m9gbj+N0OvXVEcQttWHPcX1tUpkVvwkhhJCcQnETJgzDkOLHPdW6Sxyzic1eRAxnsjjKeldwpohhwHJjipvYdPE2y/89pO9rlvVUFSeEEEJI9qG4CROp7lRJivbUkYo76MmIcu5aKVHR3gH4XGniMk4PxheYCj5r9W759+ApKZkQzVILhBBCyBlAcRMmTqSeEGeUJ64m7ojHBeU+sVdiatX2rOBKFadxurkDY24WbPCUaujdupoUjw9dmoEQQgghGUNxEyZSXCkS5RUvbpvH9WSLTpDY2rUw7LCIG5Ybz3KbLUqi7P4Vvpdt9bikzq9ZOlynRAghhBRKKG7CiM0rXozjHvdUVLEosUHEuD0WHac7yjfGjbVeVKrTLbuOJun7hpWKhfOUCCGEkEIHxU0YsaHOAsRNimdMGzEFjJkp5RU/gWPc7DmarMHGsY4oKZ3IUYkJIYSQM4HiJgKWG5tnuBuJqYJB/KBqPOLGdEsFBhNv2u9JAa9aKoEVwAkhhJAzhOImjJgxNw4j3vNarmyA5cZT4dse42+d+WObZ/C+plWKh/N0CCGEkEIJxU0YiXZ7REvaKU9wcFRCMT9x44qKTeeWwvg4M//are/b1WLJBUIIIeRMobgJI0VTvJlOCKDRgpn1/C03No87ym5xS63fc1zHt3FE2aQLi2USQgghZwzFTRg5FnvQv3ET4v3FjcSks9zM37BPX9vXLsPxbQghhJAwQHETRmzmCMSGZ4RiH05P9pTLFpOurtRfO47qa9taHN+GEEIICQcUNxFIBTdf8U7xVgR3ijeg2GK5Wb3TI24aV2IwMSGEEBIOKG4iYbkJxAwo9oob0y2FYpm7vYP31S5XJJynQgghhBRaKG7ChCGGRdx4B7oxcXncUk7xDyjetO+EuA2RxBi7lCvqXyWcEEIIITmD4iaM2N1ecWMpreDvlvLUk3J4x7lZsd0zvk3jysUlKiqE1YcQQggh2YLiJhIxNw6P+8kXemO6pcxB/LxuqW9W7tTXC2pzfBtCCCEkXFDchBFfIHGg5cYZWFsqWjbvPyHL/z0sMNhce26VcJ4GIYQQUqihuAknZsxNoIfJZ7k57ZZau+uYvm9apYRULuEdD4cQQgghZwzFTRiJMgJTwSVoVXAEFK/cfkTfN6hYNJynQAghhBR6KG7CiClqjDSPmElvuTHFTYws/me/vj+/JgfvI4QQQsIJxU1Y8YibqCJFgltuvNlU6/adkn/2nZBYR5R0qOOtHE4IIYSQgiFu3n77bTnnnHMkLi5O2rRpI8uWLctw/ddff13q1asn8fHxUrVqVRk8eLAkJydL/sDrlrJFhXBLeZbPWe+pQdW/Q00plXh6tGJCCCGEnOXiZvLkyfLggw/KyJEjZcWKFdKsWTPp2rWr7NvnKSYZyIQJE2To0KG6/rp16+Sjjz7SfTz++OOSH4gS70B8AdUXzGwpl9dyk+oNLGY9KUIIIaSAiZvXXntN+vfvL7fddps0bNhQ3n33XUlISJCPP/446Pq//PKLtG/fXvr06aPWnksvvVR69+6dqbUnNzAw1LCPEAHFLs/HI6mGxEVHybnVS+biGRJCCCGFgzwTN6mpqfLHH3/IJZdccvpkoqL086+//hp0m3bt2uk2ppjZsmWLzJo1S6644oqQx0lJSZFjx475TZHAbRE3Nltg+QXTcuP56LTZpXOD8hIX7bHgEEIIISR8eIfSzX0OHDggLpdLypcv7zcfn9evXx90G1hssN0FF1wghmGI0+mUe+65J0O31PPPPy9PPfWURBqcT6aWG6+4cdnsUr88U8AJIYSQAhlQnB0WLFggo0aNkrFjx2qMztSpU2XmzJnyzDPPhNzmsccek6NHj/qmHTt2RObk/LRNwEjFPreU4RM3dStQ3BBCCCEFynJTpkwZsdvtsnfvXr/5+FyhQoWg2wwfPlz69u0rd955p35u0qSJnDx5Uu666y554okn1K0VSGxsrE6Rxmq4SVcC01s4M81runHZHNKyGuNtCCGEkAJluYmJiZFzzz1X5s6d65vndrv1c9u2bYNuc+rUqXQCBgIpvVsoDwhmuTFxpuhLappH3NSqWELKFo284CKEEEIKI3lmuQFIA+/Xr5+0atVKWrdurWPYwBKD7Clwyy23SOXKlTVuBlx11VWaYdWiRQsdE2fTpk1qzcF8U+TkFX7aCtUwvZlR/m4pj7ipWaFELp8dIYQQUnjIU3HTq1cv2b9/v4wYMUL27NkjzZs3l9mzZ/uCjLdv3+5nqRk2bJjYbDZ93blzp5QtW1aFzXPPPSd5jkXd4ByNIG4pt1fcnFOueG6fHSGEEFJoyFNxAwYOHKhTqABiKw6HQwfww5SvCXRLuVI82scrgKqXK5Y350UIIYQUAs6qbKn8jH/IT6C4SfNVBAflSzBTihBCCIkUFDcRTQX3fnal+iqCg8qlKW4IIYSQSEFxEyb8srVcrnTZUmZFcENsUqpYfLgOSwghhJAAKG7ChGEx3dhiov2WuS2WG3t0tAYcE0IIISQyUNyECcNbWkEJEC/O1BRfzE1MLgwoSAghhBRmKG4ionI84saUOKkpyT5x44j2t+oQQgghJLxQ3IQJw1sVXEe4CRygOC1FXG6vWyomJlyHJIQQQkgQKG7CjGHDSMmn1Y3LbYjhTLVYbihuCCGEkEhCcRNmbG7n6ZAbm022HjghDiPNL6CYEEIIIZGD4ibMeAovnLbcLNt6WGLEKU6vW4qWG0IIISSyUNxEhNNp4Wt2HpFoiBvTLRWQJk4IIYSQ8EJxEwnsp0t2bd57RKJshsUtxZgbQgghJJJQ3ESYA0dP6CsDigkhhJDcgeImwiUZ9h05ru9d3vILDCgmhBBCIgvFTSTwpkudSHFKrDj1vdOwe2Nu6JYihBBCIgnFTSSqgns5kpSmwcTAKZ5AYsbcEEIIIZGF4iZMWIuCm6ngB0+mSLTNI25c4gkyZvkFQgghJLJQ3IQbw/AN4rf/WKqOcQOcNq+4oVuKEEIIiSgUNxFk7/Fkn7hxGR5xw4BiQgghJLJQ3EQEj+lm77FkS8yNN6CY49wQQgghEYXiJoxp3z68fql9x1MkRtL8sqUYUEwIIYREFoqbsGEVN56XnUeSTgcU+1LBWX6BEEIIiSQUN+HCbf1wunCmzy1l1paiW4oQQgiJKBQ3ERzoBnPMQfxYW4oQQgjJHShuwoXbz3Tjo2y8x4rjdLMqOCGEEJIbUNxEcIRiUDbBFlBbiuUXCCGEkEhCcRMmDMMVdH4Zr7hxeg07HMSPEEIIiSwUNxG03GBWWkqyvnd6LTcMKCaEEEIiC8VNRGJuTmdLVSnmGZnYZVpuopkKTgghhEQSiptw4TeI3+m3rjTTcuNZbmdtKUIIISSiUNxE2C1VLtHTxC6XZwW6pQghhJDIQnETCcuNVei40nSR6ZZi4UxCCCEkslDcRNgtVczh9o1ODJgtRQghhORjcZOc7IknIaEHuikS7faNTgzoliKEEELymbhxu93yzDPPSOXKlaVIkSKyZcsWnT98+HD56KOPpNDijakJNN2gKriZBm6LipIou6eAJiGEEELyibh59tlnZfz48fLSSy9JjCXzp3HjxvLhhx9K4cUUN4YYFhdVgv205YZWG0IIISQfiptPP/1U3n//fbnpppvEbrFCNGvWTNavXy+FFcM4Pc5Nmhk9DMuNzemLuWEaOCGEEJIPxc3OnTuldu3aQd1VaWlpUlixWmu8Q9ooNmeqT9xwAD9CCCEkH4qbhg0byuLFi9PNnzJlirRo0UIKLRZrjdP7vkLxOE0Fd5kVwVk0kxBCCIk4ntoA2WDEiBHSr18/teDAWjN16lTZsGGDuqtmzJghhRbb6SBiczTipFSXiOu05YZj3BBCCCH50HLTo0cP+e677+Snn36SxMREFTvr1q3TeV26dInMWZ6lLqrEWIeIK+V0QDFLLxBCCCH5z3IDOnToID/++GP4z6aAYFpuqpVOVLeU0+uWstMtRQghhOQ/y03NmjXl4MGD6eYfOXJElxGMcuNxUdnxYnFLMaCYEEIIyYfi5t9//xWXy5VufkpKisbhEGSOeSw3lUrEizhT6ZYihBBC8qNbavr06b73c+bMkeLFi/s+Q+zMnTtXzjnnnPCf4VmIyxtzUzw+mgHFhBBCSH4VN1dffbW+2mw2zZayEh0drcLm1VdfDf8ZnsUBxfExdhU3Lm/5BaaCE0IIIflI3CDtG9SoUUOWL18uZcqUieR5nX1YB/HzDnljipvTqeCny1UQQgghJJ9kS23dujUyZ1KAcKvQsUkRTQWHuInX+Y6Y6Lw+NUIIIaTAk6NU8JMnT8rChQtl+/btkpqa6rfsgQcekMKOKW4849wgoDhR59NyQwghhORDcbNy5Uq54oor5NSpUypySpUqJQcOHJCEhAQpV65coRU3/rWlvDE30XbNljLHuWHMDSGEEJIPU8EHDx4sV111lRw+fFji4+Nl6dKlsm3bNjn33HPllVdeicxZnmWYhRhiHFFeyw3HuSGEEELyrbhZtWqVPPTQQxIVFSV2u13Ht6lataq89NJL8vjjj0fmLM9SYtC6hut0QDHLLxBCCCH5T9wg7RvCBsANhbgbgHFvduzYIYWW014pH3Zx6utptxQDigkhhJB8F3PTokULTQWvU6eOdOzYUQtnIubms88+k8aNG0thx2aJvYkyPOLGdEsxoJgQQgjJh5abUaNGScWKFfX9c889JyVLlpR7771X9u/fL++9954UXtKbbmyGp0yFr7YU3VKEEEJI/rPctGrVyvcebqnZs2eH+5wKjsRxpemL07DrK91ShBBCSD603IRixYoVcuWVV2Z7u7fffltLN8TFxUmbNm1k2bJlGa6P6uMDBgxQ61FsbKzUrVtXZs2aJfkSt0fcuLzihm4pQgghJJ+JGxTMfPjhhzUrasuWLTpv/fr1WnfqvPPO85VoyCqTJ0+WBx98UEaOHKniqFmzZtK1a1fZt29f0PUxYGCXLl20MvmUKVNkw4YN8sEHH0jlypUlX+LyBhT7UsFZfoEQQgjJN26pjz76SPr376+D9mGMmw8//FBee+01uf/++6VXr17y999/S4MGDbJ1cGyPfd522236+d1335WZM2fKxx9/LEOHDk23PuYfOnRIfvnlF83aAvmxErnNHOkm0HLD8guEEEJI/rHcjBkzRl588UXNjPryyy/1dezYsbJ69WoVJdkVNrDC/PHHH3LJJZecPpmoKP3866+/Bt1m+vTp0rZtW3VLlS9fXrOzEODscnkCd4OBcXiOHTvmN+UaXnFDyw0hhBCSD8XN5s2b5YYbbtD31157rTgcDnn55ZelSpUqOTowxBFECUSKFXzes2dP0G3gCoM7Ctshzmb48OHy6quvyrPPPhvyOM8//7yOwWNOGHAw1wa6cZtuKY8lhwHFhBBCSD4SN0lJSVo/CthsNg3mNVPCcwvE9CBD6/3339dyD3CHPfHEE2o5CsVjjz0mR48e9U2RGmjQMryNr/yCmS3lcnvmcIRiQgghJJ+lgiPOpkiRIvre6XTK+PHjpUyZMn7rZLVwJrZD+Ya9e/f6zcfnChUqBN0GYgqxNtjOBO4wWHrg5ooJMo4MRBimiOMVNzarBccMKPaKGwYUE0IIIflI3FSrVk0zk0wgQDAqsRVYdLIqbiBEYH2ZO3euZluZlhl8HjhwYNBt2rdvLxMmTND1zBIQGzduVNETTNjkOe40cRuoEu613LD8AiGEEJJ/xA3Sr8MN0sD79eunAwO2bt1aXn/9dTl58qQve+qWW27RNG/EzQCMhPzWW2/JoEGDNEvrn3/+0YDirAqqXMed5iu9ADhCMSGEEJIPRygOJ4iZQdkG1KeCa6l58+Y64rEZZIyinKaFBiAYGGPtDB48WJo2barCB0JnyJAhkp/wxdy4nb5MKUC3FCGEEFLAxQ2ACyqUG2rBggXp5iEVfOnSpXJW4EoTl7ciuC0qSqIssUKEEEIIyeflF0gQ3Gkc44YQQgjJZShuIonL6Yu5YRo4IYQQkjtQ3ETacuNLA/eUiyCEEEJIPhQ3GK142LBh0rt3b1+Ry++//17WrFkjhZf0IxTb3Kl0SxFCCCH5XdwsXLhQmjRpIr/99ptMnTpVTpw4ofP//PNPre5dWDGClV+wuqVouSGEEELyp7hBtW7Ucvrxxx/9Bs67+OKLz54sptzCkgrOMW4IIYSQfCpuUAX8mmuuSTcfNZ9QDJP415YyU8Ht0flwBGVCCCGkAJJtcVOiRAnZvXt3uvkrV67UQfVIqFRwBhQTQggh+VLc3HjjjToiMEYURi0p1Hn6+eef5eGHH9ZyCcSCyyJu8mPtK0IIIaQAkm1xg1pO9evX11IICCZu2LChXHjhhdKuXTvNoCIBtaV8bilabgghhJB8WX4BQcSoDj58+HD5+++/VeC0aNFC6tSpE5kzPAvxyRiDqeCEEEJIvhc3S5YskQsuuECqVaumE/FiyQSP8YYU24wkSyo43VKEEEJIvnRLIeW7Ro0a8vjjj8vatWsjc1ZnOcVMceNOtsTc0C1FCCGE5Etxs2vXLnnooYd0ML/GjRtL8+bN5eWXX5b//vtPCjfBRihO9pVfoOWGEEIIyafipkyZMjJw4EDNkEIZhhtuuEE++eQTOeecc9SqU9iJsogcm5zyuaUcdEsRQggh+b9wJtxTGLH4hRde0JIMsOYUWryaxmHzDeEnNvdxjnNDCCGEnC3iBpab++67TypWrCh9+vRRF9XMmTOlsBMd5RE3RkyUFs70BRRznBtCCCEkf2ZLPfbYYzJp0iSNvenSpYuMGTNGevToIQkJCZE5w7OMaK/lxhbn8Azi5x3nhiMUE0IIIflU3CxatEgeeeQR6dmzp8bfkODiRuLsIs4UcRqxnoaO8bwSQgghJJ+JG7ijSOiYm1ivWyoq1i6SmiYuI97T0ByhmBBCCMk/4mb69Oly+eWXS3R0tL7PiO7du0thJsq03KS6RVwpPrcUY24IIYSQfCRurr76ai2UWa5cOX0fChTSdLlcUpiJMy03CQ6RI6cDipkKTgghhOQjcYPK38Hek/RuKTMR3BYd5VcVnIUzCSGEkHyaCv7pp59KSkpKuvmpqam6rLBjDuFnj4/WgGKX4ZE7tNwQQggh+VTc3HbbbXL06NF0848fP67LCjt2r+3GUSxaxG1JBec4N4QQQkj+FDeGYWhsTSCoLVW8eHEp7HhDbsTmbVm6pQghhJB8mgreokULFTWYOnfuLA7H6U0RRLx161a57LLLpLBjNwfxc3gcVAwoJoQQQvKpuDGzpFatWiVdu3aVIkWK+JbFxMRo4czrrrtOCiuGN9rG7v1ss3sCr0+ngkfn2bkRQgghhYksi5uRI0fqK0RMr169JC4uLpLnddZS1OGRN7Yot7gNEbfX88eAYkIIISSfjlDcr1+/yJxJASHN8FhwjGSMTnw6pInihhBCCMlH4qZUqVKyceNGrSVVsmTJoAHFJocOHZLCjFfbSFS84QsmBhznhhBCCMlH4mb06NFStGhR3/uMxE2hxRQ13qaJsrvE5Y23ibLbdSKEEEJIPhE3VlfUrbfeGsnzKThVwW1OSxp4TN6eFCGEEFKIyPY4NytWrJDVq1f7Pn/77beaSfX444/rKMWFnSJ2b5MaTksaODOlCCGEkHwrbu6++26NvwFbtmzRzKmEhAT56quv5NFHH5XCzimXJwXcZjjF6fZYcVgRnBBCCMnH4gbCpnnz5voegqZjx44yYcIEGT9+vHz99ddS2COJo7xuqajo00UzabkhhBBC8nn5BbMy+E8//SRXXHGFvq9ataocOHBACjvxXreUzXY6FZxp4IQQQkg+FjetWrWSZ599Vj777DNZuHChdOvWTeej/EL58uWlsOP2WnAgbhhQTAghhJwF4ub111/XoOKBAwfKE088IbVr19b5U6ZMkXbt2klhBZLGbnVLOVJ8qeAOll4ghBBC8u8IxU2bNvXLljJ5+eWXxV7Ix3JxeLPAXYLK6Sm03BBCCCFng7gx+eOPP2TdunX6vmHDhtKyZUsp7Ni94gYJ8TZ3KgOKCSGEkDwg2+Jm3759mv6NeJsSJUrovCNHjkinTp1k0qRJUrZsWSnsjZkCkeNMPe2W4iB+hBBCSP6Nubn//vvlxIkTsmbNGq0jhenvv/+WY8eOyQMPPCCFGTPeJglBxa7TlhuOc0MIIYTkY8vN7NmzNQW8QYMGvnlwS7399tty6aWXSqHFME4rRfinXKkcoZgQQgg5Gyw3GOMmOkg5Acwzx78prJhFM114tVpu6JYihBBC8q+4ufjii2XQoEGya9cu37ydO3fK4MGDpXPnzlKYMRvTBfcUxI23/IIjhoUzCSGEkHwrbt566y2NrznnnHOkVq1aOtWoUUPnvfnmm1KYMVPB03yWG09qPMsvEEIIIfk45gZlFjCI39y5c32p4Ii/ueSSS6SwE+/1SyVHebOlDG/hTLqlCCGEkPwpbiZPnizTp0+X1NRUdUEhc4qcxmu4EXua2+uWYuFMQgghJN+Km3feeUcGDBggderUkfj4eJk6daps3rxZRyYmIm4xMC6xt1WjRFynC2cyFZwQQgjJhzE3iLUZOXKkbNiwQVatWiWffPKJjB07NrJnd5aSEgtxc7r8AgfxI4QQQvKhuNmyZYv069fP97lPnz7idDpl9+7dkTq3swvDZ7cRG2JvLKngDCgmhBBC8qG4SUlJkcTExNMbRkVJTEyMJCUlRerczjpMcSOaCp7mK79AtxQhhBCSTwOKhw8fLgkJCb7PCCx+7rnnpHjx4r55r732mhR2cXMsxSnipFuKRAaXyyVpaWlsXkJIgSMmJkaNJ7kmbi688EKNt7HSrl07dVeZ2Ly1lQor5tWXTIzxK79gDzKiMyHZxTAM2bNnjxaqJYSQgkhUVJSOnQeRkyviZsGCBWd0oEKlbqBpXGmWVHCOUEzOHFPYlCtXTi2ohf1hghBSsHC73Vr9ALG81apVO6PfuGwP4hcJUHQTKeX48W7WrJmOdNy6detMt5s0aZL07t1bevToId98843kNf4BxXBLeSw2LL9AwuGKMoVN6dKl2aCEkAJJ2bJlVeAgYSlYHcuscuaOrTMEAwM++OCDmmaOkY8hbrp27Sr79u3LcLt///1XHn74YenQoYPkF3zixgwopluKhAkzxsYa80YIIQWNGK87Cg90Z0KeixsEIPfv319uu+02adiwobz77rv6A/7xxx+H3AYXfdNNN8lTTz0lNWvWlHyBIVLU7pE3J1Kd3lRwb+FMuqVImKArihBSkLGFyd2ep+IG2VZ//PGHX10qBBPh86+//hpyu6efflrN83fccYfkJ066DH2tbLNrttTpVHAGFBNCCCG5RZ6KmwMHDqgVpnz58n7z8RnxN8FYsmSJfPTRR/LBBx9keXweVCy3TpEAssZbN1NOFI0WtzNN3N7mpeWGkMhyzjnnyOuvv57j7cePHy8lSpQI6zkVFM60bbND3759ZdSoUblyLOJh6NChBbJOZI7EzeLFi+Xmm2+Wtm3bys6dO3XeZ599psIjkhw/fly//BA2ZcqUydI2zz//vI7DY06oah75gGKE3Jweh4TihhRmbr31Vrn66qsjeozly5fLXXfdlePOulevXrJx48YzEkcwp2OC9blixYq6z+3bt8vZTnba9kz4888/ZdasWfLAAw+kWzZx4kSx2+1a3zA7whT3IzDZ5Ouvv5aLLrpI+4MiRYpI06ZN1Rtw6NAhiRTYN0IpihUrpucKr8OJEycy3Aa1G6+55hoNsMV2PXv2lL179/plMJvfucBp+fLlus6TTz4ZdLl1QF7ErqKcknVYl0IpbvDFQMAvimeuXLlSLSPg6NGj2VbcECj4wlpvGMDnChUqBL3ZCCS+6qqrxOFw6PTpp59qpXK8x/JAHnvsMT03c9qxY4dECpspb6JsGultwnFuCIks6ADOJNgav2dwdZ8J6ICQwooHPvxOYlywG264QSJNpAd0PNO2zSrIkkV7QXAEAmv9o48+qiInOTk5x8d44oknVHSed9558v3338vff/8tr776qgorPKBHCgibNWvWyI8//igzZsyQRYsWZSgYT548KZdeeqkKkXnz5snPP/+sYRzo+5AubY4zh++bdbrzzjt1jJhWrVr5hEvgOohttX4v0Q+jT0dx7AKFkU2aN29ufPLJJ/q+SJEixubNm/X9ihUrjPLly2d3d0br1q2NgQMH+j67XC6jcuXKxvPPP59u3aSkJGP16tV+U48ePYyLL75Y36ekpGR6vKNHj8KDpK/h5Pe5c40l/1tg7BiyyPjp41XGsRGVjVd6djNeu/GqsB6HFE7w3V+7dq2+nm3069dP/05DsWDBAuO8884zYmJijAoVKhhDhgwx0tLSfMuPHTtm9OnTx0hISNDlr732mtGxY0dj0KBBvnWqV69ujB49Wt+73W5j5MiRRtWqVXWfFStWNO6//35dhu28XmTfBMaNG2cUL17c77ymT59utGrVyoiNjTVKly5tXH311SGvIdj2b7zxRrrfmm+++cZo0aKF7rNGjRrGk08+6Xet69atM9q3b6/LGzRoYPz444+6j2nTpunyrVu36udJkyYZF154oa6HY4MPPvjAqF+/vs6rV6+e8fbbb/v2i9/GAQMGaPthebVq1YxRo0Zl2l6BbQu2bdtmdO/e3UhMTDSKFi1q3HDDDcaePXt8y7GvZs2aGZ9++qluW6xYMaNXr156H0PhdDq1/WbMmJFu2ZYtW4z4+HjjyJEjRps2bYwvvvgi07Y3sbbdb7/9pp9ff/31oOsePnzYiAT4u8Vxly9f7pv3/fffGzabzdi5c2fQbebMmWNERUX5fXdw/dgG34lgpKamGmXLljWefvrpkOeyatUqPZdFixb5zUefXqVKFSO//9Zlp//O9jg3eBrBaMWBwMSXk5FTkQaOgpxQmhjbBuZiqFZkT4FbbrlFKleurO6luLg4ady4sd/2pjkycH5e4E2WkmSXW1xOTxobrTYkUuC3OyntzNIlc0p8tD0sWQ2wclxxxRXquoIVdv369Zo9ib91mNTN3wg8ucJCi3i8ESNG6LARzZs3D7pPWE1Gjx6t42A1atRI4/fwZA6mTp2qw03gqRnHCcXMmTPVJYAnfZwXnprhMskqGMpi2rRpapnGZLrz8Xv2xhtv6BAWsDSbT+8YCgPxh3DfYfCy3377Td3wDz30UMg4CVgcWrRooW31xRdfaLu89dZbOg9WdVwf3A/4fcUx0X5ffvml7h8WbNOKnVF7BQKrAcYVg3Vl4cKFaqGGqwjWEOtAr7g2uINgpTh8+LC6VF544QUt1xOMv/76Sy3rpsXByrhx46Rbt27axyAcAlYcFG7OLmgjnPd9990XdHlGMVdol23btoVcjvsJS1AwkByDfVuvDUkzcF/iPuN7Fgg8Ivj7io2N9c3DfcY2CP+wJuGY4P4ePHjQ13cG48MPP5S6deumG0IFfe9///2nnhG4bQsC2RY3cBdt2rQpXQOgwXOSlo0/iv379+sfJv6o8IM1e/ZsX5AxfNbhqDORG5ip4EVjo8TpsRwy3oZEDAibhiPm5EkLr326qyTEnPkYoGPHjtU4OHTK+DGvX7++DuA1ZMgQ/U3Agw7iASZMmCCdO3f2dXaVKlUKuU/8ZuB3Ch0ABgFDZ24OClqqVCkVG0WLFg3q+jZBJ3zjjTfqcBMmEEUZgc4ZnSdE56lTp3Qe4kfM+AbsC6IEYgPg9/KZZ55RdwvEDVwWEAUQCea54Ty6dOmS7lj/+9//5Nprr/V9xvYQO+Y8uCbWrl0r7733nh4PbVKnTh254IILtJ2rV6+epfYKZO7cubJ69WrZunWrL34R4g+dP+I84O4xRRBiYdDOALGS2DaUuIFwwH0JdA2a+4HLCuCeQPDh+LjG7PDPP/9om+dkYDgI24zcf3BrhgL9WuB1IYwC38VQiTPnn3++fm/wd4BwD3yn8N2BAIZrKRgQfXAvValSJehyuPMg8LCfQMy/J9yHgiJusq0a8DQwaNAgVZz4I8EPERoMvr177703RycxcOBAbVSoVey3TZs2vmX4Q8eXOxRYlh9GJwYnvKngMalOpoETkgXWrVuniQlWK1D79u012BJPkghyRKdi7WzxBF+vXr2Q+0Q8QVJSknZk+L2CBcUaA5cVVq1a5RNTWQUdObb7/fffVWi0bNnSrzOHNQSBqxBA5oTzQ2cFMQSrOASDVXSFEhlWKwAEIEQRglSt+3722Wd9cYiwjOHc0G4QXD/88EOO2gv3C+doTcxADAcsE1hmgg7SFDYAAdYZDcyK48NKEWgNhODD9cG6Z8aHQOxlNA5aKDxeqpwBMVi7du2QE7wL4Y5z+uqrr+S7777Te2l6RvCdCvawj7+VOXPmZDg8yrRp09QaaIrrYOLMFOUFgWw/ekH1QU3jDx8NARcVvpQQNwUxnSzrGL5sqbQ4Ead3dGJH9GmzIiHhdg3BgpJXx86voOOFUPjpp5+0c4QbAuVd4EbJ6lN7Rk/ioUCng44ONGjQQIUFHvjMQFUINlhvrBYXq8shO1izXcysG2SRWh8MgekSQ6cIawdcJ2gXuIlgqZkyZUpY2iuQwO0gWsxA2GBAtKA/gfvPWjAR1ghkGlnvB/YDNxbaEm2OQG4IIMy3dvxmmASEAYA7Bh4GiOXsXteZuKUgVgOFHcQjrisj6yECivEdwpApsPRAQGL9YB4SWDNRlqV79+4ZuqSuvPLKdEOvADNTDKKq0IobfEnhh37kkUfUPYU/LCj3YBHuhQoDbeN5GyWu0+LmDCubEpLR32I4XEN5CUQAYj7wVG0+tSO+Bk/9MK+XLFlSOyK4POAuMd0/SNsOFvtngs4QmSWYEBMCdxfcKejk0XlmNrQ70oPhRskofiErD4K1atWSwYMH63ExQUSYAigQWFUQB4NsUbMDMlN6MwLrwq0AKxeyckIBEYAwAEzXX3+9XHbZZdqpwT2SUXsF3i8zXse03sD9BSGBfiCnmPFT2Jf5HvEj3377rS8WyAT3Du41WJ9wDWg3iAVYpqzni7gsU9QAxOkg9giuUHgfAsE1hIq7ORO3FCyT2DcGrD333HN1HjKgIMYCxWgwzGFPsA1EUqCAwd8OxA3iuUKJtq1bt8r8+fM1LicYyBrDttZ2PtvJ8S8jfiDO5MtcEPGNcyMucbk9n+wsvUCIChJ0PlbwpAkrAZIIYPWFexqdP+JHEESMp3CIHJjR8TCFThixC1iOZaECmuGqRgeIjgMpzJ9//rl2PmacCVwmSMVF/AaszsHGzMIxYJ2GOMF66DzRwSEGIqug80ewKGKHEFiLVzw5Q6RBXOAa4KpCxwIXEtwtOB6u96WXXlIXwrBhwzy/KZkEb8OKAXcTrBTo8OHih3sMwbxoS5S5gWsIwcY4LlwesAKgM8+svazA2tOkSRMVUbhvaBfcw44dOwYNBs4qsBhAmMCyYoobWLzwHYGVKfD64aaCVQfXig4ZVo7bb79d3YGwbOB7hLgkCDnTZYTrQ3wTYnYQyI57A1GIh3SU/YFgCiZ6QLC2yCoQhDhPuPxwHIgkfNfxvTJjXXA++L4hfsl0RUKwYFu0DYKScW4QyoEuWYgeiBekgYfi448/1vt/+eWXB12OYHdYn3Jiscy3ZDdN66KLLjI6deoUcsrvRCwV/KefjN8f9KSC//LFYmPD4BqaCj5xxCNhPQ4pnJztqeCB6deY7rjjjhyngmMIiaFDhwZNV0bqL1KGkYKMdOXzzz/f+Omnn3zr/vrrr0bTpk01JTqjVPCvv/5ah77AeZUpU8a49tprQ15jqHRkHAvHQBoymD17ttGuXTtNbcb54Tref//9dKngOCbSur/77jvdHttZU8FXrlyZ7lhIkTbPt2TJkpoqPnXqVF2GY2AZ2gPH7dy5sw7fkZX2ymkquBVsj/1kxNixY/XYJk2aNDHuu+++oOtOnjxZr3P//v2+NO4HHnjAqFWrlrZtnTp1jEcffdQ4fvx40G3RNjh3XAO+C0ifjlQqODh48KDRu3dvHT4F7Xzbbbf5nZt5X+fPn++bh78DDK8SHR2t1/Pqq69q2n4g2C++U6FwuVya5v3444+HXAdDB0ycONEoSKngNvyXHTEE5WgFKhRPZHj6wBPHmDFjJD+D8gt4usGTJMy04eKPuXNFZjmkfHSU7GzqlmLL75BZu+pLtSbN5YZhz4btOKRwgkwHM0Mku/EZBQ3EV+BpHE/p+a2+XLiBiw4WBVgXYNUpyCCoGFaJyZMnqyuH5A7ff/+9WrMQx4TYnvz8W5ed/jvbV4LxEIKBMSkyG066IAONaIay2a0xNzkMyCOEeMCYLRj/BuZ6/Kgh4whgvJWCBjJaEL+ItG0IGrgikD1W0IUNgEsEbhkE0JLcfVgYN25cvhA24SRsV4PBlfDj88orr0hhxRpz4/RWBGddKULOHPyuII4CsX4IykSMQFbry51NIM4GcT0YewbXhxgXWKgKC6j5RHKX66+/vkA2edjEDQKeCru53Byh2CZOcXktN3ZmSxFyRiAIFpkmhQFkvGAihOSyuAkcowHuGAxChcj84cOHS6HFOD1CcZTbJal0SxFCCCFnh7gxB0QyQVohgsDgB0c6XmHmuMuQUg6b2N1IBfdabpgKTgghhORfcYOxEDCoFcY5wOBaxB/f2Jj2NA7iRwghhJwNtaUwlDesMzmp/l048LqlxElxQwghhJwthTMbN26sw3yTII3pCyhOE5fh+cBsKUIIISSfixsME44imRhOHIHEGFTHOhVmzFRwOyw3vpgbjnNDCCGE5Etxg4Bhs/Q86qGgeJdZ2A4TapQU9jgcn7ixnU4Fp+WGkNwDdaNQ8yjc6xYGFixYoDWcciPsAIO+mjWkrPNQBBTn8M0338itt94qV199dcTOAbWpCnsSTG6DwqjQDdAS+UbcoDAbTgiVRc0JBbvMyfxcmClipoLL6YBiewwtN6Rwg04KHRYmVB5GB4YikSjmh8rI4QRVtO+6666wr3um1x1sgrjK7ZGeb7jhBm1/jEmGUZBRzBEV1nMbWP9Rdd1k3bp12se899576hFAgUeU8kFRz0gN8Y+hS1AgNZD//vtPB4tECEYg//77r967wCKw5gCEKNaZ122O4VlGjBihhTIx6jMGgvznn38yHTwS544CodimXbt26SrSowIBCn5CnGAdFM5GIVATVJhHAVxkT2M5CsSimCtGFTfBNueff74Wcs034sYsQYXqrxlNhRbDkBS3p42iXNbyCzF5fGKE5D2oioxOC50Datl06tRJSwugSjYqS4cLVFBGZetwr5sT0Dnjms0JYJh783Ng55Gamhqxc0EYAToVVAv/4osvVEyg+jeG9siL8clQYgIVv002b97sK6mBauWo1o5zg0cgp6DPCvXdmjJlitYmQmmLQCCoUIkcYRa//fbbWdfmqCj/xhtvqPDA+ScmJkrXrl1V0IUCFcV//PFHrcS+evVqtWhBFKFauQmqy8+ePVuvAdcCMQSxM336dF2+a9cunTCaOGpNoh2xfmD9N2Rcv/POO2H9uw9KVit12mw2Y9++fcbZTqSqgi+f84Ox8ZGFWhV822evGBP7XaBVwTcu/TmsxyGFk7O9KniPHj3SzZ87d67+LX7wwQe+eajMjGrhqMKNqs2dOnUyVq1a5bfd9OnTjVatWmlV79KlSxtXX3110ArWqKCMCtVVq1bVCtIVK1Y07r///qDrZqfa9aeffqrborpzr169tGp5VsC1ogK39fioRt23b189HtoJLF682LjggguMuLg4reaMcz5x4oRvu+TkZOOhhx4yKlWqpJXSUVncWk06kJMnT2p7WtvJilkNG/vAOZqfDxw4YNx44416HFTabty4sTFhwgS/bb/66iudj3MtVaqUVhs3zxX7Q7V3nCMqpqNy9b///uvXlub7wIrxwb43qG49atQo45xzztHjoZo3jm9inv+sWbOMli1bajXtUO3SrVs34+GHH043H9+ZmjVrahV2VOXu37+/3/KMqrJ37NjRGDRoULbaPNzg/CtUqGC8/PLLvnlHjhzRv5VQVb9PnTpl2O12Y8aMGX7z0YZPPPGE73OjRo30+5rROoF8+eWX+reXlpbmm5eSkqLnY608H4mq4NkKKK5bt66UKlUqw6kwY8bcRBl0S5FcAP1l6sm8mbyW3DPh4osvlmbNmsnUqVN982DC37dvn1p3UHKhZcuW0rlzZzV5g5kzZ8o111yjsX8w+cO1gZp2wfj666+10C9cHTDLI44DY3QFA+4xWA1wnIULF+pTLLJCe/Xq5bceLAzYD57KMWHdF154IcdtgKdctAGuBU/z2D+sXNddd51WaUaF7CVLlugTsgneo9zNpEmTdB20GbYJ5XqYM2eOFqN89NFHgy4PZR3Bkz7qeKHN8SQOF17fvn1l2bJluhzWp969e8vtt9+uT/KI2cEI9qbFBPEysObjHHG+2B4unWAuKli0zH2aVq5Ann/+eS2sCYvEmjVrZPDgwVrTEPfAytChQ/We4JyaNm0adF9o01atWqWbj/CKU6dOqdUC+0Yb5yQ+JKdtDu655x61bGU0hQLVtPfs2aPnbwJLUZs2bfQeBAP3CmPYBZZPgmsJ7WQCVxWsNLDm4B6jreBeyyhuyazebS3KCZcf4q1QHy7fDOIHn2jgCMUkPXYDqeB0S5EIk3ZKZFSlvGnmx3eJxCSe8W7q16+vnR/ADyk6TogbuCXMzh9iAm4EdI7PPfec3HjjjfpbZAJxEAwUn4SLAz/0iPVBDEAoIQSRBHM8OoeqVavqPHSkjRo1UvfReeed5xNBMLcXLVpUP6Ozx7Y4r5wKvIceesjPPXDTTTf5YjcQowEXA0QCTPloGwgBXFulSpV84gDmf8wfNWpUumOYogdtnR0qV66s+zZBPAU67S+//FLbESIEHSMEDWI1gCkeIRLRscHtaFY0b9CgQdDjoLM2O3vcr2DAtYNr++mnn6Rt27Y6r2bNmvqdgXi1hkQg+QUxXaFAwDTOzWy/wCBjfL8wphtibnCMr776SuOnskNO29w8f2u7ZwcIG1C+fHm/+fhsLgsE32W06TPPPKP3COtOnDhRxVDt2rV967355pv6N4iYG4gVVCf44IMP5MILLwy6X4g77DNYXBvaftu2bZJvxA1uerly5SJ3NgUEm18qOGNuCAkFngDNp3lkYSJo0RqLAZKSknwxGQjkREBmVoBFA9lQ6KBg2YC156qrrvJ7ijTBUz5EjSlszOBHdLpYZoobBAGbwgYgaBOCI6cEWg/QBhB7iNGwthFEFYQXrEl4yoYVPbDzD2w36/Y5AceBoICYwdM6YoJwHDNOCaISVjUIGsR04AkeFaaRNQsrPgQB5kNoQGAijgXtlRM2bdqkFpVA0YJzQmFVK8EsMoHfJxBoqYDogRXRaq2A9QaCJ7viJqdtDtDH5nY/+9lnn6kFDoIWwg4WU1jlrAVrIW6WLl2q1huI2UWLFsmAAQNUqFgtRQDxSt26ddO/IWTBBQKrEO5nvhA3wcyJJKCNvK9RLkv5BY5zQyJFdILHgpJXxw4DEA41atTQ9xA26Pzg3gjEfLLHj2JWgVDZsGGDPu3DzXTffffJyy+/rG4MWHJyQuB2+F08k4wvBHtaQRvcfffdmmUSCCxPED7ofNDp4NVKKHeFKYTWr1/vs3pkBbQVgqIhECFgcK6wKJmBzzg+2vWXX36RH374QTu/J554QoNYcU9hScJ1wKoE99qwYcN0fQTZZhe0C4CLDB2wFdPKF6pNA4EIxH07fPiw3/wJEyaoKw4unEBhCfcL2hEuFmDNALKKI9OzkdM2N91SCNrNSnsEYlq+9u7d6yck8Tkw9d4KrGv4u4ALDsIE28IliwcDUxA+/vjjMm3aNBUtAC4/PGzAumoVN8i8wsMEHgKwfrC/NVj2TItenoubM1GihQ2UX/C5pWJouSERAg8cYXAN5RUYOgKuIMROADwtwnQOy0qoNGn8oMINhIyLrAAxBGsNJjxlwk2AY+JYVmCO37Fjh06m9QZjcqDDwtNnboHzwnGt7gArsFLAogJrUYcOHbK0T1hUypQpo1k06GwCwTUGiwH5+eefNQ4J1gtgdvLW9oBIQMYRJqQf44kex0BmjXm+mB577DHt5CEgciJucEyIGLjjzjQrFzEf2B/a2RovAgsNXISBVhqIYgxbgDgeWKTQlhCX1vOAIIB1yRQ1OW3zM3VLQVRC4MydO9cnZsysr3vvvTfT7SEMMUH4wQWJ8wdpaWk6wRVlBQLXKu5xLFjrcK9g4Qm0jpkghgtWvnwhbsI9HkVBttzYXKni9JZfoFuKEI/bBMIFHTOeIvE0jwBRxGTccsst2kR4+kMHiEBU/Kiio0BqqRlEDHcDxiWBKwRPfXCTI+Zj1qxZMmTIkHTNjNgYHA9P4nCl4GkYYseMD7GCY8M6gXgXWCqwX3Rq6MAyc3OEE1wHOn8EDSP+Bh0NOmFYPN566y1tE5wj2uzVV19V4bB//37tzCD8zKdqK9jHhx9+qG46DL4KawrEE2Ii4HKCYEDgbCCI90GsEywzcDVhbBLcO1PcoMPEcdGRw42CzzgXCEW40N5//309HtwWsKAhDsW819kFVgB0+BDC6IsuuOACtZ5AgMGa0q9fv2ztDx0w3E9mbBMsECtWrFB3YGCcDNwzEBwYnR/CG8IN7jrEpuBeHTx4UGNLMLQA4o/OpM3P1C0FsYlrevbZZ/X+QewgUB33wDogIv6G8DdlBqpDyMCAgTFqINIeeeQRbQfzIQJtjL8FzDf/hmDpQVyaOWYNhA2+C3A34W/NWrUAbWNaGjEcBNycga6ssGMUMiKWCj57jrHZmwp++IP7jNd6Xq6p4McPHgjrcUjh5GxPBTdTfB0Oh1G2bFnjkksuMT7++GNN77WCtGqkPiP9GKm8SOO+6aabjO3bt/vW+frrr43mzZtriinSba+99tqg6d1Iu27Tpo2mbCO9+/zzz/dLP81pKrgVbI/95DQV3Hp8k2XLlhldunQxihQpoueClOfnnnvOtzw1NdUYMWKEpkSjjZDifs011xh//fVXhsdfvny5thXaH6m4tWvXNu666y7jn3/+CZoKfvDgQU3FxnmUK1fOGDZsmHHLLbf40rPxfezatatvf3Xr1jXefPNNXYZ2Qxo0zg33CdeKczbvd2Bbol0Cu6PAVHCkOb/++utGvXr19LpxXBx/4cKFQc8/I9asWaPp7UiTBgMHDjQaNmwYdN3du3cbUVFRxrfffqufnU6n8cYbbxhNmjTRNHek62NIAKSJZ7fNIwHaafjw4Ub58uX1mEjP37Bhg986uB+4ByaTJ0/WFHjcK6SSDxgwwNc21na49dZb9W8Tqfi4D6+++qoez9r+wSZr2yCdH/ctFOFKBbfhPylEQEnCL2qmqIWL3+f8IKXnxUm0zSaJNT6Vj+d50hnv+2iixBc5HYBISE5ALACehvEkFsrUSwjJOrCqwA0IlxnJHRCvBYsS3JPBBlDM7LcuO/13tgtnkswxnGm+9wwoJoSQ/AcCpjMaM4aEH7jjEJgcStjkWSo4CY0hhi/mxm0RN6wKTggh+Q8ErWPsHpJ7IO4oVLB8uKHlJgK4XR5xg8jyqCj/dE1CCCGERBaKmwiKG0c0hQ0hhBCS21DchBHTLeVK81Q7tQcZCZUQQgghkYXiJgIYbo+4CTbMOyGEEEIiC8VNJCw3Tq+4YekFQgghJNehuIkALpfXLUVxQwghhOQ6FDfhbExvcVG3V9zQckMIIYTkPhQ3EcDl8tThYl0pQvIe1Nv55ptv8vo0zjpQMwk1jlALiOQeqFf19ddfs8nPEIqbCODyDuLHiuCEiFZZhsDAFB0drcOqP/roozrMemG5buuEwoR5eU7WAooZ8dxzz2lV8GAV2lF4EoUQly9fnm7ZRRdd5CtIGVjINLASNobTf+KJJ7RII4baR0VrFFScOnWqFnKMFAsWLNDSC6hejUHlcG6ZgYKXqLSNIqwoHIkRjgN5++23tXAoikuiCCUKSwa2TbDvhLXg6bBhw2To0KEsVn2GMJ0nTBiWoukut+eP0h4TE67dE3JWc9lll8m4ceMkLS1N/vjjD63ijB/1F198UQrDdVtBheSc1uWJyaXfFFR2/uijj7RadLAh9FEpHBWlP/74YznvvPNydIwjR474qnujijX2gwxTVJuG+L344ovTiaFwgLpFEBP33HOPVgFHZXNUYK9YsaKKtmB8//33Wo39zTff1MrX69atk/79+6uIMStrv/POO1qn6oMPPtBrWbZsma6DiupXXXWVrgPRhvtotY41a9ZM61yZXH755Xo+OGawKu8ka9ByEy4sDxkul+eDIzo2bLsn5GwGT8h4Kq9atapaDvB0/uOPP/r9yPfu3VsqV66sT8ZNmjSRiRMnpnvqfeCBB7TjK1WqlO7vySef9Fvnn3/+kQsvvFCtAA0bNvQ7hsnq1au140THVLp0abnrrrvkxIkT6awbo0aNkvLly2sH+/TTT4vT6ZRHHnlEj12lSpV0oiWj67ZOsHgAdOKtW7fWddCx4mkdx7BeLzpOWEHKlCnj63j//vtv7QBRFwnn17dvXzlw4IBvuylTpmj7mdeHtj558qS21SeffCLffvutz2IAC0YwZs2apecFF0kguO4rr7xS7r33Xr1HSUlJkhNQYwgur99++03FLu5X3bp1VRCsWrUqYnWf3n33XbUevvrqq2plQRtff/31Mnr06JDbfPbZZ/qdgCCqWbOmig4IGYhz08KEde6++27p1auXrnPjjTfqd8sq4M3vrTnh+4nvu1Xc4PtxxRVXyKRJkyJy/YUFipsI4DQ8gcWOGIobEjnwo3oq7VSeTGfiMkDnjCd/qxUCLqpzzz1XZs6cqcvRKaDTxtOvFXTOiYmJ2iG+9NJLKjpMAeN2u+Xaa6/V/WI5OrEhQ4b4bY9OHiIBT9NwqXz11Vfy008/+Z6+TebNmye7du2SRYsWyWuvvSYjR47UDh3bYd/o5NCR/ffffzlqg507d2oHhif8P//8U5/6YSmBBSPwenE9P//8s14PrB0QZi1atJDff/9dZs+eLXv37pWePXvq+rt371aRePvtt6t1AeIFbYL79fDDD+t6sCZhPUzt2rULen6LFy/W+xEI9gNxc/PNN6srCS4diKnsgnuFzhvWkEqVKqVbDmETapwwnBuWZzTBIhOKX3/9VQWfFXwnMD8UKSkp6SpUQzzi/m/bti3DdfAdhsUyGLjnEEH4TluB6MV1kpxDt1TYOP1j7zY8mtEe6/9FJyScJDmTpM2ENnnSqL/1+U0SohOyvP6MGTO004FlAp0A6q699dZbvuWw2KDzNUFBQ7hEEOeAH3qTpk2bqtAAderU0X3ArdClSxcVKevXr9ftzA4T1hdYOUwmTJigQgqxEGaHgn3AbYAnbFhCzCfsN954Q88TsRMQUnDVwNoA8NT+wgsvyJIlS7Rzyuy6TXAuEFRjx45VKxaODQsKhALEFMTYiBEj9LjmNeLYJhA/EDa4LhO4hrCvjRs3qgUKbQxBg7gQACuOtbNF+8NqkBHosIOJDrQx2sG0IkHkoIOGEM0OsDQdPnxYrzu7tGrVSi07GWHex2Ds2bMn3XJ8RvwPrFBoo0BwvYMHD1arXqdOnTRuCpYfAJGIuCSs8+GHH6qFB/E8cL/iM4QNrhfWOSsQPRDyaL9A0PY7duxQEWh+F0j2oLiJAE6vuHHEUNwQAtAhwDoBywnM/3gqv+6663yN43K5tMOGmIFVA3EJ6IRhsrcCcWMFHca+ffv0PSwV6OStnXLbtm391sc6iHGwPim3b99eO5ENGzb4Or1GjRr5dSqY37hxYz/XAVw+5rEzu24T87g4D5wbhI31PCBOYA2oVq2azgu0nsDKM3/+/KAum82bN2s8SOfOnVXQoLPFZ7hcYHHKDujkA60QppCC28W0qsBKBFcdjl2rVq0s7/9MLH8QH7lVWdoErjJcI6x3ECvFihWTQYMGqavP/J4MHz5chRNcebg+fGfgboM4DSZQIGpwn6zi3XqN+E7ibyCY2CKZQ3ETQbcUA4pJJIl3xKsFJa+OnR3QqZsdEjpICAz8uN9xxx06D5knY8aMkddff11/8LE+Yk2swZcA2VZWIA7QCYSbYMfJybGt150TAt0VED+mlSkQCD2ILrjp4Pb74YcfNAAW2UhwpSHOJKsgxgeWFSuHDh2SadOmaeduFWwQprinyK4C6PgRJBwIXGrFixf3BVUjlgmWtuwCd43VGheM9957T11ewYDVCq48K/iM8w4lJMzgdwhwCBicPyyGAPE1ANuiHXBs7A/34/3335eiRYumCyKHyIdbDm7VYKCtce8pbHIOxU0EcPksN8yWIpEDP7jZcQ3lF/AUC/fOgw8+KH369NEfcMSUIO0Ybg4A0QA3C4JMswqCQ2HKh5vAdAEsXbo03TpI+0XnYgoHHNt0P+UWOA+MZYInfNN6g/NAR4hg5VDA3YHt4AYJFZOC/cEKhAkuLrinIErQ3ojfgRjJDLi+Pv/8c795iGPBuQWOGQQRBRcNOmqIK7Qj5gWyYsUKDRgGaG+48xCECzdjoAsMIg6Wo2DXeKZuKVjMEDBtBYIw0MoXDFwfXKgAwdTYJlC4QASb9xACBtaeQMsNXJOwypjf90DgrsI9IDmHzrwI4HJ7xU00xQ0hwUB2CDoKjAtixpaYFge4bBCsG/h0nRkIEkXnCVcA3Dd4wofVwgqe5tFpYh10IHDxIL4HMSMZdYjh5r777lMhhmPDeoEMJnTyECAZxVgMGDBAn+rhDkJANFwliDG67bbbVLTAQgPrAoKNkbKN1OP9+/ermAIQRX/99Ze64BAHEirQFS6tNWvW+FlvYGmDiwvuOesE6xv2heBmgCwqCFNktpnHQlA2xMBDDz3k2x8sPXAjtmnTRmOg1q5dq9lusH6gY7dmsAVzS2U0QSSGAsHgW7Zs0aw7tD3in+AORUyNCWKh4N4zwfUhoBvrQ1jBJQWBAkujCa4ZghDXgHgaiDd8x6zxUda2RGwOXJvBwHcXLkWScyhuIoDLdEuxthQhQcETOTKUEI8AKwoGLoNVAp0qUqDhOsjqYHMmEAWwUCBeBHEMGCvEdJWYIIYHYgACAZlK6KzRiVmDm3MDPP3DeoBOEC46dLgQCWiHjICFAxYeCBl0fnDhwX0HFw+uH64VZHghEwtCD/uDVcV04yB2BJYVWD9gccC+goH94n6g0wcIjoVgtMZJmcDVhDY0A2PhpsE5QAhAcEK8YD8QA8jUMkHQNixrsF6YgdIdOnRQEQQ3penCCjdwzyErD2IabY/2QeCvdYwbiBkIx8DMNbQbLGIQfshEs8bL4J5gX9gnAtwRuA6xHjgIIsQeAtFNl2wgiDnDdhCsJOfYjEgOA5kPQUQ8/mjgE8YPQbhYNmO2VFriMXP/eXCErD+WKJ1vv1ead+UgTOTMwQ8lBh/DD3OwQE9Cwg0EAIKFYX1gxk7ugYw5WMwQr1MYSc7gty47/TdjbiKAdww/scf4ByASQsjZAgaqg4sFlgS4j0jugHpecE+SM4PiJlxYDGBOxtwQQgoAwWpEkchijUsiOYcxN5Ec54YBxYQQQkiuQ3ETJoxgAcV0SxFCCCG5DsVNmDAs8oaWG0IIISTvoLiJ4Dg3drqlCCGEkFyH4iYCmG4pB8e5IYQQQnIdiptw4Q5WOJMjFBNCCCG5DcVNmLAOhUi3FCGEEFLIxQ3qy2CIaoxGiKG6MSR5KD744AMdortkyZI6YXjvjNbPPawBxXRLEZLX3HrrrX4lHFDWgeO2pOfJJ5+U5s2b58o9QZV31H5CeQGSe9x4441aGqIwkefiZvLkyToaI4rGoWos6nKgxse+ffuCro96Higah4J3v/76q46ciRorGEUzv2CImQpOtxQhYM+ePVpsEB0bHmJQpBI1et555x05depUrjQSikg+88wzERVQGa2Hat3mhIKJqLOEwpK5CY4dWNX74Ycflrlz5+bK8VF8EsPqt2vXLt0yFEtFMVXUoMpqO6M/wDUdOXLET0ChZhn6EtQSK1OmjH7Xxo0bF7JQaDjAvcSDN77f6JdwDpmBdkdboNAn6qmh9ILT6fRbB3W5ID5xLajwjrpbwdogcNqzZ49vHdQYQ501lC0oLOS5uEG1WBRzQ5Gwhg0b6pcfNxGVYYPxxRdfaEVd3Oz69etrwTO3251rf5xZcUuZbxlQTIhoBWYURfzhhx+0QvLKlSv1wQRVmWfMmCE//fRTyGYKZ2eEQo0ZVYuONBAzu3fv1gm/VygeeuWVV0peU6RIkZDVqcMJyhiiQGmwgpEQuJMmTdLvRKjf/qwAYYOH4xdeeEHuuusutRDBso9q6m+++aYWvIwEqHmEh2yIDxQZhQCBRSyj+lAoRIoCp/he4G8CD/rTp0+XoUOH+tb5/vvvtZI9CquixhcqmI8ePTpooVcU5DS/X7t379YyDiao3l6rVi2tWl5oMPKQlJQUw263G9OmTfObf8sttxjdu3fP0j6OHTtmxMXFGd99912W1j969Ci0h76Gk5+nzjB2DFmk0+heVxuv9OxmuFzOsB6DFF6SkpKMtWvX6uvZRteuXY0qVaoYJ06cCLrc7Xb73uNvc+zYscZVV11lJCQkGCNHjjScTqdx++23G+ecc47+rdetW9d4/fXX/faBdQYPHmwUL17cKFWqlPHII4/o70iPHj1863Ts2NEYNGiQ73NycrLx0EMPGZUqVdJjtW7d2pg/f75v+bhx43R/s2fPNurXr28kJibqtezatUuX49y8zzK+ybq9lX79+vmdC1i8eLFus2/fPt+8v/76y+jUqZNeJ66jf//+xvHjx33LXS6X8dRTTxmVK1c2YmJijGbNmhnff/+932/qgAEDjAoVKhixsbFGtWrVjFGjRumy6tWr+50rPpvXgf0EnuvLL7+s+8F53HfffUZqaqpvHbTBFVdcoeeJ+/LFF1/o/kaPHm2EYvny5UZUVJT+Zgcyfvx44/zzzzeOHDmi92L79u2Zth9Ae+NaDh8+rJ9ffPFFPcaKFSvSrYvzD/UdPFPwnS1ZsqS2v8mQIUOMevXqhdzmscceM1q1auU3b/r06dqmZhv17t3buP766/3WeeONN/Tvyfy7CWyDUDz11FPGBRdcYJzNv3XZ6b/z1HKDsvIoEw8TtRV8tprUMgJmvEqVKmnsTTBSUlJUVVun3CAqyiZRUfZcORYpnEALuE+dypPJo0My5+DBg2qxwZNzYmJi0HVgQreCJ95rrrlGVq9eLbfffrtaZqtUqaLuirVr18qIESPk8ccfV3O9CeIJxo8fr0/9S5YskUOHDsm0adMyPLeBAweqBQkWA7gUbrjhBn2KRrFIq0XhlVdekc8++0wWLVok27dvVzcOwGvPnj39LDLB3C3BOHHihD5Fw01nWk1OnjypVgfEEi5fvlyvF1YtnKfJmDFj9FpxTjhnrN+9e3ffOb/xxhv69I+2wZM8LN2IZwTYJ4B7Budqfg4G3P6bN2/W108++UTbFpPJLbfcIrt27VKXyNdff60WilChBCaLFy+WunXrBrWeffTRR3LzzTdrxefLL7/c71jZAdeLvgCWwkCio6NDfgdxX2HBymiC1TEU+B5deOGFEmMJRcC9wT1Ahe9QfVNg1ev4+Hitig3rT0br/Pfff7Jt2za/+fBmVKxYUbp06SI///xzuuO1bt1arVjYZ2HgrC6cCdMjfpjwBxb4BTB5/vnn5amnnor4ufj/1BvisOe5x48UcIykJNnQ8tw8OXa9FX+ILSEh0/U2bdqkQqhevXp+8xEHgR9xAOHz4osv+pb16dNH3dRWrH/DiNlAZ4IOHOICvP766/LYY4/Jtddeq5/h3p4zZ07I80Jnhk4er3g4MsXK7Nmzdb7ZkcEthn3BpA8gNJ5++ml9jw4PHQ06C8RLZAZccNjGFDLoiDAvKsrzWzFhwgRtk08//dTXCcP9cNVVV2n74KEPogYPdAgQBZgPAYLrR2IGrqdOnTpywQUXqGiEm8SkbNmy+lqiRIlMzxcCC8dGDAzc/6gQDlcaQgjWr1+vogviqFWrVro+wgNw3IxAZ2y2tRUIs6VLl2pMFIDIQRwm4kQChW9mYF8IHM8uOK9Vq1Zl6tYMBR7G8b20Yj60YxnaMxCIH9y3iRMn6vcY65nfLYhPc53BgwdrzFGnTp3078kMDMY6EK74HuE7inuB7yLuxUUXXSS//fabtGzZ0u8a4bbDcazfi4JKnvbA+IHDH8/evXv95uNzZn98+COHuMFTYdOmTUOuhx88BFGZ044dOyQ3sDsobggJBZ4g0Zk0atQo3ZOk2WFaQcd97rnnagcNgQBLATpygL9r/NAj09IE8SzB9mMCqxCsxrAkWJ/OFy5cqBYLE8T/mcIGoCPJzEIRCnROuGZMuH50XLBSmE/g69at0yBYq3UBgbCwXMECAKszrCWYZwWfsS1AJ4j9Q0w+8MAD+vuYE3Bf8Nsc7LpxLmhfa8cJC1SwDtxKUlJS0IdQWNvQFugPAOJQcE/nzZuX7fPOqkUxEFwPriGjKSNxkxMQo4PYHMTTxMbG6ncR1w5MwQsxCUGN2CxYhc4//3yfsDXXwb1GMDb+PmA5RHu2a9dOY3OsQIiD3ArgL9SWG9ws3BA8EZiR8GZwsNUUGwii0BH5jSezjH7AAL40mCJN4N8ULTck0tji49WCklfHzgroFPD0jQ7RSs2aNf1+cK0Eug5gnYVVBU+sbdu2VbcGOgU8meYUuIXQecP8b+3EgWldMV0ZVnAtOe1AcV1oDxM8YcMNg+Etnn32WQkHEBxbt27VQFRYV2ARgJtmypQp2dpPsOvGb/OZAPECUWkFAhNuL1gTIDCs89FJd+7cWT8XK1YsnRsGIEsK98/8zkAgwLKUXSCUkdCSEXCFYgoGHsaDPaSby0IBCxUsMxDnEIf//vuvPpCbfx9od1jnYElEG0Hcm8kz5jrBaN26tbpnrcBVa7XgFXTy3C2Fm9uvXz8VKbghMNPBZGuapeHbrVy5srqXAG40fO4w4cIkZ8bmmE9eeYf/D57DwXgbElk05TMLrqG8BPEkiAGAi+P+++8PGfOQEYgfwJMosiRNrNYVCARYFiB2EPcAkE4L4WK1LlhBTAY6UFgjkL57Jg9o2E9O7x+evmHRAA0aNNBYE/z+me2Ea8c6eDpHBw/XAuZ17NjRtx98xm+nCdbr1auXTtdff73GBKFjg+UBoiWn52uCc0H7IsMHD6cA7pJQsSXWNkfqP8Sh6W6aNWuWHD9+XPdlFZnIDEIfAPECNxqOCZELK5/1YRXDh8AdZIoxuDQhQLC/wLgbuBjhlgn2HTxTtxRE9xNPPKHHMM/lxx9/1PPOzKKFtjDddXBRIY088HuLtkE/aK6D42UkUlatWqV/E1bQpohdMy1kBZ08953gDxAuJggWBEThpsDvbforoahN/yPAHwe+oPijxc0zJ+wjT/FLBTfEbnkKIaQwg/RVdIZ4gEG6K1wosOQgoBZP2YGWk0AQy/H777+rpXbjxo0yfPjwdMGwGEMHbmqM4YJ9QghZxz4JBE/4SLHFwxNiPWDtgKsID1EzZ87M8rXhAQuBvbgeJEhklLqOjhkPY5jQBhB7sCAhpgbgfOC2wcMeOiLE0mCdvn37+n4PH3nkEX3AQzvimEgbxm8mrt8cWgOdH9oAbYWgZFgOIBDM88WTP84hMzESCsTgwBqEVGu0GYQE3sMKl1GMDNxyuF5rOjYCiRHPA3cc0pXNCRYnnDMChM22wb5xvyBaIaZg2cHD8EMPPeTbHwZphJsOFh+4MpFujaEIEJ8Fl441WDycbimIKghdpLnj+nB/EPyNh3cTBLij7azAAglrFrbBGEz4DiMo3PybwHcK8TS4n+Z9xj3FdZvg/bfffqttgu8N2mDevHkayxYY0A1XWKHBKGREKhV80ZTpvlTw13p1Nz4f1Des+yeFm7M5FdxMHR44cKBRo0YNIzo62ihSpIimXiPd+OTJk7718LcZODQEUrZvvfVWTcsuUaKEce+99xpDhw71S19OS0vTNO9ixYrpOg8++GCmqeBIDR4xYoSmMuOcKlasaFxzzTWajm1NBbeCc7P+bCKNu0uXLno9maWCW9OwixYtapx33nnGlClT/NbLSir4k08+qangOOfAVPD333/faN68uaatoy06d+7slxaNVOPatWsbDocj01RwK2g3tJ/1fl5++eWabo79TJgwwShXrpzx7rvvGhnRs2dPvXdgz549eh5ffvll0HVxn1u0aOH7vGHDBr0/SN3H9eGcP/jgA7+hBMzvy/PPP280adLE147t27fXdHN8TyLFn3/+qanWaBPcnxdeeMFvOb5PgV0u7jW+YzjPNm3aGLNmzfJbvn//fk2Rx/UiRR73c+nSpX7rIP29Vq1avmu96KKLjHnz5vmtg98NHOfXX381CksquA3/SSECQXkwYyNgDebbcLH46++kxnLP09FXW1+RilVLy42v5HwwKkKsIIsG1gWY4ENlBhKSVyA1Ge4UxPmYcTLBgJULbkq4FfM2jKBw8c4776jlKKcB5vnlty47/Td9J+EiMKA4mk1LCCmYwO0BF1OTJk00bAAjC8PlZcY8hQKZrXCrofPCtiR3iI6O1hGaCxPsgSPVsNGsK0UIKZggtgiBu4hnQfYaAr4RHxOYZRUMpKuT3OXOO+8sdE1OcRMmbN5imR4MsWfhj5wQQs5GMC4NJkLyK3meLVVQYdFMQgghJG+guAkXlrhsvHNYaowQQgghJPeguAkTgTln9pjIj4pMCCGEkPRQ3EQEQxzRFDeEEEJIXkBxEyFouSGEEELyBoqbSBXOzIVinYQQQghJD8VNhHDEcBRZQogH1IFCjScUiSS5B+pJff3112zyQgjFTQTQwpmx8ZHYNSFnFahAjQHerr32Wr/5GD4dw/WjkrIVdEQXX3yxVlJGIUZUVb799tu1OKMJKmdrRXTvhGH8UZ0aBTBzk4suukiLFGaFxx57TItgYsC7QFBMEZWuUcwyEIz6ay2SaPLkk09qoWEr2B7HqFmzpu4P7YuinCiUGUlQyBHXgKHyMeowKn1nBopaogq6eY8//fTTdIMEPv3001KrVi3dLwproqCyFQhFtH/16tV1P/ieBRZUHTZsmBYXdbvdYbpacrZAcRMu0rmlaLkhBNWNIUbQMZkVngE6YVRZHjlypG/ekCFDpFevXtppT58+Xa0dEyZM0M4a4sAK6spg2H9MED4YUA6VpLFNfmP79u0yY8aMoCPzLlmyRJKSkuT666+XTz75JMfH+Pfff1XgoSyCWWkabY5K3IHVocPJL7/8Ir1799Zq2LgPV199tU6oTp1RnSPcTwg0VMN+6qmn9By/++47P1Hy3nvvacmAtWvXyj333CPXXHONn8jFqLs//vijfPbZZ3q9qHiNauU7d+70rXP55ZerCPr+++8j1gYkn2IUMiJVFXzhxG99VcFf6dnNWLtgTlj3Two3wSrlohpyarIzT6bASsyZMWbMGKNkyZJaTfqbb77RitarVq3yLUe1YvxdYr1gWI8XrFo3qmVjn9YK04cOHTL69u2rVcLj4+ONyy67zNi4caPfdqjK3bBhQyMmJkarW7/yyit+y99++22too1Kz6h6fd111wWt8o1p69atQc8dlc9btWoVdBmqnaNKNip7161bN91ynNPo0aPTzQ+s5I0K3ahEfeLEiXTrHj582IgUqPLdrVs3v3mobn333XeH3KZt27bGww8/7DcPVdxRudsEFdrfeustv3WuvfZa46abbtL3p06dMux2uzFjxgy/dVq2bGk88cQTfvNuu+024+abb87B1ZGzuSo4yy+ETSX6f3TEJoRt14QEw5nqlvcHLcyTxrlrTEeJjrVneX1YalCVuG/fvvqUPWLECHU1mEycOFHdS/fdd1/Q7eF+ysj1Zbo1WrZs6ZsPS8k///yjViBYemAZuuKKK9QSgBpIf/zxh1p7YEGAxQhWCBy/dOnSuu3vv/8uDzzwgFoG4PI4dOiQLF68WPc9ZswY2bhxozRu3FjdJ6Bs2bJBzw/btGrVKt18WBTg0vntt9/UrQNXHdbt0KGDZAecF6w0zz33nCQmJqZbXqJEiZDbwpp29913Z7h/WD1CndOvv/4qDz74oN88WNG++eabkPtLSUlJV+0ZbqVly5apOwr3JtQ6sHQBp9Op9z2jdUxat24tL7zwQobXSAoeFDdhIvCnl24pQix/HzabuiMQZ4G4DMRBWIFQgPvJ4Tj9k/Taa6+pCDKBu6F48eL6HkIAYgjArYMO8f3339cYDWCKmp9//lmFidmRIw4FHe8NN9yg++/cubMMHz5cl9etW1eFD9w6EDdwJ0EsXHnllRorg9iOFi1a6Lo4j5iYGElISNBA4YzYtm1bUHEzadIkqVOnjjRq1Eg/33jjjfLRRx9lW9xs2rQJFngVSNmle/fu0qZNmwzXqVy5cshliPMpX7683zx8DhY/ZBU/H374obqvIEYhMvEZwubAgQNSsWJFXQf3B1XGcU8RN4SYKggagPvRtm1beeaZZ/Q7hWNCIENs1a5d2+94lSpVkh07dmjcTVQUIzEKCxQ3kTHciJ1VwUmEccREqQUlr46dXT7++GMVA1u3bpX//vtPg2UzAoHE6Hxh2bj55pu1AzdB57ZixQp9f+rUKfnpp580LgNWFwTRrlu3ToWStePGMgSvYhnAa48ePfyO2b59ew3gRSfapUsXFTQQXZdddplOiPvANWQHiK9AC4PZHrguE7zv2LGjxpkECzwOhbVdsguOk51jhQOISYgfZDLh3CFM+vXrJy+99JJPfMAy1r9/fxVsEMYQOLfddpu2mQksaviOQHwhtgtCCfE/EEuB1hwIG1iD8J4UDihjw4b/D4wjhlXBSWTBjz5cQ3kxZeQmCgZcPqNHj9bAWrgJEIBq7ZRhwdiyZYs+vVvdKXgKD2Y5QCeIZZiaNm2qrhFkL7344osSLkwBBYsArAmmK+3IkSPZ2k+ZMmXk8OHDfvNgIVq6dKk8+uijKsIwobOHUINFxwTuNFipAsE5mFYstB3ux/r167N9jbBmwQKW0WS64oIBq9XevXv95uFzRtYsCAyIFFwrAqFhIYPQRXubrj28wsJ28uRJtXzh2nAuEJomEDwLFy6UEydOqGXGdGtZ1zHddrDAUdgULihuIgQtN4R4QCcGN8+9996r2TtwvaAjevfdd31NhCdudFJjx47N+d+c3a5WEgBXBeIyYPUxOXjwoGZTNWzY0LcO3FZW8BnuKewLQHQgAwdWhb/++ks7Y2QkAbilTDdJRsCVBTFjBW0Al8uff/4pq1at8k0QaVhmAktToCUCQHThPAGyzuDGQXo1xEAgGYkxWMasxw82BXOpmcA1FJhqjgwmzM8MuBKrVKmibQ1BB/dfoNsIFi+IW9xLDBMQaGkDEC4QnxCQc+bMSbcOMrdMdyIpRBiFjEhlSy344hu/bKkDO7aHdf+kcJNRBkF+54EHHtCMo5MnT/rmvfvuu0aRIkX8MoweeughzYAZPHiwsXjxYuPff//VLCpkuthsNt/fLLKlihUrZuzevVunLVu2GO+9955u+9RTT/n216NHD82Ewr6QmYVsKZxHamqqLv/jjz+MqKgo4+mnnzY2bNhgjB8/XrOqsH/w3XffafbWypUr9VzGjh2r6//999+6vH///sZ5552n17B//37N2ArG9OnTNdPK6XTqZxy/bNmyxjvvvJNuXdxj/D6Zx/j555/1mM8++6wuW716tfH4448bDodD35ts3rzZqFChgl4vMsCQFYb1cf7169c3IgXOD+eCLLN169ZpFhey1qznhmwwZK2ZoK0/++wzPcfffvvN6NWrl1GqVCm/78LSpUuNr7/+Wq9r0aJFxsUXX2zUqFHDL/Nr9uzZmmWG+//DDz9o9hgytcz7a9KxY0e9x6RwZUtR3IRZ3Gx/dKGKmyN7d4dr14ScteJmwYIFKjogMAK59NJLtdOypnlPnjzZuOiiizTVG51klSpVjD59+mhnZwLxYU3BRpo20qife+45n4CwpoJjXxAtXbt2DZkKjmNVq1ZN07ZNcM7oGJHCju2bNm2q52ftpM8//3xdllEqeFpamlGpUiXtjM1jQrDs2bMn6PoNGjRQgWcyZ84cTZPGeZQuXVrbZ+HChem2Q5r9gAEDNH0cqe1IDe/evbsxf/58I5Ig/R7tj2M2atTImDlzpt9ypM2jHU3wPW7evLm2G0QqROj69evTfW/QDri3uGbcx507d/qtg3tRs2ZNPS6EHa79yJEjfuv8999/em937NgRkWsn+Vfc2PCfFCKOHTumvmr4seHPDhcLv/hWaq0upXEEX/77ktz97qdSpGSpsO2fFG6Sk5M1ELdGjRpBg1NJ/gYuI2RvwW1Ccg+k/8NdhUw6cvb/1mWn/2a2VJgIVIgOZksRQrxgLBnEvmBsm9zOTirMlCtXLt04PKRwQHETgbpSwM5sKUKI+UPrcKSro0Uiz0MPPcRmLqQwWypSIxQ7mApOCCGE5AUUNxHAbhOxcSRMQgghJE+guAkT1iHNvENkEEIIISQPoLgJu1fKEAdMN4QQQgjJEyhuwixvomx2sVPcEEIIIXkGxU0EAoppuSGEEELyDoqbMGEOheh0p4nDzmYlhBBC8gr2whHATnFDSL4kNTVVK4mjSjnJPW688UZ59dVX2eQk16C4CRM2q1vKwXQpQkxQEfzqq6/2a5ApU6bo0Opmh4d1bDabvPDCC37rffPNNzrfZMGCBfq5UaNG6SpylyhRQsaPH59hw6MSOYZ1b9euXdBRhFGh+quvvsrSNVjPx1p5GwIKVcSbNWsmCQkJUqZMGWnfvr2MGzdO0tLSIvbFQNXyDh06aLtWrVpVzyEzUNEbbYFRkytUqKDlClCB2+TJJ5/U6wucUInbCq5/wIABWp07NjZWK5bPmjXLt3zYsGHy3HPP6bD5hOQGFDdhxxA7xQ0hIfnwww/lpptuknfeecdvBFl0yi+++KLWAsqMLVu2yKeffpq9v0zDkLfeekvuuOOOdMtOnTolkyZNkkcffVQ+/vjjHN89CJuuXbuqSLvrrrvUQrRs2TLt+N98801Zs2aNRALU3Ln00kulevXq8scff8jLL7+swiSjmkp//vmnXHHFFXLZZZfJypUrZfLkyVr/aujQob51Hn74Ydm9e7ff1LBhQ7nhhhv8rrlLly7y77//qmjdsGGDfPDBB1K5cmXfOo0bN5ZatWrJ559/HpHrJyQQll8IMzDg0HJDcgN01s6UlDxpbEdsrJ9FJavAmjBy5EgVEtdcc43fsksuuUQ2bdokzz//fKZWh/vvv1/306dPH7UUZAV0+ps3b5Zu3bqlWwZrDTptdOyVKlWSHTt2qPUju7z++uuyaNEi+f3336VFixa++TVr1lRBACEQCb744gvdN4RZTEyMWrZWrVolr732moqsYEDMNG3aVEaMGKGf4a5Du/fs2VPbFtacIkWK6GQVRGvXrlULmAmOeejQIRVy0dGekdnPOeecdMe76qqr9L5D6BESaShuwoVhtdywWUnkgbB5o9/1edLUD3wyRaKzWZ0cLo+xY8fKjBkzpHPnzumWwyU0atQoFSwPPPCAVKlSJeS+/ve//6kVANYQWBeywuLFi9VdEqxw5UcffSQ333yzVhy+/PLL1b01fPhwyYnIgEizChsTdPxm5x/I9u3bVVxlxOOPP65TMH799Ve58MILVdiYwIJkWsJKliyZbpuUlJR0VZfj4+O1KjOE4EUXXRTU6oY2hPvLBNaetm3bqmj59ttvpWzZsnoPcb9xT01at26trikcN6uClJCcQrdUhIrkEUJO8/3336tVAJ1fMGFjAmtO8+bN1XKQEYhlwTqw8mQ1jmPbtm1qlQnkn3/+kaVLl0qvXr30M0QO4mNgGcsu2Ff9+vWzvR3OC5aWjKZ77rkn5PZ79uyR8uXL+80zP2NZMCB+YG2ZOHGixi/t3LlTnn76aV0G91MgED0Qb4FuPbgI4Y7CPhBnA1GIWKpnn3023TXCuhTqfAgJJ+yFw8ZpE70jms1Kcsc1BAtKXh07O8D9ceDAARUkeIK3ujoCgbXh4osvztQig04WnSjWh8UnM5KSktJZKky3Cjp6BP4CxKFg3/PmzctQiAUjJ4LIfCCCWyg3QYwOYnMgmvr27avWFAgTWLiigtTGmzZtmhw/flz69evnN9/tdku5cuU0vgeWmnPPPVeFEvZtFamwCpnxTYREGlpuwgx+2uwhTM+EhBPEvMA1lBdTduNtEFyKzCJ0eghgRScZCrhXIDYee+yxTAUB3BxjxoyRXbt2ZXoOEC+BwcqwNnzyyScyc+ZM3R8mWIUQQ2INLC5WrFhQCxGyhNChm9lDcNmsX79esgvcUmZ8S6gpIwGHTKe9e/f6zTM/Y1koHnzwQb0GHB/is0ePHr4YoWAuqSuvvDKdhQgZUrhuqwuqQYMGaqGxxhihTQHcVoREGpoYwob3ic0wxEFxQ0g6kMmzcOFC6dSpkwqc2bNnB41/Acg2gnuqXr16GbYkgnRhIXjqqacybXHEwSBDC9YVU5zBjQKhhWwha+f8999/y2233aYdP1LMcR4Ihg2MF1mxYoWmlpuxNIg1QVwM9hcYd4M0cHT2gWnUVrdURpQqVSrkMsS8PPHEE3oM81x+/PFHPe9g8TZW0Bamuw4uKgRSt2zZ0m+drVu3yvz58zW+JhCkuU+YMEEtOKbFZ+PGjSp6rDFAaFPEUZkWMkIiilHIOHr0KFSIvoaT+R9PM3YMWWRsfvgHY8mYIWHdNyFJSUnG2rVr9fVso1+/fkaPHj18n3fs2GHUrl3baNu2re/vMHAd0LdvXyMuLk7/Xk3mz5+vnw8fPuybN3fuXMPhcOg0bty4kOdx4MABIzo62li9erVvHo7Zq1evdOu6XC6jQoUKxltvvaWfcbxy5coZPXv2NH7//Xfjn3/+MT766COjaNGixjvvvOPbLjk52ejQoYNRsmRJ3XbVqlXG5s2bjcmTJxstW7Y0Vq5caUSCI0eOGOXLl9c2+/vvv41JkyYZCQkJxnvvvedbZ+rUqUa9evX8tnvppZeMv/76S7d5+umntX2mTZuWbv/Dhg0zKlWqZDidznTLtm/fru0wcOBAY8OGDcaMGTO0rZ599lm/9XCPb7/99rBeNylcv3VHs9F/0y0VbrGIquCWpxVCiD94eoeLCm4QuJ8wRkswENwKa0BmID4Hk3XwuWCULl1aA5YRFGu6beCOuu6669KtCwsE1kUWFYD1BrEosIx0795drUpvvPGGplpj8D8TWHVgMcF4Oe+9956cf/75ct555+m6yADDeC+RAFleP/zwg1pYEPOC8YOQ4m1NA4dbDWPQBAZ6I/OpVatW2hYI+A4crBD3ANljGMjQat0ygaVnzpw5snz5co2twnUOGjTIb7wcBCNjQMb+/ftH5PoJCcQGhSOFCPyQ4ocAf+jwo4eL+eOmSZ0NZSTFlSRH6i+Tc+8YFrZ9E4LOAR0XXCDBgmJJ1kfxxYBzGO8mo6BmEl7gDkRAMgQYITn9rctO/03LTQTKL9hjOIYDIfkRWBaQXYUfT5J7IA4IYxIRklswoDjswC1FcUNIfgXuFZK73HnnnWxykqvQchPuZClYbmLpNiCEEELyCoqbiFhuKG4IIYSQvILiJhIjFLNuCiGEEJJnUNyECTPnDMln9hjPMOOEEEIIyX0obsKEdTB6RyzFDSGEEJJXUNyECetwQXaKG0IIISTPoLgJO4Y44hLCv1tCCCGEZAmKm7Bh+P53xKUvjEcIyR+gpMKll16aJ8dGsVCUbshKWQkU2axdu7b88ssvuXJuxAPKRtx///1sjrMciptw4Tpd18ZOyw0hPvbv3y/33nuvVKtWTWsvVahQQWtK/fzzz9qBo0o0qoAH45lnnpHy5ctrTSfUN0IF6wYNGqRb76uvvtJl55xzTqZDuw8fPlxGjhzpm/fkk0/qtphQOwm1klCT6dChQ37bYt/W9VBJ+4477pDDhw/71kHNLHMd6zRsmKccC6qhY7Res75VRrz77rs6BH27du3SLUM9K5wDrjvYIIWB9aGs54ZK5yZo/5deekmaNWsmCQkJei9Q5XvcuHHa5pEsg4GaVhheH+2Nc8iMuXPnalugkjy+Q0OGDElXT+zLL79U8YhrQRV6VIy3snv3bq3cXrduXa0f9r///S/dcR5++GH55JNPZMuWLWG4UpJXUNyEC9+TGNxStNwQYoLClCtXrtQOY+PGjTJ9+nS56KKL5ODBgxITEyM333yzdqbB4tggaG655RYVBCAxMVH27dsnv/76azprDMRTZkyZMkVr0qADt9KoUSPt+LZv367nAgsLBFmwYp7mehAoixYt0kKRgaBAJdYzJ2sRSYgPFNLMCFz7W2+9peIpkFOnTsmkSZO0OOfHH38sOQXCBiITwhJiDhaiZcuWyYABA7RUwpo1ayQSoD4QLGcQH3/88YcKEAjM999/P+Q2f/75p1xxxRUqDvFdmjx5sn6PrO2KIqA33XST3HPPPfL333/L2LFjZfTo0dqOJikpKVK2bFkVmxB0wYDAQ7ugHhY5izEKGdkpmZ4dfnrjU2PHkEXG+odmGKnJ6Uu1E3ImJCUlGWvXrtVXE7fbbbhSnHky4dhZ4fDhw/r3tmDBgpDr/PXXX7rO4sWL/ebPnz9f569bt04/jxs3zihevLgxcOBA48477/Stt2PHDiM2NtYYOnSoUb169QzPp1u3bsbDDz/sN2/kyJFGs2bN/OY9+OCDRsmSJf3mYd+jR4/2m/fMM88YDRs2THfOuO5QbNu2TdfZtGlTyHWWL19uREVFGceOHUu3bPz48cb5559vHDlyxEhISDC2b9/ut7xfv35Gjx490m0XeG4vvviiHmPFihXp1k1NTTVOnDhhRIKxY8dq26akpPjmDRkyxKhXr17IbR577DGjVatWfvOmT59uxMXF+dqod+/exvXXX++3zhtvvGFUqVIl6Pe1Y8eOxqBBg4Ie75NPPtHtSP74rctJ/83aUuHC5fK9dUTHhG23hITCSHPLrhF5E49R6el2YouxZ7oeKm9j+uabb+T8889Xt1QgTZo0kfPOO0+tEBdccIFvPiwocEPUr1/fb/3bb79dLT9jxoxR9wOsO3iih/sqM5YsWSJ9+/bNcJ1///1X5syZo1aljNi5c6d899130qZNG8kOsDDhXBcvXiy1atUKug6WwXUCF0wgsFLB2oXqyJdffrleP1xt2QWWp0suuURatGiRbhksZaa1LBBYrRo2bJjhvh9//HGdggGr24UXXujXvrCUoKApXHwlS5ZMtw0sLoEVouPj49XNCOsPvg9YB9+HwHX+++8/2bZtW6YuSyutW7fW7fBdyM52JP+QL9xSb7/9tn6B8OXFDwVMoxkBPzN+8LA+fhhnzZoleY7b9P0aYovKF81KSJ7jcDi084VLqkSJEuoOQqeHmAsrcL/g7/rEiRP6+fjx4+pCgpAJBJ1xzZo1dbnpugq2XiCINTl69KjGygSyevVqFWHoDBHnApcMYjoCwTxzvSpVqmgMy2uvvZZuPSwzhR0muOCs4BzQ4YYCy4Kd5z///CNLly6VXr166WfTpWcdiiKrYF+BwjEr4LxWrVqV4QTXUCj27NmTToian7EsGBA/cJtNnDhRXC6XCku4CAHcfuY6U6dO1dgcBGzDBfrqq6/6rZOdawQZ3SOSv8lzyw18pw8++KAGz0HYvP766/olhc+6XLly6dbHF7x3797y/PPPy5VXXikTJkzQ4LkVK1ZI48aNJa9wm4Ft2f+NISRH2KKj1IKSV8fOTsxNt27d1BqBjhmxEQgg/fDDD30VuvE3PXjwYA0IhVDB7wICPs1OPBCsg04dVpCTJ09qPIY1tiIYSUlJ+hpoAQD16tXTGA5YAj7//HPtoINlzDzyyCN6zhATO3bsUKGGa0PsDQJ8TXCtVqtLoDUC4gixMxmda7DzhHULv4+ICwG4bgjDefPmSefOnSU75EQQmYIVWVy5CWJ0EJsD0QTLGyyAsFahnfE9Af3795fNmzdrv4BgaMRWDRo0SON5zHWyCu4PyOgekfxNnpsY8NSDL+Vtt92mpk6IHJgWQwXKwRQNEzR+ZJA1gWyKli1bZvrDlluWG2obklvAahAVY8+TCcfODuiou3Tpoh0SHlAgEKwZS+iIrr/+el9gMV579uypVo9gIHAUQgkdFzo7dLiZUbp0aT1va3aTCVwk6LDxgIQAWwiVp556Kt16EBVYr06dOnLxxRfrwxiuZ/78+X7rwfqD9cwpsHNFJhYCW0OB4wSeJywWsIDNnDlTrxcTfiuxL+vvJdoSFqpglitcF4KyAdxe69evl+wCt5TVKhVsGjVqVMjtkem0d+9ev3nmZywLBR6CcQ04/oEDB6RHjx46H1Y8gHsL1xasf7C4wAoE95J1naxiZspldI9I/iZPxQ2i9eEvhd/Xd0JRUfo5MBvCBPOt6wM8yYRaH35YROdbp0hw9ERKRPZLSEEEDzKwuFiBBQIxMTNmzFDBECxTyKRUqVLSvXt3WbhwYZZcUqaAwXHXrl2b6brIpnnllVdk165dGa5nWmtMq1BWgHUIFoZgsS4mWAbhYbWuwP0Odx2yhawuILhq4I4xU7xhhYJbDb99VmDdhugyY2mQEv3TTz/p/gKB5SPw/oTLLdW2bVu1dFlTzX/88Uc972DxNlYgYHB8WFZw3Ugjx8Nt4D2pXLmy3m+sg+NlV6Qg2wrthCw6cnaSp+IG6htPI8H8r6F8r6H8taHWh/sKgXfmhD+GSFAswS5Ot1PcxunAYkIKO4g1gYUDrh7E2WzdulVja+CWMp+8TRBkCisHUr8RCxJsfBcriLXBb0h24kbwIAQBlRnoEJs2bZrOAgFxgd8axHAgNhAWZHScmZ2rFVic4FbBMULRqVMntUBY07ERSAwXGFKYYWEyJ1i4EM9kjp0DqxZEANoRD4+bNm1Syw6sTA899JBvfxjjBTFQcGch7hHp1hjbBa5BBH8jJicjt1RGE8RnKCCqIDwgXnF9cEHCIg/LjMm0adPS3Ve4pRAbhW1gsYeFDSn1psDEdwGWf4hCCCy4pPBdw3VbMQUY2hdjMOF9oOCFuwvj8JjuKXIWYuQhO3fu1LSuX375xW/+I488YrRu3TroNtHR0caECRP85r399ttGuXLlgq6fnJysaWPmhLTRSKSCgy37TxguV9ZSZAkJV3pkfgZ/f0jRbtmypaZxI3UZKb/Dhg0zTp06lW79UaNG6d/nSy+9lG6ZmQoeCqRpZ5YKvmbNGiM+Pl7TqDNKBQcTJ07UFHMz1Rr79nqedSpbtqxxxRVXGCtXrsxWKvhdd91l3H333UZm9OzZU9sO7Nmzx3A4HMaXX34ZdN17773XaNGihe/zhg0bjGuuucaoVKmSkZiYqNf3wQcfpEuJxv15/vnnjSZNmmhadalSpYz27dtrunlaWpoRKf7880/jggsu0PatXLmy8cILL6S714HdU6dOnfT+4zzbtGljzJo1y2/5/v37NUUe14vvWefOnY2lS5emO7b1HppT4PcG31Hcf3L2poLb8F9euqXgM0bWg3VEzX79+qmJ9dtvv023DQIIofCtI0vCd49UUzx5ZAbcUrDgwCcN3zQhZwNwZcDqAbdCsEBTknVuuOEGdWU89thjud5ssC7A/fL777/rvcwIWLoQpwQXVqjYIxJ+EPAOCxfaPyuxXCT3fuuy03/nqVsKpslzzz1XU/dMkMKHz6FMtphvXd/012Zk4iWEEKt7I6/EAsZNwci5mQkbALcYAmTxQ09yD8QaIaCdwubsJk8tNwD+Vlhq3nvvPY1sh38UPl/4TRFLA78xgsMQOwMQaNixY0f1t8L/jGHI4RfPaio4LTfkbISWG0JIYSA5TJabPLe5YRwLBHWNGDFCA/VQ9Ax1XcygYaT9WdMoEbiHsW2QzYAxJpCSCZdUXo5xQwghhJD8Q55bbnIbWm7I2QgtN4SQwkByQYi5IYRkj0L2LEIIKWQYYfqNo7gh5CzAHHiNw8ETQgoyqamp+motZ5IT8jzmhhCSOfhDx0Bt+/bt088YQiG7JRAIISQ/g2xpxODi9+1Ms9Uobgg5SzDr7pgChxBCChpRUVE6nt2ZPrxR3BByloA/9ooVK0q5cuX86vIQQkhBISYmJttV3INBcUPIWeiiOlN/NCGEFGQYUEwIIYSQAgXFDSGEEEIKFBQ3hBBCCClQOArrAEEY6ZAQQgghZwdmv52Vgf4Knbg5fvy4vlatWjWvT4UQQgghOejHUYYhIwpdbSkMErRr1y4pWrRo2AdBg6qEaNqxY0emdS8I2zm/w+8z27mgwe/02d3OkCsQNpUqVco0XbzQWW7QIFWqVInoMXAzKW4iD9s5d2A7s50LGvxOn73tnJnFxoQBxYQQQggpUFDcEEIIIaRAQXETRmJjY2XkyJH6SiIH2zl3YDuznQsa/E4XnnYudAHFhBBCCCnY0HJDCCGEkAIFxQ0hhBBCChQUN4QQQggpUFDcEEIIIaRAQXGTTd5++20555xzJC4uTtq0aSPLli3LcP2vvvpK6tevr+s3adJEZs2adSb3q9CQnXb+4IMPpEOHDlKyZEmdLrnkkkzvC8l+O1uZNGmSjvB99dVXsynD/H0GR44ckQEDBkjFihU146Ru3br87YhAO7/++utSr149iY+P1xF1Bw8eLMnJyfxOZ8CiRYvkqquu0lGC8RvwzTffSGYsWLBAWrZsqd/l2rVry/jx4yXiIFuKZI1JkyYZMTExxscff2ysWbPG6N+/v1GiRAlj7969Qdf/+eefDbvdbrz00kvG2rVrjWHDhhnR0dHG6tWr2eRhbOc+ffoYb7/9trFy5Upj3bp1xq233moUL17c+O+//9jOYWxnk61btxqVK1c2OnToYPTo0YNtHOZ2TklJMVq1amVcccUVxpIlS7S9FyxYYKxatYptHcZ2/uKLL4zY2Fh9RRvPmTPHqFixojF48GC2cwbMmjXLeOKJJ4ypU6ci09qYNm1aRqsbW7ZsMRISEowHH3xQ+8E333xT+8XZs2cbkYTiJhu0bt3aGDBggO+zy+UyKlWqZDz//PNB1+/Zs6fRrVs3v3lt2rQx7r777pzer0JBdts5EKfTaRQtWtT45JNPIniWhbOd0bbt2rUzPvzwQ6Nfv34UNxFo53feeceoWbOmkZqamr0bWsjJbjtj3YsvvthvHjrg9u3bR/xcCwqSBXHz6KOPGo0aNfKb16tXL6Nr164RPTe6pbJIamqq/PHHH+rysNapwudff/016DaYb10fdO3aNeT6JGftHMipU6ckLS1NSpUqxSYN4/cZPP3001KuXDm544472LYRaufp06dL27Zt1S1Vvnx5ady4sYwaNUpcLhfbPIzt3K5dO93GdF1t2bJFXX9XXHEF2zmM5FU/WOgKZ+aUAwcO6I8Lfmys4PP69euDbrNnz56g62M+CV87BzJkyBD1Bwf+QZEza+clS5bIRx99JKtWrWJTRrCd0cnOmzdPbrrpJu1sN23aJPfdd58Kdoz6SsLTzn369NHtLrjgAq027XQ65Z577pHHH3+cTRxGQvWDqByelJSk8U6RgJYbUqB44YUXNNh12rRpGlRIwsPx48elb9++GrxdpkwZNmsEcbvdah17//335dxzz5VevXrJE088Ie+++y7bPYwgyBUWsbFjx8qKFStk6tSpMnPmTHnmmWfYzgUAWm6yCH7Q7Xa77N27128+PleoUCHoNpifnfVJztrZ5JVXXlFx89NPP0nTpk3ZnGH8Pm/evFn+/fdfzZKwdsLA4XDIhg0bpFatWmzzM2xngAyp6Oho3c6kQYMG+gQM90tMTAzbOQztPHz4cBXsd955p35GNuvJkyflrrvuUjEJtxY5c0L1g8WKFYuY1Qbw7mUR/KDgKWru3Ll+P+74DP94MDDfuj748ccfQ65PctbO4KWXXtInrtmzZ0urVq3YlGH+PmM4g9WrV6tLypy6d+8unTp10vdIoyVn3s6gffv26ooyxSPYuHGjih4Km/B8n83YvEABYwpKllwMH3nWD0Y0XLkAphoidXD8+PGa0nbXXXdpquGePXt0ed++fY2hQ4f6pYI7HA7jlVde0RTlkSNHMhU8Au38wgsvaArolClTjN27d/um48ePh/9LUIjbORBmS0Wmnbdv367ZfgMHDjQ2bNhgzJgxwyhXrpzx7LPPnuEdL9hkt53xe4x2njhxoqYr//DDD0atWrU0y5WEBr+rGHYDEyTEa6+9pu+3bdumy9HGaOvAVPBHHnlE+0EM28FU8HwIcvSrVaumnSlSD5cuXepb1rFjR/3Bt/Lll18adevW1fWRDjdz5sw8OOuC3c7Vq1fXP7LACT9eJHztHAjFTWS+z+CXX37RYSPQWSMt/LnnntM0fBK+dk5LSzOefPJJFTRxcXFG1apVjfvuu884fPgwmzkD5s+fH/T31mxbvKKtA7dp3ry53hd8n8eNG2dEGhv+i6xtiBBCCCEk92DMDSGEEEIKFBQ3hBBCCClQUNwQQgghpEBBcUMIIYSQAgXFDSGEEEIKFBQ3hBBCCClQUNwQQgghpEBBcUMI8WP8+PFSokSJs7ZVbDabfPPNNxmuc+utt8rVV1+da+dECMldKG4IKYCg80YnHzihZlF+EE/m+aC2T5UqVeS2226Tffv2hWX/u3fvlssvv1zfo9gnjoP6V1bGjBmj5xFJnnzySd91omYR6m+hKOOhQ4eytR8KMUKyD6uCE1JAueyyy2TcuHF+88qWLSv5AVQERiVxFDf8888/Vdzs2rVL5syZc8b7zqx6PChevLjkBo0aNdIq9S6XS9atWye33367HD16VCZPnpwrxyeksELLDSEFlNjYWO3orRMsCK+99po0adJEEhMT1Zpw3333yYkTJ0LuB+ID1b+LFi2qogTVl3///Xff8iVLlkiHDh0kPj5e9/fAAw/IyZMnMzw3WDNwPpUqVVIrC7aBCEhKSlLB8/TTT6tFB9fQvHlzrfZukpqaKgMHDtQq2XFxcVK9enV5/vnng7qlatSooa8tWrTQ+RdddFE6a8j777+v52Gtwg169OihYsTk22+/lZYtW+oxa9asKU899ZQ4nc4Mr9PhcOh1Vq5cWS655BK54YYbtCKyCUTPHXfcoeeJ9qtXr55alazWn08++USPbVqBFixYoMt27NghPXv2VBdiqVKl9HxhqSKEUNwQUuiAK+iNN96QNWvWaMc5b948efTRR0Ouf9NNN6nQWL58ufzxxx8ydOhQiY6O1mWbN29WC9F1110nf/31l1okIHYgPrIDOnaIC4gFdO6vvvqqvPLKK7rPrl27Svfu3eWff/7RdXHu06dPly+//FKtP1988YWcc845Qfe7bNkyfYVwgrtq6tSp6daB4Dh48KDMnz/fNw+uIwgqXDtYvHix3HLLLTJo0CBZu3atvPfee+rWeu6557J8jRAesEzFxMT45uGa0bZfffWV7nfEiBHy+OOP67WBhx9+WAUM2hjnj6ldu3aSlpam7QLBiXP7+eefpUiRIroexB8hhZ6Il+YkhOQ6qMxrt9uNxMRE33T99dcHXferr74ySpcu7fuMir3Fixf3fS5atKgxfvz4oNvecccdxl133eU3b/HixUZUVJSRlJQUdJvA/W/cuNGoW7eu0apVK/1cqVIlrYJt5bzzztOKzeD+++83Lr74YsPtdgfdPyoUT5s2Td9v3bpVP69cuTJd+/To0cP3Ge9vv/123+f33ntPz8Plcunnzp07G6NGjfLbx2effWZUrFjRCAWq0qMd0PaoOm1WT37ttdeMjBgwYIBx3XXXhTxX89j16tXza4OUlBQjPj7emDNnTob7J6QwwJgbQgoocCW98847vs9wQ5lWDLhx1q9fL8eOHVNrSXJyspw6dUoSEhLS7efBBx+UO++8Uz777DOfa6VWrVo+lxWsK7CemEBfwCKxdetWadCgQdBzQ9wJLA1YD8e+4IIL5MMPP9TzQexN+/bt/dbHZxzLdCl16dJFXTiwVFx55ZVy6aWXnlFbwULTv39/GTt2rLrCcD033nijWrnM64R1xGqpgUspo3YDOEdYmbDe559/roHN999/v986b7/9tnz88ceyfft2dcvB8gJXXEbgfBAcDsuNFRwH1jRCCjsUN4QUUCBmateunc41AjFw7733akeNWA24kRD3gU41WCeNuI8+ffrIzJkz5fvvv5eRI0fKpEmT5JprrtFYnbvvvltjZgKpVq1ayHNDp7xixQoVD4idgVsKQNxkBuJeIJxwLhBqcNtAdE2ZMkVyylVXXaWiDNd43nnnqatn9OjRvuW4TsTYXHvttem2RQxOKOCCMu/BCy+8IN26ddP9PPPMMzoP7QjXE9xwbdu21XZ5+eWX5bfffsvwfHE+iH2yisr8FjROSF5CcUNIIQIxM7CWoDM1rRJmfEdG1K1bV6fBgwdL7969NQsL4gZCA7EigSIqM3DsYNsgYBnBvbCSdOzY0Tcfn1u3bu23Xq9evXS6/vrr1YKDOBmINStmfAusLBkBgQLhArEAiwgsLrg2E7xHfE92rzOQYcOGycUXX6zi0rxOxNAgqNsk0PKCawg8f5wP4pvKlSunbUEI8YfZUoQUItA5Ixj1zTfflC1btqir6d133w25PtwkCA5Ghs62bdu0M0ZgseluGjJkiPzyyy+6DlwuCPpFZk92A4qtPPLII/Liiy9q5w1BgQBm7BvBvADZXhMnTlS32saNGzUYFxlJwQYeROcPqxCCg/fu3avusIxcU7DcwEVkBhKbIND3008/VasLArGR1g2rC8RKdoB1pmnTpjJq1Cj9XKdOHc08Q6AxrmX48OHavlYQLA3XH9riwIEDev9wfmXKlNEMKViZYMnCPYIF7b///svWORFSIMnroB9CSPgJFoRqgoBWBMIi+LRr167Gp59+qoGuhw8fThfwiyDVG2+80ahataoRExOjQbYDBw70CxZetmyZ0aVLF6NIkSIaPNu0adN0AcEZBRQHgiDeJ5980qhcubIRHR1tNGvWzPj+++99y99//32jefPmeqxixYppsO+KFSuCBhSDDz74QM8fwb0dO3YM2T44LtoF22/evDndec2ePdto166dthuO27p1az2XjAKKce6BTJw40YiNjTW2b99uJCcnG7feequ2R4kSJYx7773XGDp0qN92+/bt87Uvzm3+/Pk6f/fu3cYtt9xilClTRvdXs2ZNo3///sbRo0dDnhMhhQUb/strgUUIIYQQEi7oliKEEEJIgYLihhBCCCEFCoobQgghhBQoKG4IIYQQUqCguCGEEEJIgYLihhBCCCEFCoobQgghhBQoKG4IIYQQUqCguCGEEEJIgYLihhBCCCEFCoobQgghhBQoKG4IIYQQIgWJ/wPxnjhGtbYLFgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import roc_curve, auc\n",
+    "\n",
+    "plt.figure()\n",
+    "print(\"\\n==== ROC AUC SCORES ====\\n\")\n",
+    "\n",
+    "for model_name, model in models.items():\n",
+    "    # Get probability/decision scores\n",
+    "    if hasattr(model, \"predict_proba\"):\n",
+    "        scores = model.predict_proba(X_test)[:, 1]\n",
+    "    else:\n",
+    "        scores = model.decision_function(X_test)\n",
+    "\n",
+    "    # Compute ROC\n",
+    "    fpr, tpr, _ = roc_curve(y_test, scores)\n",
+    "    roc_auc_score = auc(fpr, tpr)\n",
+    "\n",
+    "    print(f\"{model_name} : AUC = {roc_auc_score:.5f}\")\n",
+    "\n",
+    "    # Plot all in same graph\n",
+    "    plt.plot(fpr, tpr, label=f\"{model_name} (AUC = {roc_auc_score:.3f})\")\n",
+    "\n",
+    "# Final Graph Settings\n",
+    "plt.title(\"ROC Curve - All Models\")\n",
+    "plt.xlabel(\"False Positive Rate\")\n",
+    "plt.ylabel(\"True Positive Rate\")\n",
+    "plt.legend()\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "2437c382",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving all trained NSL-KDD Binary models to:\n",
+      "    c:\\Users\\S Rakshita\\Desktop\\SENITNELNET\\SentinelNet_Oct_Batch\\models\n",
+      "\n",
+      "Time: 2025-12-02 15:47:11\n",
+      "\n",
+      "SAVED → models\\nslkdd_binary_logistic_regression.pkl\n",
+      "SAVED → models\\nslkdd_binary_decision_tree_classifier.pkl\n",
+      "SAVED → models\\nslkdd_binary_random_forest.pkl\n",
+      "SAVED → models\\nslkdd_binary_gradient_boosting.pkl\n",
+      "SAVED → models\\nslkdd_binary_xgboost.pkl\n",
+      "SAVED → models\\nslkdd_binary_knn.pkl\n",
+      "SAVED → models\\nslkdd_binary_svm__rbf_.pkl\n",
+      "\n",
+      "======================================================================\n",
+      "ALL 7 MODELS SUCCESSFULLY SAVED!\n",
+      "Location: c:\\Users\\S Rakshita\\Desktop\\SENITNELNET\\SentinelNet_Oct_Batch\\models\n",
+      "======================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "# FINAL STEP — SAVE ALL MODELS IN YOUR PROJECT FOLDER\n",
+    "import joblib\n",
+    "import os\n",
+    "from datetime import datetime\n",
+    "\n",
+    "# Define the exact folder where you want the models\n",
+    "SAVE_DIR = \"models\"        # This will create: SentinelNet_Oct_Batch/models/\n",
+    "# OR if you want to be 100% sure (absolute path):\n",
+    "# SAVE_DIR = r\"C:\\Users\\S Rakshita\\Desktop\\SENITNELNET\\SentinelNet_Oct_Batch\\models\"\n",
+    "\n",
+    "os.makedirs(SAVE_DIR, exist_ok=True)\n",
+    "\n",
+    "print(f\"Saving all trained NSL-KDD Binary models to:\\n    {os.path.abspath(SAVE_DIR)}\\n\")\n",
+    "print(f\"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\\n\")\n",
+    "\n",
+    "saved_count = 0\n",
+    "for name, model in models.items():\n",
+    "    # Make filename safe\n",
+    "    safe_name = \"\".join(c if c.isalnum() or c in \" _-\" else \"_\" for c in name)\n",
+    "    safe_name = safe_name.replace(\" \", \"_\").lower()\n",
+    "    \n",
+    "    filename = os.path.join(SAVE_DIR, f\"nslkdd_binary_{safe_name}.pkl\")\n",
+    "    \n",
+    "    joblib.dump(model, filename)\n",
+    "    print(f\"SAVED → {filename}\")\n",
+    "    saved_count += 1\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*70)\n",
+    "print(f\"ALL {saved_count} MODELS SUCCESSFULLY SAVED!\")\n",
+    "print(f\"Location: {os.path.abspath(SAVE_DIR)}\")\n",
+    "print(\"=\"*70)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 00856c218a8c8df00b74e5699c7f29826e2b3c78 Mon Sep 17 00:00:00 2001
From: Kumkum Goyal <145197845+kum-kum1234@users.noreply.github.com>
Date: Thu, 4 Dec 2025 21:37:41 +0530
Subject: [PATCH 4/6] Add files via upload

---
 train_multiclass_kdd.ipynb | 424 +++++++++++++++++++++++++++++++++++++
 1 file changed, 424 insertions(+)
 create mode 100644 train_multiclass_kdd.ipynb

diff --git a/train_multiclass_kdd.ipynb b/train_multiclass_kdd.ipynb
new file mode 100644
index 0000000..22faec8
--- /dev/null
+++ b/train_multiclass_kdd.ipynb
@@ -0,0 +1,424 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "7f8d40e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.metrics import (\n",
+    "    accuracy_score, precision_score, recall_score,\n",
+    "    f1_score, confusion_matrix, classification_report\n",
+    ")\n",
+    "\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "\n",
+    "try:\n",
+    "    from lightgbm import LGBMClassifier\n",
+    "except ImportError:\n",
+    "    LGBMClassifier = None\n",
+    "\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "import joblib\n",
+    "import os\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "b3bbb6e3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train shape: (118813, 42)\n",
+      "Test shape : (29705, 42)\n",
+      "         0              1        2     3          4          5     6   \\\n",
+      "0  duration  protocol_type  service  flag  src_bytes  dst_bytes  land   \n",
+      "1         0              1       30     5          0          0     0   \n",
+      "2         0              1       69     5          0          0     0   \n",
+      "\n",
+      "               7       8    9   ...                  32  \\\n",
+      "0  wrong_fragment  urgent  hot  ...  dst_host_srv_count   \n",
+      "1               0       0    0  ...                  18   \n",
+      "2               0       0    0  ...                  19   \n",
+      "\n",
+      "                       33                      34  \\\n",
+      "0  dst_host_same_srv_rate  dst_host_diff_srv_rate   \n",
+      "1                    0.07                    0.07   \n",
+      "2                    0.07                    0.07   \n",
+      "\n",
+      "                            35                           36  \\\n",
+      "0  dst_host_same_src_port_rate  dst_host_srv_diff_host_rate   \n",
+      "1                          0.0                          0.0   \n",
+      "2                          0.0                          0.0   \n",
+      "\n",
+      "                     37                        38                    39  \\\n",
+      "0  dst_host_serror_rate  dst_host_srv_serror_rate  dst_host_rerror_rate   \n",
+      "1                   1.0                       1.0                   0.0   \n",
+      "2                   1.0                       1.0                   0.0   \n",
+      "\n",
+      "                         40      41  \n",
+      "0  dst_host_srv_rerror_rate  labels  \n",
+      "1                       0.0      14  \n",
+      "2                       0.0      14  \n",
+      "\n",
+      "[3 rows x 42 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "train_path = \"NSLKDD_train.csv\"\n",
+    "test_path  = \"NSLKDD_test.csv\"\n",
+    "\n",
+    "train_df = pd.read_csv(train_path, header=None)\n",
+    "test_df  = pd.read_csv(test_path,  header=None)\n",
+    "\n",
+    "print(\"Train shape:\", train_df.shape)\n",
+    "print(\"Test shape :\", test_df.shape)\n",
+    "print(train_df.head(3))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "a614284f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "   dst_host_srv_diff_host_rate  dst_host_srv_rerror_rate   label\n",
+      "0  dst_host_srv_diff_host_rate  dst_host_srv_rerror_rate  labels\n",
+      "1                          0.0                       0.0      14\n",
+      "2                          0.0                       0.0      14\n",
+      "3                         0.18                       1.0      16\n",
+      "4                          0.0                       0.0      14\n"
+     ]
+    }
+   ],
+   "source": [
+    "base_features = [\n",
+    " 'duration','protocol_type','service','flag','src_bytes','dst_bytes','land',\n",
+    " 'wrong_fragment','urgent','hot','num_failed_logins','logged_in',\n",
+    " 'num_compromised','root_shell','su_attempted','num_root','num_file_creations',\n",
+    " 'num_shells','num_access_files','num_outbound_cmds','is_host_login',\n",
+    " 'is_guest_login','count','srv_count','serror_rate','srv_serror_rate',\n",
+    " 'rerror_rate','srv_rerror_rate','same_srv_rate','diff_srv_rate',\n",
+    " 'srv_diff_host_rate','dst_host_count','dst_host_srv_count',\n",
+    " 'dst_host_same_srv_rate','dst_host_diff_srv_rate','dst_host_same_src_port_rate',\n",
+    " 'dst_host_srv_diff_host_rate','dst_host_serror_rate','dst_host_srv_serror_rate',\n",
+    " 'dst_host_rerror_rate','dst_host_srv_rerror_rate'\n",
+    "]\n",
+    "\n",
+    "train_df.columns = base_features + [\"label\"]\n",
+    "test_df.columns  = base_features + [\"label\"]\n",
+    "\n",
+    "print(train_df[[\"dst_host_srv_diff_host_rate\",\"dst_host_srv_rerror_rate\",\"label\"]].head())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "7be11cd5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Unique before drop: ['labels' '14' '16' '4' '35' '7' '1' '25' '11' '34' '15' '0' '21' '20'\n",
+      " '27' '29' '32' '28' '10' '19']\n",
+      "\n",
+      "Unique numeric labels (train): [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
+      " 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39]\n",
+      "Unique numeric labels (test): [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n",
+      " 24 25 26 27 28 29 32 34 35 37 38 39]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Convert label to numeric; 'labels' will become NaN\n",
+    "train_df[\"label_num\"] = pd.to_numeric(train_df[\"label\"], errors=\"coerce\")\n",
+    "test_df[\"label_num\"]  = pd.to_numeric(test_df[\"label\"],  errors=\"coerce\")\n",
+    "\n",
+    "print(\"Unique before drop:\", train_df[\"label\"].unique()[:20])\n",
+    "\n",
+    "# Drop header row(s) where conversion failed\n",
+    "train_df = train_df.dropna(subset=[\"label_num\"]).reset_index(drop=True)\n",
+    "test_df  = test_df.dropna(subset=[\"label_num\"]).reset_index(drop=True)\n",
+    "\n",
+    "train_df[\"label_num\"] = train_df[\"label_num\"].astype(int)\n",
+    "test_df[\"label_num\"]  = test_df[\"label_num\"].astype(int)\n",
+    "\n",
+    "print(\"\\nUnique numeric labels (train):\", np.sort(train_df[\"label_num\"].unique()))\n",
+    "print(\"Unique numeric labels (test):\", np.sort(test_df[\"label_num\"].unique()))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "ff5f62a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train class counts:\n",
+      " Series([], Name: count, dtype: int64) \n",
+      "\n",
+      "Test class counts:\n",
+      " Series([], Name: count, dtype: int64)\n"
+     ]
+    }
+   ],
+   "source": [
+    "dos_attacks = [\n",
+    " \"back\",\"land\",\"neptune\",\"pod\",\"smurf\",\"teardrop\",\n",
+    " \"mailbomb\",\"processtable\",\"udpstorm\",\"apache2\",\"worm\"\n",
+    "]\n",
+    "\n",
+    "probe_attacks = [\n",
+    " \"satan\",\"ipsweep\",\"nmap\",\"portsweep\",\"mscan\",\"saint\"\n",
+    "]\n",
+    "\n",
+    "r2l_attacks = [\n",
+    " \"guess_passwd\",\"ftp_write\",\"imap\",\"phf\",\"multihop\",\"warezmaster\",\"warezclient\",\n",
+    " \"spy\",\"xlock\",\"xsnoop\",\"snmpguess\",\"snmpgetattack\",\"httptunnel\",\"sendmail\",\"named\"\n",
+    "]\n",
+    "\n",
+    "u2r_attacks = [\n",
+    " \"buffer_overflow\",\"loadmodule\",\"rootkit\",\"perl\",\"sqlattack\",\"xterm\",\"ps\"\n",
+    "]\n",
+    "\n",
+    "def map_to_5class(label):\n",
+    "    l = str(label).strip().lower().replace(\".\", \"\")\n",
+    "    if l == \"normal\":\n",
+    "        return \"normal\"\n",
+    "    if l in dos_attacks:\n",
+    "        return \"dos\"\n",
+    "    if l in probe_attacks:\n",
+    "        return \"probe\"\n",
+    "    if l in r2l_attacks:\n",
+    "        return \"r2l\"\n",
+    "    if l in u2r_attacks:\n",
+    "        return \"u2r\"\n",
+    "    return None   # unknown / weird label\n",
+    "\n",
+    "train_df[\"target\"] = train_df[\"label\"].apply(map_to_5class)\n",
+    "test_df[\"target\"]  = test_df[\"label\"].apply(map_to_5class)\n",
+    "\n",
+    "print(\"Train class counts:\\n\", train_df[\"target\"].value_counts(), \"\\n\")\n",
+    "print(\"Test class counts:\\n\",  test_df[\"target\"].value_counts())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1dcf040d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "X_train: (0, 41) X_test: (0, 41)\n",
+      "y_train classes: [] -> ['dos', 'normal', 'probe', 'r2l', 'u2r']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Drop rows with unknown mapping (just in case)\n",
+    "train_df = train_df.dropna(subset=[\"target\"]).reset_index(drop=True)\n",
+    "test_df  = test_df.dropna(subset=[\"target\"]).reset_index(drop=True)\n",
+    "\n",
+    "# Remove difficulty if present\n",
+    "drop_cols = [\"label\", \"target\"]\n",
+    "if \"difficulty\" in train_df.columns:\n",
+    "    drop_cols.append(\"difficulty\")\n",
+    "\n",
+    "X_train = train_df.drop(columns=drop_cols)\n",
+    "X_test  = test_df.drop(columns=drop_cols)\n",
+    "\n",
+    "classes = [\"dos\", \"normal\", \"probe\", \"r2l\", \"u2r\"]\n",
+    "class_to_id = {c: i for i, c in enumerate(classes)}\n",
+    "\n",
+    "y_train = train_df[\"target\"].map(class_to_id).astype(int).values\n",
+    "y_test  = test_df[\"target\"].map(class_to_id).astype(int).values\n",
+    "\n",
+    "print(\"X_train:\", X_train.shape, \"X_test:\", X_test.shape)\n",
+    "print(\"y_train classes:\", np.unique(y_train), \"->\", classes)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "53d81495",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved: nslkdd_multi_scaler.pkl and nslkdd_multi_features.pkl\n"
+     ]
+    }
+   ],
+   "source": [
+    "cat_cols = [\"protocol_type\", \"service\", \"flag\"]\n",
+    "\n",
+    "train_cat = pd.get_dummies(X_train[cat_cols], prefix=cat_cols).astype(int)\n",
+    "test_cat  = pd.get_dummies(X_test[cat_cols],  prefix=cat_cols).astype(int)\n",
+    "\n",
+    "# Align categorical columns between train & test\n",
+    "all_cat_cols = train_cat.columns.union(test_cat.columns)\n",
+    "train_cat = train_cat.reindex(columns=all_cat_cols, fill_value=0)\n",
+    "test_cat  = test_cat.reindex(columns=all_cat_cols, fill_value=0)\n",
+    "\n",
+    "# Numeric part = everything except these categoricals\n",
+    "num_train = X_train.drop(columns=cat_cols).astype(float)\n",
+    "num_test  = X_test.drop(columns=cat_cols).astype(float)\n",
+    "\n",
+    "# Combine numeric + cat\n",
+    "X_train_full = pd.concat([num_train.reset_index(drop=True),\n",
+    "                          train_cat.reset_index(drop=True)], axis=1)\n",
+    "\n",
+    "X_test_full  = pd.concat([num_test.reset_index(drop=True),\n",
+    "                          test_cat.reset_index(drop=True)], axis=1)\n",
+    "\n",
+    "print(\"Final feature count:\", X_train_full.shape[1])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "14d8cdab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training multiclass model: decision_tree\n"
+     ]
+    },
+    {
+     "ename": "ValueError",
+     "evalue": "Found array with 0 sample(s) (shape=(0,)) while a minimum of 1 is required by DecisionTreeClassifier.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[13], line 20\u001b[0m\n\u001b[0;32m     18\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m name, model \u001b[38;5;129;01min\u001b[39;00m models\u001b[38;5;241m.\u001b[39mitems():\n\u001b[0;32m     19\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mTraining multiclass model: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 20\u001b[0m     \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX_train_scaled\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_train\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     21\u001b[0m     y_pred \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mpredict(X_test_scaled)\n\u001b[0;32m     23\u001b[0m     acc  \u001b[38;5;241m=\u001b[39m accuracy_score(y_test, y_pred)\n",
+      "File \u001b[1;32mc:\\Users\\Hp\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\base.py:1365\u001b[0m, in \u001b[0;36m_fit_context.<locals>.decorator.<locals>.wrapper\u001b[1;34m(estimator, *args, **kwargs)\u001b[0m\n\u001b[0;32m   1358\u001b[0m     estimator\u001b[38;5;241m.\u001b[39m_validate_params()\n\u001b[0;32m   1360\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m config_context(\n\u001b[0;32m   1361\u001b[0m     skip_parameter_validation\u001b[38;5;241m=\u001b[39m(\n\u001b[0;32m   1362\u001b[0m         prefer_skip_nested_validation \u001b[38;5;129;01mor\u001b[39;00m global_skip_validation\n\u001b[0;32m   1363\u001b[0m     )\n\u001b[0;32m   1364\u001b[0m ):\n\u001b[1;32m-> 1365\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m fit_method(estimator, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n",
+      "File \u001b[1;32mc:\\Users\\Hp\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\tree\\_classes.py:1024\u001b[0m, in \u001b[0;36mDecisionTreeClassifier.fit\u001b[1;34m(self, X, y, sample_weight, check_input)\u001b[0m\n\u001b[0;32m    993\u001b[0m \u001b[38;5;129m@_fit_context\u001b[39m(prefer_skip_nested_validation\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[0;32m    994\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21mfit\u001b[39m(\u001b[38;5;28mself\u001b[39m, X, y, sample_weight\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, check_input\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[0;32m    995\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Build a decision tree classifier from the training set (X, y).\u001b[39;00m\n\u001b[0;32m    996\u001b[0m \n\u001b[0;32m    997\u001b[0m \u001b[38;5;124;03m    Parameters\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1021\u001b[0m \u001b[38;5;124;03m        Fitted estimator.\u001b[39;00m\n\u001b[0;32m   1022\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m-> 1024\u001b[0m     \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_fit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1025\u001b[0m \u001b[43m        \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1026\u001b[0m \u001b[43m        \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1027\u001b[0m \u001b[43m        \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1028\u001b[0m \u001b[43m        \u001b[49m\u001b[43mcheck_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcheck_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1029\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1030\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\n",
+      "File \u001b[1;32mc:\\Users\\Hp\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\tree\\_classes.py:252\u001b[0m, in \u001b[0;36mBaseDecisionTree._fit\u001b[1;34m(self, X, y, sample_weight, check_input, missing_values_in_feature_mask)\u001b[0m\n\u001b[0;32m    248\u001b[0m check_X_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m(\n\u001b[0;32m    249\u001b[0m     dtype\u001b[38;5;241m=\u001b[39mDTYPE, accept_sparse\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcsc\u001b[39m\u001b[38;5;124m\"\u001b[39m, ensure_all_finite\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m\n\u001b[0;32m    250\u001b[0m )\n\u001b[0;32m    251\u001b[0m check_y_params \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mdict\u001b[39m(ensure_2d\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m)\n\u001b[1;32m--> 252\u001b[0m X, y \u001b[38;5;241m=\u001b[39m \u001b[43mvalidate_data\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    253\u001b[0m \u001b[43m    \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mvalidate_separately\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mcheck_X_params\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcheck_y_params\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    254\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    256\u001b[0m missing_values_in_feature_mask \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m    257\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_compute_missing_values_in_feature_mask(X)\n\u001b[0;32m    258\u001b[0m )\n\u001b[0;32m    259\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m issparse(X):\n",
+      "File \u001b[1;32mc:\\Users\\Hp\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\utils\\validation.py:2969\u001b[0m, in \u001b[0;36mvalidate_data\u001b[1;34m(_estimator, X, y, reset, validate_separately, skip_check_array, **check_params)\u001b[0m\n\u001b[0;32m   2967\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mestimator\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m check_y_params:\n\u001b[0;32m   2968\u001b[0m         check_y_params \u001b[38;5;241m=\u001b[39m {\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mdefault_check_params, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mcheck_y_params}\n\u001b[1;32m-> 2969\u001b[0m     y \u001b[38;5;241m=\u001b[39m check_array(y, input_name\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mcheck_y_params)\n\u001b[0;32m   2970\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   2971\u001b[0m     X, y \u001b[38;5;241m=\u001b[39m check_X_y(X, y, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mcheck_params)\n",
+      "File \u001b[1;32mc:\\Users\\Hp\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\utils\\validation.py:1128\u001b[0m, in \u001b[0;36mcheck_array\u001b[1;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_writeable, force_all_finite, ensure_all_finite, ensure_non_negative, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name)\u001b[0m\n\u001b[0;32m   1126\u001b[0m     n_samples \u001b[38;5;241m=\u001b[39m _num_samples(array)\n\u001b[0;32m   1127\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m n_samples \u001b[38;5;241m<\u001b[39m ensure_min_samples:\n\u001b[1;32m-> 1128\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m   1129\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFound array with \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m sample(s) (shape=\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m) while a\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1130\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m minimum of \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m is required\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1131\u001b[0m             \u001b[38;5;241m%\u001b[39m (n_samples, array\u001b[38;5;241m.\u001b[39mshape, ensure_min_samples, context)\n\u001b[0;32m   1132\u001b[0m         )\n\u001b[0;32m   1134\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ensure_min_features \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m array\u001b[38;5;241m.\u001b[39mndim \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n\u001b[0;32m   1135\u001b[0m     n_features \u001b[38;5;241m=\u001b[39m array\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m]\n",
+      "\u001b[1;31mValueError\u001b[0m: Found array with 0 sample(s) (shape=(0,)) while a minimum of 1 is required by DecisionTreeClassifier."
+     ]
+    }
+   ],
+   "source": [
+    "models = {\n",
+    "    \"decision_tree\": DecisionTreeClassifier(max_depth=25),\n",
+    "    \"random_forest\": RandomForestClassifier(n_estimators=300, random_state=42),\n",
+    "    \"extra_trees\":   ExtraTreesClassifier(n_estimators=300, random_state=42),\n",
+    "    \"naive_bayes\":   GaussianNB(),\n",
+    "    \"logistic_regression\": LogisticRegression(max_iter=2000, multi_class=\"multinomial\")\n",
+    "}\n",
+    "\n",
+    "if LGBMClassifier is not None:\n",
+    "    models[\"lightgbm\"] = LGBMClassifier(\n",
+    "        n_estimators=400,\n",
+    "        num_leaves=64,\n",
+    "        verbose=-1\n",
+    "    )\n",
+    "\n",
+    "results = []\n",
+    "\n",
+    "for name, model in models.items():\n",
+    "    print(f\"Training multiclass model: {name}\")\n",
+    "    model.fit(X_train_scaled, y_train)\n",
+    "    y_pred = model.predict(X_test_scaled)\n",
+    "\n",
+    "    acc  = accuracy_score(y_test, y_pred)\n",
+    "    prec = precision_score(y_test, y_pred, average=\"weighted\")\n",
+    "    rec  = recall_score(y_test, y_pred, average=\"weighted\")\n",
+    "    f1   = f1_score(y_test, y_pred, average=\"weighted\")\n",
+    "\n",
+    "    results.append((name, acc, prec, rec, f1))\n",
+    "\n",
+    "    save_path = f\"models/nslkdd_multi_{name}.pkl\"\n",
+    "    joblib.dump(model, save_path)\n",
+    "    print(f\"  Saved → {save_path} | Acc={acc:.4f}\")\n",
+    "\n",
+    "results_df = pd.DataFrame(results, columns=[\"Model\",\"Accuracy\",\"Precision\",\"Recall\",\"F1\"])\n",
+    "results_df\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a3191cf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "best = results_df.iloc[results_df[\"Accuracy\"].idxmax()]\n",
+    "print(\"Best:\", best[\"Model\"], best[\"Accuracy\"])\n",
+    "\n",
+    "best_model = models[best[\"Model\"]]\n",
+    "y_pred_best = best_model.predict(X_test_scaled)\n",
+    "\n",
+    "cm = confusion_matrix(y_test, y_pred_best)\n",
+    "\n",
+    "plt.figure(figsize=(7,5))\n",
+    "sns.heatmap(cm, annot=True, fmt=\"d\",\n",
+    "            xticklabels=classes, yticklabels=classes,\n",
+    "            cmap=\"Blues\")\n",
+    "plt.xlabel(\"Predicted\")\n",
+    "plt.ylabel(\"True\")\n",
+    "plt.title(f\"Confusion Matrix - {best['Model']}\")\n",
+    "plt.show()\n",
+    "\n",
+    "print(classification_report(y_test, y_pred_best, target_names=classes))\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 1fe559f8aaec0baf8228961e127f1afb48b82ed7 Mon Sep 17 00:00:00 2001
From: Kumkum Goyal <145197845+kum-kum1234@users.noreply.github.com>
Date: Thu, 4 Dec 2025 21:38:05 +0530
Subject: [PATCH 5/6] Add files via upload

---
 cicids-multiclass.ipynb | 642 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 642 insertions(+)
 create mode 100644 cicids-multiclass.ipynb

diff --git a/cicids-multiclass.ipynb b/cicids-multiclass.ipynb
new file mode 100644
index 0000000..75fc83c
--- /dev/null
+++ b/cicids-multiclass.ipynb
@@ -0,0 +1,642 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "11fe16e0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "from sklearn.preprocessing import StandardScaler, LabelEncoder,label_binarize\n",
+    "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report, roc_auc_score,roc_curve, auc\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier\n",
+    "from sklearn.naive_bayes import GaussianNB\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.svm import SVC\n",
+    "from lightgbm import LGBMClassifier\n",
+    "import matplotlib.pyplot as plt\n",
+    "from itertools import cycle"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "id": "5f13a952",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset loaded successfully!\n",
+      "Shape: (56661, 78)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Flow Duration</th>\n",
+       "      <th>Total Fwd Packets</th>\n",
+       "      <th>Total Backward Packets</th>\n",
+       "      <th>Total Length of Fwd Packets</th>\n",
+       "      <th>Total Length of Bwd Packets</th>\n",
+       "      <th>Fwd Packet Length Max</th>\n",
+       "      <th>Fwd Packet Length Min</th>\n",
+       "      <th>Fwd Packet Length Mean</th>\n",
+       "      <th>Fwd Packet Length Std</th>\n",
+       "      <th>Bwd Packet Length Max</th>\n",
+       "      <th>...</th>\n",
+       "      <th>min_seg_size_forward</th>\n",
+       "      <th>Active Mean</th>\n",
+       "      <th>Active Std</th>\n",
+       "      <th>Active Max</th>\n",
+       "      <th>Active Min</th>\n",
+       "      <th>Idle Mean</th>\n",
+       "      <th>Idle Std</th>\n",
+       "      <th>Idle Max</th>\n",
+       "      <th>Idle Min</th>\n",
+       "      <th>Label</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>4</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>37</td>\n",
+       "      <td>0</td>\n",
+       "      <td>31</td>\n",
+       "      <td>6</td>\n",
+       "      <td>18.500000</td>\n",
+       "      <td>17.677670</td>\n",
+       "      <td>0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>20</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>BENIGN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>142377</td>\n",
+       "      <td>46</td>\n",
+       "      <td>62</td>\n",
+       "      <td>1325</td>\n",
+       "      <td>105855</td>\n",
+       "      <td>570</td>\n",
+       "      <td>0</td>\n",
+       "      <td>28.804348</td>\n",
+       "      <td>111.407285</td>\n",
+       "      <td>4344</td>\n",
+       "      <td>...</td>\n",
+       "      <td>20</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>BENIGN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>118873</td>\n",
+       "      <td>23</td>\n",
+       "      <td>28</td>\n",
+       "      <td>1169</td>\n",
+       "      <td>45025</td>\n",
+       "      <td>570</td>\n",
+       "      <td>0</td>\n",
+       "      <td>50.826087</td>\n",
+       "      <td>156.137367</td>\n",
+       "      <td>2896</td>\n",
+       "      <td>...</td>\n",
+       "      <td>32</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>BENIGN</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>3 rows × 78 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Flow Duration  Total Fwd Packets  Total Backward Packets  \\\n",
+       "0              4                  2                       0   \n",
+       "1         142377                 46                      62   \n",
+       "2         118873                 23                      28   \n",
+       "\n",
+       "   Total Length of Fwd Packets  Total Length of Bwd Packets  \\\n",
+       "0                           37                            0   \n",
+       "1                         1325                       105855   \n",
+       "2                         1169                        45025   \n",
+       "\n",
+       "   Fwd Packet Length Max  Fwd Packet Length Min  Fwd Packet Length Mean  \\\n",
+       "0                     31                      6               18.500000   \n",
+       "1                    570                      0               28.804348   \n",
+       "2                    570                      0               50.826087   \n",
+       "\n",
+       "   Fwd Packet Length Std  Bwd Packet Length Max  ...  min_seg_size_forward  \\\n",
+       "0              17.677670                      0  ...                    20   \n",
+       "1             111.407285                   4344  ...                    20   \n",
+       "2             156.137367                   2896  ...                    32   \n",
+       "\n",
+       "   Active Mean  Active Std  Active Max  Active Min  Idle Mean  Idle Std  \\\n",
+       "0          0.0         0.0           0           0        0.0       0.0   \n",
+       "1          0.0         0.0           0           0        0.0       0.0   \n",
+       "2          0.0         0.0           0           0        0.0       0.0   \n",
+       "\n",
+       "   Idle Max  Idle Min   Label  \n",
+       "0         0         0  BENIGN  \n",
+       "1         0         0  BENIGN  \n",
+       "2         0         0  BENIGN  \n",
+       "\n",
+       "[3 rows x 78 columns]"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv(\"CICIDS2017_sample.csv\")\n",
+    "\n",
+    "print(f\"Dataset loaded successfully!\")\n",
+    "print(f\"Shape: {df.shape}\")\n",
+    "df.head(3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c32a3270",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After cleaning: (56580, 78)\n",
+      "\n",
+      "Class distribution:\n",
+      "Label\n",
+      "BENIGN          22719\n",
+      "DoS             18984\n",
+      "PortScan         7938\n",
+      "BruteForce       2767\n",
+      "WebAttack        2180\n",
+      "Bot              1956\n",
+      "Infiltration       36\n",
+      "Name: count, dtype: int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "df.columns = df.columns.str.strip()\n",
+    "df.replace([np.inf, -np.inf], np.nan, inplace=True)\n",
+    "df.dropna(inplace=True)\n",
+    "print(f\"After cleaning: {df.shape}\")\n",
+    "print(\"\\nClass distribution:\")\n",
+    "print(df['Label'].value_counts())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5de17bf",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Classes: ['BENIGN' 'Bot' 'BruteForce' 'DoS' 'Infiltration' 'PortScan' 'WebAttack']\n"
+     ]
+    }
+   ],
+   "source": [
+    "X = df.drop('Label', axis=1)\n",
+    "y = df['Label']\n",
+    "\n",
+    "le = LabelEncoder()\n",
+    "y = le.fit_transform(y)\n",
+    "\n",
+    "print(\"Classes:\", le.classes_)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "559fda57",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Train: (39606, 77) | Test: (16974, 77)\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42, stratify=y)\n",
+    "\n",
+    "scaler = StandardScaler()\n",
+    "X_train = scaler.fit_transform(X_train)\n",
+    "X_test = scaler.transform(X_test)\n",
+    "\n",
+    "print(f\"Train: {X_train.shape} | Test: {X_test.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48851464",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "models = {\n",
+    "    \"Decision Tree\"   : DecisionTreeClassifier(max_depth=20, random_state=42),\n",
+    "    \"Random Forest\"   : RandomForestClassifier(n_estimators=300, n_jobs=-1, random_state=42),\n",
+    "    \"Extra Trees\"     : ExtraTreesClassifier(n_estimators=300, n_jobs=-1, random_state=42),\n",
+    "    \"Logistic Reg\"    : LogisticRegression(max_iter=1000),\n",
+    "    \"LightGBM\"        : LGBMClassifier(n_estimators=500, random_state=42, verbose=-1)\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "71d71836",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training all models with complete evaluation metrics...\n",
+      "\n",
+      "Decision Tree      → training... Done\n",
+      "Random Forest      → training... Done\n",
+      "Extra Trees        → training... Done\n",
+      "Logistic Reg       → training... Done\n",
+      "LightGBM           → training... Done\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model</th>\n",
+       "      <th>Accuracy</th>\n",
+       "      <th>Precision</th>\n",
+       "      <th>Recall</th>\n",
+       "      <th>F1-Score</th>\n",
+       "      <th>AUC</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Decision Tree</td>\n",
+       "      <td>0.99523</td>\n",
+       "      <td>0.99523</td>\n",
+       "      <td>0.99523</td>\n",
+       "      <td>0.99523</td>\n",
+       "      <td>0.99673</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Random Forest</td>\n",
+       "      <td>0.99476</td>\n",
+       "      <td>0.99477</td>\n",
+       "      <td>0.99476</td>\n",
+       "      <td>0.99474</td>\n",
+       "      <td>0.99962</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Extra Trees</td>\n",
+       "      <td>0.98869</td>\n",
+       "      <td>0.98882</td>\n",
+       "      <td>0.98869</td>\n",
+       "      <td>0.98870</td>\n",
+       "      <td>0.99944</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Logistic Reg</td>\n",
+       "      <td>0.91475</td>\n",
+       "      <td>0.91149</td>\n",
+       "      <td>0.91475</td>\n",
+       "      <td>0.91014</td>\n",
+       "      <td>0.98975</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>LightGBM</td>\n",
+       "      <td>0.70243</td>\n",
+       "      <td>0.74546</td>\n",
+       "      <td>0.70243</td>\n",
+       "      <td>0.70135</td>\n",
+       "      <td>0.81310</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           Model  Accuracy  Precision   Recall  F1-Score      AUC\n",
+       "0  Decision Tree   0.99523    0.99523  0.99523   0.99523  0.99673\n",
+       "1  Random Forest   0.99476    0.99477  0.99476   0.99474  0.99962\n",
+       "2    Extra Trees   0.98869    0.98882  0.98869   0.98870  0.99944\n",
+       "3   Logistic Reg   0.91475    0.91149  0.91475   0.91014  0.98975\n",
+       "4       LightGBM   0.70243    0.74546  0.70243   0.70135  0.81310"
+      ]
+     },
+     "execution_count": 54,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results = []\n",
+    "\n",
+    "print(\"Training all models with complete evaluation metrics...\\n\")\n",
+    "\n",
+    "for name, model in models.items():\n",
+    "    print(f\"{name:18} → training...\", end=\" \")\n",
+    "    \n",
+    "    model.fit(X_train, y_train)\n",
+    "    pred = model.predict(X_test)\n",
+    "    \n",
+    "\n",
+    "    if hasattr(model, \"predict_proba\"):\n",
+    "        proba = model.predict_proba(X_test)\n",
+    "        auc_val = roc_auc_score(y_test, proba, multi_class='ovr', average='weighted')\n",
+    "    elif hasattr(model, \"decision_function\"):\n",
+    "        dec = model.decision_function(X_test)\n",
+    "        auc_val = roc_auc_score(y_test, dec, multi_class='ovr', average='weighted')\n",
+    "    else:\n",
+    "        auc_val = \"N/A\"\n",
+    "    \n",
+    "    results.append({\n",
+    "        'Model'      : name,\n",
+    "        'Accuracy'   : round(accuracy_score(y_test, pred), 5),\n",
+    "        'Precision'  : round(precision_score(y_test, pred, average='weighted'), 5),\n",
+    "        'Recall'     : round(recall_score(y_test, pred, average='weighted'), 5),\n",
+    "        'F1-Score'   : round(f1_score(y_test, pred, average='weighted'), 5),\n",
+    "        'AUC'        : round(auc_val, 5) if isinstance(auc_val, float) else auc_val\n",
+    "    })\n",
+    "    \n",
+    "    print(\"Done\")\n",
+    "\n",
+    "final_results = pd.DataFrame(results)\n",
+    "final_results = final_results.sort_values('Accuracy', ascending=False).reset_index(drop=True)\n",
+    "\n",
+    "\n",
+    "final_results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e43b97d4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x900 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "best_model = models[final_results.iloc[0]['Model']]\n",
+    "y_pred_best = best_model.predict(X_test)\n",
+    "\n",
+    "plt.figure(figsize=(11,9))\n",
+    "sns.heatmap(confusion_matrix(y_test, y_pred_best),\n",
+    "            annot=True, fmt='d', cmap='Blues', cbar=False,\n",
+    "            xticklabels=le.classes_, yticklabels=le.classes_,\n",
+    "            linewidths=1, linecolor='black')\n",
+    "plt.title(f\"Confusion Matrix - {final_results.iloc[0]['Model']}\\nAccuracy: {final_results.iloc[0]['Accuracy']}\", \n",
+    "          fontsize=18, fontweight='bold', pad=20)\n",
+    "plt.ylabel('Actual')\n",
+    "plt.xlabel('Predicted')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "c0330ae0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CLASSIFICATION REPORT – Decision Tree\n",
+      "\n",
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "      BENIGN       1.00      0.99      0.99      6816\n",
+      "         Bot       0.99      0.98      0.99       587\n",
+      "  BruteForce       1.00      1.00      1.00       830\n",
+      "         DoS       1.00      1.00      1.00      5695\n",
+      "Infiltration       0.73      0.73      0.73        11\n",
+      "    PortScan       0.99      1.00      1.00      2381\n",
+      "   WebAttack       0.99      0.99      0.99       654\n",
+      "\n",
+      "    accuracy                           1.00     16974\n",
+      "   macro avg       0.96      0.95      0.96     16974\n",
+      "weighted avg       1.00      1.00      1.00     16974\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# CELL 9: Classification Report of Best Model\n",
+    "print(f\"CLASSIFICATION REPORT – {final_results.iloc[0]['Model']}\\n\")\n",
+    "print(classification_report(y_test, y_pred_best, target_names=le.classes_))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "808ec6f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x900 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "y_test_bin = label_binarize(y_test, classes=range(len(le.classes_)))\n",
+    "\n",
+    "plt.figure(figsize=(12,9))\n",
+    "colors = cycle(['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd'])\n",
+    "\n",
+    "for (name, model), color in zip(models.items(), colors):\n",
+    "    try:\n",
+    "        if hasattr(model, \"predict_proba\"):\n",
+    "            score = model.predict_proba(X_test)\n",
+    "        else:\n",
+    "            score = model.decision_function(X_test)\n",
+    "            from scipy.special import softmax\n",
+    "            score = softmax(score, axis=1)\n",
+    "        fpr, tpr, _ = roc_curve(y_test_bin.ravel(), score.ravel())\n",
+    "        plt.plot(fpr, tpr, color=color, lw=3, label=f'{name} (AUC = {auc(fpr,tpr):.4f})')\n",
+    "    except:\n",
+    "        pass\n",
+    "\n",
+    "plt.plot([0,1], [0,1], 'k--', lw=2)\n",
+    "plt.xlim([0,1])\n",
+    "plt.ylim([0,1.05])\n",
+    "plt.xlabel('False Positive Rate', fontsize=14)\n",
+    "plt.ylabel('True Positive Rate', fontsize=14)\n",
+    "plt.title('Multi-Class ROC Curves - CIC-IDS2017', fontsize=18, fontweight='bold')\n",
+    "plt.legend()\n",
+    "plt.grid(alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "id": "245108e5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saving CIC-IDS2017 Multiclass models...\n",
+      "\n",
+      "SAVED → models/cicids_multi_decision_tree.pkl\n",
+      "SAVED → models/cicids_multi_random_forest.pkl\n",
+      "SAVED → models/cicids_multi_extra_trees.pkl\n",
+      "SAVED → models/cicids_multi_logistic_reg.pkl\n",
+      "SAVED → models/cicids_multi_lightgbm.pkl\n",
+      "\n",
+      "CIC-IDS2017 MULTICLASS MODELS SAVED SUCCESSFULLY!\n"
+     ]
+    }
+   ],
+   "source": [
+    "import joblib\n",
+    "import os\n",
+    "from datetime import datetime\n",
+    "\n",
+    "SAVE_DIR = \"models\"\n",
+    "os.makedirs(SAVE_DIR, exist_ok=True)\n",
+    "\n",
+    "print(f\"Saving CIC-IDS2017 Multiclass models...\\n\")\n",
+    "\n",
+    "for name, model in models.items():\n",
+    "    safe_name = name.replace(\" \", \"_\").lower()\n",
+    "    filename = f\"{SAVE_DIR}/cicids_multi_{safe_name}.pkl\"\n",
+    "    joblib.dump(model, filename)\n",
+    "    print(f\"SAVED → {filename}\")\n",
+    "\n",
+    "print(\"\\nCIC-IDS2017 MULTICLASS MODELS SAVED SUCCESSFULLY!\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From df09d4aae70a827116d18739e1bf6ab2f846fdbe Mon Sep 17 00:00:00 2001
From: Kumkum Goyal <145197845+kum-kum1234@users.noreply.github.com>
Date: Fri, 5 Dec 2025 18:07:01 +0530
Subject: [PATCH 6/6] Update app.py

---
 app.py | 334 ++++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 226 insertions(+), 108 deletions(-)

diff --git a/app.py b/app.py
index b453d5d..b74b9ed 100644
--- a/app.py
+++ b/app.py
@@ -278,72 +278,173 @@ def preprocess_binary(df_raw: pd.DataFrame):
 # -----------------------------------------------------------
 # PREPROCESS: MULTICLASS (NO get_dummies)
 # -----------------------------------------------------------
-def preprocess_multiclass(df_raw: pd.DataFrame):
-    """
-    Preprocessing for NSLKDDTest.csv (5-class numeric labels 0..4):
-    - 42 or 43 columns
-    - label column is numeric 0..4
-    - output labels as strings: dos, normal, probe, r2l, u2r
-    """
+# -----------------------------------------------------------
+# SERVICE → INTEGER ID MAP (70 services)
+# -----------------------------------------------------------
+SERVICE_MAP = {
+    "IRC": 0,
+    "X11": 1,
+    "Z39_50": 2,
+    "aol": 3,
+    "auth": 4,
+    "bgp": 5,
+    "courier": 6,
+    "csnet_ns": 7,
+    "ctf": 8,
+    "daytime": 9,
+    "discard": 10,
+    "domain": 11,
+    "domain_u": 12,
+    "echo": 13,
+    "eco_i": 14,
+    "ecr_i": 15,
+    "efs": 16,
+    "exec": 17,
+    "finger": 18,
+    "ftp": 19,
+    "ftp_data": 20,
+    "gopher": 21,
+    "harvest": 22,
+    "hostnames": 23,
+    "http": 24,
+    "http_2784": 25,
+    "http_443": 26,
+    "http_8001": 27,
+    "imap4": 28,
+    "iso_tsap": 29,
+    "klogin": 30,
+    "kshell": 31,
+    "ldap": 32,
+    "link": 33,
+    "login": 34,
+    "mtp": 35,
+    "name": 36,
+    "netbios_dgm": 37,
+    "netbios_ns": 38,
+    "netbios_ssn": 39,
+    "netstat": 40,
+    "nnsp": 41,
+    "nntp": 42,
+    "ntp_u": 43,
+    "other": 44,
+    "pm_dump": 45,
+    "pop_2": 46,
+    "pop_3": 47,
+    "printer": 48,
+    "private": 49,
+    "red_i": 50,
+    "remote_job": 51,
+    "rje": 52,
+    "shell": 53,
+    "smtp": 54,
+    "sql_net": 55,
+    "ssh": 56,
+    "sunrpc": 57,
+    "supdup": 58,
+    "systat": 59,
+    "telnet": 60,
+    "tftp_u": 61,
+    "tim_i": 62,
+    "time": 63,
+    "urh_i": 64,
+    "urp_i": 65,
+    "uucp": 66,
+    "uucp_path": 67,
+    "vmnet": 68,
+    "whois": 69
+}
+# Base NSL-KDD 41 feature names (same as your training notebook)
+base_features = [
+ 'duration','protocol_type','service','flag','src_bytes','dst_bytes','land',
+ 'wrong_fragment','urgent','hot','num_failed_logins','logged_in',
+ 'num_compromised','root_shell','su_attempted','num_root','num_file_creations',
+ 'num_shells','num_access_files','num_outbound_cmds','is_host_login',
+ 'is_guest_login','count','srv_count','serror_rate','srv_serror_rate',
+ 'rerror_rate','srv_rerror_rate','same_srv_rate','diff_srv_rate',
+ 'srv_diff_host_rate','dst_host_count','dst_host_srv_count',
+ 'dst_host_same_srv_rate','dst_host_diff_srv_rate','dst_host_same_src_port_rate',
+ 'dst_host_srv_diff_host_rate','dst_host_serror_rate','dst_host_srv_serror_rate',
+ 'dst_host_rerror_rate','dst_host_srv_rerror_rate'
+]
+# Numeric → 5-class mapping used during training
+label_to_5class = {}
+
+# NORMAL
+label_to_5class[0] = "normal"
+
+# DOS
+for x in [1,2,3,4,5,6,7,8,9,10,11]:
+    label_to_5class[x] = "dos"
+
+# PROBE
+for x in [12,13,14,15]:
+    label_to_5class[x] = "probe"
+
+# R2L
+for x in [16,17,18,19,20,21,22,23,24,25,26,27]:
+    label_to_5class[x] = "r2l"
+
+# U2R
+for x in [28,29,30,31,32,33,34,35,36,37,38,39]:
+    label_to_5class[x] = "u2r"
+
+
+def preprocess_multiclass(df_raw):
     df = df_raw.copy()
 
-    # Fix shape: if 42 cols, add dummy difficulty
+    # Fix columns (your notebook used only 42 + 1 label)
     if df.shape[1] == 42:
-        df[42] = 0
-    elif df.shape[1] != 43:
-        raise ValueError(f"Expected 42 or 43 columns, got {df.shape[1]}")
-
-    # Proper column names
-    df.columns = NSL_COLUMNS
-
-    # Remove accidental header row
-    if not str(df.loc[0, "duration"]).replace(".", "", 1).isdigit():
-        df = df.iloc[1:].reset_index(drop=True)
-
-    # ---- LABELS: numeric 0..4 → 5-class strings ----
-    y_raw_numeric = (
-    df["label"]
-    .astype(str)
-    .str.replace(".0", "", regex=False)
-    .astype(int)
-)
+        df.columns = base_features + ["label"]
+    else:
+        df = df.iloc[:, :43]
+        df.columns = base_features + ["label"]
 
-    y_labels = y_raw_numeric.map(INT_TO_CLASS)   # normal/dos/probe/r2l/u2r
+    # Convert label to numeric (same as notebook)
+    df["label_num"] = pd.to_numeric(df["label"], errors="coerce")
+    df = df.dropna(subset=["label_num"]).reset_index(drop=True)
+    df["label_num"] = df["label_num"].astype(int)
 
-    # ---- FEATURES ----
-    cat_cols = ["protocol_type", "service", "flag"]
-    drop_cols = cat_cols + ["label", "difficulty"]
-    numeric_cols = [c for c in df.columns if c not in drop_cols]
+    # Map to 5 classes
+    df["target"] = df["label_num"].map(label_to_5class)
 
-    numeric_part = df[numeric_cols].apply(pd.to_numeric, errors="coerce").fillna(0.0)
+    # ---------- INPUT FEATURES ----------
+    X = df.drop(columns=["label", "label_num", "target"])
 
-    # Manual one-hot encoding based ONLY on training feature list
-    df_cat = pd.DataFrame(index=df.index)
+    cat_cols = ["protocol_type", "service", "flag"]
 
-    for col in cat_cols:
-        prefix = col + "_"
-        available_features = [f for f in multi_features if f.startswith(prefix)]
-        values = df[col].astype(str)
+    # One-hot categorical
+    cat_test = pd.get_dummies(X[cat_cols], prefix=cat_cols)
+    cat_test = cat_test.loc[:, ~cat_test.columns.duplicated()]
 
-        for feat in available_features:
-            cat_value = feat[len(prefix):]
-            df_cat[feat] = (values == cat_value).astype(int)
+    # Align with training
+    all_cat_cols = [
+        c for c in multi_features
+        if any(c.startswith(p) for p in ["protocol_type_", "service_", "flag_"])
+    ]
+    cat_test = cat_test.reindex(columns=all_cat_cols, fill_value=0)
 
-    full = pd.concat([numeric_part, df_cat], axis=1)
+    # Numeric portion
+    num_test = X.drop(columns=cat_cols).astype(float)
 
-    # Ensure all model features exist
+    # Combine in correct order
+    X_final = pd.concat(
+        [num_test.reset_index(drop=True), cat_test.reset_index(drop=True)],
+        axis=1
+    )
+
+    # Add missing training columns
     for col in multi_features:
-        if col not in full.columns:
-            full[col] = 0
+        if col not in X_final.columns:
+            X_final[col] = 0
 
-    full = full[multi_features].astype(float)
+    # Reorder
+    X_final = X_final[multi_features].astype(float)
 
-    # Scale
-    X_scaled = multi_scaler.transform(full)
+    # Scale using training scaler
+    X_scaled = multi_scaler.transform(X_final)
 
-    # Return X + string labels
-    return X_scaled, y_labels.values, df
-# -----------------------------------------------------------
+    # RETURN 3 VALUES — THE FIX
+    return X_scaled, df["target"].values, df
 # UI
 # -----------------------------------------------------------
 st.markdown(
@@ -428,64 +529,81 @@ def preprocess_multiclass(df_raw: pd.DataFrame):
 
     # -------------------------- MULTICLASS -------------------------
     # -------------------------- MULTICLASS -------------------------
-    if mode == "Multiclass Classification":
-        X, y_true, df_named = preprocess_multiclass(df_raw)  # y_true are strings
-
-        model_name = st.selectbox("Select Multiclass Model", list(MULTI_MODEL_FILES.keys()))
-        model = joblib.load(f"{MODELS_DIR}/{MULTI_MODEL_FILES[model_name]}")
-
-        # model predictions (normally 0..4 integers)
-        raw_pred = model.predict(X)
-
-        # Map predictions to 5-class strings
-        y_pred = []
-        for v in raw_pred:
-            if isinstance(v, (int, np.integer, np.int64, np.int32)):
-                y_pred.append(INT_TO_CLASS.get(int(v), "unknown"))
-            else:
-                # if model somehow outputs string labels (rare), just pass through
-                y_pred.append(str(v).lower())
-
-        y_pred = np.array(y_pred)
+    # -------------------------- MULTICLASS -------------------------
+# -------------------------- MULTICLASS -------------------------
+if mode == "Multiclass Classification" and uploaded is not None:
+
+    # 1) Preprocess
+    X, y_true_raw, df_named = preprocess_multiclass(df_raw)
+
+    # 2) Load model
+    model_name = st.selectbox("Select Multiclass Model", list(MULTI_MODEL_FILES.keys()))
+    model = joblib.load(f"{MODELS_DIR}/{MULTI_MODEL_FILES[model_name]}")
+
+    # 3) True labels
+    y_true = np.array(y_true_raw, dtype=str)
+
+    # 4) Predictions
+    raw_pred = model.predict(X)
+    y_pred = np.array(raw_pred, dtype=str)
+
+    # 5) Metrics
+    acc = accuracy_score(y_true, y_pred)
+    prec = precision_score(y_true, y_pred, average="weighted", zero_division=0)
+    rec = recall_score(y_true, y_pred, average="weighted", zero_division=0)
+    f1 = f1_score(y_true, y_pred, average="weighted", zero_division=0)
+
+    st.subheader("📊 Multiclass Metrics (5-class)")
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("Accuracy", f"{acc*100:.2f}%")
+    c2.metric("Precision", f"{prec*100:.2f}%")
+    c3.metric("Recall", f"{rec*100:.2f}%")
+    c4.metric("F1 Score", f"{f1*100:.2f}%")
+
+    # Confusion Matrix
+    cm = confusion_matrix(y_true, y_pred,
+                          labels=["normal", "dos", "probe", "r2l", "u2r"])
+
+    fig = go.Figure(go.Heatmap(
+        z=cm,
+        x=["normal", "dos", "probe", "r2l", "u2r"],
+        y=["normal", "dos", "probe", "r2l", "u2r"],
+        colorscale="Blues",
+        text=cm,
+        texttemplate="%{text}"
+    ))
+    fig.update_layout(title="Confusion Matrix — Multiclass (5-Class)")
+    st.plotly_chart(fig, width="stretch")
+
+    # ---------------- ROC CURVE (Inside the block!) ----------------
+    try:
+        if hasattr(model, "predict_proba"):
+            y_proba = model.predict_proba(X)
+
+            CLASS_ORDER = ["normal", "dos", "probe", "r2l", "u2r"]
+            y_true_ids = np.array([CLASS_ORDER.index(v) for v in y_true])
+
+            fig_roc = go.Figure()
+
+            for i, cls in enumerate(CLASS_ORDER):
+                fpr, tpr, _ = roc_curve((y_true_ids == i).astype(int), y_proba[:, i])
+                roc_auc = auc(fpr, tpr)
+
+                fig_roc.add_trace(go.Scatter(
+                    x=fpr, y=tpr, mode="lines",
+                    name=f"{cls} (AUC={roc_auc:.3f})"
+                ))
+
+            fig_roc.update_layout(
+                title="ROC Curve — Multiclass (One-vs-Rest)",
+                xaxis_title="False Positive Rate",
+                yaxis_title="True Positive Rate"
+            )
 
-        # We expect no 'unknown' for NSLKDDTest; but just in case:
-        valid_mask = y_pred != "unknown"
-        y_true_valid = y_true[valid_mask]
-        y_pred_valid = y_pred[valid_mask]
+            st.plotly_chart(fig_roc, use_container_width=True)
 
-        if len(y_true_valid) == 0:
-            st.error("All predictions mapped to 'unknown'. Cannot compute metrics.")
         else:
-            # METRICS
-            acc = accuracy_score(y_true_valid, y_pred_valid)
-            prec = precision_score(y_true_valid, y_pred_valid,
-                                   average="weighted", zero_division=0)
-            rec = recall_score(y_true_valid, y_pred_valid,
-                               average="weighted", zero_division=0)
-            f1 = f1_score(y_true_valid, y_pred_valid,
-                          average="weighted", zero_division=0)
-
-            st.subheader("📊 Multiclass Metrics (5-class)")
-            c1, c2, c3, c4 = st.columns(4)
-            c1.metric("Accuracy", f"{acc*100:.2f}%")
-            c2.metric("Precision", f"{prec*100:.2f}%")
-            c3.metric("Recall", f"{rec*100:.2f}%")
-            c4.metric("F1 Score", f"{f1*100:.2f}%")
-
-            # CONFUSION MATRIX in fixed class order
-            cm = confusion_matrix(
-                y_true_valid,
-                y_pred_valid,
-                labels=MULTI_CLASSES
-            )
+            st.info("Selected model does not support probability outputs (predict_proba).")
 
-            fig = go.Figure(go.Heatmap(
-                z=cm,
-                x=MULTI_CLASSES,
-                y=MULTI_CLASSES,
-                colorscale="Blues",
-                text=cm,
-                texttemplate="%{text}"
-            ))
-            fig.update_layout(title="Confusion Matrix — Multiclass (5-Class)")
-            st.plotly_chart(fig, use_container_width=True)
+    except Exception as e:
+        st.error(f"ROC Curve could not be generated: {e}")