Stage-2 artefak (12 fitur, tanpa gensim)

.virtual_documents/__notebook_source__.ipynb

@@ -0,0 +1,593 @@
+
+
+
+
+
+
+# Kaggle: hapus komentar baris di bawah bila perlu
+# !pip install -q rank_bm25 xgboost sentence-transformers huggingface_hub
+import pandas as pd, numpy as np, re, os, time, json, pickle, warnings
+from pathlib import Path
+from itertools import product
+from collections import Counter, namedtuple
+import matplotlib.pyplot as plt
+warnings.filterwarnings('ignore')
+plt.rcParams['figure.dpi'] = 110; plt.rcParams['font.size'] = 10
+
+from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold
+from sklearn.preprocessing import StandardScaler
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.decomposition import TruncatedSVD, LatentDirichletAllocation
+from sklearn.linear_model import LogisticRegression
+from sklearn.neural_network import MLPClassifier
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import (f1_score, precision_score, recall_score, accuracy_score,
+                             confusion_matrix, classification_report, precision_recall_curve,
+                             roc_curve, auc, average_precision_score)
+from sklearn.inspection import permutation_importance
+try:
+    import xgboost as xgb; HAS_XGB = True
+except Exception:
+    HAS_XGB = False
+try:
+    import torch; ENV_HAS_GPU = torch.cuda.is_available()
+except Exception:
+    ENV_HAS_GPU = False
+print('GPU:', ENV_HAS_GPU, '| XGBoost:', HAS_XGB)
+
+
+SEED = 42; VAL_FRAC = 0.20
+W2V_DIM = 100; N_TOPICS_LDA = 30; N_TOPICS_LSA = 50
+K_RETRIEVAL = 50                          # dari Stage 1
+HF_SBERT_FT = 'HariishHafiiz/sbert-bug-eclipse-ft'   # model SBERT-FT hasil Stage-1
+HF_REPO     = 'HariishHafiiz/stage2-classifier-eclipse'
+QUICK_TEST  = False                       # True utk uji cepat (subset)
+np.random.seed(SEED)
+
+INPUT_DIR = '/kaggle/input/datasets/hpeace090104/skripsi'
+if not Path(INPUT_DIR).exists(): INPUT_DIR = '/mnt/user-data/uploads'
+OUT_DIR = '/kaggle/working' if Path('/kaggle/working').exists() else './stage2_out'
+Path(OUT_DIR).mkdir(parents=True, exist_ok=True)
+FILES = {'train_dup':f'{INPUT_DIR}/EP_Eclipse_train_dup_metadata.csv',
+         'train_nondup':f'{INPUT_DIR}/EP_Eclipse_train_nondup_metadata.csv',
+         'test_dup':f'{INPUT_DIR}/EP_Eclipse_test_dup_metadata.csv',
+         'test_nondup':f'{INPUT_DIR}/EP_Eclipse_test_nondup_metadata.csv'}
+print('INPUT_DIR:', INPUT_DIR, '| OUT_DIR:', OUT_DIR)
+
+
+
+
+
+train_dup_full    = pd.read_csv(FILES['train_dup'])
+train_nondup_full = pd.read_csv(FILES['train_nondup'])
+test_dup          = pd.read_csv(FILES['test_dup'])
+test_nondup       = pd.read_csv(FILES['test_nondup'])
+
+if QUICK_TEST:
+    train_dup_full=train_dup_full.head(1000); train_nondup_full=train_nondup_full.head(1000)
+    test_dup=test_dup.head(200); test_nondup=test_nondup.head(600)
+
+train_dup, val_dup       = train_test_split(train_dup_full,    test_size=VAL_FRAC, random_state=SEED)
+train_nondup, val_nondup = train_test_split(train_nondup_full, test_size=VAL_FRAC, random_state=SEED)
+train_df = pd.concat([train_dup, train_nondup]).sample(frac=1, random_state=SEED).reset_index(drop=True)
+val_df   = pd.concat([val_dup,   val_nondup  ]).sample(frac=1, random_state=SEED).reset_index(drop=True)
+test_df  = pd.concat([test_dup,  test_nondup ]).reset_index(drop=True)
+
+for nm, d in [('train',train_df),('val',val_df),('test',test_df)]:
+    print(f"{nm:5s}: {len(d):,} | dup={int(d.Label.sum()):,} nondup={int((d.Label==0).sum()):,} ratio={d.Label.mean():.0%}")
+if not QUICK_TEST:
+    print('train_dup:', len(train_dup), '| val_dup:', len(val_dup), '(harusnya 5920 / 1480 — konsisten Stage-1)')
+
+
+
+
+
+STOPWORDS = set(
+    "a about above after again against all an and any are arent as at be because been before being "
+    "below between both but by cant cannot could couldnt did didnt do does doesnt doing dont down during "
+    "each few for from further get got had hadnt has hasnt have havent having he hed hell hes her here "
+    "heres hers herself him himself his how hows id ill im ive if in into is isnt it its itself lets me "
+    "more most mustnt my myself nor of off on once only or other ought our ours ourselves out over own "
+    "same shant she shed shell shes should shouldnt so some such than that thats the their theirs them "
+    "themselves then there theres these they theyd theyll theyre theyve this those through to too under "
+    "until up upon us very was wasnt we wed were weve werent what whats when whens where wheres which "
+    "while who whos whom why whys with wont would wouldnt you youd youll youre youve your yours yourself "
+    "yourselves also just like will may shall still yet already even much many really actually however "
+    "another simply perhaps since using used one two three way etc via see eg ie thus hence therefore "
+    "accordingly note notes pm".split()
+)
+STOPWORDS -= {'not','no','cannot','error','bug','crash','fail','null','unable','invalid','missing','broken','wrong'}
+
+def preprocess_ir(text):
+    if pd.isna(text): return ''
+    text = str(text).lower()
+    text = re.sub(r'https?://\S+|www\.\S+|<[^>]+>|\S+@\S+', '', text)
+    text = re.sub(r'[^a-z0-9\s]', ' ', text)            # pertahankan huruf & digit
+    text = re.sub(r'\s+', ' ', text).strip()
+    return ' '.join([t for t in text.split() if t not in STOPWORDS and len(t) > 1])
+
+def ir_pair(ti, de):
+    return ' '.join([preprocess_ir(ti)]*3 + [preprocess_ir(de)])   # judul x3, seperti Stage-1
+
+def raw_text(ti, de):
+    a = '' if pd.isna(ti) else str(ti); b = '' if pd.isna(de) else str(de)
+    return re.sub(r'\s+', ' ', (a + ' ' + b)).strip()             # teks natural utk SBERT
+
+def parse_time_diff_days(s1, s2):
+    t1 = pd.to_datetime(s1, errors='coerce', utc=True)
+    t2 = pd.to_datetime(s2, errors='coerce', utc=True)
+    return (t1 - t2).dt.total_seconds().abs().fillna(0) / 86400
+
+for df in [train_df, val_df, test_df]:
+    df['text1'] = df.apply(lambda r: ir_pair(r['Title1'], r['Description1']), axis=1)   # IR (leksikal/topik)
+    df['text2'] = df.apply(lambda r: ir_pair(r['Title2'], r['Description2']), axis=1)
+    df['text1_raw'] = df.apply(lambda r: raw_text(r['Title1'], r['Description1']), axis=1)  # raw (SBERT)
+    df['text2_raw'] = df.apply(lambda r: raw_text(r['Title2'], r['Description2']), axis=1)
+
+corpus_train = list(set(train_df['text1'].tolist() + train_df['text2'].tolist()))
+print(f'Corpus train (IR, judul x3, unik): {len(corpus_train):,} dokumen')
+
+
+
+
+
+# TF-IDF
+tfidf_c = TfidfVectorizer(analyzer='char_wb', ngram_range=(2,4), max_features=30000, sublinear_tf=True).fit(corpus_train)
+tfidf_w = TfidfVectorizer(analyzer='word',    ngram_range=(1,2), max_features=30000, sublinear_tf=True).fit(corpus_train)
+
+# BM25: document frequency yang BENAR (dihitung dari set token tiap dokumen)
+tokenized_corpus = [t.split() for t in corpus_train]
+DF_COUNT = Counter()
+for doc in tokenized_corpus:
+    for t in set(doc): DF_COUNT[t] += 1
+N_DOCS = len(tokenized_corpus)
+BM25_AVGDL = float(np.mean([len(d) for d in tokenized_corpus])) if tokenized_corpus else 1.0
+print(f'BM25: N_DOCS={N_DOCS:,} | AVGDL={BM25_AVGDL:.1f} | vocab(DF)={len(DF_COUNT):,}')
+
+
+# W2V/FastText/Doc2Vec DIHAPUS: kontribusi ~0 pada feature importance, dan paling lambat
+# untuk dilatih + menyebabkan masalah sidecar .npy saat upload. Fitur akhir = 12 (tanpa SEM_STAT).
+print('SEM_STAT (W2V/FT/D2V) tidak digunakan. Fitur leksikal/semantik = TF-IDF/BM25 + SBERT.')
+
+
+# LDA + LSA
+count_vec = TfidfVectorizer(analyzer='word', ngram_range=(1,1), max_features=10000)
+X_count   = count_vec.fit_transform(corpus_train)
+lda_model = LatentDirichletAllocation(n_components=N_TOPICS_LDA, random_state=SEED, learning_method='online', n_jobs=-1).fit(X_count)
+tfidf_lsa = TfidfVectorizer(analyzer='word', ngram_range=(1,1), max_features=10000)
+X_tfidf   = tfidf_lsa.fit_transform(corpus_train)
+lsa_model = TruncatedSVD(n_components=N_TOPICS_LSA, random_state=SEED).fit(X_tfidf)
+print('Topic model (LDA/LSA) siap.')
+
+
+# SBERT-FT dari Stage-1 (HuggingFace). Bila tak tersedia, fitur cosine_sbert diisi 0 (notebook tetap jalan).
+sbert_model = None; SBERT_OK = False
+if ENV_HAS_GPU or True:
+    try:
+        from sentence_transformers import SentenceTransformer
+        sbert_model = SentenceTransformer(HF_SBERT_FT)
+        SBERT_OK = True
+        print('SBERT-FT Stage-1 dimuat:', HF_SBERT_FT)
+    except Exception as e:
+        print('SBERT gagal dimuat (', repr(e)[:120], ') -> cosine_sbert diisi 0.')
+        sbert_model = None
+print('SBERT_OK:', SBERT_OK)
+
+
+
+
+
+def cosine_rows(A, B):
+    return np.einsum('ij,ij->i', A, B) / (np.linalg.norm(A,axis=1)*np.linalg.norm(B,axis=1) + 1e-9)
+def bm25_pair(q_tokens, d_tokens, k1=1.5, b=0.75):
+    if not q_tokens or not d_tokens: return 0.0
+    dl = len(d_tokens); fr = Counter(d_tokens); s = 0.0
+    for w in set(q_tokens):
+        if w in fr:
+            dft = DF_COUNT.get(w, 0)
+            s += np.log((N_DOCS - dft + 0.5)/(dft + 0.5) + 1.0) * (fr[w]*(k1+1))/(fr[w] + k1*(1-b+b*dl/BM25_AVGDL))
+    return s
+
+ALL_FEATURES = ['cosine_tfidf_c','cosine_tfidf_w','bm25_score','cosine_sbert_ft','cosine_lda','cosine_lsa',
+                'same_component','same_priority','same_version','same_comp_ver','time_diff_created','log_time_diff']
+FEATURE_GROUPS = {'LEX':['cosine_tfidf_c','cosine_tfidf_w','bm25_score'],
+                  'SEM_CTX':['cosine_sbert_ft'],
+                  'TOPIC':['cosine_lda','cosine_lsa'],
+                  'META':['same_component','same_priority','same_version','same_comp_ver','time_diff_created','log_time_diff']}
+
+def extract_features(df, batch=256, sbert_batch=64):
+    n = len(df); t1 = df['text1'].tolist(); t2 = df['text2'].tolist()
+    cc = np.zeros(n); cw = np.zeros(n)
+    for i in range(0, n, batch):
+        sl = slice(i, i+batch)
+        cc[sl] = cosine_rows(tfidf_c.transform(t1[sl]).toarray(), tfidf_c.transform(t2[sl]).toarray())
+        cw[sl] = cosine_rows(tfidf_w.transform(t1[sl]).toarray(), tfidf_w.transform(t2[sl]).toarray())
+    bm = np.array([bm25_pair(t2[i].split(), t1[i].split()) for i in range(n)], dtype=float)
+    bm = bm / (bm.max() + 1e-9)
+    if sbert_model is not None:
+        e1 = sbert_model.encode(df['text1_raw'].tolist(), batch_size=sbert_batch, show_progress_bar=False, convert_to_numpy=True)
+        e2 = sbert_model.encode(df['text2_raw'].tolist(), batch_size=sbert_batch, show_progress_bar=False, convert_to_numpy=True)
+        cs = cosine_rows(e1, e2)
+    else:
+        cs = np.zeros(n)
+    cl = np.zeros(n); ls = np.zeros(n)
+    for i in range(0, n, batch):
+        sl = slice(i, i+batch)
+        cl[sl] = cosine_rows(lda_model.transform(count_vec.transform(t1[sl])), lda_model.transform(count_vec.transform(t2[sl])))
+        ls[sl] = cosine_rows(lsa_model.transform(tfidf_lsa.transform(t1[sl])), lsa_model.transform(tfidf_lsa.transform(t2[sl])))
+    sc = (df['Component_1'].fillna('') == df['Component_2'].fillna('')).astype(float).values
+    sp = (df['Priority_1'].fillna('')  == df['Priority_2'].fillna('')).astype(float).values
+    sv = (df['Version_1'].fillna('')   == df['Version_2'].fillna('')).astype(float).values
+    td = parse_time_diff_days(df['Created_time_1'], df['Created_time_2']).values
+    return np.column_stack([cc, cw, bm, cs, cl, ls, sc, sp, sv, sc*sv, td, np.log1p(td)])
+print('Fitur terdefinisi:', len(ALL_FEATURES))
+
+
+t0=time.time(); X_train = extract_features(train_df); y_train = train_df['Label'].values; print('train', round(time.time()-t0), 's')
+t0=time.time(); X_val   = extract_features(val_df);   y_val   = val_df['Label'].values;   print('val',   round(time.time()-t0), 's')
+t0=time.time(); X_test  = extract_features(test_df);  y_test  = test_df['Label'].values;  print('test',  round(time.time()-t0), 's')
+# print('Shape:', X_train.shape, X_val.shape, X_test.shape)
+# print('BM25 std (harus >0, bukan konstan):', round(X_train[:,2].std(), 4))
+
+
+print('Shape:', X_train.shape, X_val.shape, X_test.shape)
+
+
+
+
+
+scaler = StandardScaler().fit(X_train)
+X_train_s = scaler.transform(X_train); X_val_s = scaler.transform(X_val); X_test_s = scaler.transform(X_test)
+print('Scaler fit pada train saja. Mean train ~0:', np.round(X_train_s.mean(0)[:3], 3))
+
+
+
+
+
+feat_idx = {f:i for i,f in enumerate(ALL_FEATURES)}
+def get_feat_idx(groups):
+    idxs = []
+    for g in groups: idxs.extend([feat_idx[f] for f in FEATURE_GROUPS[g]])
+    return sorted(set(idxs))
+
+L1_SCENARIOS = {
+    'TEXT':               get_feat_idx(['LEX','SEM_CTX','TOPIC']),
+    'META':               get_feat_idx(['META']),
+    'TEXT+META':          get_feat_idx(['LEX','SEM_CTX','TOPIC','META']),
+    'LEX+META':           get_feat_idx(['LEX','META']),
+    'SEM+META':           get_feat_idx(['SEM_CTX','META']),
+    'TOPIC+META':         get_feat_idx(['TOPIC','META']),
+}
+def make_classifiers():
+    d = {'LR': LogisticRegression(max_iter=500, random_state=SEED),
+         'MLP': MLPClassifier(hidden_layer_sizes=(100,50), max_iter=300, random_state=SEED)}
+    return d
+
+ablation_l1 = []
+for scen, fidxs in L1_SCENARIOS.items():
+    Xtr, Xv = X_train_s[:, fidxs], X_val_s[:, fidxs]
+    for cn, clf in make_classifiers().items():
+        clf.fit(Xtr, y_train); yp = clf.predict(Xv)
+        ablation_l1.append({'scenario':scen, 'classifier':cn, 'n_features':len(fidxs),
+                            'precision':round(precision_score(y_val,yp),4),
+                            'recall':round(recall_score(y_val,yp),4),
+                            'f1':round(f1_score(y_val,yp),4)})
+df_abl1 = pd.DataFrame(ablation_l1).sort_values('f1', ascending=False).reset_index(drop=True)
+print(df_abl1.to_string(index=False))
+best_l1 = df_abl1.iloc[0]
+BEST_L1_SCENARIO = best_l1['scenario']; WINNER_CLASSIFIER = best_l1['classifier']
+print(f"\nBest L1: scenario={BEST_L1_SCENARIO}, clf={WINNER_CLASSIFIER}, F1(val)={best_l1['f1']}")
+
+
+# Grafik ablation L1 (F1 val per skenario, per classifier)
+piv = df_abl1.pivot(index='scenario', columns='classifier', values='f1')
+fig, ax = plt.subplots(figsize=(10,4.5))
+piv.plot(kind='bar', ax=ax, width=0.8)
+ax.set_ylabel('F1 (validasi)'); ax.set_ylim(0, 1.02); ax.set_title('Ablation L1: F1 per Skenario Fitur dan Classifier')
+ax.legend(title='Classifier'); plt.xticks(rotation=15, ha='right'); ax.grid(alpha=0.3, axis='y')
+plt.tight_layout(); plt.savefig(f'{OUT_DIR}/ablation_l1.png', bbox_inches='tight'); plt.show()
+
+
+
+
+
+L2Config = namedtuple('L2Config', ['LEX','SEM_CTX','TOPIC'])
+l2_configs = [L2Config(l,s,t) for l,s,t in product([True,False],repeat=3) if any([l,s,t])]
+ablation_l2 = []
+for cfg in l2_configs:
+    groups = ['META']
+    if cfg.LEX: groups.append('LEX')
+    if cfg.SEM_CTX: groups.append('SEM_CTX')
+    if cfg.TOPIC: groups.append('TOPIC')
+    fidxs = get_feat_idx(groups)
+    clf = make_classifiers()[WINNER_CLASSIFIER]
+    clf.fit(X_train_s[:,fidxs], y_train); yp = clf.predict(X_val_s[:,fidxs])
+    ablation_l2.append({'LEX':cfg.LEX,'SEM_CTX':cfg.SEM_CTX,'TOPIC':cfg.TOPIC,'n_features':len(fidxs),
+                        'precision':round(precision_score(y_val,yp),4),'recall':round(recall_score(y_val,yp),4),
+                        'f1':round(f1_score(y_val,yp),4)})
+df_abl2 = pd.DataFrame(ablation_l2).sort_values('f1', ascending=False).reset_index(drop=True)
+print(df_abl2.to_string(index=False))
+best_l2 = df_abl2.iloc[0]
+best_groups = ['META'] + (['LEX'] if best_l2['LEX'] else []) + (['SEM_CTX'] if best_l2['SEM_CTX'] else []) + (['TOPIC'] if best_l2['TOPIC'] else [])
+BEST_L2_FIDXS = get_feat_idx(best_groups); BEST_L2_FEATS = [ALL_FEATURES[i] for i in BEST_L2_FIDXS]
+print(f"\nBest L2: LEX={best_l2['LEX']} SEM_CTX={best_l2['SEM_CTX']} TOPIC={best_l2['TOPIC']} | {len(BEST_L2_FEATS)} fitur")
+
+
+
+
+
+TEXT_IDX = get_feat_idx(['LEX','SEM_CTX','TOPIC'])
+META_IDX = get_feat_idx(['META'])
+ALL_IDX  = get_feat_idx(['LEX','SEM_CTX','TOPIC','META'])
+scen_main = {'Text only':TEXT_IDX, 'Meta only':META_IDX, 'Text+Meta':ALL_IDX}
+clf_main = {'LR': LogisticRegression(max_iter=500, random_state=SEED),
+            'MLP': MLPClassifier(hidden_layer_sizes=(50,100,50), activation='relu', solver='adam',
+                                 learning_rate='adaptive', alpha=0.05, max_iter=500, random_state=SEED)}
+rows = []
+for scen, fidxs in scen_main.items():
+    for cn, clf in clf_main.items():
+        clf.fit(X_train_s[:,fidxs], y_train)
+        yv = clf.predict(X_val_s[:,fidxs]); yt = clf.predict(X_test_s[:,fidxs])
+        rows.append({'scenario':scen,'classifier':cn,'n_features':len(fidxs),
+                     'val_p':round(precision_score(y_val,yv),4),'val_r':round(recall_score(y_val,yv),4),'val_f1':round(f1_score(y_val,yv),4),
+                     'test_p':round(precision_score(y_test,yt),4),'test_r':round(recall_score(y_test,yt),4),'test_f1':round(f1_score(y_test,yt),4)})
+df_ablmain = pd.DataFrame(rows)
+print(df_ablmain.to_string(index=False))
+
+
+# Grafik ablation inti (Text/Meta/Text+Meta) F1 test
+fig, ax = plt.subplots(figsize=(9,4.5))
+piv = df_ablmain.pivot(index='scenario', columns='classifier', values='test_f1').reindex(['Meta only','Text only','Text+Meta'])
+piv.plot(kind='bar', ax=ax, width=0.7)
+ax.set_ylabel('F1 (test)'); ax.set_ylim(0,1.02); ax.set_title('Kontribusi Fitur: Text vs Meta vs Text+Meta (F1 test)')
+ax.legend(title='Classifier'); plt.xticks(rotation=0); ax.grid(alpha=0.3, axis='y')
+plt.tight_layout(); plt.savefig(f'{OUT_DIR}/ablation_text_meta.png', bbox_inches='tight'); plt.show()
+
+
+
+
+
+comp_clfs = {'LogReg': LogisticRegression(max_iter=500, random_state=SEED),
+             'MLP': MLPClassifier(hidden_layer_sizes=(50,100,50), activation='relu', solver='adam',
+                                  learning_rate='adaptive', alpha=0.05, max_iter=500, random_state=SEED),
+             'RandomForest': RandomForestClassifier(n_estimators=300, random_state=SEED, n_jobs=-1)}
+if HAS_XGB:
+    comp_clfs['XGBoost'] = xgb.XGBClassifier(n_estimators=300, max_depth=6, random_state=SEED, eval_metric='logloss', verbosity=0)
+rows = []; fitted = {}
+for name, clf in comp_clfs.items():
+    clf.fit(X_train_s[:,BEST_L2_FIDXS], y_train); fitted[name] = clf
+    yp = clf.predict(X_test_s[:,BEST_L2_FIDXS])
+    p,r,f,_ = (precision_score(y_test,yp), recall_score(y_test,yp), f1_score(y_test,yp), None)
+    rows.append({'Classifier':name,'Precision':round(p,4),'Recall':round(r,4),'F1':round(f,4),'Accuracy':round(accuracy_score(y_test,yp),4)})
+df_clf = pd.DataFrame(rows).sort_values('F1', ascending=False).reset_index(drop=True)
+print(df_clf.to_string(index=False))
+
+
+# Grafik perbandingan classifier
+fig, ax = plt.subplots(figsize=(10,5))
+xi = np.arange(len(df_clf)); w = 0.2
+for k, met in enumerate(['Precision','Recall','F1','Accuracy']):
+    ax.bar(xi + (k-1.5)*w, df_clf[met], w, label=met)
+ax.set_xticks(xi); ax.set_xticklabels(df_clf['Classifier']); ax.set_ylim(0.8, 1.005)
+ax.set_ylabel('Skor'); ax.legend(ncol=4, fontsize=8); ax.set_title('Perbandingan Classifier (test 3.700, fitur terbaik)')
+ax.grid(alpha=0.3, axis='y'); plt.tight_layout(); plt.savefig(f'{OUT_DIR}/classifier_comparison.png', bbox_inches='tight'); plt.show()
+
+
+
+
+
+PARAM_GRIDS = {
+    'LR' : {'C':[0.01,0.1,1,10], 'solver':['lbfgs','liblinear']},
+    'MLP': {'hidden_layer_sizes':[(50,),(100,),(50,50),(100,50),(100,100),(50,100,50),(100,50,100),(100,100,50)],
+            'activation':['relu','tanh'], 'solver':['adam'], 'learning_rate':['constant','adaptive'], 'alpha':[0.0001,0.001,0.01,0.05]},
+}
+base = {'LR': LogisticRegression(max_iter=500, random_state=SEED),
+        'MLP': MLPClassifier(max_iter=300, random_state=SEED)}[WINNER_CLASSIFIER]
+pg = PARAM_GRIDS[WINNER_CLASSIFIER]
+cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)
+gscv = GridSearchCV(base, pg, cv=cv, scoring='f1', n_jobs=-1, verbose=0)
+gscv.fit(X_train_s[:,BEST_L2_FIDXS], y_train)
+print('Best params:', gscv.best_params_); print('Best CV F1 :', round(gscv.best_score_,4))
+
+
+# Final fit pada trainval (train+val), evaluasi sekali pada test
+X_trainval = np.vstack([X_train, X_val]); y_trainval = np.concatenate([y_train, y_val])
+X_trainval_s = scaler.transform(X_trainval)[:, BEST_L2_FIDXS]
+if WINNER_CLASSIFIER == 'LR':
+    final_clf = LogisticRegression(**gscv.best_params_, max_iter=500, random_state=SEED)
+else:
+    final_clf = MLPClassifier(**gscv.best_params_, max_iter=300, random_state=SEED)
+final_clf.fit(X_trainval_s, y_trainval)
+print(f'Final classifier ({WINNER_CLASSIFIER}) dilatih pada trainval ({len(y_trainval):,} pasangan).')
+
+
+
+
+
+yp_test = final_clf.predict(X_test_s[:, BEST_L2_FIDXS])
+f1_t = f1_score(y_test, yp_test); p_t = precision_score(y_test, yp_test); r_t = recall_score(y_test, yp_test); acc_t = accuracy_score(y_test, yp_test)
+print('='*55); print('HASIL STAGE-2 ISOLATED (test 3.700)'); print('='*55)
+print(f'Precision={p_t:.4f}  Recall={r_t:.4f}  F1={f1_t:.4f}  Acc={acc_t:.4f}')
+print(); print(classification_report(y_test, yp_test, target_names=['Non-Duplicate','Duplicate']))
+cm = confusion_matrix(y_test, yp_test); print('Confusion Matrix [TN FP / FN TP]:'); print(cm)
+
+
+proba = final_clf.predict_proba(X_test_s[:,BEST_L2_FIDXS])[:,1] if hasattr(final_clf,'predict_proba') else final_clf.decision_function(X_test_s[:,BEST_L2_FIDXS])
+fig, axes = plt.subplots(1, 3, figsize=(16, 4.5))
+im = axes[0].imshow(cm, cmap='Blues')
+for (i,j), v in np.ndenumerate(cm): axes[0].text(j, i, str(v), ha='center', va='center', fontsize=13)
+axes[0].set_xticks([0,1]); axes[0].set_xticklabels(['non-dup','dup']); axes[0].set_yticks([0,1]); axes[0].set_yticklabels(['non-dup','dup'])
+axes[0].set_xlabel('Prediksi'); axes[0].set_ylabel('Aktual'); axes[0].set_title(f'Confusion Matrix ({WINNER_CLASSIFIER})')
+prec, rec, _ = precision_recall_curve(y_test, proba)
+axes[1].plot(rec, prec, color='#cc3311'); axes[1].set_xlabel('Recall'); axes[1].set_ylabel('Precision')
+axes[1].set_title(f'PR Curve (AP={average_precision_score(y_test, proba):.3f})'); axes[1].grid(alpha=0.3)
+fpr, tpr, _ = roc_curve(y_test, proba)
+axes[2].plot(fpr, tpr, color='#4477aa'); axes[2].plot([0,1],[0,1],'--',color='gray')
+axes[2].set_xlabel('FPR'); axes[2].set_ylabel('TPR'); axes[2].set_title(f'ROC (AUC={auc(fpr,tpr):.3f})'); axes[2].grid(alpha=0.3)
+plt.tight_layout(); plt.savefig(f'{OUT_DIR}/best_model_curves.png', bbox_inches='tight'); plt.show()
+
+
+
+
+
+key_feats = ['cosine_tfidf_w','cosine_sbert_ft','time_diff_created','same_component']
+idx = {f:i for i,f in enumerate(ALL_FEATURES)}
+fig, axes = plt.subplots(1, 4, figsize=(16, 3.6))
+for ax, fn in zip(axes, key_feats):
+    col = X_test[:, idx[fn]]; dup = col[y_test==1]; non = col[y_test==0]
+    hi = np.percentile(col, 95) if fn=='time_diff_created' else col.max()
+    bins = np.linspace(col.min(), hi+1e-9, 40)
+    ax.hist(non, bins=bins, alpha=0.6, label='non-dup', color='#4477aa', density=True)
+    ax.hist(dup, bins=bins, alpha=0.6, label='dup', color='#ee6677', density=True)
+    ax.set_title(fn, fontsize=9); ax.legend(fontsize=7)
+plt.suptitle('Distribusi Fitur: Duplikat vs Non-duplikat (test)')
+plt.tight_layout(); plt.savefig(f'{OUT_DIR}/feature_distributions.png', bbox_inches='tight'); plt.show()
+
+
+corr = np.corrcoef(X_train.T)
+fig, ax = plt.subplots(figsize=(9, 7.5))
+im = ax.imshow(corr, cmap='coolwarm', vmin=-1, vmax=1)
+ax.set_xticks(range(len(ALL_FEATURES))); ax.set_xticklabels(ALL_FEATURES, rotation=90, fontsize=7)
+ax.set_yticks(range(len(ALL_FEATURES))); ax.set_yticklabels(ALL_FEATURES, fontsize=7)
+for i in range(len(ALL_FEATURES)):
+    for j in range(len(ALL_FEATURES)):
+        ax.text(j, i, f'{corr[i,j]:.1f}', ha='center', va='center', fontsize=5.5, color='white' if abs(corr[i,j])>0.6 else 'black')
+plt.colorbar(im, fraction=0.046); plt.title('Korelasi Antar-Fitur (train)')
+plt.tight_layout(); plt.savefig(f'{OUT_DIR}/feature_correlation.png', bbox_inches='tight'); plt.show()
+
+
+
+
+
+pi = permutation_importance(final_clf, X_test_s[:,BEST_L2_FIDXS], y_test, n_repeats=10, random_state=SEED, n_jobs=-1)
+order = np.argsort(pi.importances_mean)
+fig, ax = plt.subplots(figsize=(9,5))
+ax.barh([BEST_L2_FEATS[i] for i in order], pi.importances_mean[order], xerr=pi.importances_std[order], color='#aa3377')
+ax.set_title(f'Permutation Importance ({WINNER_CLASSIFIER}, test)'); ax.tick_params(labelsize=8)
+plt.tight_layout(); plt.savefig(f'{OUT_DIR}/feature_importance.png', bbox_inches='tight'); plt.show()
+imp_df = pd.DataFrame({'feature':BEST_L2_FEATS,'perm_importance':pi.importances_mean,'perm_std':pi.importances_std}).sort_values('perm_importance', ascending=False)
+print(imp_df.to_string(index=False))
+
+
+
+
+
+# Ambil N korpus dari Stage-1 (untuk proyeksi O(N) Ben). Fallback bila file tak ada.
+BEN_N_CORPUS = None
+for p in [f'{INPUT_DIR}/retrieval_efficiency.json', f'{OUT_DIR}/retrieval_efficiency.json',
+          './output_stage1/retrieval_efficiency.json', '/kaggle/working/retrieval_efficiency.json']:
+    if Path(p).exists():
+        try: BEN_N_CORPUS = int(json.load(open(p)).get('corpus_size')); break
+        except Exception: pass
+if BEN_N_CORPUS is None:
+    BEN_N_CORPUS = 31916   # ganti dgn corpus_size Stage-1 Anda bila file tak terbaca
+    print(f'[catatan] retrieval_efficiency.json tak ditemukan, pakai N={BEN_N_CORPUS} (sesuaikan).')
+print('N korpus (untuk O(N)):', BEN_N_CORPUS)
+
+
+# Ukur ms/report = waktu klasifikasi 1 query thd K kandidat (batch). Ulang beberapa query.
+def time_per_report(n_reports=20, K=K_RETRIEVAL):
+    base = test_df.reset_index(drop=True); idxs = list(range(len(base)))
+    times = []
+    for r in range(n_reports):
+        sel = [(idxs[(r*K + j) % len(idxs)]) for j in range(K)]   # K baris sbg kandidat 1 query
+        batch = base.iloc[sel]
+        t0 = time.perf_counter()
+        fr = extract_features(batch); frs = scaler.transform(fr)[:, BEST_L2_FIDXS]; _ = final_clf.predict(frs)
+        times.append((time.perf_counter()-t0)*1000)
+    return float(np.mean(times)), float(np.std(times))
+ms_report, ms_std = time_per_report()
+ms_pair = ms_report / K_RETRIEVAL
+print(f'Stage-2 ms/report (batch K={K_RETRIEVAL}): {ms_report:.2f} ms (std {ms_std:.2f})')
+print(f'  -> setara ms/pair: {ms_pair:.3f} ms')
+print('Catatan: total Two-Stage = Stage1_ms + ms/report ini (ditambahkan di notebook E2E).')
+eff = {'ms_per_report_OK_batch': round(ms_report,3), 'ms_per_pair_batched': round(ms_pair,4),
+       'K_retrieval': K_RETRIEVAL, 'N_corpus_for_ON': int(BEN_N_CORPUS)}
+json.dump(eff, open(f'{OUT_DIR}/stage2_efficiency.json','w'), indent=2)
+print('Disimpan: stage2_efficiency.json')
+# Perbandingan Ben (angka diisi dari notebook replikasi Ben Anda)
+# BEN_AVG_MS_PAIR = <hasil replikasi>; ben_ms_report = BEN_AVG_MS_PAIR * BEN_N_CORPUS
+print('\n[Ben] isi BEN_AVG_MS_PAIR dari notebook replikasi Anda, lalu Ben O(N) ms/report = BEN_AVG_MS_PAIR * N.')
+
+
+
+
+
+pickle.dump({'clf':final_clf,'best_params':gscv.best_params_,'feature_idx':BEST_L2_FIDXS,
+             'feature_names':BEST_L2_FEATS,'all_features':ALL_FEATURES,'feature_groups':FEATURE_GROUPS,
+             'winner_clf':WINNER_CLASSIFIER}, open(f'{OUT_DIR}/classifier.pkl','wb'))
+pickle.dump(scaler, open(f'{OUT_DIR}/scaler.pkl','wb'))
+pickle.dump({'tfidf_c':tfidf_c,'tfidf_w':tfidf_w,'count_vec':count_vec,'lda_model':lda_model,
+             'tfidf_lsa':tfidf_lsa,'lsa_model':lsa_model,'DF_COUNT':DF_COUNT,'N_DOCS':N_DOCS,
+             'BM25_AVGDL':BM25_AVGDL,'sbert_model_name':HF_SBERT_FT}, open(f'{OUT_DIR}/feature_extractors.pkl','wb'))
+df_abl1.to_csv(f'{OUT_DIR}/ablation_l1.csv', index=False); df_abl2.to_csv(f'{OUT_DIR}/ablation_l2.csv', index=False)
+df_ablmain.to_csv(f'{OUT_DIR}/ablation_text_meta.csv', index=False); df_clf.to_csv(f'{OUT_DIR}/classifier_comparison.csv', index=False)
+summary = {'winner_classifier':WINNER_CLASSIFIER,'best_params':gscv.best_params_,'n_features':len(BEST_L2_FEATS),
+           'features':BEST_L2_FEATS,'test':{'F1':float(f1_t),'Precision':float(p_t),'Recall':float(r_t),'Accuracy':float(acc_t)},
+           'efficiency':eff,'split':{'train':len(train_df),'val':len(val_df),'test':len(test_df)}}
+json.dump(summary, open(f'{OUT_DIR}/summary.json','w'), indent=2)
+print('Artefak tersimpan di', OUT_DIR)
+
+
+
+
+
+RUN_HARD_NEG = True   # set False utk melewati
+if RUN_HARD_NEG:
+    # Untuk tiap query positif (bug1 pada test_dup), cari kandidat paling mirip (TF-IDF word) yg BUKAN partner -> hard negative
+    pos = test_df[test_df['Label']==1].reset_index(drop=True)
+    pool_text = corpus_train + pos['text1'].tolist()
+    Vpool = tfidf_w.transform(pool_text); Vq = tfidf_w.transform(pos['text1'].tolist())
+    sims = (Vq @ Vpool.T)
+    easy_neg_cos = X_test[:, feat_idx['cosine_tfidf_w']][y_test==0]
+    hard_neg_cos = np.array([np.sort(sims.getrow(i).toarray().ravel())[-2] for i in range(len(pos))])  # -2: lewati diri sendiri
+    print('Median cosine_tfidf_w:')
+    print(f'  negatif Ben (acak)    : {np.median(easy_neg_cos):.3f}')
+    print(f'  hard-neg (top mirip)  : {np.median(hard_neg_cos):.3f}')
+    fig, ax = plt.subplots(figsize=(8,4.5))
+    ax.hist(easy_neg_cos, bins=40, alpha=0.6, density=True, label='negatif Ben (acak/mudah)', color='#4477aa')
+    ax.hist(hard_neg_cos, bins=40, alpha=0.6, density=True, label='hard-neg (Top-K retrieval)', color='#ee6677')
+    ax.set_xlabel('cosine_tfidf_w'); ax.set_ylabel('densitas'); ax.legend()
+    ax.set_title('Easy vs Hard Negative: distribusi kemiripan tekstual')
+    plt.tight_layout(); plt.savefig(f'{OUT_DIR}/easy_vs_hard_negative.png', bbox_inches='tight'); plt.show()
+    print('\nInterpretasi: hard-neg punya cosine jauh lebih tinggi -> lebih sulit dipisahkan.')
+    print('Konsekuensi: F1 pada Two-Stage E2E (negatif = Top-K retrieval) diperkirakan LEBIH RENDAH')
+    print('daripada F1 isolated ini. Ini temuan kunci, bukan kelemahan implementasi.')
+else:
+    print('Dilewati (RUN_HARD_NEG=False).')
+
+
+
+
+
+# try:
+#     from kaggle_secrets import UserSecretsClient
+#     HF_TOKEN = UserSecretsClient().get_secret('HF_TOKEN')
+# except Exception:
+#     HF_TOKEN = os.environ.get('HF_TOKEN', None)
+# if HF_TOKEN:
+#     from huggingface_hub import HfApi, create_repo
+#     api = HfApi(token=HF_TOKEN)
+#     create_repo(HF_REPO, repo_type='dataset', exist_ok=True, token=HF_TOKEN)
+#     for fn in ['classifier.pkl','scaler.pkl','feature_extractors.pkl','summary.json']:
+#         p = Path(f'{OUT_DIR}/{fn}')
+#         if p.exists(): api.upload_file(path_or_fileobj=str(p), path_in_repo=fn, repo_id=HF_REPO, repo_type='dataset', token=HF_TOKEN)
+#     print('Upload selesai:', HF_REPO)
+# else:
+#     print('HF_TOKEN tidak ada, skip upload.')
+
+
+from huggingface_hub import notebook_login
+notebook_login()
+
+
+from huggingface_hub import HfApi, create_repo
+api = HfApi()
+create_repo(HF_REPO, repo_type='dataset', exist_ok=True)
+# upload SELURUH isi OUT_DIR sekaligus -> tidak ada file/sidecar yang ketinggalan
+api.upload_folder(folder_path=OUT_DIR, repo_id=HF_REPO, repo_type='dataset',
+                  commit_message='Stage-2 artefak (12 fitur, tanpa gensim)')
+print('Selesai:', f'https://huggingface.co/datasets/{HF_REPO}')
+
+
+

