Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,4 @@
+.env
+*.pkl
+*.json
+__pycache__/

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Stacking_Ensemble/catboost_info/learn/events.out.tfevents

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:805c85d02f04e1b8da81c15ab711f90119c9726938d2aac1546f0ae88cfee78d
+size 5998

Stacking_Ensemble/catboost_info/learn_error.tsv

@@ -0,0 +1,101 @@
+iter	MultiClass
+0	1.488181985
+1	1.175472709
+2	0.9714606556
+3	0.822204168
+4	0.7066984775
+5	0.6135547206
+6	0.5355362088
+7	0.4698605988
+8	0.4146191713
+9	0.3667849828
+10	0.3261929774
+11	0.2908549268
+12	0.260042417
+13	0.2327451858
+14	0.2087759212
+15	0.1877009929
+16	0.1689697491
+17	0.1522890739
+18	0.1372164668
+19	0.1238374094
+20	0.1120119492
+21	0.1013892871
+22	0.09182722355
+23	0.08338165797
+24	0.07576687175
+25	0.06886970876
+26	0.06268082522
+27	0.05716733145
+28	0.05217468551
+29	0.0476568518
+30	0.04346803928
+31	0.03974352467
+32	0.0363756203
+33	0.03339336174
+34	0.03065356329
+35	0.02817926567
+36	0.02587410778
+37	0.02389808264
+38	0.02206780387
+39	0.02037104102
+40	0.01889452817
+41	0.01760071126
+42	0.01633396123
+43	0.0152895552
+44	0.01424559459
+45	0.01327303972
+46	0.0124083342
+47	0.01171990456
+48	0.01108572132
+49	0.01055402737
+50	0.009960500889
+51	0.0093607482
+52	0.00882983384
+53	0.008336367655
+54	0.008013916605
+55	0.007621786211
+56	0.007266206996
+57	0.006893280758
+58	0.006504591733
+59	0.00618290818
+60	0.005889986567
+61	0.005563291532
+62	0.005298557961
+63	0.005087143587
+64	0.004938276785
+65	0.004628865543
+66	0.004477967255
+67	0.004348256068
+68	0.004121486135
+69	0.003937261659
+70	0.003791577086
+71	0.003666238063
+72	0.003529822238
+73	0.003393230571
+74	0.003212297574
+75	0.003042950395
+76	0.002914422938
+77	0.002762845206
+78	0.002650832149
+79	0.002554477695
+80	0.002518738147
+81	0.002437060784
+82	0.002398997496
+83	0.002315308546
+84	0.002259881865
+85	0.00218425362
+86	0.00209584122
+87	0.002055078497
+88	0.001999753615
+89	0.001930903634
+90	0.001895621403
+91	0.001834844434
+92	0.001794619572
+93	0.001753839332
+94	0.001741076217
+95	0.00170799159
+96	0.001674756988
+97	0.0016233309
+98	0.0016049431
+99	0.001573250279

Stacking_Ensemble/catboost_info/time_left.tsv

