Student Placement Salary Prediction

Predicting a student's expected placement salary (LPA) using Linear, Ridge, and Lasso Regression, with full EDA, feature engineering, hyperparameter tuning, regularization analysis, and a deployed Streamlit prediction app.

🔗 Live Demo: Try it here | 📓 Notebook: student_placement_analysis.ipynb

Overview

This project builds an end-to-end regression pipeline that predicts the salary package (LPA) a student is likely to receive at placement, based on academic performance, technical skills, internships/projects, and interview readiness. It compares three regression approaches — Linear, Ridge (L2), and Lasso (L1) — and automatically selects the best-performing model, which is then served through an interactive Streamlit app.

Problem Statement

Placement cells and students alike want a data-driven way to estimate expected salary ranges given a student's current profile — both to set realistic expectations and to identify which factors (CGPA, DSA practice, internships, backlogs, etc.) actually move the needle. This project frames that as a supervised regression problem.

Objectives

• Build a clean, reproducible ML pipeline: preprocessing → feature engineering → modeling → tuning → evaluation.
• Compare Linear Regression against L2 (Ridge) and L1 (Lasso) regularization, and explain why one wins.
• Diagnose multicollinearity (correlation + VIF) and show how regularization handles it better than plain OLS.
• Demonstrate Lasso's automatic feature selection.
• Ship a working, deployable prediction interface (Streamlit), not just a notebook.

Dataset

data/student_placement_salary.csv — 1,500 records, synthetically generated (see src/generate_data.py for full assumptions) since no public dataset matches this exact, interview-relevant feature set. Salary is generated as an explicit, documented linear combination of the features below plus Gaussian noise and a backlog penalty, so the ground-truth relationship is realistic and close to linear — the right regime to test Linear/Ridge/Lasso fairly, rather than a strawman random dataset.

Students who were not placed (~12%, salary = 0 by construction) are excluded before regression training, since 0 represents "not placed," not "low salary" — mixing the two would corrupt the target.

Features

Category	Features
Academics	CGPA, 10th %, 12th %
Technical Skills	Coding Score, DSA/LeetCode Score, Aptitude Score, Technical Interview Score
Soft Skills	Communication Score
Experience	Internships, Projects, Certifications, Hackathons, Work Experience (months)
Conduct	Backlogs, Attendance %
Preparation	Placement Training Hours
Engineered	Academic_Score, Skill_Score, Experience_Score, Overall_Placement_Score
Target	Salary_LPA

Technologies Used

Python 3 · pandas · NumPy · scikit-learn · statsmodels (VIF) · Matplotlib · Seaborn · Streamlit · joblib

Machine Learning Models

1. Linear Regression — baseline OLS.
2. Ridge Regression — L2 regularization, alpha tuned via GridSearchCV over [0.01, 0.1, 1, 10, 100, 1000], 5-fold CV.
3. Lasso Regression — L1 regularization, alpha tuned via GridSearchCV over [0.001, 0.01, 0.05, 0.1, 0.5, 1, 5, 10], 5-fold CV.

Methodology

Raw CSV
   │
   ▼
Load & validate (missing values, duplicates, dtypes)
   │
   ▼
Filter to Placed students only
   │
   ▼
Feature Engineering (Academic_Score, Skill_Score, Experience_Score, Overall_Placement_Score)
   │
   ▼
Train/Test Split (80/20, random_state=42)
   │
   ▼
StandardScaler — fit on TRAIN ONLY (no leakage)
   │
   ▼
Train Linear / Ridge (GridSearchCV) / Lasso (GridSearchCV)
   │
   ▼
Evaluate: MAE, MSE, RMSE, R² + 5-Fold Cross-Validation
   │
   ▼
Select best model → Residual Analysis → Save pipeline (joblib)
   │
   ▼
Streamlit App (app.py) loads pipeline → live predictions

EDA

Key plots (see notebooks/student_placement_analysis.ipynb and reports/figures/):

• Salary distribution — right-skewed, most students in the 6–16 LPA range.
• CGPA vs Salary — clear positive linear trend; CGPA is the strongest single driver.
• Internships / Projects vs Salary — positive relationships, internships stronger than projects.
• Coding Score vs Salary — strong positive correlation, second only to CGPA.
• Correlation heatmap — CGPA, Coding_Score, DSA_Score, Technical_Interview_Score are mutually correlated and correlated with salary → motivates the multicollinearity check below.

Multicollinearity Check

