Data Science

Preparation to establish a common technical foundation.

• Setting Up the Development Environment:
  • Installing Python (Anaconda distribution recommended)
  • Dependency management with Conda environments
  • Installing and configuring an integrated development environment (VS Code recommended)
• Command Line Interface (CLI) Fundamentals:
  • Navigating directories (cd, ls/dir, pwd)
  • File manipulation (cp, mv, rm, mkdir)
  • Running basic commands
• Version Control with Git & GitHub:
  • Concepts of repository, commit, branch, merge, pull request
  • Local Git installation and creating a GitHub account
  • Basic commands: git clone, git add, git commit, git status, git push, git pull, git branch, git checkout, git merge

Lab Session:

Exercises verifying Python/Conda installation, practicing basic CLI commands, and executing a complete Git workflow on GitHub (cloning a repo, making changes, committing, pushing)

Python Fundamentals Review & Deep Dive

Reinforcing core Python concepts in the context of data science.

• Python data types: int, float, str, bool, list, tuple, dict, set
• Operators and control flow (if/elif/else, for and while loops)
• Defining functions, arguments (args, kwargs), scope, lambda functions
• Object-Oriented Programming: classes, objects, attributes, methods, inheritance
• Working with files: reading/writing text and CSV files
• Built-in libraries: math, datetime, collections
• Python standard practices (PEP 8)

Numerical Computing with NumPy

Mastering numerical data and vectorization techniques.

• Creating NumPy arrays (ndarray), indexing, slicing, data types
• Vectorization and universal functions (ufuncs)
• Basic mathematical functions: sum, mean, std, etc.
• Linear algebra: matrix multiplication and dot products
• Broadcasting principles
• Random number generation

Data Manipulation with Pandas

Processing and analyzing tabular data.

• Pandas data structures: Series and DataFrame
• Loading and saving data (CSV, Excel, JSON, SQL)
• Indexing & selection: loc, iloc, boolean indexing, setting indexes
• Data cleaning: missing values (dropna, fillna), duplicate data
• Data transformation: apply, map, astype, renaming columns
• Combining DataFrames: merge, join, concat
• Grouping and aggregation: groupby, aggregation functions (sum, mean, count, etc.)
• Time series operations: datetime properties, resampling

Lab Session:

Ingesting multiple datasets and applying cleaning, merging, feature engineering, and group-by aggregations

Relational Databases & Advanced SQL

Database concepts and advanced SQL queries.

• Core concepts: tables, rows, columns, primary and foreign keys, schemas, data types
• SQL querying: SELECT, FROM, WHERE, GROUP BY, HAVING, ORDER BY
• Advanced SQL techniques:
  • JOINs: INNER, LEFT, RIGHT, FULL OUTER, CROSS, self-join
  • Subqueries
  • Common Table Expressions (CTEs, WITH clause)
  • Window functions: OVER, PARTITION BY, ROW_NUMBER, RANK, DENSE_RANK
  • Data definition (DDL) and manipulation (DML) commands

Connecting Python to Databases & APIs

Methods for fetching data from databases and web services.

• Database connection from Python: psycopg2, sqlite3, mysql-connector-python
• ORM usage with SQLAlchemy
• Executing queries and loading results into a Pandas DataFrame (pd.read_sql)
• Interacting with REST APIs: HTTP methods, requests library, JSON handling
• Authentication: API keys, OAuth
• Web scraping: HTML basics, BeautifulSoup, ethical considerations (robots.txt)

Lab Session:

Querying from a PostgreSQL database, fetching data from a live REST API, and combining the data into a single DataFrame

Statistical Foundations for EDA

Core statistical concepts for understanding data characteristics.

• Descriptive statistics: mean, median, mode, variance, standard deviation, range, IQR
• Probability distributions: Normal, Binomial, Poisson, Uniform; PDF and CDF
• Inferential statistics: population/sample concepts, central limit theorem
• Hypothesis testing framework: p-value, confidence interval, t-test, ANOVA, Chi-square test

Data Visualization Principles & Tools

Methods for visualizing data effectively.

• Selecting appropriate chart types: bar, line, scatter, histogram, box plot, heatmap
• Matplotlib: figure and axes concepts; chart customization (labels, titles, legends)
• Seaborn: statistical visualization, Pandas integration
• Plotly: interactive charts, zooming, dashboards
• Spatial visualization: GeoPandas, Folium