@@ -0,0 +1,101 @@
+iter	Passed	Remaining
+0	3189	315790
+1	6366	311964
+2	9516	307695
+3	12758	306199
+4	15910	302298
+5	18993	297572
+6	22008	292400
+7	25044	288007
+8	28146	284587
+9	31222	281004
+10	34412	278431
+11	37494	274962
+12	40623	271866
+13	43784	268959
+14	46955	266083
+15	50039	262709
+16	53083	259170
+17	56137	255737
+18	59190	252337
+19	62309	249237
+20	65330	245766
+21	68397	242501
+22	71456	239225
+23	74525	235996
+24	77557	232672
+25	80597	229391
+26	83622	226090
+27	86695	222931
+28	89811	219884
+29	92830	216605
+30	95940	213546
+31	98947	210263
+32	102003	207098
+33	105030	203881
+34	108046	200657
+35	111164	197626
+36	114308	194633
+37	117508	191724
+38	120567	188580
+39	123595	185393
+40	126649	182251
+41	129663	179059
+42	132711	175920
+43	135737	172756
+44	138752	169586
+45	141788	166447
+46	144842	163332
+47	147950	160279
+48	151031	157196
+49	154130	154130
+50	157266	151098
+51	160354	148019
+52	163469	144963
+53	166478	141814
+54	170027	139113
+55	173303	136166
+56	176950	133489
+57	180097	130415
+58	183294	127374
+59	186443	124295
+60	189525	121171
+61	192592	118040
+62	195659	114910
+63	198735	111788
+64	201729	108623
+65	204776	105490
+66	207807	102353
+67	210916	99254
+68	214012	96150
+69	217023	93010
+70	220109	89904
+71	223145	86778
+72	226232	83675
+73	229335	80577
+74	232447	77482
+75	235576	74392
+76	238931	71369
+77	242198	68312
+78	245371	65225
+79	248630	62157
+80	251637	59026
+81	254642	55897
+82	257755	52793
+83	261438	49797
+84	265004	46765
+85	268424	43696
+86	271569	40579
+87	274816	37474
+88	278062	34367
+89	281225	31247
+90	284462	28133
+91	287787	25024
+92	291430	21935
+93	294880	18822
+94	297937	15680
+95	301147	12547
+96	304389	9414
+97	307712	6279
+98	311401	3145
+99	314589	0

