init model

config.py

@@ -0,0 +1,14 @@
+import os
+
+# Directories
+MODEL_DIR = "models"
+
+# Model File Paths
+CATBOOST_MODEL_PATH = os.path.join(MODEL_DIR, "catboost_model.cbm")
+XGB_MODEL_PATH = os.path.join(MODEL_DIR, "xgb_model.json")
+RF_MODEL_PATH = os.path.join(MODEL_DIR, "rf_model.pkl")
+
+# Model Parameters
+CATBOOST_PARAMS = {"iterations": 800, "depth": 6, "learning_rate": 0.05, "random_seed": 42, "task_type": "CPU", "verbose": 100}
+XGB_PARAMS = {"n_estimators": 800, "learning_rate": 0.05, "max_depth": 6, "tree_method": "hist", "random_state": 42}
+RF_PARAMS = {"n_estimators": 200, "max_depth": 15, "random_state": 42, "n_jobs": -1}

data_loader.py

@@ -0,0 +1,184 @@
+import pandas as pd
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from imblearn.over_sampling import SMOTE
+
+# ===========================
+#  CONFIGURATION
+# ===========================
+
+TRAIN_PATH = "~/Downloads/train_dataset_full - train_dataset_full (1).csv"
+TEST_PATH = "~/Downloads/X_test_1st (1).csv"  # Replace with actual test dataset path
+
+CATEGORICAL_COLUMNS = ["gender", "product", "campaign_id", "webpage_id"]
+TARGET_COLUMN = "is_click"
+
+FEATURE_COLUMNS = [
+    "age_level", "gender", "product", "campaign_id", "webpage_id",
+    "product_category_1", "product_category_2", "user_group_id",
+    "user_depth", "city_development_index", "var_1"
+]
+
+AGGREGATED_COLUMNS = [
+    "click_sum_age_sex_prod", "click_count_age_sex_prod",
+    "unique_campaigns_age_sex_prod", "unique_webpages_age_sex_prod",
+    "click_sum_city_age_prod", "click_count_city_age_prod",
+    "unique_campaigns_city_age_prod", "unique_webpages_city_age_prod"
+]
+
+# ===========================
+#  LOAD DATASETS
+# ===========================
+
+def load_data(train_path=TRAIN_PATH, test_path=TEST_PATH):
+    """Load train & test datasets, handling missing values."""
+    train_df = pd.read_csv(train_path)
+    test_df = pd.read_csv(test_path)
+
+    # Fill missing values
+    train_df.fillna(-1, inplace=True)
+    test_df.fillna(-1, inplace=True)
+
+    return train_df, test_df
+
+
+# ===========================
+#  FEATURE ENGINEERING: AGGREGATIONS
+# ===========================
+
+def add_aggregated_features(df, test_df):
+    """Creates aggregated features based on age, gender, and product interactions."""
+
+    # Aggregate by age & gender vs product
+    age_sex_product_agg = df.groupby(["age_level", "gender", "product"]).agg({
+        "is_click": ["sum", "count"],
+        "campaign_id": "nunique",
+        "webpage_id": "nunique"
+    }).reset_index()
+
+    # Rename columns after aggregation
+    age_sex_product_agg.columns = ["age_level", "gender", "product",
+                                   "click_sum_age_sex_prod", "click_count_age_sex_prod",
+                                   "unique_campaigns_age_sex_prod", "unique_webpages_age_sex_prod"]
+
+    # Merge into train & test datasets
+    df = df.merge(age_sex_product_agg, on=["age_level", "gender", "product"], how="left")
+    test_df = test_df.merge(age_sex_product_agg, on=["age_level", "gender", "product"], how="left")
+
+    # Aggregate by city, age, product
+    city_age_product_agg = df.groupby(["city_development_index", "age_level", "product"]).agg({
+        "is_click": ["sum", "count"],
+        "campaign_id": "nunique",
+        "webpage_id": "nunique"
+    }).reset_index()
+
+    # Rename columns
+    city_age_product_agg.columns = ["city_development_index", "age_level", "product",
+                                    "click_sum_city_age_prod", "click_count_city_age_prod",
+                                    "unique_campaigns_city_age_prod", "unique_webpages_city_age_prod"]
+
+    # Merge into train & test datasets
+    df = df.merge(city_age_product_agg, on=["city_development_index", "age_level", "product"], how="left")
+    test_df = test_df.merge(city_age_product_agg, on=["city_development_index", "age_level", "product"], how="left")
+
+    # Fill missing values after merging
+    df.fillna(0, inplace=True)
+    test_df.fillna(0, inplace=True)
+
+    return df, test_df
+
+
+# ===========================
+#  ENCODE & NORMALIZE FEATURES
+# ===========================
+
+def preprocess_data(df, test_df, categorical_columns):
+    """Encodes categorical features, normalizes numerical features, and prepares the dataset."""
+
+    label_encoders = {}
+    for col in categorical_columns:
+        le = LabelEncoder()
+        df[col] = le.fit_transform(df[col].astype(str))
+        test_df[col] = test_df[col].astype(str).map(lambda s: le.transform([s])[0] if s in le.classes_ else -1)
+        label_encoders[col] = le  # Store encoders for later use
+
+    numerical_columns = [col for col in FEATURE_COLUMNS + AGGREGATED_COLUMNS if col not in categorical_columns]
+
+    scaler = StandardScaler()
+    df[numerical_columns] = scaler.fit_transform(df[numerical_columns])
+    test_df[numerical_columns] = scaler.transform(test_df[numerical_columns])
+
+    return df, test_df, label_encoders, scaler
+
+
+# ===========================
+#  SPLIT DATA & HANDLE IMBALANCE
+# ===========================
+
+def split_and_balance_data(df, target_column):
+    """Splits data into training and validation sets, applies SMOTE to balance classes."""
+
+    X = df[FEATURE_COLUMNS + AGGREGATED_COLUMNS]
+    y = df[target_column]
+
+    # Handle class imbalance using SMOTE
+    smote = SMOTE(sampling_strategy="auto", random_state=42)
+    X_resampled, y_resampled = smote.fit_resample(X, y)
+
+    # Split into training & validation sets
+    X_train, X_val, y_train, y_val = train_test_split(
+        X_resampled, y_resampled, test_size=0.2, random_state=42, stratify=y_resampled
+    )
+
+    return X_train, X_val, y_train, y_val
+
+
+# ===========================
+#  VISUALIZE FEATURES
+# ===========================
+
+def visualize_features():
+    """Generates visualizations for aggregated features."""
+
+    df, _ = load_data()
+    df, _ = add_aggregated_features(df, df)
+
+    sns.set_style("whitegrid")
+
+    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
+
+    sns.barplot(x="age_level", y="click_sum_age_sex_prod", hue="gender",
+                data=df, ax=axes[0], palette="coolwarm")
+    axes[0].set_title("Total Clicks by Age & Gender vs Product")
+
+    sns.barplot(x="city_development_index", y="click_sum_city_age_prod", hue="age_level",
+                data=df, ax=axes[1], palette="viridis")
+    axes[1].set_title("Total Clicks by City Development Index & Age")
+
+    plt.tight_layout()
+    plt.show()
+
+
+# ===========================
+#  RUN FULL DATA PROCESSING PIPELINE
+# ===========================
+
+def load_and_process_data():
+    """Runs the full data processing pipeline and returns preprocessed training & test data."""
+
+    df, test_df = load_data()
+    df, test_df = add_aggregated_features(df, test_df)
+    df, test_df, label_encoders, scaler = preprocess_data(df, test_df, CATEGORICAL_COLUMNS)
+    X_train, X_val, y_train, y_val = split_and_balance_data(df, TARGET_COLUMN)
+
+    return X_train, X_val, y_train, y_val, test_df
+
+
+if __name__ == "__main__":
+    print("🔹 Loading and processing data...")
+    X_train, X_val, y_train, y_val, test_df = load_and_process_data()
+    print("✅ Data successfully loaded and processed!")

