freeCodeCamp Machine Learning with Python Syllabus

What is a filter (kernel) in a CNN, and what does it produce?

A small matrix of trainable weights (e.g., $3 \times 3$) slid over the input; at each position it computes a dot product with the underlying patch, producing a feature map that highlights where its pattern occurs.

What do stride and padding control in a convolution?

Stride is how many pixels the filter moves each step (larger stride = smaller output). Padding ('same') adds a border of zeros so the output keeps the input's spatial size; 'valid' uses no padding and shrinks the output.

What does a max pooling layer do?

It downsamples each feature map by taking the maximum value in each window (typically $2 \times 2$), reducing spatial dimensions and computation while keeping the strongest activations.

Describe the typical architecture of a CNN image classifier.

Stacked Conv2D + ReLU + MaxPooling blocks extract increasingly abstract features, then a Flatten layer converts feature maps to a vector, followed by Dense layers and a final classification output (sigmoid or softmax).

What is data augmentation and why is it used in image classification?

Generating modified copies of training images (rotations, flips, shifts, zooms) to artificially enlarge the dataset, which reduces overfitting and improves generalization when data is limited.

What is a bag-of-words representation of text, and what is its main weakness?

It represents text by the counts of each word from a fixed vocabulary, ignoring word order. Its weakness: 'dog bites man' and 'man bites dog' get identical representations.

What is word embedding in NLP?

A learned mapping of each word to a dense vector in a lower-dimensional space where similar words have similar vectors (small angle/distance between them), unlike sparse one-hot encodings.

In text preprocessing for neural networks, what do tokenization and padding accomplish?

Tokenization converts text into integer sequences (each word/token gets an index); padding adds zeros (or truncates) so all sequences share a fixed length, allowing them to be batched into one tensor.

What makes a recurrent neural network (RNN) suited to sequence data?

It processes elements one at a time while maintaining a hidden internal state that summarizes what it has seen so far, so earlier inputs influence the processing of later ones.

What is the vanishing gradient problem in simple RNNs?

During backpropagation through time, gradients are multiplied at each step and can shrink exponentially, so weight updates for early time steps become negligible and the network fails to learn long-range dependencies.

How does an LSTM improve on a simple RNN?

It adds a cell state plus input, forget, and output gates that control what information is stored, discarded, and emitted, letting gradients flow across many time steps and capturing long-term dependencies.

How does an RNN language model generate text?

Trained to predict the next character/word given the sequence so far, it generates text by sampling from its output distribution and feeding each prediction back in as the next input, repeating step by step.

What is Q-learning?

A model-free reinforcement learning algorithm that learns the action-value function $Q(s, a)$ — the expected future reward of taking action $a$ in state $s$ — stored in a Q-table and updated from experience.

Write the Q-learning update rule.

$$Q(s, a) \leftarrow Q(s, a) + \alpha \left[ r + \gamma \max_{a'} Q(s', a') - Q(s, a) \right]$$ where $\alpha$ is the learning rate, $r$ the reward, $\gamma$ the discount factor, and $s'$ the next state.

What is the exploration–exploitation tradeoff, and how does the epsilon-greedy strategy handle it?

The agent must balance trying new actions (exploration) against using known good actions (exploitation). Epsilon-greedy picks a random action with probability $\epsilon$ and the best-known action with probability $1 - \epsilon$, usually decaying $\epsilon$ over time.

What does the discount factor $\gamma$ control in reinforcement learning?

How much future rewards are worth relative to immediate ones, with $0 \leq \gamma \leq 1$: $\gamma$ near 0 makes the agent myopic; $\gamma$ near 1 makes it value long-term reward. Return: $G_{t} = \sum_{k=0}^{\infty} \gamma^{k} r_{t+k+1}$.

What are the components of a Markov Decision Process (MDP)?

A tuple $(S, A, P, R, \gamma)$: states $S$, actions $A$, transition probabilities $P(s' \mid s, a)$, reward function $R$, and discount factor $\gamma$.

What is the Markov property?

The future depends only on the current state and action, not the full history: $P(s_{t+1} \mid s_{t}, a_{t}, s_{t-1}, \ldots) = P(s_{t+1} \mid s_{t}, a_{t})$.

In an MDP, what is a policy and what makes a policy optimal?

A policy $\pi(s)$ maps each state to an action (or distribution over actions). The optimal policy $\pi^{*}$ maximizes expected cumulative discounted reward from every state; with Q-learning it is $\pi^{*}(s) = \arg\max_{a} Q(s, a)$.

In the freeCodeCamp Rock Paper Scissors project, what must your player achieve, and why can't it play randomly?

It must win at least 60% of games against each of four bots (over 1000 games). Random play yields only about 50% win rate against exploitable bots, so the player must detect and exploit each opponent's pattern.

What general strategy beats the pattern-based bots in the Rock Paper Scissors project?

Track the opponent's move history (e.g., frequency of recent n-grams of moves), predict their most likely next move, and play the move that beats it — adapting as the opponent's pattern changes.

In the Cat and Dog Image Classifier project, what network type and output layer are used, and what accuracy is required?

A CNN (Conv2D + MaxPooling blocks, then dense layers) with a single sigmoid output unit for binary classification; predictions above/below a 0.5 threshold map to dog/cat. Required test accuracy: at least 63% (70% for extra credit).

What does ImageDataGenerator (with flow_from_directory) provide in the Cat and Dog project?

It loads images in batches from directory structure, rescales pixel values (e.g., multiply by $\frac{1}{255}$ to get $[0,1]$), resizes them to a fixed size, and can apply random augmentation transforms on the fly.

Why are pixel values normalized from $[0, 255]$ to $[0, 1]$ before training?

Small, consistent input scales keep gradients well-behaved, speeding up and stabilizing training; large raw values can cause unstable updates and slow convergence.

How does the Book Recommendation Engine use K-Nearest Neighbors to recommend books?

Each book is a vector of user ratings in a sparse user–book matrix; sklearn's NearestNeighbors (cosine metric) finds the books whose rating vectors are closest to the query book, and those neighbors (with their distances) are returned as recommendations.

Why are users and books with few ratings filtered out in the Book Recommendation project?

Users with fewer than 200 ratings and books with fewer than 100 ratings are removed for statistical significance — vectors with almost no ratings give unreliable, noisy distances and meaningless neighbors.

What is cosine similarity between two vectors?

$$\cos\theta = \frac{\vec{a} \cdot \vec{b}}{\lVert \vec{a} \rVert \, \lVert \vec{b} \rVert}$$ It measures the angle between vectors regardless of magnitude: 1 means same direction, 0 means orthogonal (no similarity).

What is the linear regression model equation for predicting a value from several features?

$$\hat{y} = w_{1} x_{1} + w_{2} x_{2} + \cdots + w_{n} x_{n} + b$$ Training finds the weights $w_{i}$ and bias $b$ that minimize the prediction error (e.g., mean squared error) on the training data.

In the Health Costs Calculator project, how must categorical data be handled, how is the data split, and what error is required?

Categorical features (sex, smoker, region) are converted to numbers (label or one-hot encoding); 80% of the data trains the model and 20% tests it; the model must reach mean absolute error under \$3500. MAE: $\frac{1}{n} \sum_{i=1}^{n} \lvert y_{i} - \hat{y}_{i} \rvert$.

Outline the pipeline of the Neural Network SMS Text Classifier.

Tokenize each SMS into integer sequences and pad to fixed length; feed through an Embedding layer, then a recurrent/pooling layer and dense layers to a sigmoid output giving the probability of 'spam' (vs 'ham', i.e., normal messages); classify by thresholding at 0.5.