Computed both a correlation matrix and VIF (Variance Inflation Factor). Several engineered composite features (e.g. Overall_Placement_Score, which is built from Academic_Score and Skill_Score) show very high VIF, since they are linear combinations of other features already in the model. This is an intentional stress test: it demonstrates the exact scenario where Ridge and Lasso are expected to outperform (or at least out-stabilize) plain OLS, since OLS coefficients become unstable/unreliable under high multicollinearity while regularized regression handles it gracefully.

Model Performance

Test-set results from the latest training run (models/summary.json):

Model	MAE	MSE	RMSE	R²	CV R² (5-fold)
Linear Regression	0.8114	1.0641	1.0315	0.5812	0.4927 (± 0.0252)
Ridge Regression (α=10)	0.8119	1.0646	1.0318	0.5810	0.4929 (± 0.0251)
Lasso Regression (α=0.01)	0.8125	1.0670	1.0330	0.5801	0.4943 (± 0.0242)

Selected model: Linear Regression (highest test R², confirmed by cross-validation showing no meaningful overfitting — train R² ≈ 0.51, test R² ≈ 0.58, CV R² ≈ 0.49 are all close together).

Why this result makes sense: the data was generated from a near-linear ground truth with moderate, realistic noise (see src/generate_data.py). With that little intrinsic non-linearity/overfitting risk, heavy regularization has little accuracy to gain — Ridge and Lasso land within ~0.1% R² of plain Linear Regression. Their real value here isn't raw accuracy; it's coefficient stability under multicollinearity (Ridge) and automatic feature selection (Lasso) — see below. On noisier or more collinear real-world data, Ridge/Lasso would be expected to pull further ahead of plain Linear Regression.

Ridge vs Lasso

• Ridge (L2): shrinks all coefficients smoothly towards zero but keeps every feature in the model.
• Lasso (L1): can shrink coefficients exactly to zero — i.e. performs automatic feature selection.

In this project, Lasso zeroed out 5 features entirely: Projects, Aptitude_Score, Technical_Interview_Score, Academic_Score, Skill_Score. Note that three of these are the engineered composite scores (or features they heavily overlap with) — Lasso correctly identified that once CGPA, Coding_Score and DSA_Score are already in the model, the composite scores built from them add redundant information rather than new signal.

Coefficient comparison chart: reports/figures/coefficient_comparison.png.

Residual Analysis

For the best model (Linear Regression):

• Residual mean: -0.056 (close to 0, indicating no strong systematic bias)
• Residual std: 1.030
• Actual vs Predicted plot shows points clustered around the diagonal with no strong curvature.
• Residual plot shows no obvious funnel/heteroscedasticity pattern.
• Residual distribution is approximately normal/unimodal.

Together these diagnostics suggest a reasonable, well-behaved linear fit rather than a systematically biased or misspecified model. See reports/figures/actual_vs_predicted.png, residual_plot.png, residual_distribution.png.

Results

• Best model achieves R² = 0.58 and RMSE ≈ 1.03 LPA on unseen test data — i.e. predictions are typically within about ±1 LPA of the true package, which is a realistic, non-inflated result for noisy, real-world-style placement data (not an artificially perfect R² that would suggest data leakage or an unrealistic synthetic dataset).
• The full pipeline (scaler + model + feature list) is bundled in models/best_model.pkl via joblib, so training-time preprocessing is guaranteed to match inference-time preprocessing.

Streamlit Application

app.py provides:

• Input section — sliders/number inputs for all 16 raw student features, grouped into Academics / Skills / Experience & Activities.
• Prediction — displays Predicted Salary: ₹X LPA and the Recommended Model (the model selected during training).
• Model Insights — best model name, R², RMSE, MAE, full model comparison table, and standardized feature coefficients, plus a note on which features Lasso eliminated.

Installation

git clone <your-repo-url>
cd student-placement-salary-prediction
pip install -r requirements.txt

How to Run

# 1. Generate the synthetic dataset
python src/generate_data.py

# 2. (Optional) Generate EDA / diagnostic plots
python src/make_plots.py

# 3. Train all three models, tune, evaluate, and save the best pipeline
python src/train.py

# 4. (Optional) Re-evaluate the saved model
python src/evaluate.py

# 5. (Optional) Run a CLI prediction demo
python src/predict.py

# 6. Launch the Streamlit app
streamlit run app.py

The Jupyter notebook (notebooks/student_placement_analysis.ipynb) contains the full narrated analysis with all plots embedded — open it with jupyter notebook or view it directly on GitHub.

Project Structure

