CS207 Study Guide

Navigating this Study Guide

Study Guide Structure

In this study guide, the sections in each unit (1a., 1b., etc.) are the learning outcomes of that unit. 

Beneath each learning outcome are:

• questions for you to answer independently;
• a brief summary of the learning outcome topic; and
• and resources related to the learning outcome. 

At the end of each unit, there is also a list of suggested vocabulary words.

 

How to Use this Study Guide

1. Review the entire course by reading the learning outcome summaries and suggested resources.
2. Test your understanding of the course information by answering questions related to each unit learning outcome and defining and memorizing the vocabulary words at the end of each unit.

By clicking on the gear button on the top right of the screen, you can print the study guide. Then you can make notes, highlight, and underline as you work.

Through reviewing and completing the study guide, you should gain a deeper understanding of each learning outcome in the course and be better prepared for the final exam!

Unit 1: Introduction to Machine Learning

1a. Describe machine learning and its importance in modern technology

• What is machine learning (ML), and how does it fundamentally differ from traditional programming?
• Why can't complex problems like fraud detection be effectively solved without ML?
• What are three concrete examples of ML's transformative impact on modern industries?

Machine learning (ML) is a subset of artificial intelligence (AI) where systems learn patterns from data without being explicitly programmed. Unlike traditional programming, which relies on human-defined rules, ML uses algorithms such as neural networks, which are computational models inspired by biological neural systems, to autonomously improve through data exposure. This adaptive capability is critical in solving complex, data-rich problems like fraud detection, where ML identifies subtle anomalies across millions of transactions in real time.

Predictive analytics refers to the use of statistical and machine learning techniques to analyze historical data and make predictions about future outcomes. In healthcare, for example, it supports early disease detection by identifying patterns in patient data that correlate with specific diagnoses.

Recommendation systems are algorithms that suggest items such as products, movies, or content based on a user's past behavior, preferences, or similar users' actions. In e-commerce, these systems enhance user experience by recommending relevant products, increasing engagement and sales.

ML is not magic. It is mathematics and statistics applied to data. Its effectiveness depends entirely on the quality of the input data (garbage in, garbage out). A key limitation of ML is its difficulty in establishing causality. It identifies correlations but often cannot explain the underlying reasons. A significant portion of ML work, often up to 80 percent, involves data preprocessing, which lays the foundation for building effective models.

To review, see:

• What is Machine Learning?

1b. Differentiate between supervised, unsupervised, and reinforcement learning

• How does supervised learning use labeled datasets differently from unsupervised learning's approach to unlabeled data?
• What role do reward signals play in reinforcement learning that distinguishes it from other paradigms?
• When would you choose clustering (unsupervised) over classification (supervised) for a business problem?

Supervised learning is a machine learning approach that trains models using labeled datasets, which are collections of data where each input example is paired with its known correct output or target value. This enables prediction tasks like regression, a type of supervised learning that predicts continuous numerical values such as home prices or rainfall amounts, and classification, a type of supervised learning that assigns data points to discrete categories like identifying spam emails where models output binary (spam/not spam) or multiclass (rain/hail/snow) results.

In contrast, unsupervised learning is a machine learning approach that analyzes unlabeled datasets (datasets without known target outputs or correct answers) to discover hidden patterns through techniques like clustering that group similar data points without predefined labels, such as identifying natural weather pattern clusters that might reveal seasonal segments.

Reinforcement learning is a machine learning paradigm that operates fundamentally differently by having an agent learn through trial-and-error interactions, which involve repeatedly attempting actions in an environment and learning from the consequences, with an environment where it receives reward signals for desirable actions, like a robot learning to walk by receiving positive feedback for forward movement, with this approach generating a policy that defines the optimal strategy for maximizing rewards.

Supervised learning requires expensive labeled data, unsupervised learning extracts insights from raw data, and reinforcement learning focuses on sequential decision-making through environmental feedback. Clustering is ideal for exploratory analysis when categories are unknown, whereas classification suits problems with predefined labels like fraud detection.

To review, see:

• Types of ML Systems

1c. Explain the relationship between AI, machine learning, and data science

• How is machine learning (ML) positioned as a subset of artificial intelligence (AI)?
• What distinguishes data science from machine learning in terms of scope and objectives?
• How do these three fields intersect in real-world applications like recommendation systems?

Artificial intelligence (AI) is the broad discipline focused on creating systems that mimic human intelligence, encompassing everything from chess-playing computers to voice assistants. Machine learning (ML) is a critical subset of AI where systems learn patterns from data without explicit programming. For example, ML algorithms enable AI features like Netflix's recommendation engine by predicting user preferences based on viewing history.

Data science provides the foundational framework that supports both AI and ML, involving the entire lifecycle of data collection, cleaning, analysis, and interpretation using statistical methods and domain expertise. ML focuses specifically on predictive modeling, while data science includes broader tasks like exploratory data analysis and visualization to extract insights from raw information.

These fields intersect practically: data scientists prepare and analyze data (such as user behavior logs), ML engineers build models to automate decisions (like "suggest similar shows"), and AI integrates these models into intelligent systems that simulate human-like interactions. AI is the overarching goal, ML is a method to achieve it, and data science is the toolbox. You cannot build effective AI/ML without data science principles, yet not all data science work involves AI/ML.

To review, see:

• AI, ML, Data Science: Roles and Responsibilities

Unit 1 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• artificial intelligence (AI)
• classification
• data science
• labeled dataset
• machine learning (ML)
• neural network
• predictive analysis
• recommendation system
• regression
• reinforcement learning
• supervised learning
• trial-and-error interaction
• unlabeled dataset
• unsupervised learning

Unit 2: Machine Learning Workflow

2a. Explain the ML pipeline from data collection to evaluation

• What are the three main artifacts in a machine learning project, and how do they correspond to workflow phases?
• Why is data preparation considered the most resource-intensive phase?
• How do model serving and performance monitoring ensure real-world effectiveness post-deployment?

The ML pipeline is a structured, end-to-end process that systematically transforms raw data into predictive insights through three core phases, each aligned with a primary artifact: data engineering, model engineering, and code engineering.

In the data engineering phase, which encompasses all activities related to collecting, cleaning, and preparing data for machine learning, teams perform data acquisition, the process of collecting data from various sources via APIs or CSVs, followed by data preparation, which refers to the comprehensive process of transforming raw data into a format suitable for machine learning and is the most time-intensive stage. It includes exploratory analysis, data validation (the process of checking data format, structure, and quality to ensure it meets requirements), data wrangling (the process of cleaning and transforming data by handling missing, incorrect, or inconsistent values), data labeling (the process of assigning target categories or values to data points for supervised learning), and data splitting (the practice of dividing datasets into separate portions, like training, validation, and test sets, to enable proper model development and evaluation). This phase ensures that only clean, relevant data reaches the next stage, reducing the risk of flawed outcomes.

Model engineering focuses on developing and optimizing machine learning models by selecting and applying ML algorithms via steps like model training, feature engineering, hyperparameter tuning, and model evaluation against performance metrics. After evaluation, the model testing step uses holdout data to check generalization, and model packaging prepares the trained model (using ONNX format) for deployment.

In the final code engineering phase, which involves deploying and maintaining models in production environments, models are deployed via model serving, integrated into applications, and monitored through performance monitoring, the ongoing process of tracking model behavior to detect issues like data drift or accuracy degradation, and performance logging, the systematic recording and storage of model inference results and metadata for analysis and auditing purposes. Continuous feedback enables re-training if the model's accuracy degrades in real-world settings.

Data preparation can take 60% to 80% of the total effort, but it is foundational to successful modeling. Post-deployment, monitoring and retraining are critical because real-world data evolves, and models must adapt to remain effective.

To review, see:

• ML Pipeline

2b. Explain the significance of each stage in the pipeline

• Why is data engineering considered the most critical and time-intensive phase in ML workflows?
• How does model evaluation prevent flawed deployments, and what techniques ensure reliability?
• What risks does performance monitoring address in production environments?

Each phase of the machine learning (ML) pipeline plays a vital role in ensuring models remain accurate and reliable, with data engineering standing out as the most labor-intensive (consuming up to 80% of effort) and foundational stage because it transforms raw data into clean, consistent inputs through validation (checking formats/distributions), wrangling (fixing missing values), and splitting, preventing "garbage in, garbage out" outcomes where even sophisticated algorithms fail on flawed data. Model engineering then converts this curated data into predictive models through training and rigorous evaluation techniques like cross-validation (testing on multiple data subsets) and holdout datasets (unseen data testing), which act as quality control to detect overfitting (memorizing training data) or bias before deployment.

Finally, code engineering operationalizes models via serving while performance monitoring tracks real-world accuracy decay from data drift (evolving user behaviors) and performance logging records predictions, enabling timely re-training to combat model degradation.

Skipping any stage risks systemic failures: neglected data engineering propagates hidden errors, weak model evaluation permits biased deployments, and absent monitoring creates "zombie models" that produce increasingly inaccurate results.

To review, see:

• Significance of Each Stage in ML Software Development

Unit 2 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• code engineering
• cross-validation
• data acquisition
• data drift
• data engineering
• data labeling
• data preparation
• data splitting
• data validation
• data wrangling
• ML pipeline
• model engineering
• performance logging
• performance monitoring

Unit 3: Data Preprocessing

3a. Apply data cleaning techniques to improve dataset quality

• What are the three primary methods for handling missing data, and when should each be applied?
• How does partial match deduplication differ from an exact match, and why is careful column selection critical?
• What risks do outliers pose to statistical analysis, and how can their impact be quantified?
• Why are validation rules essential for preventing data entry errors during collection?

Data cleaning is the systematic process of identifying and correcting errors, inconsistencies, and inaccuracies in datasets to transform raw, error-prone datasets into reliable inputs for analysis through systematic techniques. For missing data, which refers to absent or unavailable values in a dataset, three core methods exist: removal, the technique of deleting rows or columns containing missing values (deleting rows/columns when missingness is minimal/random, like eliminating records with empty salary fields), imputation, the process of replacing missing values with estimated or calculated substitutes (replacing gaps with statistical substitutes like mean/median values, such as filling missing ages with the average age), and flagging, the method of creating indicator variables to mark the presence or absence of missing data (marking missing entries via binary indicators like "Missing"/"Not Missing" to preserve data absence patterns).

Duplicates, which are identical or near-identical records that appear multiple times in a dataset, require careful handling. Exact match removal deletes fully identical rows, while partial match targets specific columns (such as deduplicating by ID only), with incorrect column selection risking valid record loss (such as distinct Alices with different IDs). Normalizing formats is the process of standardizing data representation to ensure consistency across the dataset, such as through date standardization (converting "Dec 5, 2023" to "2023-12-05"), text case normalization (lowercasing "Banana" → "banana"), and unit conversion (transforming "160 lbs" → "72.57 kg").

Outlier detection is the process of identifying data points that significantly deviate from the typical pattern or distribution in a dataset, employing visual methods, which are graphical techniques for identifying anomalies through data visualization (box plots revealing income anomalies) or statistical methods, which are mathematical approaches that use numerical criteria to identify unusual values (IQR/z-scores flagging values beyond ±1.5*IQR), with handling choices keeping verified anomalies (such as valid executive salaries), removing distorting values, or log-transforming skewed distributions directly impacting metrics (for example, a single $199k outlier inflating mean income by $10.4k).

Finally, data entry errors are minimized via validation rules, which are predefined constraints or checks applied to data inputs to prevent invalid or incorrect entries (blocking future birth dates), manual review for small datasets, and automated checks (format/range verification). Many people often underestimate partial match risks and outlier handling trade-offs. Context determines techniques; for example, mean imputation simplifies but distorts variance, while flagging preserves data integrity for bias analysis.

To review, see:

• Data Cleaning Techniques

3b.  Apply normalization techniques to preprocess datasets for effective analysis

• What are the four key benefits of normalizing numerical features?
• When should you choose Z-score scaling over linear scaling?
• Why is log scaling particularly effective for power law distributions?
• How does clipping mitigate the impact of extreme outliers without removing them?

Normalization transforms numerical features onto comparable scales to enhance model effectiveness, offering four key benefits: it accelerates convergence during training by stabilizing gradient descent, improves prediction accuracy by balancing feature influence, prevents NaN errors from floating-point overflows, and ensures equitable weight assignment across features. For features with uniform distributions (like ages ranging from 0–100), linear scaling, which is a normalization technique that applies a mathematical transformation to map data values from their original range to a new target range, such as min-max normalization to a [0,1] range, is effective. However, Z-score scaling, which is a standardization method that transforms data by subtracting the mean and dividing by the standard deviation (standardization using mean and standard deviation), is preferable for normally or near-normally distributed data (like adult height), as it centers the data around a mean (μ) of 0 with a standard deviation (σ) of 1, highlighting outliers while standardizing bulk values.

Log scaling, which is a transformation technique that applies the natural logarithm function to compress the range of values (that is, scaling using the natural log), is especially effective for power law distributions such as income, book sales, or movie ratings, where most values are small and a few are extremely large. This compresses the range (for example, ln(100) ≈ 4.6 vs. ln(1,000,000) ≈ 13.8), enabling better model learning from skewed data. For extreme outliers (such as a roomsPerPerson variable with a long-tailed distribution up to 17), clipping, which is a technique that limits values by setting maximum and minimum thresholds to constrain data within specified bounds, caps values at thresholds (like max = 4.0) to mitigate their influence without deleting them. Crucially, the same normalization logic must be applied to both training and inference data; otherwise, model predictions become invalid.

Be sure you understand the trade-offs: linear scaling distorts skewed data, Z-score normalization assumes Gaussian-like distributions, and aggressive clipping can suppress valid signals. Log transformation combined with clipping is often the most robust strategy for skewed industrial datasets such as housing prices, sales, or server loads.

To review, see:

• Understanding Normalization of Numerical Data

3c. Apply encoding techniques to transform categorical data for machine learning models

• Why can't machine learning models directly use raw string values like "Red" or "Blue"?
• How does one-hot encoding represent categorical variables numerically?
• When should you use sparse representation instead of full one-hot vectors?
• How are high-dimensional categorical features (like words or postal codes) handled differently from low-dimensional ones?

Since models only process floating-point numbers, categorical data encoding converts non-numerical features into machine-readable formats. For low-dimensional features (when there are few categories, like car_color with eight colors), a vocabulary encoding assigns each category a unique integer index (like Red=0, Blue=2).

However, raw indices imply false ordinal relationships (like Blue being "greater than" Red), so one-hot encoding transforms each index into a binary vector where only the category's position is 1.0, and others are 0.0; for example, "Blue" becomes [0,0,1,0,0,0,0,0]. This allows models to learn distinct weights per category.

For efficiency, sparse representation stores only the position of the 1.0 (like "Blue" → 2) rather than the full vector, saving memory while ensuring identical model input. Outliers (rare categories like "Mauve") are binned into an out-of-vocabulary (OOV) bucket (like "Other"), sharing a single weight.

High-dimensional features (such as words_in_english with 500k categories) make one-hot encoding impractical due to excessive memory use. Instead, embeddings, which are learned dense vector representations that map categorical variables to continuous low-dimensional spaces where similar categories have similar vector values, or hashing, which is a technique that applies a hash function to map categorical values into a fixed number of buckets, effectively reducing the feature space by binning categories into predetermined buckets, reduce dimensionality, improving training speed and inference latency. Many people often confuse one-hot with label encoding. One-hot prevents false ordinal assumptions but scales poorly beyond ~10k categories.

To review, see:

• Categorical Data: Vocabulary and One-Hot Encoding

Unit 3 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• clipping
• data cleaning
• duplicate
• embedding
• flagging
• hashing
• imputation
• linear scaling
• log scaling
• missing data
• normalizing format
• one-hot encoding
• outlier detection
• removal
• sparse representation
• statistical method
• validation rule
• visual method
• Z-score scaling

Unit 4: Data Visualization

4a. Apply visualization using different plot types to understand data patterns

• When should you choose a histogram over a box plot to analyze a feature's distribution?
• How does a scatter plot matrix reveal relationships between multiple numerical variables?
• Why is a heatmap effective for visualizing aggregated relationships between two categorical variables?
• What advantages do interactive visualizations offer for exploring temporal trends?

Data visualization transforms raw data into graphical representations to uncover patterns and relationships. For analyzing distributions, histograms (using sns.histplot()) bin numerical values into intervals to show frequency concentrations and are ideal for single features like critic scores in games. In contrast, box plots (using sns.boxplot()) compare distributions across categories (for example, video game platforms like PS5 vs. Xbox), visualizing medians, quartiles, and outliers, critical for skewed data.

To explore correlations between numerical variables, scatter plots (using sns.jointplot()) plot pair observations (such as critic scores vs. user scores), while scatter plot matrices (using sns.pairplot()) extend this to multiple features in one view. For categorical relationships, heatmaps (using sns.heatmap()) use color intensity to represent aggregated values (such as RPG sales on PlayStation platforms), revealing dominance patterns efficiently. Interactive visualizations (like Plotly) enable dynamic exploration, hovering for exact values, zooming into periods (such as game sales from 1995-2025), or toggling series, making them indispensable for large, multidimensional datasets.

Many people often confuse histograms with bar charts (the latter is for categorical counts) or misuse box plots for small samples (hiding distribution shapes). Match plots to analytical goals - histograms for shape, box plots for category comparisons, heatmaps for cross-tabulations, and interactivity for temporal/multivariate data. Preprocessing (like handling missing values and dtype conversion) precedes effective visualization, and library selection balances ease (like Seaborn) with flexibility (like Matplotlib) and interactivity (like Plotly).

To review, see:

• Visual Data Analysis

4b. Analyze patterns and insights from visual data

• How can visualizations help detect trends and anomalies in datasets?
• What kinds of insights can be drawn from scatter plots, heatmaps, or box plots?
• How does visual grouping or clustering suggest relationships between features?
• Why is it important to interpret visualizations critically instead of assuming patterns always imply causation?

Visualizations are essential for discovering patterns, trends, and anomalies in data. Rather than relying solely on numerical summaries, visual representations allow analysts to observe underlying structures in datasets. Scatter plots, heatmaps, and box plots make it easier to compare variables, detect outliers, and reveal relationships.

For instance, scatter plots can reveal correlations or clusters among pairs of numerical variables. In a scatter plot of study_hours vs. exam_scores, students with more study hours may generally have higher scores, indicating a positive correlation. Clusters in such a plot could suggest groupings (such as low-effort/low-score students vs. high-effort/high-score ones).

Heatmaps summarize large tables of data by using color to represent values. When applied to two categorical variables, they can show which combinations occur most frequently. For example, a heatmap showing genre vs. platform sales in gaming can highlight strong associations between specific genres and consoles.

Box plots help compare distributions across categories. They allow analysts to visualize the median, interquartile range (IQR), and outliers. For example, comparing game review scores across platforms using box plots may reveal that some platforms consistently score higher or have more variability.

Visual grouping or clustering, such as dense regions in scatter plots, suggests that some observations are more similar to each other. However, it's important to remember that correlation does not imply causation. Visual trends must be supported with statistical analysis.

Before analyzing visual data, datasets must be cleaned and correctly preprocessed to avoid misleading interpretations. Choosing the right visualization type is crucial for making accurate and efficient insights.

To review, see:

• Interpretations of Data Visualizations

4c. Explain the importance of feature engineering and key features in data

• What is feature engineering, and how does it contribute to improving machine learning model performance?
• What are the key features, and how do we identify them from raw datasets?
• Why is feature selection important, and what issues can it help prevent?

Feature engineering is a vital part of the machine learning pipeline, where raw data is transformed into meaningful inputs that enhance model performance. It involves creating new variables, modifying existing ones, and identifying the most relevant features, often called key features, that have the most predictive power. These steps directly affect how well a model learns patterns and generalizes to new data. One crucial subtask is feature selection, which helps reduce overfitting, improves model interpretability, and decreases computational cost by eliminating irrelevant or redundant features.

For instance, when predicting house prices, including features like square footage or location adds more value than identifiers such as the listing ID. Techniques such as correlation analysis, mutual information, or feature importance scores from algorithms like random forests can help identify key features. Another essential concept is feature transformation, which includes normalizing numerical data or encoding categorical variables so they are usable by machine learning algorithms. Beginners often struggle to choose the right features or may include too many, leading to poor performance. Reinforcement through visualization and real-world examples usually helps clarify these challenges. Understanding and applying feature engineering effectively ensures the data fed into a model is high quality, something no algorithm can compensate for if missing.

To review, see:

• Feature Engineering and Feature Selection

Unit 4 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• data visualization
• feature transformation
• heatmap
• interactive visualization
• scatter plot
• scatter plot matrix
• visual representation

Unit 5: Supervised Learning – Regression

5a. Implement linear regression models using Python

• What is linear regression, and when is it appropriate to use this model?
• How do you implement linear regression using Python libraries like Scikit-learn?
• What is the difference between training and predicting in a regression task?

Linear regression is a fundamental supervised learning technique that models the relationship between input features and a continuous target variable by finding the best-fitting linear equation. It predicts a continuous numerical outcome based on one or more input features. The core idea is to fit a straight line (in simple linear regression) or a hyperplane (in multiple regression) that minimizes the error between the predicted and actual values, typically using the least squares method.

The most common approach to implementing linear regression in Python is through the Scikit-learn library, which is a comprehensive ML library for Python that provides simple and efficient data analysis and modeling tools. The process starts with importing the necessary libraries and splitting the dataset into features (X) and targets (y). The LinearRegression() class from sklearn.linear_model is used to fit, which is the process of training a machine learning model by having it learn patterns from the training data, the model on training data using .fit(X, y).

Once trained, the model can predict outcomes with .predict(X_new). Important outputs include the model coefficients, which are the learned parameters that quantify the strength and direction of the relationship between each input feature and the target variable (slopes), and the intercept, which provides interpretability. For example, in a housing price dataset, the model might predict price as a function of square footage, where the coefficient indicates how much price increases per additional square foot.

Beginners often confuse regression with classification or attempt to use it on categorical data without proper preprocessing, such as encoding categorical variables. Also, without visualizing residuals, signs of poor model fit can be missed. Reinforcing implementation with real datasets and synthetic examples can help you understand how model training, evaluation, and prediction work together to build effective regressors.

To review, see:

• Linear Regression

5b. Evaluate regression models using metrics such as Mean Absolute Error (MAE), Mean Squared Error (MSE), Root Mean Squared Error (RMSE), and R-squared (R²)

• How does Mean Absolute Error (MAE) differ from Root Mean Squared Error (RMSE) in sensitivity to outliers?
• Why does Mean Squared Error (MSE) penalize large errors more heavily than MAE?
• How is R-squared (R²) interpreted as a "goodness-of-fit" measure, and what are its limitations?
• When would you prioritize RMSE over MAE for model evaluation?

Evaluating regression models requires understanding how different metrics capture prediction error and model accuracy. Mean absolute error (MAE) calculates the average of the absolute differences between predicted and actual values, making it intuitive and robust to outliers. It is interpreted as the average error in the units of the target variable. For instance, if MAE = 15, the model is off by 15 units on average. In contrast, mean squared error (MSE) squares the differences before averaging, which penalizes larger errors more severely. This makes MSE more sensitive to outliers and useful when large errors have significant consequences, such as in financial modeling. Root mean squared error (RMSE) is simply the square root of MSE. It restores the unit consistency with the original target variable, maintaining MSE's outlier sensitivity while making interpretation easier (for example, putting error in dollars rather than dollars squared).

Another key metric is R-squared (R²), which measures the proportion of variance in the dependent variable that is explained by the model. R² values range from 0 to 1, where higher values indicate better model fit. However, R² increases with more features, regardless of their relevance. Therefore, it can be misleading in high-dimensional models. For such cases, adjusted R² is preferred because it accounts for the number of predictors. Beginners often misinterpret R², assuming that R² > 0.7 is always "good", but in practice, this depends on the context and domain. For example, an R² of 0.95 might be expected in physics, whereas in social sciences, even 0.3 could be significant.

Each metric has its use case. MAE is better when all errors are equally important, and interpretability is needed. RMSE is useful when large errors are especially problematic. In practice, both are often reported together for a balanced view. Feature scaling can affect these metrics, so normalization is important during preprocessing.

To review, see:

• Evaluating Regression Models: Metrics and Loss Functions

5c. Discuss the limitations of regression models

• How do violations of linearity, constant variance, and normality assumptions invalidate regression results?
• Why does autocorrelation in time series data violate regression assumptions, and how does it distort statistical inference?
• What problems arise when applying linear regression to binary outcomes, and how does this lead to nonsensical predictions?

Regression models rely on several key assumptions, and when these are violated, the model's predictions and inferences become unreliable. The linearity assumption implies a straight-line relationship between the independent and dependent variables. When the true relationship is nonlinear (for example, drug efficacy increases and then drops at high doses), regression produces biased results. A related issue is heteroscedasticity, which is a condition where the variance of the residuals (prediction errors) changes across different levels of the independent variables, or non-constant variance, which refers to the situation where the spread or variability of residuals is not consistent across the range of predicted values, where the spread of residuals grows or shrinks across the range of fitted values such as housing price prediction errors increasing with house size. This distorts confidence intervals and undermines the validity of hypothesis tests. Additionally, if residuals do not follow a normal distribution, the model's p-values and t-statistics become unreliable, leading to a higher chance of false positives or negatives.

Another major limitation is autocorrelation, which is the correlation between residuals at different time points or observations, meaning that the error terms are not independent of each other, particularly in time series data. When error terms are correlated across time (such as daily sales that are influenced by previous days), the assumption of independence is violated. This can lead to underestimated standard errors and overconfident conclusions, for example, wrongly attributing a sales jump to a recent campaign when it may just be a seasonal pattern. Moreover, applying linear regression to binary outcomes like predicting whether a person has a disease results in illogical predictions outside the 0–1 range (like probabilities of -0.2 or 1.3), violating assumptions of constant variance and normality. In such cases, logistic regression or other classification models are more appropriate.

Many people often miss subtle issues like interaction effects, where the impact of one feature depends on another (for example, the effect of education on income differing by gender), or the dangers of extrapolation, where predictions made beyond the observed data range (like estimating house prices for 10,000 sq ft homes) can be highly misleading.