Stacking_Ensemble/super_robust.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+stacking_ensemble_safe.py (FINAL EXTENDED + FULL METRICS)
+Stacking Ensemble: XGBoost, CatBoost, LightGBM, AdaBoost + RandomForest Meta Model
+
+Features:
+ - Safe GPU fallback
+ - Full metrics logging (accuracy, precision, recall, f1, percentage, etc.)
+ - JSON-compatible for R Spider Chart
+ - Auto robustness_score & fold_variance
+ - Handles NaN, inf, weird column names, and file I/O issues
+"""
+
+import os, json, time, warnings, argparse, gc
+from huggingface_hub import HfApi, upload_file, create_repo
+import shutil
+from pathlib import Path
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split, StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.impute import SimpleImputer
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
+from sklearn.tree import DecisionTreeClassifier
+from xgboost import XGBClassifier
+from catboost import CatBoostClassifier
+import lightgbm as lgb
+import joblib
+
+warnings.filterwarnings("ignore")
+
+# ==============================================================
+# SAFE LOADING
+# ==============================================================
+def load_dataset(path, max_rows=500000):
+    ext = Path(path).suffix.lower()
+    print(f"[load_dataset] Loading: {path}")
+    try:
+        if ext == ".csv":
+            try:
+                df = pd.read_csv(path)
+            except MemoryError:
+                print(f"[load_dataset] MemoryError — loading first {max_rows} rows.")
+                df = pd.read_csv(path, nrows=max_rows)
+        elif ext in [".parquet", ".pq", ".parq"]:
+            df = pd.read_parquet(path)
+        else:
+            raise ValueError("Unsupported file format")
+    except Exception as e:
+        raise RuntimeError(f"[load_dataset] Failed to load dataset: {e}")
+    print(f"[load_dataset] Loaded {len(df)} rows × {len(df.columns)} columns.")
+    return df
+
+# ==============================================================
+# SANITIZE FEATURE NAMES
+# ==============================================================
+def sanitize_feature_names(df):
+    original = df.columns.tolist()
+    df.columns = (
+        df.columns.astype(str)
+        .str.replace(r'[^A-Za-z0-9_]+', '_', regex=True)
+        .str.strip('_')
+    )
+    renamed = {o: n for o, n in zip(original, df.columns) if o != n}
+    if renamed:
+        print(f"[sanitize_feature_names] Renamed {len(renamed)} columns for LightGBM safety.")
+    return df
+
+# ==============================================================
+# TARGET DETECTION
+# ==============================================================
+def detect_target_column(df):
+    candidates = ["label", "target", "class", "category", "attack", "output", "y"]
+    for c in df.columns:
+        if c.lower() in candidates:
+            return c
+    for c in df.columns:
+        if df[c].nunique() <= 50:
+            return c
+    return df.columns[-1]
+
+# ==============================================================
+# DATA PREP
+# ==============================================================
+def prep_data(df, target=None):
+    if target is None:
+        target = detect_target_column(df)
+    y = df[target]
+    X = df.drop(columns=[target])
+
+    le = LabelEncoder()
+    y = le.fit_transform(y.astype(str))
+
+    for col in X.select_dtypes(include=["object", "bool"]).columns:
+        X[col] = LabelEncoder().fit_transform(X[col].astype(str))
+
+    X = X.replace([np.inf, -np.inf], np.nan)
+    X = pd.DataFrame(SimpleImputer(strategy="mean").fit_transform(X), columns=X.columns)
+    X = sanitize_feature_names(X)
+    return X, y, target, le
+
+# ==============================================================
+# TRAIN BASE MODELS
+# ==============================================================
+def train_base_models(X_train, y_train, X_val):
+    try:
+        import cupy
+        gpu_ok = cupy.cuda.runtime.getDeviceCount() > 0
+    except Exception:
+        gpu_ok = False
+
+    device = "gpu" if gpu_ok else "cpu"
+    print(f"[train_base_models] Using {device.upper()} mode")
+
+    models, preds, times = {}, {}, {}
+    num_cls = len(np.unique(y_train))
+
+    def safe_train(name, fn):
+        try:
+            start = time.perf_counter()
+            print(f"[train_base_models] Training {name} ...")
+            m = fn()
+            dur = round(time.perf_counter() - start, 2)
+            times[name.lower()] = dur
+            print(f"[train_base_models] {name} done in {dur:.2f}s")
+            return m
+        except Exception as e:
+            print(f"[train_base_models] {name} failed: {e}")
+            times[name] = 0.0
+            return None
+
+    # XGBoost
+    xgb_fn = lambda: XGBClassifier(
+        n_estimators=50, learning_rate=0.3, max_depth=4,
+        tree_method="gpu_hist" if gpu_ok else "hist",
+        objective="binary:logistic" if num_cls == 2 else "multi:softmax",
+        num_class=num_cls if num_cls > 2 else None,
+        use_label_encoder=False, eval_metric="logloss", random_state=42, verbosity=0
+    ).fit(X_train, y_train)
+    xgb = safe_train("XGBoost", xgb_fn)
+    if xgb: preds["xgboost"] = xgb.predict(X_val); models["xgboost"] = xgb
+
+    # CatBoost
+    cat_fn = lambda: CatBoostClassifier(
+        iterations=100, learning_rate=0.1, depth=6,
+        loss_function="Logloss" if num_cls == 2 else "MultiClass",
+        task_type="GPU" if gpu_ok else "CPU", verbose=False, random_seed=42
+    ).fit(X_train, y_train)
+    cat = safe_train("CatBoost", cat_fn)
+    if cat: preds["catboost"] = cat.predict(X_val); models["catboost"] = cat
+
+    # LightGBM
+    lgb_fn = lambda: lgb.LGBMClassifier(
+        n_estimators=50, learning_rate=0.3, max_depth=4,
+        device="gpu" if gpu_ok else "cpu",
+        objective="binary" if num_cls == 2 else "multiclass",
+        num_class=num_cls if num_cls > 2 else None, random_state=42
+    ).fit(X_train, y_train)
+    lgbm = safe_train("LightGBM", lgb_fn)
+    if lgbm: preds["lightgbm"] = lgbm.predict(X_val); models["lightgbm"] = lgbm
+
+    # AdaBoost
+    ada_fn = lambda: AdaBoostClassifier(
+        estimator=DecisionTreeClassifier(max_depth=3),
+        n_estimators=50, random_state=42
+    ).fit(X_train, y_train)
+    ada = safe_train("AdaBoost", ada_fn)
+    if ada: preds["adaboost"] = ada.predict(X_val); models["adaboost"] = ada
+
+    gc.collect()
+    return models, preds, times
+
+# ==============================================================
+# OOF STACKING (WITH FULL METRICS)
+# ==============================================================
+def oof_stacking(X, y, n_folds=5):
+    skf = StratifiedKFold(n_splits=n_folds, shuffle=True, random_state=42)
+    oof, folds = {}, []
+    for k in ["xgboost", "catboost", "lightgbm", "adaboost"]:
+        oof[k] = np.zeros(len(y), dtype=np.int32)
+
+    for i, (tr, val) in enumerate(skf.split(X, y), start=1):
+        print(f"\n[oof_stacking] ==== Fold {i}/{n_folds} ====")
+        X_tr, X_val, y_tr, y_val = X.iloc[tr], X.iloc[val], y[tr], y[val]
+        try:
+            models, preds, times = train_base_models(X_tr, y_tr, X_val)
+        except Exception as e:
+            print(f"[Fold {i}] Fold skipped: {e}")
+            continue
+
+        fold_metrics = {}
+        for name, y_pred in preds.items():
+            y_pred = np.ravel(y_pred)
+            oof[name][val] = y_pred
+            acc = accuracy_score(y_val, y_pred)
+            pre = precision_score(y_val, y_pred, average='weighted', zero_division=0)
+            rec = recall_score(y_val, y_pred, average='weighted', zero_division=0)
+            f1v = f1_score(y_val, y_pred, average='weighted', zero_division=0)
+            total_v = int((y_pred != 0).sum())
+            pct = round(total_v / len(y_pred) * 100, 4)
+            is_vul = bool(total_v > 0)
+
+            fold_metrics[name] = {
+                "accuracy": float(acc),
+                "precision": float(pre),
+                "recall": float(rec),
+                "f1": float(f1v),
+                "total_vulnerable": total_v,
+                "percentage": pct,
+                "is_vulnerable": is_vul,
+                "train_time_sec": float(times.get(name.lower(), 0.0))
+            }
+            print(f"[Fold {i}] {name}: acc={acc:.4f}, f1={f1v:.4f}, vuln={pct}%")
+
+        folds.append({"fold": i, "metrics": fold_metrics})
+    print("[oof_stacking] Completed all folds.")
+    return oof, folds
+
+# ==============================================================
+# META MODEL & EVALUATION
+# ==============================================================
+def train_meta_model(oof_preds, y):
+    meta_X = np.column_stack([oof_preds[k] for k in oof_preds])
+    meta = RandomForestClassifier(n_estimators=50, random_state=42, max_features="sqrt")
+    meta.fit(meta_X, y)
+    return meta
+
+def evaluate(models, meta, X_test, y_test, times):
+    results = {}
+    for name, m in models.items():
+        y_pred = m.predict(X_test)
+        acc = accuracy_score(y_test, y_pred)
+        pre = precision_score(y_test, y_pred, average='weighted', zero_division=0)
+        rec = recall_score(y_test, y_pred, average='weighted', zero_division=0)
+        f1v = f1_score(y_test, y_pred, average='weighted', zero_division=0)
+        total_v = int((y_pred != 0).sum())
+        pct = round(total_v / len(y_pred) * 100, 4)
+        is_vul = bool(total_v > 0)
+        results[name] = {
+            "accuracy": acc, "precision": pre, "recall": rec, "f1": f1v,
+            "total_vulnerable": total_v, "percentage": pct, "is_vulnerable": is_vul, "train_time_sec": float(times.get(name.lower(), 0.0))
+        }
+        print(f"[evaluate] {name}: acc={acc:.4f}, f1={f1v:.4f}, vuln={pct}%")
+
+    meta_X = np.column_stack([models[k].predict(X_test) for k in models])
+    y_meta = meta.predict(meta_X)
+    results["meta_model"] = {
+        "accuracy": accuracy_score(y_test, y_meta),
+        "precision": precision_score(y_test, y_meta, average='weighted', zero_division=0),
+        "recall": recall_score(y_test, y_meta, average='weighted', zero_division=0),
+        "f1": f1_score(y_test, y_meta, average='weighted', zero_division=0)
+    }
+    return results
+
+# ==============================================================
+# SAVE SUMMARY
+# ==============================================================
+def save_summary_json(outdir, target, nrows, class_labels, folds, results):
+    outdir = Path(outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    # Calculate fold variance & robustness
+    fold_acc = [np.mean([m["accuracy"] for m in f["metrics"].values()]) for f in folds]
+    fold_variance = float(np.var(fold_acc))
+    robustness_score = float(1 - fold_variance)
+
+    summary = {
+        "target_column": target,
+        "rows": int(nrows),
+        "folds": folds,
+        "final_results": results,
+        "class_labels": list(class_labels),
+        "fold_variance": round(fold_variance, 6),
+        "robustness_score": round(robustness_score, 6)
+    }
+    path = outdir / "summary.json"
+    with open(path, "w") as f:
+        json.dump(summary, f, indent=2)
+    print(f"[save_summary_json] Saved to {path}")
+
+# ==============================================================
+# HUGGINGFACE UPLOAD
+# ============================================================== 
+
+# ============================================================== 
+# SAVE MODELS LOCALLY
+# ============================================================== 
+def save_models(models, meta_model, outdir):
+    model_dir = os.path.join(outdir, "models")
+    os.makedirs(model_dir, exist_ok=True)
+
+    for name, model in models.items():
+        joblib.dump(model, os.path.join(model_dir, f"{name}_model.pkl"))
+    joblib.dump(meta_model, os.path.join(model_dir, "meta_model.pkl"))
+
+    print(f"[save_models] All base and meta models saved to {model_dir}")
+    return model_dir
+
+# ==============================================================
+# MAIN
+# ==============================================================
+def main(args):
+    start = time.perf_counter()
+    df = load_dataset(args.dataset)
+    X, y, target, le = prep_data(df, args.target_label)
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=args.test_size, random_state=42, stratify=y if len(np.unique(y))>1 else None
+    )
+    oof_preds, folds = oof_stacking(X_train, y_train, n_folds=args.n_folds)
+    meta = train_meta_model(oof_preds, y_train)
+    models, _, times = train_base_models(X_train, y_train, X_test)
+    results = evaluate(models, meta, X_test, y_test, times)
+
+    # === Simpan Model dan Hasil Analisis ===
+    save_models(models, meta, args.outdir)
+    save_summary_json(args.outdir, target, len(df), le.classes_, folds, results)
+
+    # === Hitung total waktu training dan evaluasi ===
+    total_time = round(time.perf_counter() - start, 2)
+    print(f"\n Completed in {total_time} sec")
+
+    # === Simpan ke JSON dengan waktu total ===
+    save_summary_json(args.outdir, target, len(df), le.classes_, folds, results)
+
+    # Tambahkan waktu total ke JSON yang sudah tersimpan
+    summary_path = Path(args.outdir) / "summary.json"
+    if summary_path.exists():
+        with open(summary_path, "r+") as f:
+            data = json.load(f)
+            data["total_train_time_sec"] = total_time
+            f.seek(0)
+            json.dump(data, f, indent=2)
+            f.truncate()
+        print(f"[save_summary_json] total_train_time_sec={total_time} saved.")
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    p.add_argument("--dataset", required=True)
+    p.add_argument("--outdir", required=True)
+    p.add_argument("--target-label", default=None)
+    p.add_argument("--test-size", type=float, default=0.2)
+    p.add_argument("--n-folds", type=int, default=5)
+    args = p.parse_args()
+    main(args)

visualization/final_result_visualization.R

@@ -0,0 +1,73 @@
+library(jsonlite)
+library(dplyr)
+library(fmsb)
+
+# === 1. Baca file JSON ===
+data <- fromJSON("summary.json", simplifyVector = FALSE)
+
+# === 2. Ambil final_results ===
+final_results <- data$final_results
+
+# === 3. Ubah ke data frame ===
+df_final <- lapply(names(final_results), function(model_name) {
+  metric <- final_results[[model_name]]
+  data.frame(
+    model = model_name,
+    accuracy = metric$accuracy,
+    precision = metric$precision,
+    recall = metric$recall,
+    f1 = metric$f1,
+    total_vulnerable = metric$total_vulnerable %||% NA,
+    percentage = metric$percentage %||% NA,
+    is_vulnerable = as.numeric(metric$is_vulnerable %||% NA),
+    train_time_sec = metric$train_time_sec %||% NA
+  )
+}) %>% bind_rows()
+
+print("=== FINAL RESULTS DATA ===")
+print(df_final)
+
+# === 4. Normalisasi semua nilai ke skala 0–1 (biar proporsional di radar chart) ===
+norm_df <- df_final
+num_cols <- sapply(norm_df, is.numeric)
+norm_df[num_cols] <- lapply(norm_df[num_cols], function(x) {
+  rng <- range(x, na.rm = TRUE)
+  if (rng[1] == rng[2]) rep(1, length(x)) else (x - rng[1]) / (rng[2] - rng[1])
+})
+
+# === 5. Siapkan data radar chart ===
+radar_data <- norm_df %>% select(-model)
+rownames(radar_data) <- df_final$model
+
+max_val <- rep(1, ncol(radar_data))
+min_val <- rep(0, ncol(radar_data))
+radar_plot_data <- rbind(max_val, min_val, radar_data)
+
+# === 6. Plot radar chart ===
+colors <- c("red", "blue", "green", "orange", "purple")
+par(mfrow = c(1, 1), mar = c(2, 2, 4, 2))
+
+radarchart(
+  radar_plot_data,
+  axistype = 1,
+  pcol = colors,
+  plwd = 3,
+  plty = 1,
+  cglcol = "grey",
+  cglty = 1,
+  axislabcol = "grey30",
+  caxislabels = seq(0, 1, 0.2),
+  cglwd = 0.8,
+  vlcex = 0.8,
+  title = "Final Results – Model Comparison (All Metrics Normalized)"
+)
+
+legend(
+  "bottomright",
+  legend = rownames(radar_data),
+  col = colors,
+  lty = 1,
+  lwd = 3,
+  bty = "n",
+  cex = 0.8
+)

visualization/fold_visualization.R

@@ -0,0 +1,73 @@
+library(jsonlite)
+library(dplyr)
+library(fmsb)
+
+# === 1. Baca file JSON ===
+data <- fromJSON("summary.json", simplifyVector = FALSE)
+
+# === 2. Ambil fold 1 ===
+fold1 <- data$folds[[5]]
+metrics_list <- fold1$metrics
+
+# === 3. Buat data frame semua model di fold 1 ===
+df_fold1 <- lapply(names(metrics_list), function(model_name) {
+  metric <- metrics_list[[model_name]]
+  data.frame(
+    model = model_name,
+    accuracy = metric$accuracy,
+    precision = metric$precision,
+    recall = metric$recall,
+    f1 = metric$f1,
+    total_vulnerable = metric$total_vulnerable,
+    percentage = metric$percentage,
+    is_vulnerable = as.numeric(metric$is_vulnerable),
+    train_time_sec = metric$train_time_sec
+  )
+}) %>% bind_rows()
+
+print("=== Data Fold 1 ===")
+print(df_fold1)
+
+# === 4. Normalisasi semua kolom numerik ke skala 0–1 (biar radar chart proporsional) ===
+norm_df <- df_fold1
+num_cols <- sapply(norm_df, is.numeric)
+norm_df[num_cols] <- lapply(norm_df[num_cols], function(x) {
+  (x - min(x)) / (max(x) - min(x))
+})
+
+# === 5. Siapkan data radar chart ===
+radar_data <- norm_df %>% select(-model)
+rownames(radar_data) <- df_fold1$model
+
+max_val <- rep(1, ncol(radar_data))
+min_val <- rep(0, ncol(radar_data))
+radar_plot_data <- rbind(max_val, min_val, radar_data)
+
+# === 6. Plot radar chart untuk fold 1 ===
+colors <- c("red", "blue", "green", "orange")
+par(mfrow = c(1, 1), mar = c(2, 2, 4, 2))
+
+radarchart(
+  radar_plot_data,
+  axistype = 1,
+  pcol = colors,
+  plwd = 3,
+  plty = 1,
+  cglcol = "grey",
+  cglty = 1,
+  axislabcol = "grey30",
+  caxislabels = seq(0, 1, 0.2),
+  cglwd = 0.8,
+  vlcex = 0.8,
+  title = "📊 Fold 1 – Model Comparison (All Metrics Normalized)"
+)
+
+legend(
+  "bottomright",
+  legend = rownames(radar_data),
+  col = colors,
+  lty = 1,
+  lwd = 3,
+  bty = "n",
+  cex = 0.8
+)

visualization/label_tables.R

@@ -0,0 +1,59 @@
+# === Load libraries ===
+library(jsonlite)
+library(grid)
+library(gridExtra)
+
+# === 1. Baca file JSON ===
+data <- fromJSON("summary.json", simplifyVector = FALSE)
+
+# === 2. Ambil metadata ===
+fold_variance <- data$fold_variance
+robustness_score <- data$robustness_score
+total_train_time <- data$total_train_time_sec
+class_labels <- data$class_labels
+table_data <- data.frame(Label = class_labels)
+
+# === 3. Layout proporsional ===
+grid.newpage()
+pushViewport(viewport(layout = grid.layout(2, 1, heights = unit(c(1, 2), "null"))))
+
+# === 3a. Header teks metadata ===
+pushViewport(viewport(layout.pos.row = 1))
+grid.text("Model Summary", x = 0.5, y = 0.8,
+          gp = gpar(fontsize = 16, fontface = "bold"))
+grid.text(sprintf("Fold Variance: %.6f", fold_variance), 
+          x = 0.5, y = 0.55, gp = gpar(fontsize = 12, col = "#333333"))
+grid.text(sprintf("Robustness Score: %.6f", robustness_score), 
+          x = 0.5, y = 0.40, gp = gpar(fontsize = 12, col = "#333333"))
+grid.text(sprintf("Total Train Time: %.2f sec", total_train_time), 
+          x = 0.5, y = 0.25, gp = gpar(fontsize = 12, col = "#333333"))
+popViewport()
+
+# === 3b. Tabel class labels di bawah ===
+pushViewport(viewport(layout.pos.row = 2))
+
+# Judul class labels — posisikan sedikit lebih dekat ke tabel
+grid.text("Class Labels", x = 0.5, y = 0.78, 
+          gp = gpar(fontsize = 14, fontface = "bold", col = "#222222"))
+
+# Tema tabel elegan dan kompak
+table_theme <- gridExtra::ttheme_default(
+  core = list(
+    fg_params = list(cex = 0.85, col = "#222222"),
+    bg_params = list(fill = rep("#f9f9f9", nrow(table_data)), col = NA)
+  ),
+  colhead = list(
+    fg_params = list(cex = 0.9, fontface = "bold", col = "#222222"),
+    bg_params = list(fill = "#e8e8e8", col = NA)
+  ),
+  padding = unit(c(2, 4), "mm")
+)
+
+# Buat tabel dan posisikan tepat di bawah judul
+table_grob <- gridExtra::tableGrob(
+  table_data, rows = NULL, theme = table_theme
+)
+
+# Posisi tabel lebih dekat ke judul dan tetap proporsional
+grid.draw(editGrob(table_grob, vp = viewport(x = 0.5, y = 0.43, width = 0.25, height = 0.4)))
+popViewport()