main.py

@@ -0,0 +1,45 @@
+import argparse
+import os
+from data_loader import load_and_process_data
+from model_trainer import train_models
+from model_manager import save_models, load_models
+from model_predictor import predict
+from config import MODEL_DIR
+## ===========================
+#  MAIN FUNCTION
+# ===========================
+
+def main(train=True, retrain=False):
+    """ Main entry point to train, retrain or predict """
+    # Create model directory if it doesn't exist
+    if not os.path.exists(MODEL_DIR):
+        os.makedirs(MODEL_DIR)
+    print("\n🚀 Loading data...")
+    X_train, X_val, y_train, y_val, test_df = load_and_process_data()
+
+    if train or retrain:
+        print("\n🚀 Training models...")
+        models = train_models(X_train, y_train)
+        save_models(models)
+
+    else:
+        print("\n🚀 Loading existing models...")
+        models = load_models()
+
+    print("\n🔍 Making predictions...")
+    predictions = predict(models, test_df)
+
+    # Save final predictions
+    predictions.to_csv("final_predictions.csv", index=False)
+    print("\n✅ Predictions saved successfully as 'final_predictions.csv'!")
+
+# ===========================
+#  COMMAND-LINE EXECUTION
+# ===========================
+if __name__ == "__main__":
+    # parser = argparse.ArgumentParser(description="Train, retrain or make predictions")
+    # parser.add_argument("--train", action="store_true", help="Train new models")
+    # parser.add_argument("--retrain", action="store_true", help="Retrain models with updated data")
+    #
+    # args = parser.parse_args()
+    main(train=True, retrain=False)