student-placement-salary-prediction/
│
├── data/
│   └── student_placement_salary.csv
│
├── notebooks/
│   └── student_placement_analysis.ipynb
│
├── reports/
│   └── figures/                  # EDA + diagnostic plots (PNG)
│
├── src/
│   ├── generate_data.py          # Synthetic dataset generation
│   ├── data_preprocessing.py     # Load, clean, feature-engineer, split, scale
│   ├── make_plots.py             # EDA + diagnostic plot generation
│   ├── train.py                  # Train, tune (GridSearchCV), evaluate, save
│   ├── evaluate.py               # Reload saved model, print full report
│   ├── predict.py                # Single-student prediction function
│   └── build_notebook.py         # Programmatically builds the analysis notebook
│
├── models/
│   ├── best_model.pkl            # Saved pipeline: scaler + best model + metadata
│   ├── model_comparison.csv
│   ├── coefficients.csv
│   ├── vif.csv
│   └── summary.json
│
├── app.py                        # Streamlit application
├── requirements.txt
├── README.md
└── .gitignore

Key ML Concepts (Interview Prep)

1. Why Linear Regression? It's the natural baseline for a continuous target with roughly linear relationships to the inputs — interpretable coefficients, fast to train, and a sanity check for whether more complex models are even needed.
2. What problem does Ridge solve? It reduces coefficient variance/instability caused by multicollinearity by adding an L2 penalty (sum of squared coefficients) to the loss, shrinking coefficients smoothly.
3. What problem does Lasso solve? Same instability problem, but via an L1 penalty (sum of absolute coefficients) that can drive some coefficients to exactly zero — combining regularization with feature selection.
4. L1 vs L2: L1 (Lasso) uses absolute value of coefficients as the penalty and produces sparse solutions (some coefficients = 0). L2 (Ridge) uses squared coefficients and shrinks everything smoothly but rarely to exactly zero. Geometrically, L1's diamond-shaped constraint region has corners on the axes (where a coefficient is 0), which is why it induces sparsity, while L2's circular region doesn't.
5. Why feature scaling is required: Ridge/Lasso penalize coefficient magnitude directly, so unscaled features with larger natural ranges would be penalized unfairly relative to their true importance. StandardScaler puts all features on a comparable footing (mean 0, std 1).
6. What is alpha? The regularization strength hyperparameter. Alpha = 0 reduces Ridge/Lasso to plain OLS; larger alpha shrinks coefficients more aggressively (higher bias, lower variance).
7. How GridSearchCV selects alpha: It exhaustively trains/evaluates the model for every alpha in the given grid using k-fold cross-validation, then picks the alpha with the best average validation score (R² here) — avoiding overfitting to a single train/test split.
8. Why Lasso performs feature selection: Its L1 penalty's constraint region has sharp corners aligned with the coordinate axes, so the optimal solution frequently lands exactly on an axis (coefficient = 0) rather than just near it, unlike Ridge's smooth circular constraint.
9. What is multicollinearity? When two or more input features are highly correlated with each other, making it hard for OLS to isolate each feature's individual effect — coefficients become unstable and hard to interpret. Detected here via correlation matrix and VIF.
10. Why R² is used: It measures the proportion of variance in the target explained by the model (1.0 = perfect, 0 = no better than predicting the mean), giving an intuitive, scale-independent measure of fit quality.
11. MAE vs MSE vs RMSE: MAE (mean absolute error) is the average absolute prediction error, robust to outliers. MSE (mean squared error) squares errors before averaging, penalizing large errors more heavily. RMSE is the square root of MSE, bringing the error back to the target's original units (LPA here) for interpretability.
12. How cross-validation works: The training data is split into k folds; the model trains on k−1 folds and validates on the remaining fold, k times, rotating which fold is held out. Averaging the k scores gives a more robust performance estimate than a single train/test split.
13. How to detect overfitting: Compare train, test, and cross-validation performance. A large gap (high train score, much lower test/CV score) signals overfitting. Here, train R² (0.51), test R² (0.58) and CV R² (0.49) are all close, indicating no significant overfitting.
14. Why the final model was selected: Linear Regression had the highest test R² and its cross-validation score closely matched Ridge and Lasso, confirming the near-linear ground truth doesn't require regularization for raw accuracy — though Ridge/Lasso remain valuable for coefficient stability and feature selection, and would be preferred in noisier, more collinear real-world settings.

---

Dataset is synthetic and generated for educational/portfolio purposes; predictions are estimates, not guarantees of actual placement offers.