From 2319b62d2493a2276975b8fbf411d75b210277f5 Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 07:02:53 +0600
Subject: [PATCH 01/13] Update requirements.txt and fit script for draft

---
 model/rfc_fit.py | 19 +++++++++++++++----
 requirements.txt |  2 ++
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/model/rfc_fit.py b/model/rfc_fit.py
index 745bb4b..a863b02 100644
--- a/model/rfc_fit.py
+++ b/model/rfc_fit.py
@@ -1,8 +1,17 @@
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import train_test_split
+from sklearn.model_selection import train_test_split, RandomizedSearchCV
 from sklearn.preprocessing import StandardScaler
-from sklearn.metrics import classification_report, confusion_matrix
 from sklearn.impute import SimpleImputer
+from sklearn.metrics import classification_report
+
+from sklearn.ensemble import RandomForestClassifier,VotingClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from xgboost import XGBClassifier
+
+from imblearn.over_sampling import SMOTE
+from imblearn.pipeline import Pipeline
+
+import time
 import pandas as pd
 import numpy as np
 import joblib
@@ -105,6 +114,9 @@ def get_window(camps):
     X_scaled, y, test_size=1/3, shuffle=True, random_state=91, stratify=y
 )
 
+##### STAR CHANGING FROM HERE !!
+
+
 # Model Development
 model = RandomForestClassifier(n_estimators=1000,max_depth=None,random_state=91,class_weight="balanced")
 model.fit(X_train, y_train)
@@ -112,7 +124,6 @@ def get_window(camps):
 # Model Performence Evaluation
 y_pred = model.predict(X_test)
 print("Confusion Matrix:")
-print(confusion_matrix(y_test, y_pred))
 print("\nClassification Report:")
 print(classification_report(y_test, y_pred, target_names=["FALSE POSITIVE","CANDIDATE","CONFIRMED"]))
 
diff --git a/requirements.txt b/requirements.txt
index 8d2e3f8..fa878c8 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -4,3 +4,5 @@ pandas
 scikit-learn
 joblib
 gunicorn
+xgboost
+imbalanced-learn

From 928df3c692be0b8463efc430a602db4d049a813d Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:29:04 +0600
Subject: [PATCH 02/13] Delete old files

---
 model/rfc_cross_val.py | 114 --------------------------------
 model/rfc_fit.py       | 144 -----------------------------------------
 2 files changed, 258 deletions(-)
 delete mode 100644 model/rfc_cross_val.py
 delete mode 100644 model/rfc_fit.py

