Stanford CS229 - Machine Learning Fundamentals Flashcards

Question 1

What is Machine Learning?

Accepted Answer

Machine Learning is a field of study that gives computers the ability to learn without being explicitly programmed. It focuses on developing algorithms that allow systems to learn from data, identify patterns, and make decisions or predictions with minimal human intervention.

Question 2

Differentiate between Supervised and Unsupervised Learning.

Accepted Answer

1.  **Supervised Learning:** Uses labeled data (input-output pairs) to learn a mapping function from inputs to outputs. The goal is to predict an output given new input data. Examples: Regression (predicting continuous values), Classification (predicting discrete labels).
2.  **Unsupervised Learning:** Works with unlabeled data to find hidden patterns, structures, or relationships within the data. The goal is to model the underlying structure or distribution of the data. Examples: Clustering, Dimensionality Reduction.

Question 3

What is the hypothesis function for Linear Regression?

Accepted Answer

The hypothesis function, often denoted as $h_	heta(x)$, predicts a continuous output. For a single feature, it's $h_	heta(x) = 	heta_0 + 	heta_1 x$. For multiple features, it's expressed in vector form as $h_	heta(x) = 	heta^T x$, where $	heta$ is the vector of parameters (weights) and $x$ is the vector of features (with $x_0=1$ for the intercept term).

Question 4

What is the Mean Squared Error (MSE) cost function for Linear Regression?

Accepted Answer

The Mean Squared Error (MSE) cost function, $J(	heta)$, measures the average squared difference between the predicted values and the actual target values. It is defined as:
$J(	heta) = \frac{1}{2m} \sum_{i=1}^{m} (h_	heta(x^{(i)}) - y^{(i)})^2$
where $m$ is the number of training examples, $h_	heta(x^{(i)})$ is the prediction for the $i$-th example, and $y^{(i)}$ is the actual target value. The $\frac{1}{2}$ term is included for mathematical convenience, simplifying the derivative during gradient descent.

Question 5

Explain the purpose of Gradient Descent and its update rule.

Accepted Answer

Gradient Descent is an iterative optimization algorithm used to find the minimum of a function (e.g., a cost function). It repeatedly adjusts the model's parameters ($	heta$) in the direction opposite to the gradient of the cost function, which is the direction of steepest descent.

The update rule for each parameter $	heta_j$ is:
$	heta_j := 	heta_j - \alpha \frac{\partial}{\partial 	heta_j} J(	heta)$
where $\alpha$ is the learning rate and $\frac{\partial}{\partial 	heta_j} J(	heta)$ is the partial derivative of the cost function with respect to $	heta_j$.

Question 6

What is the role of the learning rate ($\alpha$) in Gradient Descent?

Accepted Answer

The learning rate ($\alpha$) is a hyperparameter in Gradient Descent that controls the step size taken during each iteration. It determines how much the parameters are adjusted in the direction of the negative gradient.
*   If $\alpha$ is too small, convergence to the minimum will be very slow.
*   If $\alpha$ is too large, Gradient Descent might overshoot the minimum, oscillate, or even diverge, failing to converge to an optimal solution.

Question 7

Why is Feature Scaling important in Machine Learning?

Accepted Answer

Feature scaling (e.g., normalization or standardization) transforms features to a similar scale. It is crucial for algorithms sensitive to feature magnitudes (like Gradient Descent, SVMs, K-Nearest Neighbors) because it helps to:
1.  **Speed up convergence:** Prevents oscillations and allows Gradient Descent to converge much faster.
2.  **Prevent dominance:** Ensures that features with larger numerical ranges do not disproportionately influence the cost function or distance calculations, allowing all features to contribute equally to the model's learning process.

A common method is Min-Max scaling: $x' = \frac{x - \min(x)}{\max(x) - \min(x)}$.

Question 8

Differentiate between Overfitting and Underfitting.

Accepted Answer