ablation_l1.csv

@@ -1,13 +1,13 @@
 scenario,classifier,n_features,precision,recall,f1
-LEX+META,MLP,9,0.9993,0.9953,0.9973
+LEX+META,MLP,9,0.998,0.9966,0.9973
+TOPIC+META,MLP,8,1.0,0.9939,0.997
 META,MLP,6,1.0,0.9932,0.9966
-TOPIC+META,MLP,8,0.9993,0.9939,0.9966
-SEM+META,MLP,10,0.9993,0.9919,0.9956
-LEX+META,LR,9,0.998,0.9905,0.9942
-TEXT+META,MLP,15,0.9986,0.9885,0.9935
-TOPIC+META,LR,8,0.9993,0.9865,0.9929
-TEXT+META,LR,15,0.9986,0.9865,0.9925
+SEM+META,MLP,7,0.9986,0.9926,0.9956
+TEXT+META,MLP,12,0.9993,0.9899,0.9946
+LEX+META,LR,9,0.9986,0.9899,0.9942
+TOPIC+META,LR,8,0.9959,0.9905,0.9932
+TEXT+META,LR,12,0.9986,0.9872,0.9929
 META,LR,6,1.0,0.9845,0.9922
-SEM+META,LR,10,0.9979,0.9858,0.9918
-TEXT,LR,9,0.9891,0.9203,0.9534
-TEXT,MLP,9,0.9912,0.9128,0.9504
+SEM+META,LR,7,0.9986,0.9845,0.9915
+TEXT,LR,6,0.9891,0.9189,0.9527
+TEXT,MLP,6,0.9897,0.9128,0.9497

