Upload 7 files

Dockerfile

@@ -0,0 +1,6 @@
+FROM python:3.9
+WORKDIR /code
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,38 @@
+from flask import Flask, render_template, request, jsonify
+import joblib
+import pandas as pd
+import numpy as np
+
+app = Flask(__name__)
+
+model = joblib.load("music_genre_classifier.pkl")
+scaler = joblib.load("scaler.pkl")
+le = joblib.load("label_encoder.pkl")
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+
+@app.route('/predict', methods = ['POST'])
+def predict():
+    data = request.get_json()
+    
+    input_df = pd.DataFrame([data])
+    
+    # Scale and Predict
+    scaled_data = scaler.transform(input_df)
+    prediction_idx = model.predict(scaled_data)[0]
+    
+    # Get probability / confidence
+    probs = model.predict_proba(scaled_data)[0]
+    confidence = np.max(probs) * 100
+    
+    genre = le.inverse_transform([prediction_idx])[0]
+    
+    return jsonify({
+        'prediction': genre,
+        'confidence': confidence
+    })
+
+if __name__ == "__main__":
+    app.run(host = "0.0.0.0", port = 7860)

label_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16794a76fdfb082780a6ff856dde9776d9a1b3e213395c3f4c446bd77f19fce9
+size 557

model.py