1.  **Overfitting:** Occurs when a model learns the training data too well, capturing noise and specific patterns unique to the training set. This leads to excellent performance on training data but poor generalization and high error on unseen data (high variance, low bias).
2.  **Underfitting:** Occurs when a model is too simple to capture the underlying patterns in the training data. It performs poorly on both training and unseen data, indicating that the model has not learned enough from the data (high bias, low variance).

Question 9

Explain the Bias-Variance Trade-off.

Accepted Answer

The Bias-Variance Trade-off is a central concept in supervised learning, describing the relationship between a model's complexity and its generalization error.
*   **Bias:** Error due to overly simplistic assumptions in the learning algorithm, causing the model to miss relevant relations between features and target outputs (underfitting). High bias implies the model is too simple.
*   **Variance:** Error due to the model's excessive sensitivity to small fluctuations in the training data, leading it to learn noise (overfitting). High variance implies the model is too complex.

Reducing bias often increases variance, and vice versa. The goal is to find a balance that minimizes the total error on unseen data.

Question 10

What is regularization, and compare L1 (Lasso) and L2 (Ridge) regularization.

Accepted Answer

Regularization is a technique used to prevent overfitting by adding a penalty term to the cost function, which discourages the model from assigning excessively large weights to features.

*   **L1 (Lasso) Regularization:** Adds the sum of the absolute values of the coefficients ($\lambda \sum_{j=1}^{n} |	heta_j|$) to the cost function. It tends to shrink some coefficients to exactly zero, effectively performing feature selection.
*   **L2 (Ridge) Regularization:** Adds the sum of the squared values of the coefficients ($\lambda \sum_{j=1}^{n} 	heta_j^2$) to the cost function. It shrinks coefficients towards zero but rarely makes them exactly zero. It helps in reducing the impact of less important features.

In both cases, $\lambda$ is the regularization parameter, controlling the strength of the penalty.

Question 11

What is the hypothesis function for Logistic Regression?

Accepted Answer

Logistic Regression uses the sigmoid (or logistic) function to output a probability between 0 and 1, suitable for binary classification. The hypothesis function is:
$h_	heta(x) = g(	heta^T x)$
where $g(z) = \frac{1}{1 + e^{-z}}$ is the sigmoid function. The output $h_	heta(x)$ can be interpreted as the estimated probability that the target variable $y=1$ given input $x$ and parameters $	heta$, i.e., $P(y=1|x;	heta)$.

Question 12

What is the cost function for Logistic Regression?

Accepted Answer

Logistic Regression uses a cost function based on maximum likelihood estimation, which is convex and suitable for optimization. For a single training example, the cost is:
$Cost(h_	heta(x), y) = \begin{cases} -\log(h_	heta(x)) & 	ext{if } y=1 \ -\log(1-h_	heta(x)) & 	ext{if } y=0 \end{cases}$

For the entire training set of $m$ examples, the overall cost function $J(	heta)$ is:
$J(	heta) = -\frac{1}{m} \sum_{i=1}^{m} [y^{(i)} \log(h_	heta(x^{(i)})) + (1 - y^{(i)}) \log(1 - h_	heta(x^{(i)}))]$
This function penalizes incorrect predictions more heavily.

Question 13

What is the primary goal of a Support Vector Machine (SVM)?

Accepted Answer

The primary goal of a Support Vector Machine (SVM) is to find an optimal hyperplane that maximally separates data points of different classes in a high-dimensional space. It aims to maximize the 'margin' – the distance between the hyperplane and the nearest data points from each class (called support vectors) – thereby achieving robust classification and good generalization to unseen data.

Question 14

What is the Hinge Loss function used in SVMs?

Accepted Answer

The Hinge Loss is a cost function primarily used for training classifiers, especially Support Vector Machines (SVMs). For a binary classification problem with labels $y \in \{-1, 1\}$ and a model's prediction score $f(x)$ (where $f(x) = 	heta^T x$), the Hinge Loss for a single example is defined as:
$L(y, f(x)) = \max(0, 1 - y \cdot f(x))$
This loss function penalizes predictions that are on the wrong side of the margin or within the margin, but incurs no penalty if the prediction is correct and outside the margin (i.e., $y \cdot f(x) \ge 1$). It encourages a clear separation with a margin.