ablation_l2.csv

@@ -1,8 +1,8 @@
-LEX,SEM_STAT,TOPIC,n_features,precision,recall,f1
-True,False,True,11,0.9986,0.9959,0.9973
-True,False,False,9,0.9993,0.9953,0.9973
-False,False,True,8,0.9993,0.9939,0.9966
-False,True,False,10,0.9993,0.9919,0.9956
-True,True,False,13,0.9986,0.9912,0.9949
-False,True,True,12,0.9993,0.9905,0.9949
-True,True,True,15,0.9986,0.9885,0.9935
+LEX,SEM_CTX,TOPIC,n_features,precision,recall,f1
+True,False,False,9,0.998,0.9966,0.9973
+False,False,True,8,1.0,0.9939,0.997
+True,False,True,11,0.9973,0.9966,0.997
+False,True,False,7,0.9986,0.9926,0.9956
+True,True,True,12,0.9993,0.9899,0.9946
+True,True,False,10,0.998,0.9912,0.9946
+False,True,True,9,0.9986,0.9899,0.9942

ablation_text_meta.csv

@@ -1,7 +1,7 @@
 scenario,classifier,n_features,val_p,val_r,val_f1,test_p,test_r,test_f1
-Text only,LR,9,0.9891,0.9203,0.9534,0.9606,0.9374,0.9489
-Text only,MLP,9,0.9898,0.9176,0.9523,0.9513,0.9445,0.9479
+Text only,LR,6,0.9891,0.9189,0.9527,0.9608,0.9417,0.9511
+Text only,MLP,6,0.9884,0.9196,0.9527,0.9472,0.9445,0.9459
 Meta only,LR,6,1.0,0.9845,0.9922,1.0,0.9275,0.9624
 Meta only,MLP,6,1.0,0.9932,0.9966,0.9985,0.9644,0.9812