To review, see:

• Limitations of Regression Model

Unit 5 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• adjusted R²
• autocorrelation
• extrapolation
• heteroscedasticity
• interaction effect
• linearity assumption
• linear regression
• mean absolute error (MAE)
• mean squared error (MSE
• model coefficient
• non-constant variance
• R-squared (R²)
• root mean squared error (RMSE)
• Scikit-learn

Unit 6: Supervised Learning – Classification

6a. Implement logistic regression models

• What role does the sigmoid function play in converting linear outputs to probabilities in logistic regression?
• How does logistic regression handle binary classification differently from linear regression?
• Why is log loss used instead of mean squared error to train logistic regression models?

To implement a logistic regression (a statistical method used for binary classification that models the probability of class membership using the logistic function rather than predicting continuous values directly), we use the sigmoid function, which is a mathematical function that maps any real-valued input to an output between 0 and 1, creating a smooth S-shaped curve, defined as σ(z) = 1 / (1 + e^(-z)). This transformation is essential when predicting binary outcomes, such as spam vs. non-spam emails. For instance, a model output of 2.5 becomes σ(2.5) ≈ 0.92, or a 92% probability of the positive class. Unlike linear regression, which predicts continuous values and may yield invalid probabilities (like -0.3 or 1.2), logistic regression ensures outputs are valid for classification.

During training, the model minimizes log loss (also known as cross-entropy loss), which is a loss function specifically designed for classification problems that measures the difference between predicted probabilities and actual class labels by penalizing incorrect predictions based on confidence. Log loss penalizes incorrect predictions based on confidence: highly confident but wrong predictions (like predicting 0.99 for a true label of 0) are punished more severely than slightly incorrect ones. Mean squared error (MSE) is not ideal for classification, as it leads to slower convergence and treats all errors equally, regardless of confidence. A threshold (typically 0.5) is used to convert predicted probabilities into class labels: if σ(z) ≥ 0.5, the prediction is class 1; otherwise, class 0. However, this threshold may be adjusted in contexts like medical diagnosis, where reducing false negatives is more important than accuracy. A common mistake is misapplying linear regression for classification tasks.

To review, see:

• Logistic Regression: Sigmoid Function

6b. Explain the fundamentals of classification, including thresholding and confusion metrics, to assess model performance

• How does classification fundamentally differ from regression, and what types of problems require classification?
• Why is thresholding necessary in logistic regression, and how does adjusting the threshold impact false positives vs. false negatives?
• How do the four components of a confusion matrix (true positives, false positives, true negatives, and false negatives) quantify different types of prediction errors?

Classification differs from regression by predicting categorical rather than continuous outcomes; for example, classifying emails as "spam" or "not spam" rather than predicting a numerical spam score. Problems like medical diagnosis, fraud detection, and sentiment analysis are better suited for classification because they involve discrete labels. In logistic regression, the model outputs probabilities, which must be converted into class labels using a threshold(commonly 0.5). Adjusting this threshold shifts the balance between false positives (FP) and false negatives (FN). Lowering the threshold increases sensitivity (more true cases detected) but may trigger more FPs, while raising it reduces FPs but risks missing actual positives (more FNs).

The confusion matrix breaks down prediction results into four categories: true positives (TP) are correctly predicted positive cases, true negatives (TN) are correctly predicted negatives, false positives (FP) are negative cases incorrectly predicted as positive, and false negatives (FN) are positive cases the model missed.

These values help calculate key evaluation metrics: precision (TP / (TP + FP)) measures how reliable positive predictions are, while recall (TP / (TP + FN)) measures how well the model captures all actual positives. For example, if a spam filter identifies 80 spam emails correctly (TP), marks 5 legitimate emails as spam (FP), and misses 15 spam emails (FN), then precision = 80 / (80 + 5) ≈ 94% and recall = 80 / (80 + 15) ≈ 84%.

Many people often confuse precision and recall. Clarify that precision asks "When the model predicts positive, how often is it right?", while recall asks "Of all actual positives, how many did the model catch?". Additionally, you may overlook the business context when choosing a threshold; for example, a false negative can be far more costly in cancer detection than a false positive. Visual tools like ROC curves can help you understand the trade-offs involved in threshold selection across different operating points.

To review, see:

• Classification

6c. Explain classification models using metrics like accuracy, precision, recall, and F1-score

• Why is accuracy misleading for imbalanced datasets (such as fraud detection with 99% legitimate transactions)?
• How do precision and recall measure conflicting aspects of model performance?
• Why does the F1 score provide a more reliable metric than accuracy when class distribution is skewed?
• How do ROC curves visualize the trade-off between true positives and false positives across classification thresholds?

Evaluating classification models requires more than just accuracy, which is calculated as (TP + TN) / total predictions. Although intuitive, accuracy becomes misleading for imbalanced datasets. For example, in fraud detection, if only 1% of transactions are fraudulent, a model labeling everything as legitimate achieves 99% accuracy but fails to identify any fraud. This limitation underscores the need for more nuanced metrics.

Precision, defined as TP / (TP + FP), evaluates the reliability of positive predictions: how often the model is correct when it predicts a positive case like fraud. Recall, or TP / (TP + FN), measures coverage of how well the model captures actual positive cases. These two metrics often conflict: increasing recall by capturing more positives may increase false positives, thereby lowering precision.

To balance these trade-offs, the F1 score provides a harmonic mean of precision and recall: F1 = 2 × (precision × recall) / (precision + recall). It is especially useful when a class imbalance exists, and both types of errors matter.

Receiver operating characteristic (ROC) curves help visualize model performance across different thresholds by plotting the true positive rate (recall) against the false positive rate (FPR = FP / (FP + TN)). The area under the curve (AUC) summarizes this curve into a single value: 0.5 indicates random guessing, while 1.0 represents perfect classification.

To review, see:

• Evaluating Classification Model

Unit 6 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• accuracy
• area under the curve (AUC)
• confusion matrix
• F1 score
• false negative (FN)
• false positive (FP)
• logistic regression
• log loss
• precision
• recall
• receiver operating characteristic (ROC) curve
• sigmoid function
• true negative (TN)
• true positive (TP)

Unit 7: Unsupervised Learning – Clustering

7a. Explain clustering and its types

• What is clustering in unsupervised learning, and how does it differ from classification?
• What are the four main types of clustering algorithms, and what characteristics of data or tasks guide their selection?
• How does density-based clustering handle irregular shapes and noise compared to centroid-based methods like K-Means?

Clustering is an unsupervised learning technique that groups similar data points based on inherent patterns without predefined labels. Unlike classification, which assigns inputs to known categories (like spam or not spam), clustering discovers natural groupings in unlabeled data, making it ideal for exploratory tasks such as customer segmentation, anomaly detection, or image compression.

There are four primary types of clustering algorithms, each suited to different kinds of data and patterns. Centroid-based methods like K-Means clustering form spherical clusters around central points (centroids) and are efficient for large datasets with evenly sized, well-separated clusters. However, K-Means is sensitive to outliers and initial centroid placement and fails on irregular shapes.

Hierarchical clustering builds tree-like structures called dendrograms through agglomerative (bottom-up) or divisive (top-down) approaches, capturing nested relationships but scaling poorly with large data.

Distribution-based clustering, such as Gaussian mixture models (GMM), assumes the data comes from a combination of probability distributions, offering flexibility for elliptical clusters but requiring careful parameter tuning.

Density-based clustering algorithms like DBSCAN group data into dense regions separated by sparse areas and excel at handling non-globular clusters and noise, though they may struggle with varying densities.

Many people apply K-Means by default, even on unsuitable datasets, resulting in poor results. The importance of visual inspection and evaluation metrics like the silhouette score or Davies-Bouldin index to assess cluster quality. Introduce density-based methods early when working with spatial or geographic data, as they are robust to noise and non-linear boundaries.

To review, see:

• Introduction to Clustering

7b. Implement the K-Means clustering algorithm using Python

• What are the main steps of the K-Means clustering algorithm, and how does the algorithm converge?
• How do we choose the optimal number of clusters (k) using techniques like the elbow method or silhouette score?
• What are the common implementation pitfalls of K-Means, and how do outliers, feature scaling, and cluster shapes impact its performance?

The K-Means clustering algorithm is one of the most widely used unsupervised learning techniques for discovering inherent groupings in unlabeled data. It partitions the dataset into k clusters by minimizing the inertia (the sum of squared distances between each point and its assigned centroid). The algorithm begins with the random initialization of centroids, then follows an iterative process: (1) assign each data point to the nearest centroid based on Euclidean distance, (2) update each centroid to be the mean of the points in its cluster, and (3) repeat until convergence, where cluster assignments stabilize. K-Means assumes that clusters are roughly spherical, of similar size, and equally distributed. Conditions are often violated in real-world datasets. Therefore, it struggles with non-globular clusters, varying densities, and outliers, which can drastically skew centroids and distort clustering results.

To determine an appropriate value for k, you can use the elbow method, where the inertia is plotted against a range of k values to identify the point beyond which adding more clusters yields diminishing returns. Another helpful tool is the silhouette score, which measures how similar a point is to its own cluster compared to other clusters; a higher average score suggests more well-defined clusters. In practice, feature scaling (transforming variables to have similar scales or ranges, typically by standardizing them to have zero mean and unit variance) is critical, as K-Means is sensitive to variable magnitudes. Unscaled features can bias the clustering toward variables with larger numeric ranges. The algorithm is also non-deterministic due to random centroid initialization, so using multiple runs (n_init) helps avoid poor local minima. In Python, the KMeans class from scikit-learn simplifies implementation, offering options for initialization, distance metrics, number of iterations, and evaluation tools. A typical implementation involves importing libraries like pandas, matplotlib, and sklearn.cluster.KMeans, fitting the model on a preprocessed dataset, and visualizing clusters with scatter plots color-coded by labels.

Many people often confuse K-Means with classification because it uses labels post-training. These are not ground-truth classes but inferred groupings. Moreover, be careful not to default to K-Means even when data characteristics suggest that density-based or hierarchical methods would yield better insights.

To review, see:

• K-Means Clustering

7c. Analyze clustering results to identify patterns in data

• How do we interpret cluster centroids and feature distributions to understand the defining characteristics of each cluster?
• What visual tools can help us evaluate the quality of clusters, and how do intra-cluster compactness and inter-cluster separation reflect clustering effectiveness?
• How can we use clustering insights to support decision-making in real-world scenarios such as customer segmentation, market targeting, or anomaly detection?

Analyzing clustering results is critical in deriving actionable insights from unsupervised learning. After fitting a K-Means model, the primary tool for interpretation is the cluster centroid, which represents the average profile of each group. By examining the feature values of centroids (for example, high income and low age in one customer cluster), we identify defining characteristics and compare them across clusters. Effective analysis requires evaluating intra-cluster compactness (how tightly grouped the data points are within a cluster) and inter-cluster separation (how distinct clusters are from one another). Visualization tools such as scatter plots, pair plots, and parallel coordinate plots help uncover meaningful groupings and detect overlaps. A low inertia (sum of squared distances to centroids) suggests the model has formed cohesive clusters, but this metric alone is insufficient.

We often use silhouette analysis to assess how well each point fits within its assigned cluster versus others, with values close to +1 indicating well-separated clusters and values near 0 or negative values suggesting ambiguity or misclassification.

In spatial data, you should look for patterns, such as clusters representing niche customer segments, fraudulent transactions, or geographic groupings. For example, in retail, a cluster might reveal high-spending but infrequent buyers, enabling targeted promotions. Beginners often stop at labeling clusters without exploring business context or domain implications. Clustering is exploratory, and interpreting its results involves collaborations with subject matter experts to validate hypotheses and take informed actions. The value of clustering lies in grouping data and identifying interpretable patterns that inform real-world decisions.

To review, see:

• Analyzing Clustering Results

Unit 7 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• agglomerative
• centroid
• cluster centroid
• clustering
• convergence
• DBSCAN
• density-based clustering
• distribution-based clustering
• divisive
• elbow method
• feature scaling
• Gaussian mixture model (GMM)
• hierarchical clustering
• inertia
• inter-cluster separation
• intra-cluster compactness
• K-means clustering
• silhouette analysis
• silhouette score

Unit 8: Model Evaluation and Validation

8a. Apply a train-test split on datasets and cross-validation techniques to assess model performance

• Why is a train-test split essential for evaluating machine learning models, and what ratio is commonly used?
• How does cross-validation, particularly k-fold cross-validation, improve the reliability of performance estimates compared to a simple train-test split?
• What are the benefits and trade-offs of using stratified sampling during splitting, especially for imbalanced datasets?

To assess how well a machine learning model generalizes to new data, practitioners apply a train-test split, dividing the dataset into two subsets: one for training the model and the other for testing its performance. A typical split ratio is 80:20 or 70:30, where the majority is used for training and the remainder for validation. This process helps detect overfitting, where a model performs well on training data but poorly on unseen data. However, a single split might not reflect the true variability in the data. To address this, cross-validation is used, especially k-fold cross-validation, where the dataset is divided into k equal parts, and the model is trained and validated k times, each time using a different fold as the test set and the rest for training. This results in a more robust and stable estimate of model performance.

Stratified sampling ensures that each fold maintains the same class distribution as the original dataset, which is especially crucial in imbalanced datasets (like with fraud detection). Without stratification, some folds might lack minority class samples, skewing results. Key metrics like accuracy, precision, or F1-score should be calculated over all folds and averaged to represent model quality.

Many people often confuse cross-validation with hyperparameter tuning. While cross-validation is used for model assessment, it also plays a role in model selection and optimization. Remember the difference between validation sets (which are used during model development) and test sets, which are kept untouched until final evaluation.

To review, see:

• Train-Test Split and Cross-Validation

8b. Identify overfitting and underfitting in models

• What are the key differences between overfitting and underfitting, and how do they affect model performance?
• How can performance metrics on training vs. validation data help detect overfitting or underfitting?
• What visualization tools and diagnostic techniques help identify these issues during model training?

In machine learning, recognizing overfitting and underfitting is essential to ensure that models generalize well to unseen data. Overfitting occurs when a model learns not just the underlying patterns but also the noise (random variation, measurement errors, or irrelevant information in the data that doesn't represent the true underlying patterns the model should learn) in the training data, resulting in high accuracy on the training set but poor performance on the validation or test set. This often happens when a model is too complex, uses too many features or deep trees, and memorizes the data rather than generalizing. On the other hand, underfitting arises when a model is too simple to capture the patterns in the data, leading to poor performance on both training and test sets. A classic sign of underfitting is high bias, while overfitting is associated with high variance.

One common diagnostic technique is to plot learning curves showing training and validation loss as a function of training size or epochs. In overfitting, the training loss is low, but the validation loss is high and diverging. In underfitting, both losses remain high. Comparing metrics like accuracy, mean squared error (MSE), or F1-score across training and validation datasets can also reveal these issues.

Many people often mistakenly attribute poor test performance to model failure when, in fact, it may indicate overfitting due to a lack of regularization or underfitting due to insufficient model complexity. Know the importance of balancing bias and variance using tools such as cross-validation, simpler models, or early stopping, and use visual aids to make the concepts intuitive.

To review, see:

• Overfitting and Underfitting

8c. Apply techniques such as L1 and L2 regularization and early stopping to avoid overfitting and improve model performance

• How do L1 and L2 regularization help reduce overfitting by penalizing model complexity?
• What is the difference between early stopping and traditional regularization methods in controlling overfitting?
• How can loss curves be interpreted to apply these techniques effectively during model training?

To prevent overfitting, machine learning practitioners apply techniques like L1 regularization, L2 regularization, and early stopping to control model complexity. L1 regularization (also called lasso) adds a penalty proportional to the absolute value of the model's weights, encouraging sparsity and effectively eliminating irrelevant features. L2 regularization (also called ridge) adds a penalty based on the squared magnitude of weights, shrinking them without necessarily removing any, making it ideal when all features contribute small effects. Both are forms of regularization, a strategy to constrain model parameters and reduce variance, leading to better generalization on unseen data.

Another powerful technique is early stopping, where training is halted once the model's validation loss starts increasing, even if training loss continues to decrease. This indicates the model is beginning to memorize noise. By monitoring loss curves (graphs showing training and validation loss over epochs), you can visually detect the point where overfitting begins. A sharp divergence between the two curves signals that training should stop.

Many people often confuse minimizing training loss with overall model improvement. The goal is low validation error, not perfect training accuracy. Remember that a combination of regularization (L1/L2), smaller models, and early stopping typically results in robust, generalizable models, especially in noisy or high-dimensional datasets.

To review, see:

• Techniques to Avoid Overfitting

Unit 8 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• early stopping
• k-fold cross-validation
• L1 regularization
• L2 regularization
• lasso
• loss curve
• noise
• overfitting
• ridge
• stratified sampling
• train-test split
• underfitting
• validation set

Unit 9: Practical Implementation of ML Models

9a. Build an end-to-end ML project using Python

• What are the essential steps in building a complete machine learning pipeline, from data loading to model evaluation?
• Why is data preprocessing (handling missing values, encoding categorical data, and normalization) crucial before model training?
• How does integrating all ML stages in one pipeline improve project reproducibility and real-world deployment readiness?

Building an end-to-end machine learning project involves following all essential steps, from data loading, exploration, and preprocessing to model training, evaluation, and prediction within a single coherent workflow. The process typically starts with importing libraries such as pandas, numpy, and sklearn, then loading a dataset using tools like read_csv. Afterward, exploratory data analysis (EDA) is performed to understand data distributions and relationships. Key preprocessing tasks include handling missing values, applying label encoding or one-hot encoding to categorical variables, and scaling numerical features using normalization or standardization.

Once preprocessed, the data is split into training and test sets, and a suitable algorithm like logistic regression is applied using sklearn.linear_model. Model training involves fitting the algorithm to the training data, while evaluation uses metrics like accuracy, confusion matrix, and classification report to assess performance on the test set. Finally, predictions are made on new or test data, and visualizations (like ROC curves) are used to communicate results.

Many people focus only on model training and skip structured preparation and post-model steps, which are essential for real-world applications. Treat ML as a holistic pipeline, emphasizing modularity, reusability, and documentation for reproducibility.

To review, see:

• Developing an ML Project

9b. Evaluate the performance of ML models within a project using domain-relevant metrics such as accuracy, precision, recall, F1-score for classification models, and MSE, RMSE, and R²

• How does documenting model performance using standard metrics contribute to the reproducibility and transparency of a machine learning project?
• How do domain-relevant considerations (like the cost of false positives vs. false negatives) influence metric selection in real-world ML projects?
• In what ways can improper or inconsistent use of metrics lead to misleading conclusions or irreproducible results?

Evaluating machine learning (ML) models using standardized, domain-relevant metrics is essential for achieving reproducibility and transparency in applied ML projects. Common metrics include accuracy, precision, recall, F1-score for classification tasks, and Mean Squared Error (MSE), Root Mean Squared Error (RMSE), and R-squared (R²) for regression tasks. These metrics assess model performance, communicate results clearly to stakeholders, support comparisons across experiments, and promote replicable workflows.

In real-world scenarios, domain-specific considerations heavily influence which metrics are most meaningful. For instance, minimizing false negatives (missed diagnoses) may take precedence in healthcare, so recall becomes critical. In contrast, in email spam detection, reducing false positives (legitimate emails marked as spam) may matter more, highlighting the need for precision. Choosing the wrong metric can lead to misleading conclusions, especially in imbalanced datasets where high accuracy might mask poor predictive power.

Research integrity is the commitment to honesty, transparency, and accountability in conducting research. It is essential for building trust and advancing knowledge. Consistent documentation of metric definitions, thresholds, and evaluation conditions is vital to maintain research integrity. Without it, results can become irreproducible, hampering collaboration and progress. Thus, aligning metric selection with domain goals and following reproducibility principles ensures that ML projects are technically sound and ethically and scientifically robust.

To review, see:

• Reproducible Research

9c. Explain the importance of the reproducibility of the project results

• Why is reproducibility impossible without systematic version control of code, data, and environments in ML projects?
• How does version control (like Git + DVC) transform experimental ML workflows from chaotic to auditable and collaborative?
• What scientific, ethical, and operational risks emerge when project results lack reproducibility?

Reproducibility is a cornerstone of ethical and reliable machine learning projects. Reproducibility ensures that results can be consistently regenerated by others or by the original developer at a later time, thereby building trust, promoting transparency, and supporting long-term collaboration. In machine learning, reproducibility is not just about rerunning a script. It requires systematically managing code, data, parameters, and environments to make the full experimental pipeline traceable and recoverable. Without such a structure, even a highly accurate model loses credibility if its results cannot be reproduced.

Version control tools (like Git and extended systems like data version control (DVC)) play a critical role in maintaining reproducibility. They allow every change in code, datasets, and configuration files to be tracked and annotated over time. This makes the development process auditable and supports collaborative workflows where multiple contributors may modify the same project simultaneously. Proper version control ensures that results are not accidental or ephemeral but grounded in a documented and repeatable process.

The risks of not prioritizing reproducibility are significant. Scientifically, it can lead to unverifiable claims; operationally, it creates instability in deploying or scaling models; and ethically, it raises concerns about accountability and fairness when decisions are made based on models that no one can fully explain or replicate. From a pedagogical standpoint, reproducibility is not optional. It is a best practice. They should learn to document their workflows, commit code with meaningful messages, version their datasets and environments, and regularly test the full pipeline from scratch. By doing so, they align their work with FAIR (findable, accessible, interoperable, and reusable) principles and contribute to a culture of responsible machine learning.

To review, see:

• Version Control

Unit 9 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• data version control (DVC)
• exploratory data analysis (EDA)
• Git
• model training
• preprocessing task
• reproducibility
• research integrity
• version control tool

Unit 10: Ethical and Responsible AI

10a. Discuss ethical considerations in ML, including bias and fairness

• What are the five pillars of ethical AI identified in industry frameworks?
• How can algorithmic bias emerge from training data, and what societal impacts can result?
• Why is transparency crucial for ethical ML systems, and how does it relate to accountability?
• What techniques can mitigate discriminatory outcomes in high-stakes domains like hiring or lending?

Creating ethical machine learning systems involves respecting five foundational principles: fairness, transparency, accountability, privacy, and social benefit. These pillars are emphasized in global AI guidelines to ensure responsible development and deployment. Algorithmic bias arises when training data encodes historical inequalities, such as underrepresenting certain demographic groups, leading to unjust outcomes. For example, facial recognition systems may misidentify individuals with darker skin due to biased datasets, which can have serious societal impacts, which are the broader consequences and effects that technology has on communities, institutions, and social structures, from wrongful arrests to loan denials.

Fairness (the principle of ensuring that machine learning systems treat all individuals and groups equitably without discrimination or bias) is promoted through methods like disparate impact analysis (a statistical method for measuring whether an algorithm's decisions disproportionately affect certain demographic groups compared to others) and reweighing training data to correct imbalances. Transparency (the openness and explainability of machine learning systems, allowing stakeholders to understand how decisions are made) requires documentation of data sources, feature selection, and decision logic so that end-users and regulators can understand and audit model behavior. This supports accountability (the principle that organizations and individuals must take responsibility for the consequences and outcomes of their AI systems), which ensures that institutions, not just algorithms, are held responsible when harm occurs. Privacy is another cornerstone, requiring safeguards like differential privacy to protect individuals' data during training and deployment. Finally, social benefit emphasizes that AI applications should align with human welfare and avoid harmful uses, such as surveillance abuse or autonomous weapons.

Many people often conflate technical performance (like "95% accuracy") with ethical soundness, but a model can be accurate and still systematically discriminate against certain groups. Ethical ML is not a one-time checkbox but a continuous process involving bias detection tools (such as AI Fairness 360), regular audits, and diverse stakeholder input.

To review, see:

• Ethical Considerations in ML

10b. Apply basic techniques to detect and mitigate bias in ML models, such as fairness metrics and simple mitigation methods like balanced datasets and re-weighting data

• What are fairness metrics like demographic parity and equal opportunity, and how do they quantify different types of bias?
• How can balanced dataset creation through oversampling or undersampling reduce representation bias?
• What is re-weighting data in model training, and how does it adjust for underrepresented groups?
• Why is disaggregated evaluation critical for identifying hidden bias in subgroups?

Mitigating bias in machine learning requires measurable definitions of fairness and deliberate changes to data and modeling strategies. Fairness metrics provide quantitative tools for bias detection. 

Demographic parity ensures that the selection rate (such as for job offers or loan approvals) is equal across demographic groups. For instance, if Group A receives 60% approvals and Group B only 30%, demographic parity is violated. Equal opportunity focuses on ensuring similar true positive rates, meaning qualified individuals across all groups have an equal chance of being correctly selected (for example, to ensure that equally capable candidates are being hired).

To reduce representation bias, practitioners can balance datasets. Oversampling involves duplicating data from minority groups, while undersampling reduces data from overrepresented groups. Both aim to create a fairer learning process, although oversampling can risk overfitting. Synthetic data generation tools like SMOTE (Synthetic Minority Oversampling Technique) intelligently produce new minority-class examples to preserve variability.

Re-weighting is another strategy, where training gives higher importance (loss weight) to underrepresented samples. For example, in credit models, data points from rural applicants might be weighted more heavily to compensate for their lower representation. Finally, disaggregated evaluation, measuring model performance separately for each subgroup (such as precision for different ethnicities or genders), helps uncover disparities masked by overall averages.

Many people often treat accuracy as sufficient. Fairness requires auditing using fairness metrics, balancing datasets when differences exceed thresholds (such as when there is a higher than 10% difference between groups), and retraining with re-weighting. Regular disaggregated analysis ensures that improvements are meaningful across all groups.

To review, see:

• Responsible AI Practices

Unit 10 Vocabulary

This vocabulary list includes terms you will need to know to successfully complete the final exam.

• accountability
• algorithmic bias
• demographic parity
• disaggregated evaluation
• disparate impact analysis
• fairness
• fairness metric
• oversampling
• privacy
• re-weighting
• social benefit
• societal impact
• transparency
• undersampling