diff --git a/model/rfc_cross_val.py b/model/rfc_cross_val.py
deleted file mode 100644
index 02d7150..0000000
--- a/model/rfc_cross_val.py
+++ /dev/null
@@ -1,114 +0,0 @@
-from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import cross_val_score, StratifiedKFold
-from sklearn.preprocessing import StandardScaler
-from sklearn.impute import SimpleImputer
-import pandas as pd
-import numpy as np
-
-# Loading and processing 1st Dataset (NASA Kepler Objects of Interest)
-df_raw = pd.read_csv("data/kepler_data.csv", comment="#")
-feature_list = ["koi_disposition","koi_period","koi_time0bk","koi_depth","koi_prad","koi_sma","koi_incl","koi_teq","koi_insol","koi_impact","koi_ror","koi_srho","koi_dor","koi_num_transits"]
-df_selected = df_raw[feature_list]
-
-df_1 = df_selected.copy()
-
-# Loading and processing 2nd dataset (NASA K2 Objects of Interest)
-df_2 = pd.read_csv("data/k2_data.csv",comment="#")
-
-## Feature Engineering missing column in K2 (koi_num_transits) 
-#### This part was generated with an AI tool (a LLM service named Grok, URL: https://grok.com)
-
-# Campaign dates dictionary (BJD)
-campaign_dates = {
-    0: (2456725.0, 2456805.0),
-    1: (2456808.0, 2456891.0),
-    2: (2456893.0, 2456975.0),
-    3: (2456976.0, 2457064.0),
-    4: (2457065.0, 2457159.0),
-    5: (2457159.0, 2457246.0),
-    6: (2457250.0, 2457338.0),
-    7: (2457339.0, 2457420.0),
-    8: (2457421.0, 2457530.0),
-    9: (2457504.0, 2457579.0),
-    10: (2457577.0, 2457653.0),
-    11: (2457657.0, 2457732.0),
-    12: (2457731.0, 2457819.0),
-    13: (2457820.0, 2457900.0),
-    14: (2457898.0, 2457942.0),
-    15: (2457941.0, 2458022.0),
-    16: (2458020.0, 2458074.0),
-    17: (2458074.0, 2458176.0),
-    18: (2458151.0, 2458201.0),
-    19: (2458232.0, 2458348.0)
-}
-
-def get_window(camps):
-    if pd.isna(camps) or not camps:
-        return np.nan, np.nan
-    
-    camps = str(camps).split(',') if isinstance(camps, str) else camps
-    
-    # Filter valid campaign numbers and get start/end times
-    starts = []
-    ends = []
-    for c in camps:
-        try:
-            camp_num = int(c.strip())
-            if camp_num in campaign_dates:
-                start, end = campaign_dates[camp_num]
-                starts.append(start)
-                ends.append(end)
-        except (ValueError, KeyError):
-            continue  
-    
-    return (min(starts) if starts else np.nan, max(ends) if ends else np.nan)
-
-
-df_2['campaigns'] = df_2['k2_campaigns']
-df_2[['obs_start_bjd', 'obs_end_bjd']] = df_2['campaigns'].apply(lambda x: pd.Series(get_window(x)))
-
-# For transit counting (as before)
-df_2['n_min'] = np.ceil((df_2['obs_start_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
-df_2['n_max'] = np.floor((df_2['obs_end_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
-df_2['num_transits'] = (df_2['n_max'] - df_2['n_min'] + 1).clip(lower=0)
-df_2 = df_2[["disposition","pl_orbper","pl_tranmid","pl_trandep","pl_rade","pl_orbsmax","pl_orbincl","pl_eqt","pl_insol","pl_imppar","pl_ratror","pl_dens","pl_ratdor","num_transits"]]
-
-#### AI written part ends here
-
-# Concatenating df_1 and df_2
-mapping = {"disposition":"koi_disposition","pl_orbper":"koi_period","pl_tranmid":"koi_time0bk",
-           "pl_trandep":"koi_depth","pl_rade":"koi_prad","pl_orbsmax":"koi_sma",
-           "pl_orbincl":"koi_incl","pl_eqt":"koi_teq","pl_insol":"koi_insol","pl_imppar":"koi_impact",
-           "pl_ratror":"koi_ror","pl_dens":"koi_srho","pl_ratdor":"koi_dor","num_transits":"koi_num_transits"
-           }
-df_2 = df_2.rename(columns=mapping)
-
-df = pd.concat([df_1,df_2])
-print(df.shape)               # Output: (13568, 14)
-
-# Input-output separation
-X = df.iloc[:,1:].to_numpy()
-y = df["koi_disposition"].map({"FALSE POSITIVE":0,"CANDIDATE":1,"CONFIRMED":2,"REFUTED":0}).to_numpy()
-
-# Imputation
-imputer = SimpleImputer(strategy="median")
-X = imputer.fit_transform(X)
-
-# Feature scaling 
-scaler = StandardScaler()
-X_scaled = scaler.fit_transform(X)
-
-# The Model
-model = RandomForestClassifier(n_estimators=500,max_depth=None,random_state=91,class_weight="balanced")
-
-# Performing Cross Validation
-kfold = StratifiedKFold(n_splits=5,shuffle=True,random_state=89)
-score = cross_val_score(model,X_scaled,y,cv=kfold)
-print(f"Average = {score.mean()}")
-print(f"Full Matrix:\n {score}")
-
-## Output
-
-## Average = 0.7502214425969995
-## Full Matrix:
-##  [0.74907885 0.74907885 0.74797347 0.75340951 0.75156653]
\ No newline at end of file
diff --git a/model/rfc_fit.py b/model/rfc_fit.py
deleted file mode 100644
index a863b02..0000000
--- a/model/rfc_fit.py
+++ /dev/null
@@ -1,144 +0,0 @@
-from sklearn.model_selection import train_test_split, RandomizedSearchCV
-from sklearn.preprocessing import StandardScaler
-from sklearn.impute import SimpleImputer
-from sklearn.metrics import classification_report
-
-from sklearn.ensemble import RandomForestClassifier,VotingClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.svm import SVC
-from xgboost import XGBClassifier
-
-from imblearn.over_sampling import SMOTE
-from imblearn.pipeline import Pipeline
-
-import time
-import pandas as pd
-import numpy as np
-import joblib
-
-# Loading and processing 1st Dataset (NASA Kepler Objects of Interest)
-df_raw = pd.read_csv("data/kepler_data.csv", comment="#")
-feature_list = ["koi_disposition","koi_period","koi_time0bk","koi_depth","koi_prad","koi_sma","koi_incl","koi_teq","koi_insol","koi_impact","koi_ror","koi_srho","koi_dor","koi_num_transits"]
-df_selected = df_raw[feature_list]
-
-df_1 = df_selected.copy()
-
-# Loading and processing 2nd dataset (NASA K2 Objects of Interest)
-df_2 = pd.read_csv("data/k2_data.csv",comment="#")
-
-## Feature Engineering missing column in K2 (koi_num_transits) 
-#### This part was generated with an AI tool (a LLM service named Grok, URL: https://grok.com)
-
-# Campaign dates dictionary (BJD)
-campaign_dates = {
-    0: (2456725.0, 2456805.0),
-    1: (2456808.0, 2456891.0),
-    2: (2456893.0, 2456975.0),
-    3: (2456976.0, 2457064.0),
-    4: (2457065.0, 2457159.0),
-    5: (2457159.0, 2457246.0),
-    6: (2457250.0, 2457338.0),
-    7: (2457339.0, 2457420.0),
-    8: (2457421.0, 2457530.0),
-    9: (2457504.0, 2457579.0),
-    10: (2457577.0, 2457653.0),
-    11: (2457657.0, 2457732.0),
-    12: (2457731.0, 2457819.0),
-    13: (2457820.0, 2457900.0),
-    14: (2457898.0, 2457942.0),
-    15: (2457941.0, 2458022.0),
-    16: (2458020.0, 2458074.0),
-    17: (2458074.0, 2458176.0),
-    18: (2458151.0, 2458201.0),
-    19: (2458232.0, 2458348.0)
-}
-
-def get_window(camps):
-    if pd.isna(camps) or not camps:
-        return np.nan, np.nan
-    
-    camps = str(camps).split(',') if isinstance(camps, str) else camps
-    
-    # Filter valid campaign numbers and get start/end times
-    starts = []
-    ends = []
-    for c in camps:
-        try:
-            camp_num = int(c.strip())
-            if camp_num in campaign_dates:
-                start, end = campaign_dates[camp_num]
-                starts.append(start)
-                ends.append(end)
-        except (ValueError, KeyError):
-            continue  
-    
-    return (min(starts) if starts else np.nan, max(ends) if ends else np.nan)
-
-
-df_2['campaigns'] = df_2['k2_campaigns']
-df_2[['obs_start_bjd', 'obs_end_bjd']] = df_2['campaigns'].apply(lambda x: pd.Series(get_window(x)))
-
-# For transit counting (as before)
-df_2['n_min'] = np.ceil((df_2['obs_start_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
-df_2['n_max'] = np.floor((df_2['obs_end_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
-df_2['num_transits'] = (df_2['n_max'] - df_2['n_min'] + 1).clip(lower=0)
-df_2 = df_2[["disposition","pl_orbper","pl_tranmid","pl_trandep","pl_rade","pl_orbsmax","pl_orbincl","pl_eqt","pl_insol","pl_imppar","pl_ratror","pl_dens","pl_ratdor","num_transits"]]
-
-#### AI written part ends here
-
-# Concatenating df_1 and df_2
-mapping = {"disposition":"koi_disposition","pl_orbper":"koi_period","pl_tranmid":"koi_time0bk",
-           "pl_trandep":"koi_depth","pl_rade":"koi_prad","pl_orbsmax":"koi_sma",
-           "pl_orbincl":"koi_incl","pl_eqt":"koi_teq","pl_insol":"koi_insol","pl_imppar":"koi_impact",
-           "pl_ratror":"koi_ror","pl_dens":"koi_srho","pl_ratdor":"koi_dor","num_transits":"koi_num_transits"
-           }
-df_2 = df_2.rename(columns=mapping)
-
-df = pd.concat([df_1,df_2])
-print(df.shape)               # Output: (13568, 14)
-
-# Input-output separation
-X = df.iloc[:,1:].to_numpy()
-y = df["koi_disposition"].map({"FALSE POSITIVE":0,"CANDIDATE":1,"CONFIRMED":2,"REFUTED":0}).to_numpy()
-
-# Imputation
-imputer = SimpleImputer(strategy="median")
-X = imputer.fit_transform(X)
-
-# Feature scaling 
-scaler = StandardScaler()
-X_scaled = scaler.fit_transform(X)
-
-# Train-test split
-X_train, X_test, y_train, y_test = train_test_split(
-    X_scaled, y, test_size=1/3, shuffle=True, random_state=91, stratify=y
-)
-
-##### STAR CHANGING FROM HERE !!
-
-
-# Model Development
-model = RandomForestClassifier(n_estimators=1000,max_depth=None,random_state=91,class_weight="balanced")
-model.fit(X_train, y_train)
-
-# Model Performence Evaluation
-y_pred = model.predict(X_test)
-print("Confusion Matrix:")
-print("\nClassification Report:")
-print(classification_report(y_test, y_pred, target_names=["FALSE POSITIVE","CANDIDATE","CONFIRMED"]))
-
-## Saving the model for pipeline (NOTE: This code should be run only once)
-joblib.dump(model, "model.pkl")
-joblib.dump(scaler, "scaler.pkl")
-
-# Model Performence Evaluation Result 
-# Classification Report:
-#                 precision    recall  f1-score   support
-
-# FALSE POSITIVE       0.81      0.84      0.82      1718
-#      CANDIDATE       0.59      0.47      0.53      1118
-#      CONFIRMED       0.77      0.83      0.80      1687
-# 
-#       accuracy                           0.75      4523
-#      macro avg       0.72      0.72      0.72      4523
-#   weighted avg       0.74      0.75      0.74      4523
\ No newline at end of file

From 086013c0c9d4f9aea56ec4d76a59aac9aa774baf Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:29:31 +0600
Subject: [PATCH 03/13] Update fit.py

---
 fit.py | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 149 insertions(+)
 create mode 100644 fit.py

diff --git a/fit.py b/fit.py
new file mode 100644
index 0000000..57a105f
--- /dev/null
+++ b/fit.py
@@ -0,0 +1,149 @@
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.impute import SimpleImputer
+
+from sklearn.ensemble import RandomForestClassifier, StackingClassifier
+from sklearn.linear_model import LogisticRegression
+from xgboost import XGBClassifier
+
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+
+from imblearn.over_sampling import SMOTE
+from imblearn.pipeline import Pipeline
+
+import time
+import pandas as pd
+import numpy as np
+import joblib
+
+# Loading and processing 1st Dataset (NASA Kepler Objects of Interest)
+df_raw = pd.read_csv("data/kepler_data.csv", comment="#")
+
+feature_list = ["koi_disposition","koi_period","koi_time0bk",
+ "koi_depth","koi_prad","koi_sma","koi_incl","koi_teq","koi_insol",
+ "koi_impact","koi_ror","koi_srho","koi_dor","koi_num_transits"
+]
+
+df_selected = df_raw[feature_list]
+
+df_1 = df_selected.copy()
+
+# Loading and processing 2nd dataset (NASA K2 Objects of Interest)
+df_2 = pd.read_csv("data/k2_data.csv",comment="#")
+
+## Feature Engineering missing column in K2 (koi_num_transits) 
+# Campaign dates dictionary (BJD)
+campaign_dates = {
+    0: (2456725.0, 2456805.0),
+    1: (2456808.0, 2456891.0),
+    2: (2456893.0, 2456975.0),
+    3: (2456976.0, 2457064.0),
+    4: (2457065.0, 2457159.0),
+    5: (2457159.0, 2457246.0),
+    6: (2457250.0, 2457338.0),
+    7: (2457339.0, 2457420.0),
+    8: (2457421.0, 2457530.0),
+    9: (2457504.0, 2457579.0),
+    10: (2457577.0, 2457653.0),
+    11: (2457657.0, 2457732.0),
+    12: (2457731.0, 2457819.0),
+    13: (2457820.0, 2457900.0),
+    14: (2457898.0, 2457942.0),
+    15: (2457941.0, 2458022.0),
+    16: (2458020.0, 2458074.0),
+    17: (2458074.0, 2458176.0),
+    18: (2458151.0, 2458201.0),
+    19: (2458232.0, 2458348.0)
+}
+
+def get_window(camps):
+    if pd.isna(camps) or not camps:
+        return np.nan, np.nan
+    
+    camps = str(camps).split(',') if isinstance(camps, str) else camps
+    
+    # Filter valid campaign numbers and get start/end times
+    starts = []
+    ends = []
+    for c in camps:
+        try:
+            camp_num = int(c.strip())
+            if camp_num in campaign_dates:
+                start, end = campaign_dates[camp_num]
+                starts.append(start)
+                ends.append(end)
+        except (ValueError, KeyError):
+            continue  
+    
+    return (min(starts) if starts else np.nan, max(ends) if ends else np.nan)
+
+df_2['campaigns'] = df_2['k2_campaigns']
+df_2[['obs_start_bjd', 'obs_end_bjd']] = df_2['campaigns'].apply(lambda x: pd.Series(get_window(x)))
+
+# For transit counting (as before)
+df_2['n_min'] = np.ceil((df_2['obs_start_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
+df_2['n_max'] = np.floor((df_2['obs_end_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
+df_2['num_transits'] = (df_2['n_max'] - df_2['n_min'] + 1).clip(lower=0)
+df_2 = df_2[["disposition","pl_orbper","pl_tranmid","pl_trandep","pl_rade","pl_orbsmax","pl_orbincl","pl_eqt","pl_insol","pl_imppar","pl_ratror","pl_dens","pl_ratdor","num_transits"]]
+
+# Concatenating df_1 and df_2
+mapping = {"disposition":"koi_disposition","pl_orbper":"koi_period","pl_tranmid":"koi_time0bk",
+           "pl_trandep":"koi_depth","pl_rade":"koi_prad","pl_orbsmax":"koi_sma",
+           "pl_orbincl":"koi_incl","pl_eqt":"koi_teq","pl_insol":"koi_insol","pl_imppar":"koi_impact",
+           "pl_ratror":"koi_ror","pl_dens":"koi_srho","pl_ratdor":"koi_dor","num_transits":"koi_num_transits"
+           }
+df_2 = df_2.rename(columns=mapping)
+
+df = pd.concat([df_1,df_2])
+
+# Input-output separation
+X = df.iloc[:,1:]
+column_name = X.columns
+X = X.to_numpy()
+y = df["koi_disposition"].map({"FALSE POSITIVE":0,"CANDIDATE":1,"CONFIRMED":2,"REFUTED":0}).to_numpy()
+
+# Train-test split
+x_train, x_test, y_train, y_test = train_test_split(
+    X, y, test_size=1/3, shuffle=True, random_state=91, stratify=y
+)
+
+# Define Models
+rf = RandomForestClassifier(n_estimators=1000,max_depth=None,random_state=542,class_weight="balanced")
+xgb = XGBClassifier(n_estimators=1000,max_depth=None,learning_rate=0.5,random_state=9)
+
+# Define estimators list for stacking
+estimators = [
+    ("rf",rf),
+    ("xgb",xgb)
+]
+
+# Define final estimator for stacking
+final_estimator = LogisticRegression(
+    random_state=891,class_weight="balanced",C=0.1,penalty="l2",solver="saga",max_iter=5000
+)
+
+# Stacking
+mv = StackingClassifier(
+    estimators=estimators,final_estimator=final_estimator,
+    cv=5,passthrough=True,n_jobs=-1
+)
+
+# Pipeline
+pipe_mv = Pipeline([
+  ("impute",SimpleImputer(strategy="mean")),
+  ("scale",StandardScaler()),
+  ("smote",SMOTE()),
+  ("model",mv)
+])
+
+print("Starting model training. It will take some time, sit tight......")
+t1 = time.time()
+pipe_mv.fit(x_train,y_train)
+t2 = time.time()
+print("Model trained successfully")
+minutes,seconds = np.divmod(t2-t1,60)
+print(f"Time Elapsed: {minutes} M {seconds:.2f} S")
+
+# Dumping the model in pickle files
+joblib.dump(pipe_mv,"models/pipe.pkl")
+joblib.dump(column_name,"models/column_names.pkl")
\ No newline at end of file

From 8a8e330c1f4ceda404750154f91e225057095a4e Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:29:48 +0600
Subject: [PATCH 04/13] Upload final version of research.ipynb

---
 research.ipynb | 711 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 711 insertions(+)
 create mode 100644 research.ipynb

diff --git a/research.ipynb b/research.ipynb
new file mode 100644
index 0000000..6f29b44
--- /dev/null
+++ b/research.ipynb
@@ -0,0 +1,711 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "4424f511",
+   "metadata": {},
+   "source": [
+    "# Exoplanet Classifier\n",
+    "Welcome to my forked version of The Exoplanet Classifier. This project was developed with my teammates from Ontohin 4b for the NASA Space Apps Challenge 2025.\n",
+    "\n",
+    "I have used this notebook as a sandbox to test out different approaches to see how we can yield the maximum predictive performance. You will also find some interesting plots too."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9dead9cb",
+   "metadata": {},
+   "source": [
+    "## Importing the libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 55,
+   "id": "37dd9f00",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split, RandomizedSearchCV, GridSearchCV,learning_curve\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.metrics import classification_report\n",
+    "\n",
+    "from sklearn.ensemble import RandomForestClassifier,VotingClassifier,StackingClassifier\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.svm import SVC\n",
+    "from xgboost import XGBClassifier\n",
+    "from lightgbm import LGBMClassifier\n",
+    "\n",
+    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n",
+    "from sklearn.decomposition import PCA\n",
+    "\n",
+    "from imblearn.over_sampling import SMOTE\n",
+    "from imblearn.pipeline import Pipeline\n",
+    "from imblearn.combine import SMOTETomek\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "import time\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import joblib"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "36860f5f",
+   "metadata": {},
+   "source": [
+    "## Importing and cleaning Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "a0777e94",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loading and processing 1st Dataset (NASA Kepler Objects of Interest)\n",
+    "df_raw = pd.read_csv(\"data/kepler_data.csv\", comment=\"#\")\n",
+    "\n",
+    "feature_list = [\"koi_disposition\",\"koi_period\",\"koi_time0bk\",\n",
+    " \"koi_depth\",\"koi_prad\",\"koi_sma\",\"koi_incl\",\"koi_teq\",\"koi_insol\",\n",
+    " \"koi_impact\",\"koi_ror\",\"koi_srho\",\"koi_dor\",\"koi_num_transits\"\n",
+    "]\n",
+    "\n",
+    "df_selected = df_raw[feature_list]\n",
+    "\n",
+    "df_1 = df_selected.copy()\n",
+    "\n",
+    "# Loading and processing 2nd dataset (NASA K2 Objects of Interest)\n",
+    "df_2 = pd.read_csv(\"data/k2_data.csv\",comment=\"#\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2ec57b1b",
+   "metadata": {},
+   "source": [
+    "Feature Engineering to construct number of transits in K2 Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "59bebfeb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "## Feature Engineering missing column in K2 (koi_num_transits) \n",
+    "\n",
+    "# Campaign dates dictionary (BJD)\n",
+    "campaign_dates = {\n",
+    "    0: (2456725.0, 2456805.0),\n",
+    "    1: (2456808.0, 2456891.0),\n",
+    "\n",
+    "    3: (2456976.0, 2457064.0),\n",
+    "    4: (2457065.0, 2457159.0),\n",
+    "    5: (2457159.0, 2457246.0),\n",
+    "    6: (2457250.0, 2457338.0),\n",
+    "    7: (2457339.0, 2457420.0),\n",
+    "    8: (2457421.0, 2457530.0),\n",
+    "    9: (2457504.0, 2457579.0),\n",
+    "    10: (2457577.0, 2457653.0),\n",
+    "    11: (2457657.0, 2457732.0),\n",
+    "    12: (2457731.0, 2457819.0),\n",
+    "    13: (2457820.0, 2457900.0),\n",
+    "    14: (2457898.0, 2457942.0),\n",
+    "    15: (2457941.0, 2458022.0),\n",
+    "    16: (2458020.0, 2458074.0),\n",
+    "    17: (2458074.0, 2458176.0),\n",
+    "    18: (2458151.0, 2458201.0),\n",
+    "    19: (2458232.0, 2458348.0)\n",
+    "}\n",
+    "\n",
+    "def get_window(camps):\n",
+    "    if pd.isna(camps) or not camps:\n",
+    "        return np.nan, np.nan\n",
+    "    \n",
+    "    camps = str(camps).split(',') if isinstance(camps, str) else camps\n",
+    "    \n",
+    "    # Filter valid campaign numbers and get start/end times\n",
+    "    starts = []\n",
+    "    ends = []\n",
+    "    for c in camps:\n",
+    "        try:\n",
+    "            camp_num = int(c.strip())\n",
+    "            if camp_num in campaign_dates:\n",
+    "                start, end = campaign_dates[camp_num]\n",
+    "                starts.append(start)\n",
+    "                ends.append(end)\n",
+    "        except (ValueError, KeyError):\n",
+    "            continue  \n",
+    "    \n",
+    "    return (min(starts) if starts else np.nan, max(ends) if ends else np.nan)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "c8a88b17",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_2['campaigns'] = df_2['k2_campaigns']\n",
+    "df_2[['obs_start_bjd', 'obs_end_bjd']] = df_2['campaigns'].apply(lambda x: pd.Series(get_window(x)))\n",
+    "\n",
+    "# For transit counting (as before)\n",
+    "df_2['n_min'] = np.ceil((df_2['obs_start_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])\n",
+    "df_2['n_max'] = np.floor((df_2['obs_end_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])\n",
+    "df_2['num_transits'] = (df_2['n_max'] - df_2['n_min'] + 1).clip(lower=0)\n",
+    "df_2 = df_2[[\"disposition\",\"pl_orbper\",\"pl_tranmid\",\"pl_trandep\",\n",
+    "\"pl_rade\",\"pl_orbsmax\",\"pl_orbincl\",\"pl_eqt\",\"pl_insol\",\"pl_imppar\",\"pl_ratror\",\"pl_dens\",\n",
+    "\"pl_ratdor\",\"num_transits\"]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30f37767",
+   "metadata": {},
+   "source": [
+    "Concatenating df_1 and df_2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5e2e3b89",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(13568, 14)\n"
+     ]
+    }
+   ],
+   "source": [
+    "mapping = {\"disposition\":\"koi_disposition\",\"pl_orbper\":\"koi_period\",\"pl_tranmid\":\"koi_time0bk\",\n",
+    "           \"pl_trandep\":\"koi_depth\",\"pl_rade\":\"koi_prad\",\"pl_orbsmax\":\"koi_sma\",\n",
+    "           \"pl_orbincl\":\"koi_incl\",\"pl_eqt\":\"koi_teq\",\"pl_insol\":\"koi_insol\",\"pl_imppar\":\"koi_impact\",\n",
+    "           \"pl_ratror\":\"koi_ror\",\"pl_dens\":\"koi_srho\",\"pl_ratdor\":\"koi_dor\",\"num_transits\":\"koi_num_transits\"\n",
+    "           }\n",
+    "df_2 = df_2.rename(columns=mapping)\n",
+    "\n",
+    "df = pd.concat([df_1,df_2])\n",
+    "print(df.shape)               # Output: (13568, 14)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "2f7f0c9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Input-output separation\n",
+    "X = df.iloc[:,1:].to_numpy()\n",
+    "y = df[\"koi_disposition\"].map({\"FALSE POSITIVE\":0,\"CANDIDATE\":1,\"CONFIRMED\":2,\"REFUTED\":0}).to_numpy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7e8f588",
+   "metadata": {},
+   "source": [
+    "## ML Tasks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f1867cb",
+   "metadata": {},
+   "source": [
+    "Train-test split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "077969ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Train-test split\n",
+    "x_train, x_test, y_train, y_test = train_test_split(\n",
+    "    X, y, test_size=1/3, shuffle=True, random_state=91, stratify=y\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "296c37a0",
+   "metadata": {},
+   "source": [
+    "### **Trial - 01**: Trying out with different learners\n",
+    "In this part, I have performed a **GridSearchCV** on multiple classifier algorithms (**RandomForest** and **XGBoost**) to find the best hyperparameter configuration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "ca79b349",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define Models\n",
+    "rf_model_1 = RandomForestClassifier(random_state=93)\n",
+    "xgb_model_1 = XGBClassifier(random_state = 94)\n",
+    "\n",
+    "# Dimensionality Reduction\n",
+    "pca_1 = PCA(random_state=81)\n",
+    "lda_1 = LDA(n_components=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "5b70a030",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pipe_1 = Pipeline([\n",
+    "  (\"impute\",SimpleImputer(strategy=\"median\")),\n",
+    "  (\"scale\",StandardScaler()),\n",
+    "  (\"smote\",SMOTE(random_state=11)),\n",
+    "  (\"dimen\",pca_1),\n",
+    "  (\"model\",xgb_model_1)\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "13aa6740",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "param_grid = [\n",
+    "  { # XGBClassifier, PCA On\n",
+    "    \"model\":[xgb_model_1],\"model__n_estimators\":[500,1000],\n",
+    "    \"model__max_depth\": [10,16,None],\"model__learning_rate\": [0.05,0.1],\n",
+    "    \"dimen\": [pca_1], \"dimen__n_components\": [0.90,0.95]\n",
+    "  },\n",
+    "  { # XGBClassifier, PCA On, SMOTE Off\n",
+    "    \"model\":[xgb_model_1],\"model__n_estimators\":[500,1000],\n",
+    "    \"model__max_depth\": [10,16,None],\"model__learning_rate\": [0.05,0.1],\n",
+    "    \"dimen\": [lda_1], \"smote\":[\"passthrough\"]\n",
+    "  },\n",
+    "  { # RandomForestClassifier, PCA On\n",
+    "    \"model\": [rf_model_1],\"model__n_estimators\":[500,1000], \n",
+    "    \"model__max_depth\": [10,16,None], \"dimen\": [pca_1], \n",
+    "    \"dimen__n_components\": [0.90,0.95]\n",
+    "  },\n",
+    "  { # RandomForestClassifier, LDA On\n",
+    "    \"model\": [rf_model_1], \"model__n_estimators\": [500,1000], \n",
+    "    \"model__max_depth\": [10,16,None], \"dimen\": [lda_1]\n",
+    "  }\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "083032ca",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best Score = 0.6719750304142318\n",
+      "Best Configuration = {'dimen': PCA(random_state=81), 'dimen__n_components': 0.95, 'model': RandomForestClassifier(random_state=93), 'model__max_depth': 16, 'model__n_estimators': 500}\n"
+     ]
+    }
+   ],
+   "source": [
+    "rscv_1 = GridSearchCV(\n",
+    "  estimator=pipe_1,param_grid=param_grid,refit=True,cv=4,verbose=1,n_jobs=-1,\n",
+    ")\n",
+    "\n",
+    "rscv_1.fit(x_train,y_train)\n",
+    "\n",
+    "config_1 = rscv_1.best_params_\n",
+    "score_1 = rscv_1.best_score_\n",
+    "estimator = rscv_1.best_estimator_\n",
+    "print(f\"Best Score = {score_1}\")\n",
+    "print(f\"Best Configuration = {config_1}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "id": "7b12e8a7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.80      0.75      0.77      1718\n",
+      "           1       0.48      0.47      0.47      1118\n",
+      "           2       0.69      0.73      0.71      1687\n",
+      "\n",
+      "    accuracy                           0.68      4523\n",
+      "   macro avg       0.65      0.65      0.65      4523\n",
+      "weighted avg       0.68      0.68      0.68      4523\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "y_ture = y_test \n",
+    "y_pred = rscv_1.predict(x_test)\n",
+    "print(classification_report(y_ture,y_pred))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91fee85a",
+   "metadata": {},
+   "source": [
+    "### **Trial - 02**: Stacking fine-tuned classifiers \n",
+    "In this trial, I have fine-tuned a RandomForest and a XGBoost classifiers. Then, I stacked those two using **stacking** ensemble technique. This should generate a better generalization result.\n",
+    "\n",
+    "**NOTE**: I have kept the max_depth for both of the models None because it actually generates a higher performace. I tested it when I was working with this notebook for the first time. The GridSearchCV has actually failed to fit the configuration where max_dpeth is None. After some internet search, I found out that GridSearchCV doesn't keep None as it is. So, it did not capture performance gain when the max_depth was None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "568c9c50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define Models\n",
+    "rf = RandomForestClassifier(n_estimators=500,max_depth=None,random_state=542,class_weight=\"balanced\")\n",
+    "xgb = XGBClassifier(n_estimators=500,max_depth=None,learning_rate=0.05,random_state=9)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "38faed81",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# List of estimators\n",
+    "estimators = [\n",
+    "    (\"rf\",rf),\n",
+    "    (\"xgb\",xgb)\n",
+    "]\n",
+    "\n",
+    "# Final estimator for stacking\n",
+    "final_estimator = LogisticRegression(random_state=891,class_weight=\"balanced\",C=1,penalty=\"l2\",solver=\"lbfgs\")\n",
+    "\n",
+    "# Stacking using scikit-learn's implementation\n",
+    "mv = StackingClassifier(\n",
+    "    estimators=estimators,final_estimator=final_estimator,\n",
+    "    cv=5,passthrough=True,verbose=1\n",
+    ")\n",
+    "\n",
+    "pipe_mv = Pipeline([\n",
+    "  (\"impute\",SimpleImputer(strategy=\"mean\")),\n",
+    "  (\"scale\",StandardScaler()),\n",
+    "  (\"smote\",SMOTE()),\n",
+    "  (\"model\",mv)\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "07cb100f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.2s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.1s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.2s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.9s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.0s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   20.9s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.7s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.4s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   20.9s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.0s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   45.3s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   45.0s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.2s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.1s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.9s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   45.7s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.0s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.0s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   45.2s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   44.9s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   20.8s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.0s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   45.9s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   45.4s finished\n",
+      "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n",
+      "[Parallel(n_jobs=-1)]: Using backend ThreadingBackend with 8 concurrent workers.\n",
+      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:    4.1s remaining:    6.1s\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:    4.2s finished\n",
+      "[Parallel(n_jobs=-1)]: Done   2 out of   5 | elapsed:   21.0s remaining:   31.5s\n",
+      "[Parallel(n_jobs=-1)]: Done   5 out of   5 | elapsed:   21.2s finished\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Best config\n",
+      "{'model__final_estimator__solver': 'saga', 'model__final_estimator__penalty': 'l2', 'model__final_estimator__max_iter': 5000, 'model__final_estimator__C': 0.1}\n",
+      "Best score = 0.7417357656163626\n"
+     ]
+    }
+   ],
+   "source": [
+    "param_grid = [\n",
+    "  {\n",
+    "    \"model__final_estimator__C\": [0.1,1,10], \"model__final_estimator__penalty\": [\"l2\"],\n",
+    "    \"model__final_estimator__solver\": [\"lbfgs\",\"saga\"],\"model__final_estimator__max_iter\": [5000]\n",
+    "  }\n",
+    "]\n",
+    "rscv = RandomizedSearchCV(pipe_mv,param_grid,n_iter=4,cv=3,refit=True,n_jobs=2,random_state=85)\n",
+    "rscv.fit(x_train,y_train)\n",
+    "print(f\"Best config\\n{rscv.best_params_}\")\n",
+    "print(f\"Best score = {rscv.best_score_}\")\n",
+    "estimator = rscv.best_estimator_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "967f3010",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "              precision    recall  f1-score   support\n",
+      "\n",
+      "           0       0.82      0.81      0.81      1718\n",
+      "           1       0.56      0.55      0.56      1118\n",
+      "           2       0.79      0.80      0.80      1687\n",
+      "\n",
+      "    accuracy                           0.75      4523\n",
+      "   macro avg       0.72      0.72      0.72      4523\n",
+      "weighted avg       0.75      0.75      0.75      4523\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "y_true = y_test\n",
+    "y_pred = rscv.predict(x_test)\n",
+    "print(classification_report(y_true,y_pred))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b1f82880",
+   "metadata": {},
+   "source": [
+    "As we can see, we have got 0.75 overall accuracy. Unfortunately, we could not improve it much from the original version which we crafted during the hackathon. We have achieved a bit higher recall for class 1. But, it is still not a huge win. \n",
+    "\n",
+    "However, it is a drastic improvement from **Trial-01**. This indirectly prooves that GridSearchCV failed to test with `max_depth=None`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "13890590",
+   "metadata": {},
+   "source": [
+    "## Visualization"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0886fb1b",
+   "metadata": {},
+   "source": [
+    "Plotting **Correlational Heatmap** of the original dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "id": "cce8475d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(12,8))\n",
+    "cor = df.iloc[:,1:].corr()\n",
+    "sns.heatmap(cor,cmap=\"icefire\",fmt=\".2f\",annot=True)\n",
+    "plt.title(\"Correlational Heatmap of the feature columns\", fontdict={\"fontsize\":15})\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7ff5bc57",
+   "metadata": {},
+   "source": [
+    "This heatmap clearly shows **high multicollinearity**, especially between `koi_ror` and `koi_impact` (0.99) and `koi_period` and `koi_sma` (0.87)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db0e7120",
+   "metadata": {},
+   "source": [
+    "Plotting **Learning Curve**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "21d0418e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_sizes, train_sc, val_sc = learning_curve(\n",
+    "  estimator,x_train,y_train,train_sizes=np.linspace(0.1,1.0,10),cv=5,n_jobs=-1,shuffle=True,random_state=59\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "id": "0ea4f14a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(10,6))\n",
+    "\n",
+    "train_mean = np.mean(train_sc,axis=1)\n",
+    "train_std = np.std(train_sc,axis=1)\n",
+    "val_mean = np.mean(val_sc,axis=1)\n",
+    "val_std = np.std(val_sc,axis=1)\n",
+    "\n",
+    "plt.plot(\n",
+    "  train_sizes,train_mean, color=\"red\", marker=\"v\", markersize=5, label=\"Training Mean\"\n",
+    ")\n",
+    "\n",
+    "plt.fill_between(\n",
+    "  train_sizes, train_mean-train_std, train_mean+train_std, color=\"red\",alpha=0.3\n",
+    ")\n",
+    "\n",
+    "plt.plot(\n",
+    "  train_sizes,val_mean, color=\"orange\", marker=\"s\", markersize=5, label=\"Validation Mean\"\n",
+    ")\n",
+    "\n",
+    "plt.fill_between(\n",
+    "  train_sizes, val_mean-val_std, train_mean+val_std, color=\"orange\",alpha=0.3\n",
+    ")\n",
+    "\n",
+    "plt.xlabel(\"Training Size\", fontdict={\"fontsize\":14})\n",
+    "plt.ylabel(\"Accuracy\",fontdict={\"fontsize\":14})\n",
+    "plt.title(\"Learning Curve\", fontdict={\"fontsize\":14})\n",
+    "plt.ylim((0.4,1.1))\n",
+    "plt.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.grid()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3d434fdf",
+   "metadata": {},
+   "source": [
+    "Well, the model is **overfitting** because it is **too complex** for the given problem and data. Adding more training data (by extending the x-axis) is unlikely to help significantly, as the validation accuracy has already flattened out."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "010ecb7b",
+   "metadata": {},
+   "source": [
+    "I have tried everything I could to make it robust. But, I think this data is just too much complex for classification even with complex techniques and algorithms. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a543cd94",
+   "metadata": {},
+   "source": [
+    "## Summary"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c41dc50b",
+   "metadata": {},
+   "source": [
+    "The biggest win of the entire fork is that I have initiated a 100 times more **standard** and **robust** way to find out the best possible performance. I have tested with Grid and Randomized searches for tuning the hyperparameters as much as possible, which is paired with ensemble techniques like **VotingClassifier** and **Stacking**. Furthermore, I tried using the multiple times Kaggle-winning algorithm, the **XGBoost** implementation of **Gradient Boosting**. \n",
+    "\n",
+    "However, the data was still too much complex for classification. If anyone has any idea, I would love to hear it!\n",
+    "\n",
+    "\n",
+    "Thanks for giving this notebook a look ! I hope you like it."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "JupyterFix (Py3.13)",
+   "language": "python",
+   "name": "jupyterfix"
+  },
+  "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.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From 2fd9c9a702d63152110fdfba3b2ca22d50b074ca Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:30:05 +0600
Subject: [PATCH 05/13] Update flask app  code

---
 app.py | 64 ++++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 44 insertions(+), 20 deletions(-)

diff --git a/app.py b/app.py
index 98e0199..ef717b3 100644
--- a/app.py
+++ b/app.py
@@ -1,34 +1,58 @@
-from flask import render_template,request,jsonify,Flask
+from flask import Flask, render_template, request, jsonify
 import numpy as np
 import joblib
+import pandas as pd
 
-model = joblib.load("model.pkl")
-scaler = joblib.load("scaler.pkl")
+pipe = joblib.load("models/pipe.pkl")          # sklearn Pipeline (scaler + model)
+column_names = joblib.load("models/column_names.pkl")   # list of feature names
 
-reverse_mapping = {0:"FALSE POSITIVE",1:"CANDIDATE",2:"CONFIRMED"}
+reverse_mapping = {0: "FALSE POSITIVE", 1: "CANDIDATE", 2: "CONFIRMED"}
 
 app = Flask(__name__)
 
 @app.route("/")
 def home():
-  return render_template("index.html")
-
-@app.route("/predict",methods=["POST"])
-def predict():
-  try:
-    data = request.json["features"]
-    arr = np.array(data).reshape(1,-1)
-    arr_scaled = scaler.transform(arr)
-    pred = model.predict(arr_scaled)[0]
-    proba_pred = model.predict_proba(arr_scaled)[0]
-    proba_dict = {reverse_mapping[i]: round(p,3) for i,p in enumerate(proba_pred)}
-    return jsonify({"prediction":reverse_mapping[pred],"probabilities":proba_dict})
-  except Exception as e:
-    return jsonify({"error":e})
+    return render_template("index.html")
 
 @app.route("/about")
 def about():
-  return render_template("about.html")
+    return render_template("about.html")
+
+@app.route("/predict", methods=["POST"])
+def predict():
+    try:
+        raw_features = [
+            request.json["orbital-period"],
+            request.json["transit-epoch"],
+            request.json["transit-depth"],
+            request.json["planet-radius"],
+            request.json["semi-major-axis"],
+            request.json["inclination"],
+            request.json["equilibrium-temp"],
+            request.json["insolation-flux"],
+            request.json["impact-parameter"],
+            request.json["radius-ratio"],
+            request.json["stellar-density"],
+            request.json["star-distance"],
+            request.json["num-transits"],
+        ]
+        
+        df = pd.DataFrame([raw_features], columns=column_names)
+
+        pred = int(pipe.predict(df)[0])
+        proba = pipe.predict_proba(df)[0]
+
+        proba_dict = {
+            reverse_mapping[i]: round(p, 3) for i, p in enumerate(proba)
+        }
+
+        return jsonify(
+            {"prediction": reverse_mapping[pred], "probabilities": proba_dict}
+        )
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+
 
 if __name__ == "__main__":
-  app.run(debug=True)
\ No newline at end of file
+    app.run(debug=True)
\ No newline at end of file

From 909008a9066509e08fd03f9e42e6c0d69f49711d Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:30:33 +0600
Subject: [PATCH 06/13] Update index.html to protect integration

---
 templates/index.html | 688 ++++++++++++++-----------------------------
 1 file changed, 225 insertions(+), 463 deletions(-)

diff --git a/templates/index.html b/templates/index.html
index e88980b..68241ec 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -4,12 +4,15 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-
     <title>Exoplanet Classifier™</title>
+
     <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/7.0.1/css/all.min.css"
+
+    <link rel="stylesheet"
+        href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/7.0.1/css/all.min.css"
         integrity="sha512-2SwdPD6INVrV/lHTZbO2nodKhrnDdJK9/kg2XD1r9uGqPo1cUbujc+IYdlYdEErWNu69gVcYgdxlmVmzTWnetw=="
         crossorigin="anonymous" referrerpolicy="no-referrer" />
+
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link
@@ -24,7 +27,7 @@
                 src="{{ url_for('static', filename='materials/32247a32f95f2504404c78a8df9ed849.png') }}"
                 alt="error loading image">
             <div class="relative min-w-[100px] flex items-center justify-center ">
-                <h1 id="nav-text" class=" site-title relative text-4xl font-bold text-sky-400">
+                <h1 id="nav-text" class="site-title relative text-4xl font-bold text-sky-400">
                     Int. Space Apps Challenge
                     <span id="hanger" class="absolute top-10 right-0 text-sm text-white">
                         Presented by Ontohin 4b
@@ -35,11 +38,13 @@ <h1 id="nav-text" class=" site-title relative text-4xl font-bold text-sky-400">
         <a href="{{ url_for('about') }}" class="text-2xl font-bold text-sky-400">Learn more</a>
     </header>
 
-    <main class="bg-[#141414] w-full h-[200vw - 150px] ">
+    <main class="bg-[#141414] w-full h-[200vw - 150px]">
+        <!-- HERO SECTION -->
         <div id="hero-div" class="w-full h-[700px] flex items-center justify-center bg-[#141414]">
             <div id="image-container" class="w-[800px] h-[700px] flex items-center justify-center">
                 <img class="mask-r-from-80% mask-t-from-80% mask-b-from-80% mask-l-from-80% w-[100%]"
-                    src="{{ url_for('static', filename='materials/d821657540b6765c2d915b547bfce9c5 (1).jpg') }}" alt="">
+                    src="{{ url_for('static', filename='materials/d821657540b6765c2d915b547bfce9c5 (1).jpg') }}"
+                    alt="">
             </div>
             <div id="text-container" class="w-[50%]">
                 <h3 id="welcome-text" class="text-xl text-white ">Welcome, To The</h3>
@@ -50,7 +55,8 @@ <h1 id="hero" class="text-5xl font-bold text-white ">Exoplanet-Classifier</h1>
                     will classify it under 3 classes:
                     Confirmed planet, Planetary Candidate or False Positive.
                 </p>
-                <button id="animated-btn" class="px-12 rounded-md relative font-semibold hover:text-white">
+                <button id="animated-btn"
+                    class="px-12 rounded-md relative font-semibold hover:text-white">
                     Get Started <i class="fa-regular fa-circle-right"></i>
                 </button>
             </div>
@@ -59,8 +65,9 @@ <h1 id="hero" class="text-5xl font-bold text-white ">Exoplanet-Classifier</h1>
         <!-- FORM SECTION -->
         <div id="form-section"
             class="w-full min-h-screen border-t flex items-center justify-center border-white rounded-[100px]">
-            <div id="wrapper" class="w-[50%] rounded-[50px] h-[70%] bg-[#141414] flex flex-col">
-                <div id="container-head" class=" px-12 pt-12 flex justify-between">
+            <div id="wrapper"
+                class="w-[50%] rounded-[50px] h-[70%] bg-[#141414] flex flex-col">
+                <div id="container-head" class="px-12 pt-12 flex justify-between">
                     <h1 id="card-head" class="text-white font-bold text-3xl leading-[40px]">
                         The <br><span id="exo" class="text-5xl">Exoplanet</span><br><span id="classifier"
                             class="text-6xl text-sky-400">Classifier</span>
@@ -69,9 +76,11 @@ <h1 id="card-head" class="text-white font-bold text-3xl leading-[40px]">
                 </div>
 
                 <div id="idk" class="relative flex-1 flex justify-center items-center px-7">
-                    <p class="form-label top-[-25px] right-16 absolute text-white text-md font-semibold">Enter the
-                        details</p>
+                    <p class="form-label top-[-25px] right-16 absolute text-white text-md font-semibold">
+                        Enter the details</p>
+
                     <form id="predictForm" class="form-grid w-[95%] pt-10 pb-10">
+                        <!-- ==== INPUTS (same IDs as before) ==== -->
                         <div class="input-wrapper">
                             <input type="number" step="any" placeholder=" " id="orbital-period" required>
                             <label for="orbital-period">Orbital Period [in days]</label>
@@ -132,14 +141,13 @@ <h1 id="card-head" class="text-white font-bold text-3xl leading-[40px]">
                             <label for="star-distance">Planet-Star Distance [R★ stellar radii]</label>
                         </div>
 
-                        <!-- Last row -->
                         <div class="input-wrapper wide">
                             <input type="number" step="any" id="num-transits" placeholder=" " required>
                             <label for="num-transits">Number of Transits</label>
                         </div>
 
                         <button id="animated-btn" type="submit" form="predictForm"
-                            class=" px-8 z-30 py-4 outline-none border-none rounded-md relative hover:text-white font-semibold">
+                            class="px-8 z-30 py-4 outline-none border-none rounded-md relative hover:text-white font-semibold">
                             Predict <i class="fa-regular fa-circle-right"></i>
                         </button>
                     </form>
@@ -147,55 +155,45 @@ <h1 id="card-head" class="text-white font-bold text-3xl leading-[40px]">
             </div>
         </div>
 
-        <!-- Popup Modal -->
-        <div id="resultModal" class="hidden fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
-            <div class="bg-white rounded-lg shadow-lg p-6 w-[400px] relative">
-                <!-- Close Button -->
+        <!-- RESULT MODAL -->
+        <div id="resultModal"
+            class="hidden fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+            <div class="bg-white rounded-lg shadow-lg p-6 w-[420px] relative">
                 <button id="closeModal"
                     class="absolute top-4 right-4 text-gray-500 hover:text-gray-800 text-xl font-bold">&times;</button>
+
                 <h2 class="text-xl font-semibold mb-4">Classification Results</h2>
-                <div id="resultsBox" class="text-gray-700 space-y-2">
-                    <!-- Results will be injected here -->
+
+                <div id="resultsBox" class="space-y-4">
+                    <!-- Filled by JS -->
                 </div>
             </div>
         </div>
-
     </main>
 
+    <!-- ====================== STYLES ====================== -->
     <style>
+        /* ---- Global ---- */
         html,
-        body {
-            overflow-x: hidden;
-        }
-
-        * {
-            font-family: "Poppins", sans-serif;
-            ;
-        }
+        body { overflow-x: hidden; }
+        * { font-family: "Poppins", sans-serif; }
 
-        #wrapper {
-            border: 1px solid white;
-        }
-
-        a {
-            position: relative;
-        }
+        #wrapper { border: 1px solid white; }
 
+        a { position: relative; }
         a::before {
-            content: " ";
+            content: "";
             position: absolute;
             bottom: -6px;
             left: 0;
-            width: 0%;
+            width: 0;
             height: 3px;
             background: white;
-            transition: all 0.5s ease;
-        }
-
-        a:hover::before {
-            width: 100%;
+            transition: width .5s ease;
         }
+        a:hover::before { width: 100%; }
 
+        /* ---- Autofill fixes ---- */
         input:-webkit-autofill,
         input:-webkit-autofill:hover,
         input:-webkit-autofill:focus,
@@ -206,85 +204,25 @@ <h2 class="text-xl font-semibold mb-4">Classification Results</h2>
             background-color: transparent !important;
             transition: background-color 9999s ease-in-out 0s;
         }
-
         input:-webkit-autofill {
             -webkit-text-fill-color: white !important;
-            /* Make text white */
             -webkit-box-shadow: 0 0 0 1000px #141414 inset !important;
-            /* Match background */
             box-shadow: 0 0 0 1000px #141414 inset !important;
             caret-color: white !important;
-            /* Keep caret visible */
-            transition: background-color 5000s ease-in-out 0s;
-            /* Prevent flash */
-        }
-
-        input:-webkit-autofill:active {
-            color: white;
-        }
-
-        input {
-            color: white;
-            background-color: transparent;
-        }
-
-        input:hover {
-            color: white !important;
-            background-color: transparent !important;
-        }
-
-        input:-webkit-autofill,
-        input:-webkit-autofill:hover,
-        input:-webkit-autofill:focus {
-            -webkit-text-fill-color: white !important;
-            box-shadow: 0 0 0px 1000px transparent inset !important;
-            background-color: transparent !important;
-            transition: background-color 9999s ease-in-out 0s;
         }
 
-        input:-webkit-autofill:focus {
-            -webkit-text-fill-color: #00BCFF !important;
-            /* Highlight when focused */
-            -webkit-box-shadow: 0 0 0 1000px #141414 inset !important;
-        }
-
-
-        #resultsBox {
-            opacity: 0;
-            transform: translateY(20px);
-            transition: opacity 1s ease, transform 1s ease;
-        }
-
-        #resultsBox.show {
-            opacity: 1;
-            transform: translateY(0);
-        }
+        input { color: white; background: transparent; }
+        input::placeholder { color: white; }
 
+        /* ---- Form grid ---- */
         .form-grid {
             display: grid;
             grid-template-columns: repeat(3, 1fr);
             gap: 25px;
         }
+        .wide { grid-column: span 2; }
 
-        .wide {
-            grid-column: span 2;
-        }
-
-        input,
-        #animated-btn {
-            padding-left: 20px;
-            padding-right: 20px;
-            padding-top: 12px;
-            padding-bottom: 12px;
-            border: none;
-            border-radius: 8px;
-            font-size: 14px;
-        }
-
-        .input-wrapper {
-            position: relative;
-        }
-
+        .input-wrapper { position: relative; }
         .input-wrapper input {
             width: 100%;
             background: transparent;
@@ -294,409 +232,233 @@ <h2 class="text-xl font-semibold mb-4">Classification Results</h2>
             font-size: 16px;
             padding: 12px 12px 12px 0;
         }
-
         .input-wrapper label {
             position: absolute;
             left: 0;
             top: 12px;
-            color: rgb(92, 92, 92);
+            color: rgb(92,92,92);
             font-size: 13px;
             pointer-events: none;
-            transition: all 0.3s ease;
+            transition: all .3s ease;
         }
-
-        .input-wrapper input:focus+label,
-        .input-wrapper input:not(:placeholder-shown)+label {
+        .input-wrapper input:focus + label,
+        .input-wrapper input:not(:placeholder-shown) + label {
             top: -10px;
             font-size: 12px;
             color: #e2e2e2;
         }
+        .input-wrapper input:focus { border-bottom-color: #4f5258; outline: none; }
 
-        .input-wrapper input:focus {
-            border-bottom-color: #4f5258;
-            outline: none;
-        }
-
-        input::placeholder {
-            color: white;
-        }
-
+        /* ---- Animated button ---- */
         #animated-btn {
             background-color: white;
             font-size: 20px;
             font-weight: 600;
-            transition: all 0.7s ease;
+            transition: all .7s ease;
             overflow: hidden;
             z-index: 0;
-            /* create stacking context */
         }
-
         #animated-btn::after {
-            content: " ";
-            z-index: 0;
+            content: "";
             position: absolute;
-            height: 0.25rem;
-            width: 0.25rem;
+            height: .55rem;
+            width: .25rem;
             background-color: #00BCFF;
             left: 1.25rem;
             bottom: 0;
-            border-radius: 0.375rem;
+            border-radius: .375rem;
             transform: translateY(100%) scale(1);
             transition: all 1s ease;
             z-index: -1;
-            /* sit behind text */
-        }
-
-        #animated-btn:hover::after {
-            transform: translateY(0) scale(300);
-        }
-
-
-
-        /* RESPONSIVENESS FIX */
-        @media (max-width: 768px) {
-            .form-grid {
-                grid-template-columns: 1fr;
-            }
-
-            #idk {
-                padding: 0px 45px;
-            }
-
-            .wide,
-            .submit-btn {
-                grid-column: span 1;
-            }
-
-            #form-section {
-                height: 150vh;
-            }
-
-            #wrapper {
-                height: 90%;
-            }
-
         }
+        #animated-btn:hover::after { transform: translateY(0) scale(300); }
 
-        @media (max-width:1340px) {
-            #wrapper {
-                width: 80%;
-            }
-
-            .form-grid {
-                margin: auto;
-            }
-        }
-
-        @media (max-width:720px) {
-            .form-label {
-                font-size: 15px;
-                font-weight: 400;
-                margin-top: 40px;
-            }
-        }
-
-        @media (max-width:666px) {
-            #exo {
-                font-size: 30px;
-            }
-
-            #card-head {
-                font-size: 18px;
-            }
-
-            #classifier {
-                font-size: 40px;
-            }
-        }
-
-        @media (max-width:1392px) {
-            #image-container {
-                width: 650px;
-            }
+        /* ---- Result animation ---- */
+        #resultsBox {
+            opacity: 0;
+            transform: translateY(20px);
+            transition: opacity 1s ease, transform 1s ease;
         }
+        #resultsBox.show { opacity: 1; transform: translateY(0); }
 
-        @media (max-width:1300px) {
-
-            #hero {
-                font-size: 35px;
-            }
-
-            #hero-text {
-                width: 80%;
-                font-size: 15px;
-            }
-
-            #welcome-text {
-                margin-bottom: 10px;
-                font-size: 14px;
-            }
-
-            #text-container #animated-btn {
-                font-size: 16px;
-            }
+        /* ---- Progress bars (the part you missed) ---- */
+        .prob-bar {
+            height: 8px;
+            background: #e0e0e0;
+            border-radius: 4px;
+            overflow: hidden;
+            margin-top: 4px;
         }
-
-        @media (max-width:1080px) {
-            #image-container {
-                width: 450px;
-                height: 500px;
-            }
-
-            #hero-div {
-                justify-content: flex-start;
-            }
-
-            #hanger {
-                font-size: 13px;
-            }
-
-            #nav-text {
-                margin-top: 10px;
-                font-size: 30px;
-            }
+        .prob-fill {
+            height: 100%;
+            background: #00BCFF;
+            width: 0%;
+            transition: width 1.2s ease;
         }
 
-        @media (max-width:906px) {
-            #hero-div {
-                height: 900px;
-                flex-direction: column;
-            }
-
-            #text-container {
-                width: 90%;
-                text-align: center;
-            }
-
-            #image-container {
-                width: 650px;
-            }
-
-            a {
-                margin-top: 10px;
-                font-size: 18px;
-            }
-
-            #hero-text {
-                width: 100%;
-                text-align: center;
-            }
+        /* ---- Responsiveness ---- */
+        @media (max-width: 768px) {
+            .form-grid { grid-template-columns: 1fr; }
+            .wide, .submit-btn { grid-column: span 1; }
+            #form-section { height: 150vh; }
+            #wrapper { height: 90%; }
+            #idk { padding: 0 45px; }
+        }
+        @media (max-width: 1340px) { #wrapper { width: 80%; } }
+        @media (max-width: 720px) { .form-label { font-size:15px; margin-top:40px; } }
+        @media (max-width: 666px) {
+            #exo {font-size:30px;}
+            #card-head {font-size:18px;}
+            #classifier {font-size:40px;}
+        }
+        @media (max-width: 1392px) { #image-container { width:650px; } }
+        @media (max-width: 1300px) {
+            #hero {font-size:35px;}
+            #hero-text {width:80%;font-size:15px;}
+            #welcome-text {margin-bottom:10px;font-size:14px;}
+            #text-container #animated-btn {font-size:16px;}
+        }
+        @media (max-width: 1080px) {
+            #image-container {width:450px;height:500px;}
+            #hero-div {justify-content:flex-start;}
+            #hanger {font-size:13px;}
+            #nav-text {margin-top:10px;font-size:30px;}
+        }
+        @media (max-width: 906px) {
+            #hero-div {height:900px;flex-direction:column;}
+            #text-container {width:90%;text-align:center;}
+            #image-container {width:650px;}
+            a {margin-top:10px;font-size:18px;}
+            #hero-text {width:100%;text-align:center;}
         }
-
         @media (max-width: 770px) {
-            #nav-text {
-                margin-top: 5px;
-                letter-spacing: -1px;
-            }
-
-            #hanger {
-                letter-spacing: 0px;
-            }
-
-            #nasa-logo {
-                height: 35px;
-                width: 100px;
-            }
+            #nav-text {margin-top:5px;letter-spacing:-1px;}
+            #hanger {letter-spacing:0;}
+            #nasa-logo {height:35px;width:100px;}
         }
-
-        @media (max-width: 730px) {
-            #text-container {
-                width: 70%;
-            }
-        }
-
+        @media (max-width: 730px) { #text-container {width:70%;} }
         @media (max-width: 655px) {
-            .site-title {
-                font-size: 22px;
-                position: relative;
-                /* optional - shrink text size */
-            }
-
-            #circle {
-                display: none;
-            }
-
-            .site-title::before {
-
-                content: "ISAC";
-            }
-
-            .site-title span {
-                display: none;
-            }
-
-            .site-title {
-                font-weight: 700;
-            }
-
-            .site-title {
-                visibility: hidden;
-            }
-
-            .site-title::before {
-                visibility: visible;
-                display: flex;
-                top: 100px;
-                content: "ISAC";
-                color: inherit;
-            }
-
-            header {
-                padding-left: 30px;
-                padding-right: 30px;
-            }
-
-            a {
-                width: 150px;
-                margin-top: 0px;
-            }
-
-            #nav-text::before {
-                margin-top: 65px;
-            }
-        }
-
-        @media (max-width:515px) {
-            a {
-                width: 200px;
-            }
-
-            #nav-text::before {
-                margin-top: 97px;
-            }
+            .site-title {font-size:22px;}
+            #circle {display:none;}
+            .site-title::before {content:"ISAC";visibility:visible;position:absolute;top:100px;}
+            .site-title span {display:none;}
+            .site-title {visibility:hidden;}
+            header {padding-left:30px;padding-right:30px;}
+            a {width:150px;margin-top:0;}
+        }
+        @media (max-width: 515px) {
+            a {width:200px;}
+            #nav-text::before {margin-top:97px;}
         }
-
         @media (max-width: 433px) {
-            header {
-                flex-direction: column;
-            }
-
-            .site-title::before {
-
-                content: "";
-            }
-
-            .site-title {
-                font-weight: 700;
-            }
-
-            .site-title {
-                visibility: inherit;
-            }
-
-            header div {
-                flex-direction: column;
-            }
-
-            #nav-text {
-                text-align: center;
-                font-weight: 400;
-            }
-
-            header {
-                padding-top: 50px;
-            }
-
-            #image-container {
-                height: 400px;
-                padding-top: 20px;
-            }
-
-            #image-container img {
-                width: 500px;
-            }
-
-            a {
-                text-align: center;
-                margin-top: 10px;
-            }
-
-            .site-title::before {
-                display: none;
-                top: 100px;
-                content: "ISAC";
-                color: inherit;
-            }
-
-        }
-
-        @media (max-width:1115px) {
-            .input-wrapper label {
-                font-size: 10px;
-            }
-        }
-
+            header {flex-direction:column;padding-top:50px;}
+            .site-title::before {display:none;}
+            .site-title {visibility:visible;}
+            #nav-text {text-align:center;font-weight:400;}
+            #image-container {height:400px;padding-top:20px;}
+            #image-container img {width:500px;}
+            a {text-align:center;margin-top:10px;}
+        }
+        @media (max-width: 1115px) { .input-wrapper label {font-size:10px;} }
         @media (max-width: 480px) {
-            #form-section {
-                border: none;
-            }
-
-            header {
-                justify-content: center;
-                padding-top: 30px
-            }
-
-            #image-container {
-                padding-top: 0px;
-            }
-
-            #nav-text {
-                font-size: 20px;
-            }
-
-            a {
-                margin-top: 6px;
-            }
+            #form-section {border:none;}
+            header {justify-content:center;padding-top:30px;}
+            #image-container {padding-top:0;}
+            #nav-text {font-size:20px;}
+            a {margin-top:6px;}
         }
