Why Companies in Noida Choose Uncodemy for Data Science

Project: Predict which customers may churn next month
Data: company-like accounts, usage, support tickets (synthetic)
Steps:
  1. Clean and join the data
  2. Build a majority-class baseline
  3. Train logistic regression and a tree model
  4. Compare with cross-validation (ROC-AUC)
  5. Explain top drivers and limitations
Output: short write-up + reviewed notebook

from sklearn.model_selection import cross_val_score
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression

base = cross_val_score(DummyClassifier(strategy="most_frequent"),
                       X, y, cv=5, scoring="roc_auc").mean()
model = cross_val_score(LogisticRegression(max_iter=1000),
                        X, y, cv=5, scoring="roc_auc").mean()
print(f"baseline {base:.2f} vs model {model:.2f}")

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score

# Scaling inside the pipeline is refit per fold -> no leakage
pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
scores = cross_val_score(pipe, X, y, cv=5, scoring="roc_auc")
print("ROC-AUC per fold:", scores.round(3), "mean", scores.mean().round(3))

Business question -> Metric to prioritise
Missing a fraud case is costly    -> Recall
False alarms are costly           -> Precision
Need one balanced number          -> F1 or ROC-AUC
Ranking customers by risk         -> ROC-AUC / PR-AUC
Always report the baseline alongside the model.

import joblib
from fastapi import FastAPI
from pydantic import BaseModel

model = joblib.load("churn_model.joblib")
app = FastAPI()

class Customer(BaseModel):
    tenure_months: int
    monthly_spend: float
    support_tickets: int

@app.post("/predict")
def predict(c: Customer):
    import pandas as pd
    df = pd.DataFrame([c.model_dump()])
    prob = float(model.predict_proba(df)[0, 1])
    return {"churn_probability": round(prob, 3)}

import numpy as np

def mean_shift(train_values, live_values):
    """Rough signal: how far the live mean has moved, in train std units."""
    return abs(np.mean(live_values) - np.mean(train_values)) / (np.std(train_values) + 1e-9)

# A large shift on a key feature suggests the model may need review.
print(mean_shift(train_spend, live_spend))

Company / team:
Main goal: modelling / evaluation / deployment
Participants (roles):
Business problems to target:
Data available (synthetic/anonymised):
Format: on-site / online / blended
Schedule constraints:
Success measures:

Before and after (60-90 minutes):
1. Frame a given business problem as ML
2. Build a baseline and one model with cross-validation
3. Choose and justify a metric
4. Explain one risk of leakage in the setup
Score: complete / partial / not done

Programme results
Goal:
Participants:
Assessment (before -> after):
Models built on real problems:
Evaluation habits adopted (baselines, pipelines):
One model served or planned for serving:
Manager feedback after 6 weeks: