Overview
Domain 3 covers deep learning at a conceptual level. It starts with the artificial neural network: input neurons, one or more hidden layers and an output layer, connected by weights that are adjusted during training. You should know how a forward pass produces a prediction, how a loss function measures the error, and how backpropagation with gradient descent pushes that error back through the network to update weights.
The section then covers two architecture families. Convolutional neural networks use filters that slide across an image to detect edges, textures and shapes. Recurrent neural networks pass a hidden state from one step to the next so they can handle ordered data, and long short-term memory networks add gates that help them remember information across longer sequences.
How it's tested
Items describe a data type or a network component and ask you to pick the right architecture or explain a behaviour. Pay attention to whether the data is spatial, like an image grid, or sequential, like words in a sentence. Watch also for questions about what happens during training, such as backpropagation.
-
Match architecture to data
Images point to CNNs, while sentences, audio and sensor readings over time point to RNNs or LSTMs.
-
Explain a component
You identify what weights, activation functions, pooling layers, hidden state or LSTM gates contribute.
-
Training mechanics
A question asks how the network reduces its error, testing loss, backpropagation and gradient descent in plain terms.
A utility wants to forecast tomorrow's electricity demand from readings taken every hour for the past two years. The data is a time-ordered sequence, so a model that carries information across steps is needed. A basic RNN may lose track of patterns from many steps earlier, while an LSTM uses gates and a cell state to keep longer-range information. The LSTM is the better answer.
Objectives 3
Official objectives from the Oracle outline, in outline order.
3.1 Explain deep learning basicsNeurons, layers, weights, activation and backpropagation.
- What it means
- Deep learning uses artificial neural networks with several hidden layers. Each neuron takes weighted inputs, adds a bias, applies an activation function and passes the result on, so stacked layers learn increasingly abstract features.
- What to understand
- Activation functions such as ReLU and sigmoid add non-linearity; without them the network would act like a single linear model. Training repeats a cycle: a forward pass makes predictions, a loss function scores the error, backpropagation calculates how each weight contributed, and gradient descent nudges weights to reduce the loss. One full pass through the training data is an epoch. GPUs speed this up because the work is mostly parallel matrix multiplication.
- How it shows up
- Expect questions on what backpropagation does or why activation functions are needed.
- Common confusion
- Thinking backpropagation makes predictions; it only computes how to adjust weights after an error is measured.
3.2 Explain convolutional models (CNN)Filters and pooling for image data.
- What it means
- A convolutional neural network applies small learnable filters across an image to produce feature maps. Early layers detect edges and colours, deeper layers combine them into shapes and objects, and final fully connected layers make the prediction.
- What to understand
- Convolution shares the same filter weights across the whole image, which keeps the parameter count manageable and lets the model find a feature wherever it appears. Pooling layers shrink feature maps and add tolerance to small shifts. CNNs power image classification, object detection, medical imaging and quality inspection. Their weak points are a need for large labelled image sets and limited suitability for long sequential data.
- How it shows up
- A visual inspection or image tagging scenario usually expects CNN as the architecture.
- Common confusion
- Assuming pooling adds detail; it reduces the size of feature maps.
3.3 Explain sequence models (RNN and LSTM)Networks that keep state across ordered inputs.
- What it means
- Recurrent neural networks process a sequence one element at a time and pass a hidden state forward, giving the model a form of memory. Long short-term memory networks extend this with a cell state and gates that control what to keep, add and output.
- What to understand
- Plain RNNs struggle with long sequences because gradients shrink as they pass back through many steps, known as the vanishing gradient problem. LSTM input, forget and output gates reduce this by deciding what information flows through. Sequence models come in shapes such as one-to-many for caption generation, many-to-one for sentiment, and many-to-many for translation. Uses include speech recognition, language modelling and time-series forecasting.
- How it shows up
- A question on long text or long time series usually rewards choosing LSTM over a basic RNN.
- Common confusion
- Believing LSTMs process the whole sequence in parallel; they still step through it in order.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Artificial neuron
Computes a weighted sum plus bias, then applies an activation.
- Remember
- Weights are what training changes.
- Tested as
- Component questions.
- Trap
- Treating the bias as a training label.
-
Activation function
Adds non-linearity, for example ReLU or sigmoid.
- Remember
- Without it stacked layers collapse to a linear model.
- Tested as
- Why-needed questions.
- Trap
- Thinking it normalises input data.
-
Loss function
Measures how far predictions are from targets.
- Remember
- Training aims to minimise it.
- Tested as
- Training mechanics items.
- Trap
- Confusing loss with accuracy.
-
Backpropagation
Computes each weight's contribution to the error.
- Remember
- Works backward from output to input.
- Tested as
- Most common DL basics question.
- Trap
- Saying it generates predictions.
-
Gradient descent
Updates weights in the direction that lowers the loss.
- Remember
- Learning rate controls step size.
- Tested as
- Paired with backpropagation.
- Trap
- Assuming bigger learning rates always train faster without risk.
-
Convolution filter
Small learnable window that detects a pattern across an image.
- Remember
- Weights are shared across positions.
- Tested as
- CNN component items.
- Trap
- Thinking each pixel gets its own weight.
-
Pooling
Downsamples feature maps.
- Remember
- Reduces size and adds shift tolerance.
- Tested as
- CNN component items.
- Trap
- Believing it increases resolution.
-
Hidden state
The memory an RNN passes from step to step.
- Remember
- Lets output depend on earlier inputs.
- Tested as
- Sequence model items.
- Trap
- Confusing it with a hidden layer in a feed-forward net.
-
Vanishing gradient
Gradients shrink over many steps, so early inputs stop influencing learning.
- Remember
- Main weakness of plain RNNs.
- Tested as
- Why LSTMs exist.
- Trap
- Linking it to CNNs rather than long sequences.
-
LSTM gates
Input, forget and output gates controlling a cell state.
- Remember
- Help retain long-range information.
- Tested as
- Choosing LSTM over RNN.
- Trap
- Thinking gates make LSTMs parallel like transformers.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Architecture by data type
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Feed-forward network | Layers pass data one way with no memory. | Fits fixed-size tabular input. | Using it for ordered sequences. |
| CNN | Filters scan spatial data. | Built for grids like images. | Choosing it for long text. |
| RNN | Processes sequences with a hidden state. | Short memory due to vanishing gradients. | Expecting it to recall distant context. |
| LSTM | RNN with gated cell state. | Retains longer dependencies. | Assuming it removes sequential processing. |
Training terms
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Forward pass | Input flows through layers to a prediction. | No weights change. | Calling it training on its own. |
| Backpropagation | Error contributions flow backward. | Produces gradients. | Mixing it up with the update rule. |
| Gradient descent | Weights move to reduce loss. | Applies the gradients. | Thinking it measures error. |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
CNN for everything
- What candidates pick
- CNN for sentiment on long reviews
- Why it looks right
- CNNs are the headline deep learning model.
- Why it's wrong
- Long text depends on word order and distant context, which sequence models or transformers handle better than image filters.
Clue to watch for Words like sentence, sequence or over time.
-
Backprop as prediction
- What candidates pick
- Backpropagation generates outputs
- Why it looks right
- It is the most famous training term.
- Why it's wrong
- The forward pass makes predictions; backpropagation only works out how each weight should change afterwards.
Clue to watch for Question asks how error is reduced.
-
Plain RNN for long context
- What candidates pick
- Basic RNN
- Why it looks right
- It is the original sequence model.
- Why it's wrong
- Plain RNNs lose earlier information over long sequences because of vanishing gradients, so LSTM is the safer choice.
Clue to watch for Long documents or multi-year time series.
-
Pooling adds detail
- What candidates pick
- Pooling sharpens features
- Why it looks right
- It sounds like collecting more information.
- Why it's wrong
- Pooling summarises nearby values and shrinks the feature map, trading detail for efficiency and shift tolerance.
Clue to watch for A question on reducing size or computation.
-
Linear without activation
- What candidates pick
- Stacking more layers adds power
- Why it looks right
- Depth sounds like capability.
- Why it's wrong
- Without non-linear activation functions, many layers still compute only a linear function of the input.
Clue to watch for Any mention of removing activation functions.
Answer framework
Use these steps to pick a network type or explain a training behaviour in Domain 3 questions.
- Identify the structure of the input data: fixed-length rows, a two-dimensional grid such as an image, or an ordered sequence such as text, speech or sensor readings over time.
- For grid data, prefer a convolutional network, since shared filters find local patterns anywhere in the image.
- For ordered data, prefer a recurrent design, and choose LSTM when the sequence is long or distant context matters.
- If the question is about learning, trace the cycle of forward pass, loss calculation, backpropagation and gradient descent, where the learning rate controls how large each weight update is.
- Eliminate options that misuse a component, such as pooling that adds detail or activation functions described as normalisers.
Practice question
Want more like this? The 1Z0-1122-26 practice test has questions for every domain.
Checklist
0 of 11
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Give this section five to seven hours. Begin with the deep learning lessons in Oracle's AI Foundations course and sketch a small neural network as you watch: three inputs, one hidden layer, one output, with arrows labelled as weights. Annotate where the activation function, loss and backpropagation happen.
Next, make a three-row architecture card for CNN, RNN and LSTM. For each, write the data it suits, one key component, its main limitation and two example applications. Keep the card next to you during practice questions.
For training mechanics, explain the learning loop out loud in under a minute without notes. If you cannot, rewatch that lesson. Avoid going deep into maths; the exam does not ask for derivatives or formulas.
When you review mistakes, check whether you misread the data shape or misunderstood a component. End by previewing Domain 4: list the two RNN weaknesses, sequential processing and vanishing gradients, that transformers were designed to overcome, because that link is a favourite bridge between the two sections.
FAQ
What share of the exam is Intro to DL Foundations?
Oracle has not published section weights for 1Z0-1122-26. Secondary sources estimate this deep learning section at roughly six of the 40 questions.
Do I need the maths behind backpropagation?
No. Know what it does and why, not the calculus. Questions stay at the conceptual level.
Are transformers covered here?
Transformers belong to the generative AI and LLM section. This section stops at CNNs, RNNs and LSTMs, though it explains why transformers were needed.
What is the single most useful fact for this section?
Images map to CNNs, sequences map to RNNs or LSTMs, and long sequences favour LSTMs.
Will I see questions on specific activation functions?
Possibly at a basic level. Know that ReLU and sigmoid are examples and that activation functions add non-linearity.
Why do deep learning models need GPUs?
Training involves huge numbers of matrix operations that run in parallel, which GPUs handle far faster than CPUs.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 3 knowledge
You have reviewed neural network training, CNNs, RNNs and LSTMs. Test whether you can pick the right architecture from a short scenario.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the 1Z0-1122-26 AI tutor Get any concept explained your way