-
-        /* --- FIX for iPhone / small screens --- */
         @media (max-width: 450px) {
-
-
-            #form-section {
-                height: auto;
-                /* let it grow naturally */
-                padding: 50px 0;
-                /* add breathing space */
-                align-items: flex-start;
-                /* align to top */
-            }
-
-            #wrapper {
-                width: 90%;
-                /* full but with side space */
-                min-height: auto;
-                /* don’t force tall boxes */
-                height: auto;
-                /* adapt to content */
-                padding: 25px 20px;
-                /* internal spacing */
-                border-radius: 30px;
-                /* softer corners for mobile */
-            }
-
-            .form-grid {
-                grid-template-columns: 1fr;
-                /* single column inputs */
-                gap: 18px;
-            }
-
-            #idk {
-                padding: 10px 0;
-            }
-
-            .input-wrapper input {
-                font-size: 14px;
-            }
-
-            .input-wrapper label {
-                font-size: 12px;
-            }
+            #form-section {height:auto;padding:50px 0;align-items:flex-start;}
+            #wrapper {width:90%;min-height:auto;height:auto;padding:25px 20px;border-radius:30px;}
+            .form-grid {grid-template-columns:1fr;gap:18px;}
+            #idk {padding:10px 0;}
+            .input-wrapper input {font-size:14px;}
+            .input-wrapper label {font-size:12px;}
         }
     </style>
 