-Text+Meta,LR,15,0.9986,0.9865,0.9925,0.9928,0.9815,0.9871
-Text+Meta,MLP,15,0.9973,0.9905,0.9939,0.9872,0.99,0.9886
+Text+Meta,LR,12,0.9986,0.9872,0.9929,0.9928,0.9787,0.9857
+Text+Meta,MLP,12,0.998,0.9919,0.9949,0.9928,0.9872,0.99

classifier.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e95ffb71927357f5d922e1301d463a1bad7bef96485b5ecd23c116dbaaf8197f
-size 534994
+oid sha256:160dd2c2705a1c2e7106b08df6f75d391e0a8072b5364024fa3fced486334f77
+size 352094

classifier_comparison.csv

@@ -1,5 +1,5 @@
 Classifier,Precision,Recall,F1,Accuracy
-MLP,0.9942,0.9673,0.9805,0.9927
-LogReg,0.9913,0.9673,0.9791,0.9922
-RandomForest,0.9322,0.9787,0.9549,0.9824
-XGBoost,0.8987,0.9844,0.9396,0.9759
+MLP,0.9942,0.9687,0.9813,0.993
+LogReg,0.9926,0.9559,0.9739,0.9903
+XGBoost,0.9186,0.9787,0.9477,0.9795
+RandomForest,0.8809,0.9787,0.9272,0.9708