@@ -0,0 +1,272 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import time
+import tracemalloc
+import warnings
+import os
+warnings.filterwarnings('ignore')
+
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+from sklearn.model_selection import (train_test_split, KFold,
+                                     cross_val_score, learning_curve)
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.svm import SVC
+from sklearn.metrics import (classification_report, confusion_matrix,
+                              accuracy_score, roc_auc_score)
+import joblib
+
+# Load Dataset
+df = pd.read_csv("data/features_30_sec.csv", index_col=0)
+print(f"Dataset shape: {df.shape}")
+print(f"Class distribution:\n{df['label'].value_counts()}\n")
+
+# Preprocess Data
+le = LabelEncoder()
+y = le.fit_transform(df["label"])
+X = df.drop("label", axis=1)
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X, y, test_size=0.2, random_state=42, stratify=y
+)
+
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled  = scaler.transform(X_test)
+
+X_full = np.vstack([X_train_scaled, X_test_scaled])
+y_full = np.hstack([y_train, y_test])
+
+# Comutational Cost Measurement Function
+def measure_cost(model, X_tr, y_tr, X_te):
+    tracemalloc.start()
+    t0 = time.time()
+    model.fit(X_tr, y_tr)
+    train_time = time.time() - t0
+    _, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    t0 = time.time()
+    model.predict(X_te)
+    infer_time = (time.time() - t0) / len(X_te)
+
+    return round(train_time, 3), round(peak / 1024**2, 3), round(infer_time * 1000, 4)
+
+# Models
+models = {
+    "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
+    "Random Forest":       RandomForestClassifier(n_estimators=300, max_depth=20, random_state=42),
+    "SVM (RBF)":           SVC(kernel="rbf", C=10, gamma="scale", probability=True, random_state=42),
+}
+
+results  = {}
+cost_rows = []
+
+# Train, evaluate, and measure cost for each model
+for name, model in models.items():
+    train_time, mem_mb, infer_ms = measure_cost(model, X_train_scaled, y_train, X_test_scaled)
+    y_pred = model.predict(X_test_scaled)
+    y_prob = model.predict_proba(X_test_scaled)
+
+    acc     = accuracy_score(y_test, y_pred)
+    roc_auc = roc_auc_score(y_test, y_prob, multi_class='ovr', average='macro')
+
+    results[name] = {
+        "model":   model,
+        "y_pred":  y_pred,
+        "y_prob":  y_prob,
+        "acc":     acc,
+        "roc_auc": roc_auc,
+    }
+    cost_rows.append({
+        "Model":                name,
+        "Train Time (s)":       train_time,
+        "Peak Memory (MB)":     mem_mb,
+        "Inference/sample (ms)": infer_ms,
+    })
+
+    print(f"\n{'='*55}")
+    print(f"  {name}")
+    print(f"  Accuracy : {acc*100:.2f}%   ROC-AUC : {roc_auc:.4f}")
+    print(classification_report(y_test, y_pred, target_names=le.classes_))
+
+# K-Fold Cross Validation
+print("\n" + "="*55)
+print("  K-FOLD CROSS VALIDATION  (K = 10)")
+print("="*55)
+
+kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+for name, info in results.items():
+    cv = cross_val_score(info["model"], X_full, y_full, cv=kf, scoring="accuracy", n_jobs=-1)
+    results[name]["cv"] = cv
+    print(f"\n{name}")
+    print(f"  Fold scores : {cv.round(3)}")
+    print(f"  Mean ± Std  : {cv.mean():.4f} ± {cv.std():.4f}")
+    print(f"  Test acc    : {info['acc']:.4f}  "
+          f"({'overfit' if info['acc'] > cv.mean() + 0.05 else 'generalises well'})")
+
+# Visualizations
+os.makedirs('plots', exist_ok=True)
+
+# Heatmaps
+fig, axes = plt.subplots(1, 3, figsize=(22, 7))
+for ax, (name, info) in zip(axes, results.items()):
+    cm = confusion_matrix(y_test, info["y_pred"])
+    sns.heatmap(cm, annot=True, fmt="d", cmap="Blues",
+                xticklabels=le.classes_, yticklabels=le.classes_, ax=ax,
+                linewidths=0.5, cbar=False)
+    ax.set_title(f"{name}\nAcc: {info['acc']*100:.1f}%  ROC-AUC: {info['roc_auc']:.3f}",
+                 fontsize=11, fontweight="bold")
+    ax.set_xlabel("Predicted Label")
+    ax.set_ylabel("True Label")
+    ax.tick_params(axis="x", rotation=45)
+plt.suptitle("Confusion Matrices — All Models", fontsize=14, fontweight="bold", y=1.02)
+plt.tight_layout()
+plt.savefig("plots/confusion_matrices.png", dpi=150, bbox_inches="tight")
+plt.show()
+
+# CV Score Boxplot
+fig, ax = plt.subplots(figsize=(10, 5))
+cv_vals  = [info["cv"] for info in results.values()]
+bp = ax.boxplot(cv_vals, labels=results.keys(), patch_artist=True, widths=0.4)
+colors = ["#4e9e94", "#2a7d74", "#1a5c55"]
+for patch, color in zip(bp["boxes"], colors):
+    patch.set_facecolor(color)
+    patch.set_alpha(0.7)
+ax.set_title("K-Fold CV Score Distribution (K = 10)", fontweight="bold")
+ax.set_ylabel("Accuracy")
+ax.set_ylim(0.5, 1.0)
+ax.axhline(y=0.8, color="red", linestyle="--", alpha=0.4, label="80% threshold")
+ax.legend()
+ax.grid(axis="y", linestyle="--", alpha=0.4)
+plt.tight_layout()
+plt.savefig("plots/cv_boxplot.png", dpi=150, bbox_inches="tight")
+plt.show()
+
+# Learning Curves — all 3 models
+def plot_learning_curve(model, X, y, title):
+    train_sz, train_sc, val_sc = learning_curve(
+        model, X, y, cv=5, n_jobs=-1,
+        train_sizes=np.linspace(0.1, 1.0, 10),
+        scoring="accuracy"
+    )
+    t_mean, t_std = train_sc.mean(axis=1), train_sc.std(axis=1)
+    v_mean, v_std = val_sc.mean(axis=1),   val_sc.std(axis=1)
+
+    gap = t_mean[-1] - v_mean[-1]
+    diagnosis = ("Overfitting"  if gap > 0.08 else
+                 "Underfitting" if v_mean[-1] < 0.65 else
+                 "Generalises well")
+
+    plt.figure(figsize=(9, 5))
+    plt.plot(train_sz, t_mean, "o-", color="teal",  label="Training Score")
+    plt.fill_between(train_sz, t_mean - t_std, t_mean + t_std, alpha=0.15, color="teal")
+    plt.plot(train_sz, v_mean, "o-", color="coral", label="Validation Score")
+    plt.fill_between(train_sz, v_mean - v_std, v_mean + v_std, alpha=0.15, color="coral")
+    plt.title(f"Learning Curve — {title}\nDiagnosis: {diagnosis}", fontweight="bold")
+    plt.xlabel("Training Set Size")
+    plt.ylabel("Accuracy")
+    plt.legend(loc="lower right")
+    plt.grid(linestyle="--", alpha=0.4)
+    plt.ylim(0.3, 1.05)
+    plt.tight_layout()
+    plt.savefig(f"plots/learning_curve_{title.replace(' ','_')}.png", dpi=150, bbox_inches="tight")
+    plt.show()
+
+for name, info in results.items():
+    plot_learning_curve(info["model"], X_full, y_full, name)
+
+# Feature Importance (Random Forest only)
+rf          = results["Random Forest"]["model"]
+importances = pd.Series(rf.feature_importances_, index=X.columns).sort_values(ascending=True).tail(10)
+fig, ax = plt.subplots(figsize=(11, 6))
+importances.plot(kind="barh", color="teal", ax=ax, edgecolor="white")
+ax.set_title("Top 10 Most Important Audio Features (Random Forest)", fontweight="bold")
+ax.set_xlabel("Feature Importance Score")
+ax.grid(axis="x", linestyle="--", alpha=0.4)
+plt.tight_layout()
+plt.savefig("plots/feature_importance.png", dpi=150, bbox_inches="tight")
+plt.show()
+
+# Model Accuracy Comparison Bar Chart
+fig, ax = plt.subplots(figsize=(8, 5))
+names  = list(results.keys())
+accs   = [info["acc"] * 100 for info in results.values()]
+aucs   = [info["roc_auc"] for info in results.values()]
+x      = np.arange(len(names))
+bars   = ax.bar(x - 0.2, accs,  0.35, label="Accuracy (%)",  color="teal",  alpha=0.8)
+bars2  = ax.bar(x + 0.2, [a*100 for a in aucs], 0.35, label="ROC-AUC × 100", color="coral", alpha=0.8)
+ax.set_xticks(x)
+ax.set_xticklabels(names)
+ax.set_ylim(60, 100)
+ax.set_title("Model Comparison — Accuracy vs ROC-AUC", fontweight="bold")
+ax.legend()
+ax.grid(axis="y", linestyle="--", alpha=0.4)
+for bar in bars:
+    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.3,
+            f"{bar.get_height():.1f}", ha="center", fontsize=9)
+plt.tight_layout()
+plt.savefig("plots/model_comparison.png", dpi=150, bbox_inches="tight")
+plt.show()
+
+# Computational Cost Analysis
+cost_df = pd.DataFrame(cost_rows)
+print("\n" + "="*55)
+print("  COMPUTATIONAL COST ANALYSIS")
+print("="*55)
+print(cost_df.to_string(index=False))
+
+# Save the best model + scaler + label encoder
+best_name = max(results, key=lambda k: results[k]["acc"])
+joblib.dump(results[best_name]["model"], "music_genre_classifier.pkl")
+joblib.dump(scaler, "scaler.pkl")
+joblib.dump(le,     "label_encoder.pkl")
+print(f"\nBest model ({best_name}) + scaler + label encoder saved.")
+
+# Class Distribution Bar Chart
+plt.figure(figsize=(10, 5))
+df['label'].value_counts().sort_index().plot(kind='bar', color='teal', edgecolor='white')
+plt.title("Class Distribution Across Music Genres", fontweight='bold')
+plt.xlabel("Genre")
+plt.ylabel("Number of Samples")
+plt.xticks(rotation=45)
+plt.tight_layout()
+plt.savefig("plots/class_distribution.png", dpi=150)
+plt.show()
+
+# Corelation Heatmap
+plt.figure(figsize=(12, 8))
+top_features = X.columns[:15]
+sns.heatmap(X[top_features].corr(), cmap='coolwarm', annot=False, linewidths=0.5)
+plt.title("Feature Correlation Heatmap", fontweight='bold')
+plt.tight_layout()
+plt.savefig("plots/correlation_heatmap.png", dpi=150)
+plt.show()
+
+# Scalability Analysis — Training Time vs. Dataset Size
+fractions = np.linspace(0.1, 1.0, 10)
+scalability = {name: [] for name in models}
+
+for frac in fractions:
+    n = int(len(X_train_scaled) * frac)
+    X_sub = X_train_scaled[:n]
+    y_sub = y_train[:n]
+    for name, model in models.items():
+        t0 = time.time()
+        model.fit(X_sub, y_sub)
+        scalability[name].append(time.time() - t0)
+
+plt.figure(figsize=(10, 5))
+for name, times in scalability.items():
+    plt.plot([int(len(X_train_scaled) * f) for f in fractions], times, marker='o', label=name)
+plt.title("Scalability — Training Time vs. Dataset Size", fontweight='bold')
+plt.xlabel("Training Samples")
+plt.ylabel("Training Time (seconds)")
+plt.legend()
+plt.grid(linestyle='--', alpha=0.4)
+plt.tight_layout()
+plt.savefig("plots/scalability_curve.png", dpi=150)
+plt.show()

music_genre_classifier.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24b63fddcc290ea151f63f2834802aec7dcee0c1c2c8b967922979180ae14004
+size 14408809

requirements.txt

@@ -0,0 +1,5 @@
+flask
+pandas
+numpy
+scikit-learn
+joblib

scaler.pkl

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