+    <!-- ====================== SCRIPTS ====================== -->
     <script src="https://cdn.jsdelivr.net/npm/locomotive-scroll@3.5.4/dist/locomotive-scroll.js"></script>
     <script src="{{ url_for('static', filename='script.js') }}"></script>
-</body>
 
-</html>
\ No newline at end of file
+    <script>
+        const form = document.getElementById('predictForm');
+        const modal = document.getElementById('resultModal');
+        const resultsBox = document.getElementById('resultsBox');
+        const closeBtn = document.getElementById('closeModal');
+
+        form.addEventListener('submit', async (e) => {
+            e.preventDefault();
+
+            const payload = {
+                "orbital-period":   parseFloat(document.getElementById('orbital-period').value),
+                "transit-epoch":    parseFloat(document.getElementById('transit-epoch').value),
+                "transit-depth":    parseFloat(document.getElementById('transit-depth').value),
+                "planet-radius":    parseFloat(document.getElementById('planet-radius').value),
+                "semi-major-axis":  parseFloat(document.getElementById('semi-major-axis').value),
+                "inclination":      parseFloat(document.getElementById('inclination').value),
+                "equilibrium-temp": parseFloat(document.getElementById('equilibrium-temp').value),
+                "insolation-flux":  parseFloat(document.getElementById('insolation-flux').value),
+                "impact-parameter": parseFloat(document.getElementById('impact-parameter').value),
+                "radius-ratio":     parseFloat(document.getElementById('radius-ratio').value),
+                "stellar-density":  parseFloat(document.getElementById('stellar-density').value),
+                "star-distance":    parseFloat(document.getElementById('star-distance').value),
+                "num-transits":     parseFloat(document.getElementById('num-transits').value),
+            };
+
+            try {
+                const resp = await fetch('/predict', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(payload)
+                });
+
+                const data = await resp.json();
+                if (data.error) throw new Error(data.error);
+
+                const barsHTML = Object.entries(data.probabilities)
+                    .sort((a, b) => b[1] - a[1]) // highest first
+                    .map(([cls, prob]) => {
+                        const pct = (prob * 100).toFixed(1);
+                        return `
+                            <div class="mb-3">
+                                <div class="flex justify-between text-sm mb-1">
+                                    <span>${cls}</span>
+                                    <span>${pct}%</span>
+                                </div>
+                                <div class="prob-bar">
+                                    <div class="prob-fill" style="width:0%"></div>
+                                </div>
+                            </div>`;
+                    }).join('');
+
+                resultsBox.innerHTML = `
+                    <p class="text-lg font-medium mb-3">Prediction: <strong>${data.prediction}</strong></p>
+                    <div class="space-y-2">${barsHTML}</div>
+                `;
+
+            
+                modal.classList.remove('hidden');
+                setTimeout(() => {
+                    resultsBox.classList.add('show');
+                    document.querySelectorAll('.prob-fill').forEach(bar => {
+                        const pct = bar.parentElement.previousElementSibling.querySelector('span:last-child').textContent;
+                        bar.style.width = pct;
+                    });
+                }, 50);
+
+            } catch (err) {
+                resultsBox.innerHTML = `<p class="text-red-600">Error: ${err.message}</p>`;
+                modal.classList.remove('hidden');
+                resultsBox.classList.add('show');
+            }
+        });
+        
+        closeBtn.addEventListener('click', () => {
+            modal.classList.add('hidden');
+            resultsBox.classList.remove('show');
+            resultsBox.innerHTML = '';
+        });
+        modal.addEventListener('click', e => { if (e.target === modal) closeBtn.click(); });
+    </script>
+</body
\ No newline at end of file

