Data Science Courses in Gurugram — Fees, Faculty, Reviews

# baseline-model.py — a real data science starting point
# Every data science course in Gurugram should teach this.

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression

# Load a real dataset (Telco churn is a classic)
url = "https://raw.githubusercontent.com/IBM/telco-customer-churn-on-icp4d/master/data/Telco-Customer-Churn.csv"
df = pd.read_csv(url)

# Basic cleaning
df["TotalCharges"] = pd.to_numeric(df["TotalCharges"], errors="coerce")
df = df.dropna()

# Encode target
df["Churn"] = df["Churn"].map({"Yes": 1, "No": 0})

# Drop ID column and encode categoricals
X = df.drop(columns=["customerID", "Churn"])
X = pd.get_dummies(X, drop_first=True)
y = df["Churn"]

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

# Baseline: logistic regression
lr = LogisticRegression(max_iter=1000)
lr.fit(X_train, y_train)
lr_preds = lr.predict(X_test)

# Stronger model: random forest
rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X_train, y_train)
rf_preds = rf.predict(X_test)

print(f"Logistic Regression accuracy: {accuracy_score(y_test, lr_preds):.3f}")
print(f"Random Forest accuracy:      {accuracy_score(y_test, rf_preds):.3f}")
print(classification_report(y_test, rf_preds))

# What a good course teaches:
# - Always start with a baseline
# - Compare models honestly
# - Use stratified splits for imbalanced targets
# - Report more than accuracy
#
# A great course teaches you WHY each step exists.

-- gurugram-hiring.sql — the SQL every data role expects
-- From a fictional Gurugram company's hiring dataset.

-- 1. Who is hiring data scientists in Gurugram?
SELECT
  company_name,
  COUNT(*) AS open_roles,
  AVG(salary_lpa) AS avg_salary_lpa,
  MIN(experience_years) AS min_exp
FROM job_postings
WHERE city = 'Gurugram'
  AND role_title ILIKE '%data scientist%'
  AND posted_at >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
GROUP BY company_name
ORDER BY open_roles DESC
LIMIT 10;

-- 2. What skills are most requested?
SELECT
  skill,
  COUNT(*) AS mentions,
  ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER (), 2) AS pct_of_postings
FROM (
  SELECT UNNEST(required_skills) AS skill
  FROM job_postings
  WHERE city = 'Gurugram'
    AND posted_at >= DATE_SUB(CURRENT_DATE(), INTERVAL 90 DAY)
) skills
GROUP BY skill
ORDER BY mentions DESC
LIMIT 15;

-- 3. Where do junior hires come from?
SELECT
  previous_role,
  COUNT(*) AS hires
FROM employees
WHERE joined_as_role = 'Data Scientist'
  AND office_city = 'Gurugram'
  AND years_experience_at_joining <= 2
GROUP BY previous_role
ORDER BY hires DESC;

-- What a great course does:
-- - Teaches SQL until you can write this without thinking
-- - Uses real data, not toy datasets
-- - Explains window functions, CTEs, subqueries, not just SELECT *
--
-- Most Gurugram job posts list SQL as a hard requirement.
-- A data science course that doesn't teach SQL deeply is not
-- preparing you for the market.

# deploy-model.py — how models leave a notebook and become useful
# A real portfolio project every data science course should include.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib
import numpy as np

# Load the trained model saved during training
model = joblib.load("model/churn_model.pkl")

app = FastAPI(title="Churn Prediction API")

class CustomerFeatures(BaseModel):
    tenure_months: int
    monthly_charges: float
    total_charges: float
    contract_type: str
    has_internet: bool

@app.get("/")
def health():
    return {"status": "ok", "model": "churn_v1"}

@app.post("/predict")
def predict(customer: CustomerFeatures):
    # Encode features to the same shape the model expects
    features = np.array([[
        customer.tenure_months,
        customer.monthly_charges,
        customer.total_charges,
        1 if customer.contract_type == "two_year" else 0,
        1 if customer.has_internet else 0,
    ]])
    prob = model.predict_proba(features)[0][1]
    return {
        "churn_probability": round(float(prob), 4),
        "risk_level": "high" if prob > 0.6 else "low",
    }

# Run: uvicorn deploy-model:app --reload
# Then POST to http://localhost:8000/predict
#
# Why this matters:
# - Companies don't hire for notebooks — they hire for working models
# - Deployment is what separates a portfolio project from a homework
# - If your course never covers deployment, your portfolio is
#   missing the piece that actually impresses employers