feature_extractors.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b319247b71cdd64b106b00c866575f358a496a444750225a2ee5087b0e94a315
-size 15289968
+oid sha256:f4aa29cbf3a6b4d60a251435d128fc5964ff4c52850825b8471fd01900823eca
+size 13566511

scaler.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:94cac5dc1ced92e415450d070219026b2acb2684ae8350d1dd5c0c13c6670ca2
-size 810
+oid sha256:264e83e73ae96d9ae982f8b4a6bd3845cd958e4f7580e88f7019c285e59208c9
+size 738

stage2_efficiency.json

@@ -1,6 +1,6 @@
 {
-  "ms_per_report_OK_batch": 2428.121,
-  "ms_per_pair_batched": 48.5624,
+  "ms_per_report_OK_batch": 1866.907,
+  "ms_per_pair_batched": 37.3381,
   "K_retrieval": 50,
   "N_corpus_for_ON": 31916
 }

summary.json

@@ -1,23 +1,21 @@
 {
   "winner_classifier": "MLP",
   "best_params": {
-    "activation": "relu",
-    "alpha": 0.01,
+    "activation": "tanh",
+    "alpha": 0.001,
     "hidden_layer_sizes": [
-      100,
+      50,
       100,
       50
     ],
     "learning_rate": "constant",
     "solver": "adam"
   },
-  "n_features": 11,
+  "n_features": 9,
   "features": [
     "cosine_tfidf_c",
     "cosine_tfidf_w",
     "bm25_score",
-    "cosine_lda",
-    "cosine_lsa",
     "same_component",
     "same_priority",
     "same_version",
@@ -26,14 +24,14 @@
     "log_time_diff"
   ],
   "test": {
-    "F1": 0.9792114695340501,
-    "Precision": 0.9869942196531792,
-    "Recall": 0.9715504978662873,
-    "Accuracy": 0.9921621621621621
+    "F1": 0.985632183908046,
+    "Precision": 0.9956458635703919,
+    "Recall": 0.9758179231863442,
+    "Accuracy": 0.9945945945945946
   },
   "efficiency": {
-    "ms_per_report_OK_batch": 2428.121,
-    "ms_per_pair_batched": 48.5624,
+    "ms_per_report_OK_batch": 1866.907,
+    "ms_per_pair_batched": 37.3381,
     "K_retrieval": 50,
     "N_corpus_for_ON": 31916
   },