model_manager.py

@@ -0,0 +1,23 @@
+import joblib
+from catboost import CatBoostClassifier
+from xgboost import XGBClassifier
+from config import CATBOOST_MODEL_PATH, XGB_MODEL_PATH, RF_MODEL_PATH
+
+def save_models(models):
+    """ Save trained models """
+    models["CatBoost"].save_model(CATBOOST_MODEL_PATH)
+    models["XGBoost"].save_model(XGB_MODEL_PATH)
+    joblib.dump(models["RandomForest"], RF_MODEL_PATH)
+    print("✅ Models saved successfully!")
+
+def load_models():
+    """ Load trained models """
+    catboost = CatBoostClassifier()
+    catboost.load_model(CATBOOST_MODEL_PATH)
+
+    xgb = XGBClassifier()
+    xgb.load_model(XGB_MODEL_PATH)
+
+    rf = joblib.load(RF_MODEL_PATH)
+
+    return {"CatBoost": catboost, "XGBoost": xgb, "RandomForest": rf}

model_predictor.py

@@ -0,0 +1,17 @@
+import numpy as np
+import pandas as pd
+
+def predict(models, X_test):
+    """ Make predictions using trained models """
+    test_predictions = {name: np.array(model.predict(X_test)).squeeze() for name, model in models.items()}
+
+    test_predictions_df = pd.DataFrame(test_predictions)
+
+    # Ensure binary values (0 or 1)
+    for col in test_predictions_df.columns:
+        test_predictions_df[col] = (test_predictions_df[col] > 0.5).astype(int)
+
+    # Apply "at least one model predicts 1" rule
+    test_predictions_df["is_click_predicted"] = test_predictions_df.max(axis=1)
+
+    return test_predictions_df

model_trainer.py

@@ -0,0 +1,35 @@
+import time
+from catboost import CatBoostClassifier
+from xgboost import XGBClassifier
+from sklearn.ensemble import RandomForestClassifier
+from config import CATBOOST_PARAMS, XGB_PARAMS, RF_PARAMS
+
+def train_models(X_train, y_train, categorical_columns):
+    """ Train and return machine learning models """
+    models = {}
+
+    # Train CatBoost
+    start_time = time.time()
+    catboost = CatBoostClassifier(**CATBOOST_PARAMS)
+    catboost.fit(X_train, y_train, cat_features=[X_train.columns.get_loc(col) for col in categorical_columns])
+    models["CatBoost"] = catboost
+    print(f"✅ CatBoost trained in {time.time() - start_time:.2f} sec")
+
+    # Train XGBoost
+    if set(y_train.unique()) <= {0, 1}:  # Ensure only valid labels exist
+        start_time = time.time()
+        xgb = XGBClassifier(**XGB_PARAMS)
+        xgb.fit(X_train, y_train)
+        models["XGBoost"] = xgb
+        print(f"✅ XGBoost trained in {time.time() - start_time:.2f} sec")
+    else:
+        print("⚠ XGBoost training skipped due to invalid labels!")
+
+    # Train RandomForest
+    start_time = time.time()
+    rf = RandomForestClassifier(**RF_PARAMS)
+    rf.fit(X_train, y_train)
+    models["RandomForest"] = rf
+    print(f"✅ RandomForest trained in {time.time() - start_time:.2f} sec")
+
+    return models

requirements.txt

@@ -0,0 +1,9 @@
+pandas
+numpy
+scikit-learn
+imbalanced-learn
+matplotlib
+seaborn
+catboost
+xgboost
+joblib