Exploratory Data Analysis Workflow & Storytelling

The process of analyzing data and communicating insights.

• Data loading and initial inspection: .info(), .describe(), .head()
• Univariate and bivariate analysis: distributions, relationships, correlations
• Identifying anomalies, trends, and patterns
• Creating an EDA report and data storytelling

Lab Session:

Performing EDA on a real-world dataset; presenting insights with static (Matplotlib, Seaborn) and interactive (Plotly) charts

Data Preprocessing Techniques

Steps for preparing raw data for modeling.

• Missing data management: deletion, mean/median/mode imputation, regression, KNN
• Categorical variable encoding: one-hot, dummy, label encoding, ordinal encoding, target encoding, hashing trick
• Feature scaling: standardization (Z-score), normalization (min-max), robust scaling
• Outlier detection and treatment

Feature Creation & Transformation

Methods for deriving new features from existing data.

• Creating interaction features (such as multiplication, division)
• Polynomial features: generating polynomial terms for linear models
• Binning/discretization
• Logarithmic, square root, and Box-Cox transformations
• Date/time feature engineering: year, month, day, week, duration calculations

Dimensionality Reduction & Feature Selection

Reducing the number of features while preserving important information.

• Curse of Dimensionality concept
• PCA: principal components, selecting the number of components
• Feature selection methods:
  • Filter methods (correlation, ANOVA, Chi-square)
  • Wrapper methods (Recursive Feature Elimination)
  • Embedded methods (Lasso, tree-based methods)
• Introduction to Automated Feature Engineering concepts

Lab Session:

Building a Scikit-learn pipeline to apply data preprocessing, scaling, encoding, and feature selection

Core Machine Learning Concepts

Principles of model training and evaluation.

• Overview of supervised, unsupervised, and reinforcement learning
• Data splitting: train, validation, and test sets
• Model training, prediction, and evaluation
• Bias-variance tradeoff, underfitting/overfitting
• Model evaluation metrics:
  • Classification: accuracy, precision, recall, F1-score, ROC, AUC, log loss
  • Regression: MAE, MSE, RMSE, R²
• Cross-validation: K-fold, stratified K-fold, LOOCV
• Hyperparameter tuning: Grid Search, Randomized Search

Core Supervised Algorithms

Implementation of linear and non-linear models.

• Linear Regression: model assumptions, MSE, gradient descent
• Logistic Regression: sigmoid, log loss, decision boundary
• K-Nearest Neighbors (KNN): distance metrics, choosing k, dimensionality issues
• Support Vector Machines (SVM): maximum margin, kernels (linear, polynomial, RBF), hyperparameters (C, gamma)
• Decision Trees: recursive splitting, Gini impurity, entropy, pruning, visualization

Lab Session:

Implementing models on regression and classification datasets, cross-validation, and hyperparameter tuning

Ensemble Learning Theory & Techniques

Working principles and applications of ensemble methods.

• Bagging: Bootstrap aggregating, variance reduction, parallel training
  • Random Forests: trees, feature subsampling, Out-of-Bag error
• Boosting: sequential model building, bias reduction
  • AdaBoost, Gradient Boosting, XGBoost (regularization, tree pruning, parallel processing)
  • LightGBM: histogram-based splitting, GOSS, EFB
  • CatBoost: ordered boosting, oblivious trees
• Stacking & Blending: using a meta-model
• Introduction to AutoML concepts

Unsupervised Learning Techniques

Data exploration and dimensionality reduction methods without labels.

• Clustering:
  • K-Means: choosing k, Elbow method, Silhouette score
  • Hierarchical Clustering: dendrograms, linkage methods
  • DBSCAN: density-based, choosing eps and min_samples
• Clustering performance metrics: Silhouette score, Davies-Bouldin index
• Dimensionality reduction methods:
  • PCA, t-SNE, UMAP
• Anomaly/Outlier detection:
  • Isolation Forest, Local Outlier Factor, One-Class SVM

Lab Session:

Hyperparameter tuning on a Kaggle-style tabular dataset, applying clustering algorithms (PCA/t-SNE/UMAP visualizations), and anomaly detection

Advanced Statistical Inference

Statistical methods for obtaining more rigorous conclusions.