Question 15

Explain the role of Kernels in SVMs.

Accepted Answer

Kernels are functions that transform data from a lower-dimensional input space to a higher-dimensional feature space, making it possible to find a linear separation (hyperplane) in the higher dimension even if the data is not linearly separable in the original space. This is known as the 'kernel trick'. Instead of explicitly computing the transformed features, kernels compute the dot product of the transformed features.

Common kernels include:
*   **Linear Kernel:** $K(x_i, x_j) = x_i^T x_j$
*   **Polynomial Kernel:** $K(x_i, x_j) = (\gamma x_i^T x_j + r)^d$
*   **Radial Basis Function (RBF) / Gaussian Kernel:** $K(x_i, x_j) = \exp(-\gamma ||x_i - x_j||^2)$

Question 16

How do Decision Trees make predictions, and what is a common splitting criterion?

Accepted Answer

Decision Trees make predictions by recursively partitioning the data into subsets based on feature values, forming a tree-like structure of decisions. Each internal node represents a 'test' on an attribute, each branch represents the outcome of the test, and each leaf node represents a class label (for classification) or a numerical value (for regression).

At each node, the tree selects the feature and split point that best separates the data. A common splitting criterion for classification is **Information Gain**, which uses **Entropy**, or **Gini Impurity**. These metrics measure the 'purity' of the resulting subsets, aiming to maximize the reduction in impurity after a split.

Question 17

Compare Gini Impurity and Entropy as splitting criteria for Decision Trees.

Accepted Answer

Both Gini Impurity and Entropy are metrics used in Decision Trees to measure the 'impurity' or disorder of a set of samples, guiding the splitting process.

*   **Gini Impurity:** $G = 1 - \sum_{k=1}^{C} p_k^2$, where $p_k$ is the proportion of samples belonging to class $k$ in a given node, and $C$ is the number of classes. A node with $G=0$ is perfectly pure (all samples belong to one class). Gini Impurity is computationally faster as it doesn't involve logarithms.
*   **Entropy:** $E = -\sum_{k=1}^{C} p_k \log_2(p_k)$. A node with $E=0$ is perfectly pure. Entropy is rooted in information theory and measures the average amount of information needed to identify the class of a sample in the set.

Both criteria aim to find splits that maximize the reduction in impurity (Information Gain). While Gini is often faster, Entropy can sometimes produce slightly more balanced trees.

Question 18

Outline the main steps of the K-Means Clustering algorithm.

Accepted Answer

K-Means is an iterative unsupervised algorithm for partitioning $n$ observations into $k$ clusters, where each observation belongs to the cluster with the nearest mean (centroid).

1.  **Initialization:** Randomly select $k$ data points from the dataset to serve as initial cluster centroids.
2.  **Assignment Step:** Assign each data point to the cluster whose centroid is closest (e.g., using Euclidean distance).
3.  **Update Step:** Recalculate the centroids by taking the mean of all data points currently assigned to that cluster.
4.  **Repeat:** Steps 2 and 3 until the cluster assignments no longer change, the centroids no longer move significantly, or a maximum number of iterations is reached.

Question 19

How are centroids updated in the K-Means algorithm?

Accepted Answer

In the K-Means algorithm's 'Update Step,' each cluster centroid is recalculated as the mean of all data points currently assigned to that cluster. If a cluster $j$ contains $N_j$ data points $\{x^{(i)} | x^{(i)} 	ext{ belongs to cluster } j\}$, the new centroid $\mu_j$ for that cluster is calculated as:
$\mu_j = \frac{1}{N_j} \sum_{x^{(i)} \in 	ext{cluster } j} x^{(i)}$
This process effectively moves the centroid to the center of its assigned data points.

Question 20

Define Precision and its formula in classification.

Accepted Answer

