Data Science and Machine Learning 101: Business Applications and Soft Skills Building a Data Science Portfolio Kaggle GitHub Projects Blogging

What This Is

A Data‑Science portfolio is the curated collection of public work that shows you can take a raw problem (e.g., “predict which telecom customers will churn”) through the full data‑science pipeline—data wrangling, modeling, evaluation, and communication. Recruiters and hiring managers look at Kaggle notebooks, GitHub repos, and blog posts to gauge your technical chops, coding style, and ability to tell a story with data.

Key Terms & Formulas

• Kaggle Competition – A hosted data‑science challenge (often with a leaderboard) that forces you to split data, engineer features, and iterate quickly.
• GitHub Repository – A version‑controlled folder where you store notebooks, scripts, and documentation; the README acts as your project “elevator pitch.”
• README.md – Markdown file that explains the problem, data sources, methodology, results, and how to run the code.
• CI/CD (Continuous Integration/Continuous Deployment) – Automated tests (e.g., pytest) that run on every push to GitHub; shows you write production‑ready code.
• Dockerfile – Text file that builds a reproducible container (FROM python:3.11, RUN pip install -r requirements.txt); useful for sharing a runnable environment.
• Precision = TP / (TP + FP) – Fraction of predicted positives that are truly positive; crucial when false positives are costly (e.g., fraud alerts).
• Recall = TP / (TP + FN) – Fraction of actual positives captured; important when missing a positive is expensive (e.g., disease detection).
• F1‑Score = 2·(Precision·Recall)/(Precision+Recall) – Harmonic mean that balances precision and recall for imbalanced data.
• Cross‑Validation (CV) – Repeated train/validation splits; k‑fold CV computes average metric:

[ \text{CV_score} = \frac{1}{k}\sum_{i=1}^{k} \text{metric}_i ]

• Feature Importance (Tree‑based) – For a RandomForest model, importance of feature j is

[ I_j = \frac{1}{T}\sum_{t=1}^{T} \frac{\Delta \text{impurity}{t,j}}{\text{samples} ] }

• MLflow Tracking – Logs parameters, metrics, and artifacts (e.g., plots) to a UI; great for showing systematic experimentation.
• Blog Post (Technical Writing) – A medium‑length article (≈800‑1500 words) that explains the end‑to‑end workflow, includes code snippets, and visualizations; demonstrates communication skill.

Step‑by‑Step / Process Flow

1. Pick a Real‑World Problem & Dataset
2. Search Kaggle Datasets, UCI repository, or open‑source APIs (e.g., yfinance).

3. Example: Predict churn from a telecom CSV (customer_id, tenure, monthly_charges, churn).

4. Set Up a Reproducible Repo
   bash
mkdir churn-prediction && cd churn-prediction
git init
echo "# Churn Prediction" > README.md
touch requirements.txt # list pandas, scikit-learn, matplotlib, mlflow

5. Exploratory Data Analysis (EDA) Notebook

6. Load with pandas.read_csv, visualize with seaborn.

7. Commit the notebook (git add eda.ipynb && git commit -m "EDA").

8. Modeling Pipeline (train/validation)
   
   ```python
   from sklearn.model_selection import train_test_split, cross_val_score
   from sklearn.preprocessing import OneHotEncoder, StandardScaler
   from sklearn.compose import ColumnTransformer
   from sklearn.pipeline import Pipeline
   from sklearn.ensemble import GradientBoostingClassifier

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

preproc = ColumnTransformer([
('num', StandardScaler(), numeric_cols),
('cat', OneHotEncoder(handle_unknown='ignore'), categorical_cols)
])

model = Pipeline([
('prep', preproc),
('clf', GradientBoostingClassifier(random_state=42))
])

cv_scores = cross_val_score(model, X_train, y_train,
cv=5, scoring='f1')
```

1. Evaluation & Visualization
2. Plot ROC curve (sklearn.metrics.roc_curve) and confusion matrix.
3. Log metrics to MLflow:

python
import mlflow
mlflow.log_metric('f1_cv', cv_scores.mean())
mlflow.sklearn.log_model(model, 'model')

1. Documentation & Publication
2. Write a concise README with a “How to run” section (python -m venv venv && pip install -r requirements.txt).
3. Push to GitHub, enable GitHub Pages for a blog post that walks through the notebook, explains feature importance, and reflects on business impact (e.g., “Reducing churn by 5 % could save $1.2 M annually”).

Common Mistakes

Data Science Interview / Practical Insights

1. Portfolio Depth vs. Breadth – Interviewers ask, “Why do you have three Kaggle notebooks on the same dataset?” Expect to explain different techniques (e.g., baseline logistic regression, tree‑based model, deep learning) and what you learned from each.
2. Reproducibility Questions – Be ready to discuss how you ensure reproducibility: pinned package versions (requirements.txt), random seeds, Docker containers, and CI pipelines.
3. Explainability – You may be asked to justify a model choice: “Why did you pick Gradient Boosting over a Neural Net for churn?” Highlight interpretability (feature importance) and data size constraints.
4. Business Impact – Expect a “What would you tell a non‑technical stakeholder?” question; practice translating metrics (e.g., F1 = 0.78) into ROI (e.g., “saving $500 K per year”).

Quick Check Questions

1. Scenario: Your validation F1‑score is 0.55 but training F1‑score is 0.95.
   Answer: The model is over‑fitting; apply stronger regularization (e.g., increase learning_rate decay, add max_depth=3, or use L2 penalty).

2. Scenario: You publish a Kaggle notebook but the leaderboard score is lower than the public baseline.
   Answer: Check data leakage (e.g., using the test set in feature engineering) and ensure proper cross‑validation; fix leakage and re‑train.

3. Scenario: A hiring manager asks why you kept the notebook “clean” and moved code to .py files.
   Answer: Modular code is testable, reusable, and easier for collaborators to read; it also demonstrates software‑engineering best practices.

Last‑Minute Cram Sheet (10 one‑liners)

1. ⚠️ StandardScaler assumes Gaussian features; use MinMaxScaler for skewed distributions.
2. Kaggle → treat the public leaderboard as a validation set; never peek at the private test labels.
3. README must contain: problem statement, data source, setup instructions, and key results (metric + baseline).
4. MLflow logs: parameters → mlflow.log_param(), metrics → mlflow.log_metric(), artifacts → mlflow.log_artifact().
5. Cross‑validation reduces variance of performance estimates; k=5 is a good default for medium datasets.
6. Feature importance from tree models is relative; always validate with SHAP or permutation importance for trust.
7. Docker → docker build -t churn-app . then docker run -p 5000:5000 churn-app to serve a model.
8. GitHub Pages can host a static blog (mkdocs, Jekyll) that automatically pulls from the repo’s docs/ folder.
9. CI (GitHub Actions) can run pytest and flake8 on every PR to enforce code quality.
10. Blog post length: 800–1500 words; include 1‑2 code blocks, 2‑3 visualizations, and a “Takeaway” section.