• Deep dive into hypothesis testing: assumptions, interpretation
• Constructing and interpreting confidence intervals
• A/B Testing: design, sample size, hypothesis tests, regression to the mean, multiple testing problem
• Power analysis: statistical power and sample size calculations
• Bootstrapping: empirical sampling distribution estimation

Introduction to Time Series Analysis

Core components and models in time-dependent data.

• Time series components: trend, seasonality, cyclicity, noise
• Time series decomposition: additive vs. multiplicative models
• Stationarity: concept, ADF test, differencing
• Autocorrelation (ACF) and partial autocorrelation (PACF)
• Classical models: AR, MA, ARMA, ARIMA

Introduction to Bayesian Methods

Principles and methods of Bayesian reasoning.

• Frequentist vs. Bayesian approach
• Bayes' theorem: likelihood, prior, posterior, evidence
• Bayesian inference workflow: model definition, choosing priors, computing and interpreting results
• Introduction to Markov Chain Monte Carlo (MCMC) methods
• Applications: Bayesian A/B testing, hyperparameter optimization

Lab Session:

Analyzing simulated A/B test data and constructing confidence intervals; performing decomposition and generating ACF/PACF plots on real-world time series data; discussing Bayesian methods

Introduction to Neural Networks

Learning the fundamental building blocks and training process of neural networks.

• Biological inspiration and the perceptron concept
• Multi-Layer Perceptrons (MLP) / Feedforward neural networks: input, hidden, and output layers
• Activation functions: Sigmoid, Tanh, ReLU (and variants), Softmax
• Loss functions: Cross-Entropy, MSE/MAE
• Backpropagation algorithm: gradient computation principles
• Gradient descent optimization: SGD, mini-batch, momentum, RMSprop, Adam
• Regularization: L1/L2 and Dropout

Deep Learning Frameworks & Training

Building deep learning models using PyTorch or TensorFlow.

• Tensors, automatic differentiation (autograd/GradientTape)
• Building neural network models using nn.Module or tf.keras.Model
• Defining layers, loss functions, and optimizers
• Training loop: forward pass, loss calculation, backward pass, optimization
• GPU acceleration, saving and loading models
• Training monitoring (TensorBoard)

Introduction to CNNs and RNNs

Fundamentals of specialized neural network architectures for spatial and sequential data.

• CNNs:
  • Convolution operation: filters, stride, padding, feature maps
  • Pooling layers: max pooling, average pooling
  • Basic CNN architecture: Conv -> ReLU -> Pool -> Fully Connected
• RNNs:
  • Sequential data processing and hidden state
  • Gradient problems of simple RNNs
  • LSTM: cell state, gates (input, forget, output)
  • GRU: simplified alternative to LSTMs

Lab Session:

Implementing an MLP on a tabular dataset, a CNN for MNIST/Fashion-MNIST, and an LSTM/GRU on a small text dataset (e.g., IMDB); tracking training with TensorBoard

Advanced CNN Architectures & Transfer Learning

SOTA CNN architectures and using pre-trained models.

• Challenges of deep networks: vanishing gradients, model depth
• Residual Networks (ResNet): skip connections
• Inception Networks (GoogLeNet): parallel filters
• EfficientNets: model scaling
• Transfer Learning:
  • Feature extraction and fine-tuning
  • Using PyTorch/TensorFlow Hub

Core Computer Vision Tasks

Tasks beyond image classification.

• Object detection: bounding boxes, Intersection over Union (IoU)
• Image segmentation: semantic and instance segmentation; FCN, U-Net

SOTA Trends: Vision Transformers & Self-Supervised Learning

Modern CV paradigms.

• Vision Transformers (ViT):
  • Applying the Transformer architecture to images
  • Image patching, positional encodings, self-attention
  • Comparison with CNNs and data requirements
• Self-Supervised Learning (SSL):
  • Contrastive learning (SimCLR, MoCo)
  • Masked image modeling (MAE, BEiT)

Lab Session:

Fine-tuning a pre-trained ResNet model, performing inference with YOLO or SSD for object detection; discussing ViT and SSL workflows

From RNNs to Attention & Transformers

Limitations of RNNs in language models and the advantages of the Transformer.

• Long-range dependency issues of RNNs/LSTMs
• Attention mechanism:
  • Scaled dot-product attention: queries, keys, values
• Fundamentals of the Transformer Architecture:
  • Encoder-Decoder structure, self-attention, multi-head attention, positional encoding
  • Layer normalization and feed-forward networks

Pre-Trained Language Models & LLMs

Using large language models.

• The power of pre-training: BERT (Masked Language Modeling), GPT (Causal Language Modeling)
• Architecture and scaling laws of LLMs: GPT-3/4, Llama, Claude, Gemini, Mistral
• Zero-shot and Few-shot learning, text embedding techniques

SOTA Techniques: Prompting, RAG, PEFT & Hugging Face

Interacting with LLMs using modern techniques.

• Prompt Engineering: zero-shot, few-shot, instruction tuning, Chain-of-Thought
• Retrieval-Augmented Generation (RAG):
  • Retriever + Generator, using vector databases
• Parameter-Efficient Fine-Tuning (PEFT):
  • LoRA, QLoRA
• Hugging Face ecosystem: transformers, datasets, evaluate, pipelines

Lab Session:

Fine-tuning a pre-trained model with Hugging Face transformers (e.g., sentiment analysis or NER), prompt engineering experiments with LLM APIs; building a basic RAG system

Overview of Generative Models

General differences between generative and discriminative models.

• GANs: Generator vs. Discriminator, training challenges (mode collapse, instability)
• Variational Autoencoders (VAEs): encoder-decoder, latent space, probabilistic approach
• Flow-based models (brief mention)

Deep Dive: Diffusion Models

SOTA methods for high-quality image generation.

• Forward process: gradually adding Gaussian noise to data
• Reverse process: step-by-step denoising with a U-Net architecture
• Noise schedule, conditioning (text-to-image)
• Applications: DALL-E, Stable Diffusion, Imagen, image editing, inpainting, super-resolution
• Challenges: sampling speed, knowledge distillation, controllability

Advanced Sequential & Graph Models

Alternative model configurations for modern sequential and graph data.

• Efficient sequential models:
  • State Space Models (SSMs), Linear RNNs, Mamba example, hybrid architectures
• Graph Neural Networks (GNNs):
  • Message passing, GCN, GAT, scalability and over-smoothing issues

Lab Session:

Text-to-image generation using Stable Diffusion, experimenting with different prompts, guidance scales, and negative prompts; implementing a basic GCN model

Data Pipelines & Orchestration

Building automated and reliable data workflows.

• ETL vs. ELT paradigms
• Data pipeline components: sources, transformations, destinations
• Workflow orchestration tools:
  • Apache Airflow: DAGs, operators, tasks, scheduling
  • Alternatives: Prefect, Dagster
• Data quality checks and monitoring
• Batch vs. Streaming data processing (Kafka, Spark Streaming)

Data Storage Architectures

Storing and managing large datasets.

• Data warehouses: Redshift, BigQuery, Snowflake
• Data lakes: S3, ADLS, GCS; Parquet, ORC
• Data lakehouses: Databricks Delta Lake, Apache Iceberg, Apache Hudi
• Vector databases: Pinecone, Milvus, Weaviate, Chroma concepts

Distributed Computing & Big Data Processing

Processing data that exceeds a single machine's scale.

• Need for distributed computing and the Hadoop ecosystem (HDFS, MapReduce/YARN)
• Apache Spark:
  • RDDs, DataFrame API, lazy evaluation, driver/executor architecture
  • Spark SQL, cloud integration
• Cloud-based Big Data services: AWS EMR, Google Dataproc, Azure HDInsight/Synapse

Lab Session:

Simple data reading, transformation, and output operations with PySpark; creating an Apache Airflow DAG; discussion on integrating a vector database into an LLM/RAG pipeline

Fundamentals of MLOps

Processes for operationalizing ML models.

• Why MLOps? Challenges in model deployment and ML lifecycle management
• Versioning, automation (CI/CD), testing, deployment, monitoring, governance
• Reproducibility: tracking code, data, parameters, and environment

Model Deployment Strategies

Making trained models available for inference.

• Containerization with Docker: writing a Dockerfile, building images, running containers
• Deployment patterns:
  • Online/real-time inference (REST APIs: Flask, FastAPI)
  • Batch inference
  • Edge deployment
• Model serving frameworks: TF Serving, TorchServe, KFServing, Seldon Core
• Serverless deployment: AWS Lambda, Google Cloud Functions, Azure Functions
• Kubernetes: container orchestration (conceptual)