From f8004ae24dd76b26340ac0d8624b13287770946f Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:30:46 +0600
Subject: [PATCH 07/13] Update requirements.txt

---
 requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/requirements.txt b/requirements.txt
index fa878c8..a18ea4b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,3 +6,4 @@ joblib
 gunicorn
 xgboost
 imbalanced-learn
+matplotlib
\ No newline at end of file

From e728a5e5fb4965e475b727858439463862965893 Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:30:53 +0600
Subject: [PATCH 08/13] Update .gitignore

---
 .gitignore | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 287246d..4501521 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,4 +20,5 @@ scaler.pkl
 instance/
 shit/
 *.db
-.vscode/
\ No newline at end of file
+.vscode/
+*.pkl
\ No newline at end of file

From 1bead9b72e2a2a46e04bfd9142a5b912c94eea41 Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:31:05 +0600
Subject: [PATCH 09/13] Add info.txt in models

---
 models/info.txt | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 models/info.txt

diff --git a/models/info.txt b/models/info.txt
new file mode 100644
index 0000000..43ab66d
--- /dev/null
+++ b/models/info.txt
@@ -0,0 +1,2 @@
+.pkl files go here. Run fit.py  to train the train the model.
+ It will automatically create the .pkl files.
\ No newline at end of file

From aa130b8348a0c166636ca91204a1daac99dee33a Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:54:58 +0600
Subject: [PATCH 10/13] Update code structure in fit.py

