Capstone — Full ML Project, from Data to API

import pandas as pd

df = pd.read_csv("student_scores.csv")
print(df.shape)
print(df.describe())
print(df.isnull().sum())  # confirm no missing values before training

from sklearn.model_selection import train_test_split

features = ["StudyHours", "Attendance", "PrevScore", "AssignmentsDone"]
X = df[features]
y = df["FinalScore"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
print(f"Train: {X_train.shape[0]} rows · Test: {X_test.shape[0]} rows")

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.model_selection import cross_val_score

candidates = {
    "Linear Regression": LinearRegression(),
    "Ridge": Ridge(alpha=1.0),
    "Decision Tree": DecisionTreeRegressor(max_depth=5, random_state=42),
    "Random Forest": RandomForestRegressor(n_estimators=200, random_state=42),
    "Gradient Boosting": GradientBoostingRegressor(n_estimators=200, random_state=42),
}

results = {}
for name, estimator in candidates.items():
    pipe = Pipeline([("scaler", StandardScaler()), ("model", estimator)])
    scores = cross_val_score(pipe, X_train, y_train, cv=5, scoring="r2")
    results[name] = scores.mean()
    print(f"{name:<20} CV R²: {scores.mean():.3f} (+/- {scores.std():.3f})")

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

best_pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("model", GradientBoostingRegressor(n_estimators=200, random_state=42))
])
best_pipeline.fit(X_train, y_train)

y_pred = best_pipeline.predict(X_test)

mae = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"Test MAE:  {mae:.2f}")
print(f"Test RMSE: {rmse:.2f}")
print(f"Test R²:   {r2:.3f}")

import joblib

joblib.dump(best_pipeline, "student_score_model_final.joblib")
print("Final capstone pipeline saved to student_score_model_final.joblib")

from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import pandas as pd

app = FastAPI(title="Student Score Predictor API — Capstone", version="1.0")
model = joblib.load("student_score_model_final.joblib")

class StudentInput(BaseModel):
    study_hours: float
    attendance: float
    prev_score: float
    assignments_done: int

class PredictionOutput(BaseModel):
    predicted_score: float
    confidence: str

@app.get("/health")
def health():
    return {"status": "ok", "model_loaded": model is not None}

@app.post("/predict", response_model=PredictionOutput)
def predict(student: StudentInput):
    features = pd.DataFrame([{
        "StudyHours": student.study_hours,
        "Attendance": student.attendance,
        "PrevScore": student.prev_score,
        "AssignmentsDone": student.assignments_done
    }])
    pred = model.predict(features)[0]
    confidence = "high" if pred > 80 else "medium" if pred > 60 else "low"
    return PredictionOutput(predicted_score=round(float(pred), 1), confidence=confidence)

# Run with: uvicorn api:app --reload

import pandas as pd
import numpy as np
import joblib
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# 1. Load
df = pd.read_csv("student_scores.csv")
features = ["StudyHours", "Attendance", "PrevScore", "AssignmentsDone"]
X, y = df[features], df["FinalScore"]

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 3. Compare candidates with cross-validation
candidates = {
    "Linear Regression": LinearRegression(),
    "Ridge": Ridge(alpha=1.0),
    "Decision Tree": DecisionTreeRegressor(max_depth=5, random_state=42),
    "Random Forest": RandomForestRegressor(n_estimators=200, random_state=42),
    "Gradient Boosting": GradientBoostingRegressor(n_estimators=200, random_state=42),
}
best_name, best_score = None, -np.inf
for name, estimator in candidates.items():
    pipe = Pipeline([("scaler", StandardScaler()), ("model", estimator)])
    score = cross_val_score(pipe, X_train, y_train, cv=5, scoring="r2").mean()
    print(f"{name:<20} CV R²: {score:.3f}")
    if score > best_score:
        best_name, best_score = name, score

print(f"\nBest candidate: {best_name} (CV R² = {best_score:.3f})")

# 4. Fit the winner on the full training set, evaluate on the held-out test set
best_pipeline = Pipeline([("scaler", StandardScaler()), ("model", candidates[best_name])])
best_pipeline.fit(X_train, y_train)
y_pred = best_pipeline.predict(X_test)
print(f"Test MAE:  {mean_absolute_error(y_test, y_pred):.2f}")
print(f"Test RMSE: {np.sqrt(mean_squared_error(y_test, y_pred)):.2f}")
print(f"Test R²:   {r2_score(y_test, y_pred):.3f}")

# 5. Save with joblib — ready for Section 7's FastAPI app
joblib.dump(best_pipeline, "student_score_model_final.joblib")
print("Saved to student_score_model_final.joblib")