Experiment Tracking, Model Monitoring & Versioning

Monitoring and versioning models and experiments.

• Experiment tracking: logging parameters, metrics, code versions, and artifacts
  • MLflow, Weights & Biases, Comet ML
• Model monitoring: measuring performance, data drift, and concept drift
• Versioning: code version control with Git, data/model versioning with DVC
• Feature stores: Feast, Tecton, etc.

Lab Session:

Model training and logging with MLflow, Docker containerization, inference via API, and discussing DVC and drift detection tools

Introduction to Causal Inference

Differences and methods between correlation and causation.

• Examples of "Correlation does not imply causation"
• Neyman-Rubin Causal Model: treatment, control groups, Average Treatment Effect (ATE)
• Confounding variables and causal bias
• Methods:
  • Randomized controlled trials (RCTs, A/B tests)
  • Observational methods: propensity score matching, difference-in-differences, regression discontinuity
  • ML-based causal methods (Causal Forests, Double ML)
• Causal discovery (brief mention)

Explainable AI (XAI) & Model Interpretability

Interpreting and explaining complex models.

• Need for explainability: trust, debugging, fairness, regulation
• Model-specific vs. model-agnostic methods
• Interpretation techniques:
  • Coefficient interpretation of linear models
  • Feature importance and decision paths in tree-based models
  • Local (LIME) and global (SHAP) explanations
  • Counterfactual explanations, concept-based methods (e.g., TCAV)

Responsible AI: Ethics, Fairness & Privacy

Applying ethical principles in AI applications.

• Ethical principles in AI: accountability, transparency, fairness, non-maleficence
• Sources of bias in ML: data, algorithm, human bias
• Fairness metrics: demographic parity, equal opportunity, trade-offs
• Bias mitigation techniques: preprocessing, in-processing constraints, post-processing adjustments
• Privacy: data anonymization, differential privacy, federated learning

Lab Session:

Explaining a complex model with SHAP analysis, evaluating fairness metrics; discussing potential bias mitigation strategies

Project Ideation & Scoping

The process of identifying real-world problems that apply learned techniques.

• Identifying real-world problems
• Individual or team-based brainstorming
• Defining objectives, deliverables, and success metrics
• Project planning, scoping, and ethical review

Data Collection & Advanced EDA for the Capstone Project

Collecting data and performing in-depth analysis aligned with project goals.

• Finding and acquiring relevant datasets (public sources, APIs, web scraping)
• Building data ingestion pipelines
• Goal-oriented EDA and advanced visualization techniques
• Formulating initial hypotheses

Baseline Modeling & Iteration Plan

Evaluating initial model performance and planning improvements.

• Selecting and implementing appropriate baseline models
• Measuring model performance
• Identifying areas for improvement
• Iteration plan: feature engineering, SOTA model selection, hyperparameter tuning

Lab Session:

Intensive hands-on work on the project with dedicated mentorship, refining the problem statement, securing data, conducting comprehensive EDA, and planning baseline model implementation

Advanced Modeling & Evaluation for the Capstone Project

Evaluating the final solution by applying SOTA models.

• Implementing advanced models (Transformers, XGBoost/LightGBM, RAG, Diffusion)
• Advanced hyperparameter optimization (e.g., Bayesian optimization)
• Model evaluation, error analysis, and interpretation (SHAP, LIME)
• Simulating deployment strategies

Project Presentation & Documentation

Effectively communicating project methodology, results, and impact.

• Structuring a technical presentation
• Creating compelling visualizations for results
• Communicating complex ideas clearly to diverse audiences
• Writing project documentation (e.g., README, technical report)
• Building a project portfolio piece

Career Launchpad

Preparing for a successful job search in data science.

• The data science job market: roles, required skills, industry trends
• Crafting an effective resume
• Building a professional online presence (LinkedIn, GitHub portfolio)
• Networking strategies
• Technical and behavioral interview preparation (STAR method, take-home assignments, case studies, salary negotiation)

Lab Session:

Project finalization, presentation practice, peer and instructor feedback, mock interview sessions, and resume review workshops

Continuous Learning & Community

Resources and networking to stay current and receive ongoing support.

• Access to curated resources (blogs, newsletters, key researchers, conferences)
• Ongoing support and networking via the bootcamp alumni network

Career Services Extension

Post-graduation job search support and access to employer partner networks.