---
 fit.py | 254 +++++++++++++++++++++++++++++----------------------------
 1 file changed, 128 insertions(+), 126 deletions(-)

diff --git a/fit.py b/fit.py
index 57a105f..cc68ef9 100644
--- a/fit.py
+++ b/fit.py
@@ -1,70 +1,25 @@
+import time
+import pandas as pd
+import numpy as np
+import joblib
+
 from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import StandardScaler
 from sklearn.impute import SimpleImputer
-
 from sklearn.ensemble import RandomForestClassifier, StackingClassifier
 from sklearn.linear_model import LogisticRegression
 from xgboost import XGBClassifier
-
-from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
-
 from imblearn.over_sampling import SMOTE
 from imblearn.pipeline import Pipeline
 
-import time
-import pandas as pd
-import numpy as np
-import joblib
 
-# Loading and processing 1st Dataset (NASA Kepler Objects of Interest)
-df_raw = pd.read_csv("data/kepler_data.csv", comment="#")
-
-feature_list = ["koi_disposition","koi_period","koi_time0bk",
- "koi_depth","koi_prad","koi_sma","koi_incl","koi_teq","koi_insol",
- "koi_impact","koi_ror","koi_srho","koi_dor","koi_num_transits"
-]
-
-df_selected = df_raw[feature_list]
-
-df_1 = df_selected.copy()
-
-# Loading and processing 2nd dataset (NASA K2 Objects of Interest)
-df_2 = pd.read_csv("data/k2_data.csv",comment="#")
-
-## Feature Engineering missing column in K2 (koi_num_transits) 
-# Campaign dates dictionary (BJD)
-campaign_dates = {
-    0: (2456725.0, 2456805.0),
-    1: (2456808.0, 2456891.0),
-    2: (2456893.0, 2456975.0),
-    3: (2456976.0, 2457064.0),
-    4: (2457065.0, 2457159.0),
-    5: (2457159.0, 2457246.0),
-    6: (2457250.0, 2457338.0),
-    7: (2457339.0, 2457420.0),
-    8: (2457421.0, 2457530.0),
-    9: (2457504.0, 2457579.0),
-    10: (2457577.0, 2457653.0),
-    11: (2457657.0, 2457732.0),
-    12: (2457731.0, 2457819.0),
-    13: (2457820.0, 2457900.0),
-    14: (2457898.0, 2457942.0),
-    15: (2457941.0, 2458022.0),
-    16: (2458020.0, 2458074.0),
-    17: (2458074.0, 2458176.0),
-    18: (2458151.0, 2458201.0),
-    19: (2458232.0, 2458348.0)
-}
-
-def get_window(camps):
+def get_window(camps, campaign_dates):
     if pd.isna(camps) or not camps:
         return np.nan, np.nan