Precision measures the proportion of positive identifications that were actually correct. It answers the question: "Of all items I predicted as positive, how many are truly positive?"

$Precision = \frac{True \ Positives}{True \ Positives + False \ Positives}$

High precision indicates a low false positive rate, meaning the model is good at avoiding incorrect positive predictions.

Question 21

Define Recall (Sensitivity) and its formula in classification.

Accepted Answer

Recall (also known as Sensitivity or True Positive Rate) measures the proportion of actual positives that were correctly identified. It answers the question: "Of all actual positive items, how many did I correctly identify?"

$Recall = \frac{True \ Positives}{True \ Positives + False \ Negatives}$

High recall indicates a low false negative rate, meaning the model is good at finding all positive instances.

Question 22

What is the F1-Score, and why is it used?

Accepted Answer

The F1-Score is the harmonic mean of Precision and Recall. It provides a single metric that balances both precision and recall, making it particularly useful when there is an uneven class distribution in the dataset.

$F1 = 2 \cdot \frac{Precision \cdot Recall}{Precision + Recall}$

The F1-Score ranges from 0 to 1, where 1 represents perfect precision and recall. It's a good metric to use when you need to seek a balance between precision and recall, and when false positives and false negatives have similar costs.

Question 23

What is the purpose of Cross-Validation in machine learning?

Accepted Answer

Cross-validation is a robust technique used to assess how the results of a statistical analysis will generalize to an independent data set. Its primary purposes are to:
1.  **Estimate model performance:** Provide a more reliable estimate of a model's performance on unseen data than a single train-test split.
2.  **Detect and mitigate overfitting:** Help identify if a model is overfitting to the training data by evaluating its performance on multiple validation sets.
3.  **Tune hyperparameters:** Systematically evaluate different hyperparameter settings to find the optimal configuration for a model.

Common methods include K-Fold Cross-Validation, where the dataset is split into 'k' folds, and the model is trained and validated 'k' times.

Question 24

List and define the four main components of a Confusion Matrix.

Accepted Answer

A Confusion Matrix is a table used to describe the performance of a classification model on a set of test data for which the true values are known. Its four main components are:
1.  **True Positives (TP):** Instances where the model correctly predicted the positive class. (Actual: Positive, Predicted: Positive)
2.  **True Negatives (TN):** Instances where the model correctly predicted the negative class. (Actual: Negative, Predicted: Negative)
3.  **False Positives (FP):** Instances where the model incorrectly predicted the positive class. This is a Type I error. (Actual: Negative, Predicted: Positive)
4.  **False Negatives (FN):** Instances where the model incorrectly predicted the negative class. This is a Type II error. (Actual: Positive, Predicted: Negative)

Question 25

Compare Stochastic Gradient Descent (SGD) and Batch Gradient Descent.

Accepted Answer

Both are variants of Gradient Descent, differing in how they compute the gradient and update parameters:

*   **Batch Gradient Descent:** Computes the gradient of the cost function with respect to the parameters for the *entire* training dataset before making a single parameter update. It provides a stable convergence but can be very slow and computationally expensive for large datasets.
*   **Stochastic Gradient Descent (SGD):** Computes the gradient and updates parameters for *each individual training example* at a time. It's much faster for large datasets and can escape shallow local minima due to its noisy updates. However, its updates are noisy, leading to oscillations around the minimum rather than direct convergence.
*   **Mini-Batch Gradient Descent:** A common compromise, computing the gradient and updating parameters using a small 'mini-batch' of samples (e.g., 32-512 examples) for each iteration. It offers a balance between the stability of Batch GD and the speed of SGD.

Stanford CS229 - Machine Learning Fundamentals

Cards in this deck

Related Flashcard Sets

Korean TOPIK I - Essential Vocabulary & Grammar (Levels 1-2)

TypeScript - Advanced Types, Interfaces & Generics

Organic Chemistry Mechanisms - SN1/SN2 & E1/E2 Reactions

Cisco CCNA (200-301) - Enterprise Networking & IP Services