-    
+
     camps = str(camps).split(',') if isinstance(camps, str) else camps
-    
-    # Filter valid campaign numbers and get start/end times
-    starts = []
-    ends = []
+    starts, ends = [], []
+
     for c in camps:
         try:
             camp_num = int(c.strip())
@@ -73,77 +28,124 @@ def get_window(camps):
                 starts.append(start)
                 ends.append(end)
         except (ValueError, KeyError):
-            continue  
-    
+            continue
+
     return (min(starts) if starts else np.nan, max(ends) if ends else np.nan)
 
-df_2['campaigns'] = df_2['k2_campaigns']
-df_2[['obs_start_bjd', 'obs_end_bjd']] = df_2['campaigns'].apply(lambda x: pd.Series(get_window(x)))
-
-# For transit counting (as before)
-df_2['n_min'] = np.ceil((df_2['obs_start_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
-df_2['n_max'] = np.floor((df_2['obs_end_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
-df_2['num_transits'] = (df_2['n_max'] - df_2['n_min'] + 1).clip(lower=0)
-df_2 = df_2[["disposition","pl_orbper","pl_tranmid","pl_trandep","pl_rade","pl_orbsmax","pl_orbincl","pl_eqt","pl_insol","pl_imppar","pl_ratror","pl_dens","pl_ratdor","num_transits"]]
-
-# Concatenating df_1 and df_2
-mapping = {"disposition":"koi_disposition","pl_orbper":"koi_period","pl_tranmid":"koi_time0bk",
-           "pl_trandep":"koi_depth","pl_rade":"koi_prad","pl_orbsmax":"koi_sma",
-           "pl_orbincl":"koi_incl","pl_eqt":"koi_teq","pl_insol":"koi_insol","pl_imppar":"koi_impact",
-           "pl_ratror":"koi_ror","pl_dens":"koi_srho","pl_ratdor":"koi_dor","num_transits":"koi_num_transits"
-           }
-df_2 = df_2.rename(columns=mapping)
-
-df = pd.concat([df_1,df_2])
-
-# Input-output separation
-X = df.iloc[:,1:]
-column_name = X.columns
-X = X.to_numpy()
-y = df["koi_disposition"].map({"FALSE POSITIVE":0,"CANDIDATE":1,"CONFIRMED":2,"REFUTED":0}).to_numpy()
-
-# Train-test split
-x_train, x_test, y_train, y_test = train_test_split(
-    X, y, test_size=1/3, shuffle=True, random_state=91, stratify=y
-)
-
-# Define Models
-rf = RandomForestClassifier(n_estimators=1000,max_depth=None,random_state=542,class_weight="balanced")
-xgb = XGBClassifier(n_estimators=1000,max_depth=None,learning_rate=0.5,random_state=9)
-
-# Define estimators list for stacking
-estimators = [
-    ("rf",rf),
-    ("xgb",xgb)
-]
-
-# Define final estimator for stacking
-final_estimator = LogisticRegression(
-    random_state=891,class_weight="balanced",C=0.1,penalty="l2",solver="saga",max_iter=5000
-)
-
-# Stacking
-mv = StackingClassifier(
-    estimators=estimators,final_estimator=final_estimator,
-    cv=5,passthrough=True,n_jobs=-1
-)
-
-# Pipeline
-pipe_mv = Pipeline([
-  ("impute",SimpleImputer(strategy="mean")),
-  ("scale",StandardScaler()),
-  ("smote",SMOTE()),
-  ("model",mv)
-])
-
-print("Starting model training. It will take some time, sit tight......")
-t1 = time.time()
-pipe_mv.fit(x_train,y_train)
-t2 = time.time()
-print("Model trained successfully")
-minutes,seconds = np.divmod(t2-t1,60)
-print(f"Time Elapsed: {minutes} M {seconds:.2f} S")
-
-# Dumping the model in pickle files
-joblib.dump(pipe_mv,"models/pipe.pkl")
-joblib.dump(column_name,"models/column_names.pkl")
\ No newline at end of file
+
+def load_and_prepare_data():
+    # Load Kepler dataset
+    df_raw = pd.read_csv("data/kepler_data.csv", comment="#")
+    feature_list = [
+        "koi_disposition", "koi_period", "koi_time0bk", "koi_depth", "koi_prad",
+        "koi_sma", "koi_incl", "koi_teq", "koi_insol", "koi_impact",
+        "koi_ror", "koi_srho", "koi_dor", "koi_num_transits"
+    ]
+    df_1 = df_raw[feature_list].copy()
+
+    # Load K2 dataset
+    df_2 = pd.read_csv("data/k2_data.csv", comment="#")
+
+    # Define campaign windows
+    campaign_dates = {
+        0: (2456725.0, 2456805.0), 1: (2456808.0, 2456891.0), 2: (2456893.0, 2456975.0),
+        3: (2456976.0, 2457064.0), 4: (2457065.0, 2457159.0), 5: (2457159.0, 2457246.0),
+        6: (2457250.0, 2457338.0), 7: (2457339.0, 2457420.0), 8: (2457421.0, 2457530.0),
+        9: (2457504.0, 2457579.0), 10: (2457577.0, 2457653.0), 11: (2457657.0, 2457732.0),
+        12: (2457731.0, 2457819.0), 13: (2457820.0, 2457900.0), 14: (2457898.0, 2457942.0),
+        15: (2457941.0, 2458022.0), 16: (2458020.0, 2458074.0), 17: (2458074.0, 2458176.0),
+        18: (2458151.0, 2458201.0), 19: (2458232.0, 2458348.0)
+    }
+
+    # Add observation window
+    df_2['campaigns'] = df_2['k2_campaigns']
+    df_2[['obs_start_bjd', 'obs_end_bjd']] = df_2['campaigns'].apply(
+        lambda x: pd.Series(get_window(x, campaign_dates))
+    )
+
+    # Transit counting
+    df_2['n_min'] = np.ceil((df_2['obs_start_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
+    df_2['n_max'] = np.floor((df_2['obs_end_bjd'] - df_2['pl_tranmid']) / df_2['pl_orbper'])
+    df_2['num_transits'] = (df_2['n_max'] - df_2['n_min'] + 1).clip(lower=0)
+
+    # Select and rename columns
+    df_2 = df_2[
+        ["disposition", "pl_orbper", "pl_tranmid", "pl_trandep", "pl_rade",
+         "pl_orbsmax", "pl_orbincl", "pl_eqt", "pl_insol", "pl_imppar",
+         "pl_ratror", "pl_dens", "pl_ratdor", "num_transits"]
+    ]
+
+    mapping = {
+        "disposition": "koi_disposition", "pl_orbper": "koi_period", "pl_tranmid": "koi_time0bk",
+        "pl_trandep": "koi_depth", "pl_rade": "koi_prad", "pl_orbsmax": "koi_sma",
+        "pl_orbincl": "koi_incl", "pl_eqt": "koi_teq", "pl_insol": "koi_insol",
+        "pl_imppar": "koi_impact", "pl_ratror": "koi_ror", "pl_dens": "koi_srho",
+        "pl_ratdor": "koi_dor", "num_transits": "koi_num_transits"
+    }
+    df_2 = df_2.rename(columns=mapping)
+
+    # Combine both datasets
+    df = pd.concat([df_1, df_2])
+
+    # Prepare input/output
+    X = df.iloc[:, 1:].to_numpy()
+    y = df["koi_disposition"].map({
+        "FALSE POSITIVE": 0, "CANDIDATE": 1, "CONFIRMED": 2, "REFUTED": 0
+    }).to_numpy()
+
+    return X, y, df.columns[1:]
+
+
+def build_pipeline():
+    rf = RandomForestClassifier(
+        n_estimators=1000, max_depth=None, random_state=542, class_weight="balanced"
+    )
+    xgb = XGBClassifier(
+        n_estimators=1000, max_depth=None, learning_rate=0.5, random_state=9
+    )
+    estimators = [("rf", rf), ("xgb", xgb)]
+
+    final_estimator = LogisticRegression(
+        random_state=891, class_weight="balanced", C=0.1,
+        penalty="l2", solver="saga", max_iter=5000
+    )
+
+    mv = StackingClassifier(
+        estimators=estimators, final_estimator=final_estimator,
+        cv=5, passthrough=True, n_jobs=-1
+    )
+
+    pipe = Pipeline([
+        ("impute", SimpleImputer(strategy="mean")),
+        ("scale", StandardScaler()),
+        ("smote", SMOTE()),
+        ("model", mv)
+    ])
+    return pipe
+
+
+def main():
+    X, y, column_name = load_and_prepare_data()
+
+    x_train, x_test, y_train, y_test = train_test_split(
+        X, y, test_size=1/3, shuffle=True, random_state=91, stratify=y
+    )
+
+    pipe_mv = build_pipeline()
+
+    print("Starting model training. It will take some time, sit tight......")
+    t1 = time.time()
+    pipe_mv.fit(x_train, y_train)
+    t2 = time.time()
+
+    print("Model trained successfully")
+    minutes, seconds = np.divmod(t2 - t1, 60)
+    print(f"Time Elapsed: {minutes:.0f} M {seconds:.2f} S")
+
+    joblib.dump(pipe_mv, "models/pipe.pkl")
+    joblib.dump(column_name, "models/column_names.pkl")
+    print("Model and column names saved successfully.")
+
+
+if __name__ == "__main__":
+    main()

From de1c574f8668c020014a4338ba0437865491d2a9 Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 17:55:21 +0600
Subject: [PATCH 11/13] Add self-heal functionality in app.py

---
 app.py | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 66 insertions(+), 5 deletions(-)

diff --git a/app.py b/app.py
index ef717b3..2aa55b7 100644
--- a/app.py
+++ b/app.py
@@ -1,13 +1,65 @@
-from flask import Flask, render_template, request, jsonify
-import numpy as np
+import os
 import joblib
 import pandas as pd
+import numpy as np
+from flask import Flask, render_template, request, jsonify
+from fit import main
 
-pipe = joblib.load("models/pipe.pkl")          # sklearn Pipeline (scaler + model)
-column_names = joblib.load("models/column_names.pkl")   # list of feature names
-
+# --- Configuration ---
+MODEL_DIR = "models"
+PIPE_PATH = os.path.join(MODEL_DIR, "pipe.pkl")
+COLUMNS_PATH = os.path.join(MODEL_DIR, "column_names.pkl")
 reverse_mapping = {0: "FALSE POSITIVE", 1: "CANDIDATE", 2: "CONFIRMED"}
 
+# --- Self-Heal Function ---
+def initialize_artifacts():
+    """
+    Checks if model artifacts exist. If not, runs the training script.
+    """
+    # 1. Ensure the model directory exists
+    os.makedirs(MODEL_DIR, exist_ok=True)
+    
+    # 2. Check for missing files
+    pipe_exists = os.path.exists(PIPE_PATH)
+    columns_exists = os.path.exists(COLUMNS_PATH)
+    
+    if not pipe_exists or not columns_exists:
+        print("--- MODEL ARTIFACTS MISSING ---")
+        if not pipe_exists:
+            print(f"Missing: {PIPE_PATH}")
+        if not columns_exists:
+            print(f"Missing: {COLUMNS_PATH}")
+        
+        print("Running training routine (fit.main())... This may take a moment.")
+        try:
+            # Run the main training function from fit.py
+            main()
+            print("Training complete. Artifacts generated successfully.")
+            print("---------------------------------")
+        except Exception as e:
+            print(f"\nFATAL: Error during self-heal training: {e}")
+            print("Application cannot start without model artifacts.")
+            print("Please fix the training script (fit.py) and restart.")
+            exit(1) # Exit if training fails
+    else:
+        print("Model artifacts found. Loading...")
+
+# --- Application Startup ---
+
+# Run the self-heal check *before* loading models
+initialize_artifacts()
+
+# Load models
+try:
+    pipe = joblib.load(PIPE_PATH)
+    column_names = joblib.load(COLUMNS_PATH)
+    print("Models loaded successfully.")
+except Exception as e:
+    print(f"\nFATAL: Error loading model artifacts: {e}")
+    print("Files might be corrupt. Try deleting the 'models' directory and restarting.")
+    exit(1) # Exit if loading fails
+
+# Initialize Flask App
 app = Flask(__name__)
 
 @app.route("/")
@@ -21,6 +73,7 @@ def about():
 @app.route("/predict", methods=["POST"])
 def predict():
     try:
+        # Extract features from the JSON request
         raw_features = [
             request.json["orbital-period"],
             request.json["transit-epoch"],
@@ -37,20 +90,28 @@ def predict():
             request.json["num-transits"],
         ]
         
+        # Create DataFrame with correct column names
         df = pd.DataFrame([raw_features], columns=column_names)
 
+        # Get prediction and probabilities
         pred = int(pipe.predict(df)[0])
         proba = pipe.predict_proba(df)[0]
 
+        # Format probabilities for the response
         proba_dict = {
             reverse_mapping[i]: round(p, 3) for i, p in enumerate(proba)
         }
 
+        # Send response
         return jsonify(
             {"prediction": reverse_mapping[pred], "probabilities": proba_dict}
         )
 
+    except KeyError as e:
+        print(f"Prediction Error: Missing key in request {e}")
+        return jsonify({"error": f"Missing feature in request: {e}"}), 400
     except Exception as e:
+        print(f"Prediction Error: {e}")
         return jsonify({"error": str(e)}), 400
 
 

From 28991071833d8b27713c2faaff3382078cd12d64 Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 18:11:57 +0600
Subject: [PATCH 12/13] Update fit.py to show classification report

---
 fit.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/fit.py b/fit.py
index cc68ef9..61c0538 100644
--- a/fit.py
+++ b/fit.py
@@ -11,6 +11,7 @@
 from xgboost import XGBClassifier
 from imblearn.over_sampling import SMOTE
 from imblearn.pipeline import Pipeline
+from sklearn.metrics import classification_report
 
 
 def get_window(camps, campaign_dates):
@@ -123,6 +124,10 @@ def build_pipeline():
     ])
     return pipe
 
+def eval(y_test,x_test,estimator):
+    y_true = y_test
+    y_pred = estimator.predict(x_test)
+    return classification_report(y_true,y_pred)
 
 def main():
     X, y, column_name = load_and_prepare_data()
@@ -142,6 +147,9 @@ def main():
     minutes, seconds = np.divmod(t2 - t1, 60)
     print(f"Time Elapsed: {minutes:.0f} M {seconds:.2f} S")
 
+
+    print(eval(y_test,x_test,pipe_mv))
+
     joblib.dump(pipe_mv, "models/pipe.pkl")
     joblib.dump(column_name, "models/column_names.pkl")
     print("Model and column names saved successfully.")

From 54349cd9fc2b5a804c215643c491916a78f1dd89 Mon Sep 17 00:00:00 2001
From: Sakib Hossain <sakibhossainalif29@gmail.com>
Date: Fri, 7 Nov 2025 18:12:08 +0600
Subject: [PATCH 13/13] Update about.html

---
 templates/about.html | 186 +------------------------------------------
 1 file changed, 3 insertions(+), 183 deletions(-)

diff --git a/templates/about.html b/templates/about.html
index b7b2588..3d879bb 100644
--- a/templates/about.html
+++ b/templates/about.html
@@ -1,177 +1,3 @@
-<!-- <!DOCTYPE html>
-<html lang="en">
-
-<head>
-    <meta charset="UTF-8">
-    <title>About - Exoplanet Classifier™</title>
-
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            margin: 20px;
-            line-height: 1.6;
-            background-color: #141414;
-            color: white;
-            padding: 20px 30px;
-        }
-
-        h1,
-        h2,
-        h3 {
-            color: #00BCFF;
-        }
-
-        a {
-            color: white;
-        }
-
-        table {
-            border-collapse: collapse;
-            width: 100%;
-            margin-top: 15px;
-        }
-
-        table,
-        th,
-        td {
-            border: 1px solid #00BCFF;
-            padding: 8px;
-            text-align: left;
-        }
-
-        th {
-            color: #141414;
-            background-color: #00BCFF;
-        }
-    </style>
-</head>
-
-<body>
-    <h1>Welcome!</h1>
-
-    <p>
-        The <b>Exoplanet Classifier™</b> is a project developed by <b>Team Ontohin 4b</b>
-        for the NASA Space Apps Challenge 2025.
-    </p>
-
-    <h2>Objective</h2>
-    <p>
-        The objective of this web app is to predict new exoplanet’s status (<b>CONFIRMED</b>, <b>CANDIDATE</b>, <b>FALSE
-            POSITIVE</b>) by evaluating user-given inputs.
-    </p>
-
-    <h2>How does it work?</h2>
-    <p>
-        User inputs are sent to our model through a Flask API endpoint.
-        The model then predicts the class and returns a probability for each category.
-        We built this using <b>scikit-learn’s LogisticRegression</b> with Softmax regression,
-        which allows classification into more than two classes.
-    </p>
-
-    <h3>Possible Outputs:</h3>
-    <ul>
-        <li><b>CONFIRMED (2)</b> → Represents a confirmed exoplanet.</li>
-        <li><b>CANDIDATE (1)</b> → Not confirmed or false positive; requires further analysis.</li>
-        <li><b>FALSE POSITIVE (0)</b> → Does not represent an exoplanet.</li>
-    </ul>
-
-    <h2>User Inputs</h2>
-    <p>
-        The model is trained on 14 features from NASA’s KOI dataset.
-        To run predictions, the user must provide 13 numeric inputs.
-    </p>
-
-    <table>
-        <tr>
-            <th>Input Feature</th>
-            <th>Unit</th>
-            <th>Description</th>
-        </tr>
-        <tr>
-            <td>Orbital Period</td>
-            <td>Days</td>
-            <td>Time to complete one orbit</td>
-        </tr>
-        <tr>
-            <td>Transit Epoch</td>
-            <td>BJD - 2,454,833.0</td>
-            <td>Reference time of transit</td>
-        </tr>
-        <tr>
-            <td>Transit Depth</td>
-            <td>ppm</td>
-            <td>Brightness dip during transit</td>
-        </tr>
-        <tr>
-            <td>Planet Radius</td>
-            <td>Earth radii</td>
-            <td>Size compared to Earth</td>
-        </tr>
-        <tr>
-            <td>Semi-Major Axis</td>
-            <td>AU</td>
-            <td>Average planet-star distance</td>
-        </tr>
-        <tr>
-            <td>Inclination</td>
-            <td>Degrees</td>
-            <td>Orbit tilt relative to Earth</td>
-        </tr>
-        <tr>
-            <td>Equilibrium Temperature</td>
-            <td>K</td>
-            <td>Estimated surface temperature</td>
-        </tr>
-        <tr>
-            <td>Insolation Flux</td>
-            <td>Earth flux</td>
-            <td>Starlight received vs. Earth</td>
-        </tr>
-        <tr>
-            <td>Impact Parameter</td>
-            <td>None (dimensionless)</td>
-            <td>Transit centrality (0=center, 1=edge)</td>
-        </tr>
-        <tr>
-            <td>Planet/Star Radius Ratio</td>
-            <td>None (dimensionless)</td>
-            <td>Planet size vs. star size</td>
-        </tr>
-        <tr>
-            <td>Stellar Density</td>
-            <td>g/cm³</td>
-            <td>Average density of star</td>
-        </tr>
-        <tr>
-            <td>Planet-Star Distance</td>
-            <td>R★ (stellar radii)</td>
-            <td>Distance in stellar radii</td>
-        </tr>
-        <tr>
-            <td>Number of Transits</td>
-            <td>None (count)</td>
-            <td>Observed transit count</td>
-        </tr>
-    </table>
-
-    <h2>Things to Keep in Mind</h2>
-    <ul>
-        <li>No ML model is 100% accurate — same here.</li>
-        <li>We tested with multiple NASA datasets, but extra data added noise and overfitting.</li>
-        <li>Final model uses only the KOI dataset for best balance.</li>
-    </ul>
-
-    <p>
-        Thank you for trying out our work!
-        We hope you enjoyed exploring this concept and our attempt to solve
-        an astronomical challenge with machine learning. 🌌
-    </p>
-
-    <a class="text-white" href="/">← Back to Prediction Page</a>
-</body>
-
-</html> -->
-
 <!DOCTYPE html>
 <html lang="en">
 
@@ -251,14 +77,8 @@ <h2>How does it work?</h2>
     </p>
 
     <p>
-        We have used the widely known <b>Scikit-learn</b> library and its
-        <b>RandomForestClassifier</b> to build it from the ground up.
-        It is an ensemble model which works by creating a bunch of decision trees
-        and training them with slightly different features.
-        If you want to learn more about it, click
-        <a href="https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html"
-            target="_blank">here</a>
-        to see the official docs.
+        We have used the widely known <b>Scikit-learn</b> library to build it from the ground up.
+        More info about the ML part can be found at the <a href="https://github.com/ByteBard58/Exoplanet_Classifier/blob/main/README.md",target="_blank">README file</a> of the repository.
     </p>
 
     <p>
@@ -378,7 +198,7 @@ <h2>Things to Keep in Mind</h2>
     <p><b>Have a great day!</b></p>
 
     <p>
-        <a href="https://github.com/ByteBard58/Exoplanet-Classifier" target="_blank">
+        <a href="https://github.com/ByteBard58/Exoplanet_Classifier" target="_blank">
             Click here to visit the GitHub repository.
         </a>
     </p>