33. Markov Decision Processes and Q-Learning¶
Understand how Markov Decision Processes provide the mathematical foundation for Reinforcement Learning and how Q-Learning enables agents to learn optimal actions from experience without explicitly modeling the environment.
π― Learning Objectives¶
After completing this chapter, you will be able to:
- Explain the Markov Property
- Understand Markov Decision Processes (MDPs)
- Identify the components of an MDP
- Understand states, actions, rewards, and transitions
- Explain transition probabilities
- Understand reward functions
- Understand policies in an MDP
- Explain value functions
- Explain action-value functions
- Understand the Bellman Equation
- Understand the Bellman Optimality Equation
- Explain Q-Learning
- Understand the Q-table
- Understand the Q-Learning update rule
- Understand temporal-difference learning
- Understand exploration and exploitation in Q-Learning
- Explain the Ξ΅-greedy strategy
- Understand learning rate and discount factor
- Understand terminal states
- Implement a basic Q-Learning agent
- Understand the limitations of tabular Q-Learning
- Understand the relationship between Q-Learning and Deep Q-Networks
- Understand production considerations for value-based Reinforcement Learning
π Overview¶
Reinforcement Learning problems involve sequential decision-making.
An agent repeatedly:
Observe State
β
Choose Action
β
Interact with Environment
β
Receive Reward
β
Observe New State
β
Learn
To mathematically describe this interaction, Reinforcement Learning commonly uses the concept of a:
Markov Decision Process (MDP)
Q-Learning then provides a model-free algorithm that allows an agent to learn which actions are valuable in different states.
The core idea is:
π§ Markov Property¶
The Markov Property states that the future depends on the current state rather than the complete history of previous states and actions.
Conceptually:
If the current state contains all relevant information required to predict future behavior, the problem satisfies the Markov property.
π§ Markov Property Example¶
Consider a chess game.
If the complete current board position is known:
The entire sequence of previous moves may not be required to determine the legal moves available from the current board.
The current state acts as a sufficient representation of the relevant history.
π§ Non-Markov Example¶
Suppose a system only records:
but not:
For a moving vehicle, position alone may not be enough to predict the next state.
Two vehicles can have:
and therefore behave differently in the future.
A better state representation might include:
π§ Markov Decision Process¶
A Markov Decision Process (MDP) provides a mathematical framework for sequential decision-making under uncertainty.
An MDP is commonly represented as:
[ (S,A,P,R,\gamma) ]
where:
S = Set of States
A = Set of Actions
P = Transition Probability
R = Reward Function
Ξ³ = Discount Factor
𧩠Components of an MDP¶
| Component | Meaning |
|---|---|
S |
Set of possible states |
A |
Set of possible actions |
P |
Transition dynamics |
R |
Reward function |
Ξ³ |
Discount factor |
π§ State Space¶
The State Space represents all possible states that the environment can be in.
For a simple Grid World:
For a robot:
π§ Action Space¶
The Action Space represents all actions available to the agent.
For Grid World:
For a vehicle:
π§ Transition Dynamics¶
The transition function describes how the environment changes after an action.
Conceptually:
For stochastic environments, the result is represented using probabilities.
π§ Transition Probability¶
The transition probability can be written as:
[ P(s'|s,a) ]
This means:
The probability of transitioning to state
s'after taking actionain states.
For example:
The environment is therefore stochastic.
π§ Deterministic Transition¶
In a deterministic environment:
for one particular next state.
Example:
There is no uncertainty.
π§ Stochastic Transition¶
In a stochastic environment:
State A
+
Move Right
β
βββββββββββββββ
β State B 70% β
β State C 20% β
β State D 10% β
βββββββββββββββ
The same action may lead to different outcomes.
π§ Reward Function¶
The reward function defines the immediate feedback associated with transitions.
A common notation is:
[ R(s,a,s') ]
It represents the reward received when:
π§ Example Reward Function¶
Consider a Grid World:
The reward structure encourages the agent to:
β Reward Design¶
The reward function defines what the agent is incentivized to optimize.
Therefore:
Even if the RL algorithm works correctly, the agent may learn undesirable behavior if the reward does not accurately represent the intended objective.
π§ Episode¶
An episode is one complete sequence of interactions.
For example:
The episode then ends.
π§ Terminal State¶
A terminal state represents the end of an episode.
Examples:
Once a terminal state is reached:
for that episode.
π§ Trajectory¶
A trajectory represents the sequence of experiences generated during an episode.
For example:
It captures:
over time.
π§ Policy¶
A policy determines which action the agent takes in a given state.
A stochastic policy can be represented as:
[ \pi(a|s) ]
A deterministic policy can be represented as:
[ a=\pi(s) ]
π§ Optimal Policy¶
The objective of an RL agent is often to learn an optimal policy:
[ \pi^* ]
The optimal policy maximizes expected cumulative reward.
Conceptually:
π§ Return¶
The return represents cumulative future reward.
A discounted return is:
[ G_t= r_{t+1} + \gamma r_{t+2} + \gamma^2r_{t+3} +\cdots ]
where:
π§ Discount Factor¶
The discount factor determines how strongly future rewards influence current decisions.
Low Ξ³¶
High Ξ³¶
π§ Value Function¶
The state-value function estimates the expected return from a state when following a particular policy.
[ V^\pi(s) = \mathbb{E}_\pi[G_t|S_t=s] ]
Conceptually:
π§ Action-Value Function¶
The action-value function evaluates:
and estimates the expected future return.
[ Q^\pi(s,a) = \mathbb{E}_\pi[G_t|S_t=s,A_t=a] ]
π§ V(s) vs Q(s,a)¶
| V(s) | Q(s,a) |
|---|---|
| Evaluates a state | Evaluates state + action |
| Estimates expected return | Estimates expected return after action |
| Does not explicitly specify action | Directly evaluates actions |
| Used in value-based and actor-critic methods | Central to Q-Learning |
π§ Why Q-Values Matter¶
Suppose the agent is in:
and possible actions are:
The Q-values might be:
The agent can choose:
because it currently has the highest estimated value.
π§ Q-Table¶
For small discrete environments, Q-values can be stored in a table.
Example:
| State | Up | Down | Left | Right |
|---|---|---|---|---|
| S1 | 0.2 | 0.4 | 0.1 | 0.8 |
| S2 | 0.5 | 0.2 | 0.9 | 0.3 |
| S3 | 0.1 | 0.7 | 0.2 | 0.4 |
| S4 | 0.9 | 0.1 | 0.4 | 0.2 |
The table estimates:
for every state-action pair.
π§ Q-Learning¶
Q-Learning is a:
Reinforcement Learning algorithm.
The goal is to learn the optimal action-value function:
[ Q^*(s,a) ]
The optimal Q-function tells the agent:
How valuable is it to take action
ain states, assuming optimal future behavior?
π§ Q-Learning Workflow¶
flowchart TD
STATE["Current State"]
ACTION["Choose Action"]
ENV["Environment"]
REWARD["Receive Reward"]
NEXT["Observe Next State"]
MAXQ["Find Best Next Q-Value"]
UPDATE["Update Q-Value"]
STATE --> ACTION
ACTION --> ENV
ENV --> REWARD
ENV --> NEXT
NEXT --> MAXQ
REWARD --> UPDATE
MAXQ --> UPDATE
UPDATE --> STATEπ§ Q-Learning Update Rule¶
The fundamental Q-Learning update is:
[ Q(s,a) \leftarrow Q(s,a) + \alpha \left[ r+ \gamma\max_{a'}Q(s',a') - Q(s,a) \right] ]
where:
Q(s,a) = Current Q-value
Ξ± = Learning Rate
r = Immediate Reward
Ξ³ = Discount Factor
s' = Next State
a' = Possible Next Action
π§ Understanding the Q-Learning Formula¶
The update contains:
The learning target is:
π§ Temporal-Difference Error¶
The difference between the target and current estimate is the:
Temporal-Difference (TD) Error
[ \delta= r+ \gamma\max_{a'}Q(s',a') - Q(s,a) ]
The Q-value is then adjusted according to this error.
π§ Q-Learning Update Intuition¶
Current Q-Value
β
Estimate Future Reward
β
Compare with Actual Experience
β
Calculate TD Error
β
Update Q-Value
π§ Learning Rate¶
The learning rate is represented by:
It determines how strongly new experience changes the existing Q-value.
Small Ξ±¶
Large Ξ±¶
π§ Discount Factor¶
The discount factor:
determines how much future rewards contribute to the target.
The Q-Learning target is:
[ r+\gamma\max_{a'}Q(s',a') ]
π§ Q-Learning Example¶
Suppose:
The agent takes:
and receives:
The next state has:
Assume:
The target becomes:
The Q-value moves toward:
rather than immediately becoming 17.2.
This is controlled by the learning rate.
π§ Q-Learning Learning Process¶
flowchart LR
QOLD["Current Q(s,a)"]
EXPERIENCE["New Experience"]
TARGET["Reward + Discounted Future Value"]
ERROR["TD Error"]
UPDATE["Q-Value Update"]
QNEW["Updated Q(s,a)"]
QOLD --> ERROR
EXPERIENCE --> TARGET
TARGET --> ERROR
ERROR --> UPDATE
QOLD --> UPDATE
UPDATE --> QNEWπ§ Why Q-Learning Is Off-Policy¶
Q-Learning learns the optimal policy:
[ \pi^* ]
while the behavior policy can be different.
For example, the agent may use:
to explore.
But the Q-Learning target uses:
meaning it assumes the best possible next action.
Therefore:
This makes Q-Learning an off-policy algorithm.
π§ Q-Learning vs SARSA¶
Both are temporal-difference learning algorithms.
The major difference is how they calculate the next-state value.
Q-Learning¶
Uses:
SARSA¶
Uses:
π§ Q-Learning vs SARSA¶
| Q-Learning | SARSA |
|---|---|
| Off-policy | On-policy |
| Uses maximum next Q-value | Uses actual next action |
| Learns optimal target policy | Learns behavior policy |
| More aggressive | Can account for exploration behavior |
π§ Q-Learning and Exploration¶
If the agent always chooses:
it may never discover better actions.
Therefore, exploration is required.
A common strategy is:
Ξ΅-Greedy
π§ Ξ΅-Greedy Strategy¶
With probability:
the agent explores.
With probability:
the agent exploits.
Action Selection
β
βββββββββ΄βββββββββ
β β
Explore Exploit
β β
Random Action Best Q Action
π§ Ξ΅ Decay¶
The exploration rate can decrease during training.
Example:
Episode 1 β Ξ΅ = 1.00
Episode 100 β Ξ΅ = 0.50
Episode 500 β Ξ΅ = 0.10
Episode 1000 β Ξ΅ = 0.01
The exact schedule depends on the environment.
π§ Q-Learning in Grid World¶
Consider:
where:
Actions:
π§ Grid World Learning¶
Initially:
The agent explores.
After many episodes:
π§ Learned Policy¶
The final policy may look like:
Each arrow represents the action with the highest Q-value for that state.
π§ Q-Learning Algorithm¶
Pseudo-code:
initialize Q(s, a)
for each episode:
initialize state s
while state is not terminal:
choose action a using epsilon-greedy
execute action a
observe reward r
observe next state s'
Q[s, a] = Q[s, a] + alpha * (
r
+ gamma * max(Q[s'])
- Q[s, a]
)
s = s'
π§ Simplified Python Implementation¶
import numpy as np
q_table = np.zeros((state_size, action_size))
alpha = 0.1
gamma = 0.99
epsilon = 1.0
for episode in range(num_episodes):
state = env.reset()
done = False
while not done:
if np.random.random() < epsilon:
action = env.sample_action()
else:
action = np.argmax(q_table[state])
next_state, reward, done = env.step(action)
best_next_q = np.max(q_table[next_state])
q_table[state, action] += alpha * (
reward
+ gamma * best_next_q
- q_table[state, action]
)
state = next_state
This simplified implementation assumes a discrete state and action space.
π§ Q-Table Limitations¶
Tabular Q-Learning works well when:
But real-world problems can have enormous or continuous state spaces.
For example:
A Q-table becomes impractical.
π§ Curse of Dimensionality¶
Suppose:
The Q-table requires:
Large state spaces quickly become computationally expensive.
π§ From Q-Table to Neural Network¶
Instead of storing:
we can use a neural network:
This leads to:
Deep Q-Networks (DQN)
π§ Q-Learning vs DQN¶
| Tabular Q-Learning | DQN |
|---|---|
| Q-table | Neural network |
| Small discrete state spaces | High-dimensional states |
| Explicit Q-values | Approximated Q-values |
| Simple | More complex |
| Limited scalability | Much more scalable |
π§ DQN Concept¶
A DQN approximates:
[ Q(s,a;\theta) ]
where:
The network receives:
and outputs:
π§ DQN Architecture¶
flowchart LR
STATE["State"]
NETWORK["Deep Neural Network"]
QVALUES["Q-Values"]
ACTION["Best Action"]
STATE --> NETWORK
NETWORK --> QVALUES
QVALUES --> ACTIONDQN will be covered in detail in:
34. Deep Reinforcement Learning and DQN
π§ Bellman Equation¶
The Bellman Equation expresses the recursive relationship between the value of a state and the values of future states.
For a policy:
[ V^\pi(s) = \mathbb{E}_\pi \left[ r+\gamma V^\pi(s') \mid s \right] ]
The important idea is:
π§ Bellman Optimality Equation¶
For the optimal action-value function:
[ Q^(s,a) = \mathbb{E} \left[ r+ \gamma\max_{a'}Q^(s',a') \right] ]
This equation is fundamental to Q-Learning.
π§ Bellman Equation Intuition¶
This recursive relationship allows an agent to reason about long-term consequences.
π§ Dynamic Programming Perspective¶
If the environment model is known, Bellman equations can be used with techniques such as:
These methods can compute or improve policies using known transition and reward information.
Q-Learning is different because it does not require an explicit model of the environment.
π§ Value Iteration¶
Conceptually:
Initialize Values
β
Apply Bellman Optimality Update
β
Update Values
β
Repeat
β
Optimal Value Function
π§ Policy Iteration¶
Policy iteration alternates between:
until the policy converges.
π§ Model-Based vs Q-Learning¶
| Model-Based Methods | Q-Learning |
|---|---|
| Require environment model | Model-free |
| Know or learn transitions | Learn directly from experience |
| Can plan explicitly | Learns action values |
| Can use dynamic programming | Uses temporal-difference learning |
π§ Temporal-Difference Learning¶
Temporal-Difference (TD) learning updates estimates using:
rather than waiting until the entire episode ends.
This makes TD learning useful for continuing and episodic tasks.
π§ Monte Carlo vs TD¶
| Monte Carlo | Temporal Difference |
|---|---|
| Waits until episode ends | Updates during episode |
| Uses actual return | Uses bootstrapped estimate |
| Can have high variance | Often lower variance |
| Requires complete episodes | Can learn online |
π§ Q-Learning as TD Learning¶
Q-Learning uses:
Therefore it is a temporal-difference learning algorithm.
π§ Bootstrapping¶
Q-Learning uses an estimate to update another estimate.
This is called:
Bootstrapping
π§ Experience Replay¶
Basic Q-Learning updates immediately from each experience.
Deep RL systems often improve training by storing experiences:
in a replay buffer.
Experience replay will be covered in more detail in the DQN chapter.
π§ Q-Learning Convergence¶
Under suitable theoretical conditions, tabular Q-Learning can converge toward the optimal Q-function.
However, practical convergence depends on factors such as:
β Common Q-Learning Problems¶
Potential issues include:
Large State Spaces
Slow Learning
Sparse Rewards
Poor Exploration
Reward Hacking
Unstable Hyperparameters
Insufficient State Representation
β Sparse Rewards¶
Suppose an agent receives:
The agent receives little feedback until reaching the goal.
This can make learning difficult.
Potential approaches include:
Reward shaping must be designed carefully to avoid unintended behavior.
β State Representation¶
Q-Learning depends heavily on the quality of the state representation.
Poor state:
Better state:
If important information is missing, the environment may no longer appear Markovian to the agent.
π§ Q-Learning Hyperparameters¶
Important parameters include:
Other practical parameters may include:
π§ Hyperparameter Intuition¶
| Parameter | Controls |
|---|---|
Ξ± |
How quickly Q-values change |
Ξ³ |
Importance of future rewards |
Ξ΅ |
Exploration probability |
Ξ΅ decay |
How exploration changes over time |
π§ Q-Learning Training Curve¶
A useful metric is:
Conceptually:
Reward
β
β ______
β ___/
β ___/
β ___/
β __/
β__/
βββββββββββββββββββββββββ
Training Episodes
A rising curve generally indicates improving performance, although reward curves can be noisy and should not be interpreted in isolation.
π§ Q-Learning Debugging¶
When a Q-Learning agent fails to learn, inspect:
State Representation
Reward Function
Action Space
Learning Rate
Discount Factor
Exploration Rate
Episode Length
Terminal Conditions
π§ͺ Practical Exercise 1 β MDP Design¶
Create a simple Grid World.
Define:
Document the complete MDP as:
π§ͺ Practical Exercise 2 β Q-Table¶
Create a Q-table:
Initialize:
Train an agent to reach a goal.
π§ͺ Practical Exercise 3 β Ξ΅-Greedy¶
Implement:
Track:
π§ͺ Practical Exercise 4 β Ξ΅ Decay¶
Experiment with:
and gradually reduce it.
Compare:
versus:
π§ͺ Practical Exercise 5 β Learning Rate¶
Compare:
Measure:
π§ͺ Practical Exercise 6 β Discount Factor¶
Compare:
Observe how the agent's behavior changes.
π§ͺ Practical Exercise 7 β Reward Design¶
Create two reward functions:
and:
Compare the learned policies.
π§ͺ Practical Exercise 8 β Q-Learning vs SARSA¶
Implement both:
Compare their behavior in an environment with risky states.
π§ͺ Practical Exercise 9 β Visualize Q-Values¶
For every Grid World state, display:
Then visualize the learned policy.
π§ͺ Practical Exercise 10 β Build a DQN¶
Replace the Q-table with a neural network:
Then introduce:
Continue this implementation in:
34. Deep Reinforcement Learning and DQN
π§ Interview Questions¶
Beginner¶
1. What is an MDP?¶
An MDP is a mathematical framework for modeling sequential decision-making under uncertainty.
2. What are the components of an MDP?¶
3. What is the Markov Property?¶
The future depends on the current state rather than requiring the complete history, assuming the state contains the relevant information.
4. What is a Q-value?¶
A Q-value estimates the expected return from taking a particular action in a particular state.
5. What is Q-Learning?¶
Q-Learning is a model-free, off-policy, value-based Reinforcement Learning algorithm that learns the optimal action-value function.
Intermediate¶
6. What is the difference between V(s) and Q(s,a)?¶
V(s) evaluates a state, while Q(s,a) evaluates taking a specific action in a specific state.
7. What is the Bellman Equation?¶
It expresses a value recursively as immediate reward plus discounted future value.
8. What is the Bellman Optimality Equation?¶
It expresses the optimal value using the maximum value over possible future actions.
9. Why is Q-Learning off-policy?¶
Because it learns the optimal target policy using the maximum next-state Q-value, even if a different behavior policy generated the experience.
10. What is TD Error?¶
It is the difference between the current estimate and the updated target based on reward and estimated future value.
11. What does Ξ± control?¶
The learning rate controls how strongly new information changes the existing Q-value.
12. What does Ξ³ control?¶
The discount factor controls the importance of future rewards.
13. What does Ξ΅ control?¶
The exploration probability in an Ξ΅-greedy strategy.
Advanced¶
14. Why does Q-Learning not require a model of the environment?¶
Because it learns Q-values directly from observed state-action-reward-next-state experiences.
15. What is bootstrapping?¶
Using an existing estimate of future value to update another value estimate.
16. What is the difference between Q-Learning and SARSA?¶
Q-Learning uses the maximum next-state Q-value, while SARSA uses the Q-value associated with the actual next action selected by the behavior policy.
17. Why does tabular Q-Learning struggle with large state spaces?¶
Because the Q-table grows with the number of state-action combinations and becomes impractical for high-dimensional or continuous states.
18. How does DQN address the Q-table limitation?¶
DQN uses a neural network to approximate Q-values instead of explicitly storing every state-action value.
19. Why is exploration important?¶
Without exploration, the agent may never discover potentially better actions.
20. What is reward shaping?¶
Reward shaping modifies or supplements the reward signal to provide more useful learning feedback, while requiring careful design to avoid changing the intended objective.
π’ Enterprise Perspective¶
Markov Decision Processes and Q-Learning provide the mathematical foundation for understanding more advanced Reinforcement Learning systems.
The progression is:
MDP
β
Value Functions
β
Bellman Equations
β
Temporal-Difference Learning
β
Q-Learning
β
Deep Q-Learning
β
DQN
β
Modern Deep RL
For an AI Engineer, understanding this progression is more important than memorizing individual formulas.
π’ Q-Learning in Production¶
Tabular Q-Learning is usually appropriate for:
Small State Spaces
Small Action Spaces
Controlled Environments
Simulation
Educational Systems
Simple Optimization Problems
For larger systems, neural-network-based methods are generally more appropriate.
π’ Production Decision Architecture¶
A production decision system may look like:
Business Context
β
State Builder
β
RL Policy
β
Proposed Action
β
Safety / Business Rules
β
Approved Action
β
Environment
β
Outcome
β
Reward / Feedback
π’ RL Policy Interface¶
A backend service can abstract policy decisions behind an interface:
This allows the implementation to evolve from:
to:
or:
without forcing business services to understand the underlying RL algorithm.
π’ Policy Versioning¶
Every production policy should have an identifiable version.
Track:
Policy Version
Environment Version
Reward Version
Training Dataset
Hyperparameters
Evaluation Results
π’ Safety Layer¶
A production policy should not necessarily control the environment without constraints.
flowchart LR
STATE["State"]
POLICY["Q-Learning / RL Policy"]
ACTION["Proposed Action"]
GUARDRAIL["Business + Safety Guardrails"]
ENV["Environment"]
RESULT["Outcome"]
STATE --> POLICY
POLICY --> ACTION
ACTION --> GUARDRAIL
GUARDRAIL --> ENV
ENV --> RESULTπ’ Monitoring¶
Production monitoring should include:
Average Reward
Action Distribution
Invalid Actions
Policy Latency
State Distribution
Business KPI
Constraint Violations
Failure Rate
For RL systems, monitoring the environment is just as important as monitoring the model.
π’ Model Lifecycle¶
MDP Definition
β
Reward Design
β
Environment / Simulator
β
Training
β
Evaluation
β
Policy Registry
β
Deployment
β
Monitoring
β
Retraining
Production Insight
Q-Learning teaches an important production AI engineering principle: a model is only useful when its decision-making objective, state representation, feedback loop, and operating environment are correctly designed.
The core loop is:
In production systems, the surrounding architecture must also provide:
State Validation
Reward Integrity
Safety Guardrails
Policy Versioning
Evaluation
Monitoring
Rollback
For small discrete environments, tabular Q-Learning is an excellent foundation. For high-dimensional production environments, the same principles lead naturally to Deep Q-Networks and other Deep Reinforcement Learning approaches.
π Key Takeaways¶
- A Markov Decision Process provides a mathematical framework for sequential decision-making.
- The main MDP components are states, actions, transition dynamics, rewards, and discount factor.
- The Markov Property means the current state contains sufficient information about the relevant past for predicting the future.
- State representation is critical to successful Reinforcement Learning.
- Transition dynamics describe how actions change the environment.
- Transition probabilities represent uncertainty in environment behavior.
- Reward functions define what the agent is incentivized to optimize.
- Poor reward design can lead to unintended behavior.
- A policy determines how actions are selected.
- The value function evaluates states.
- The action-value function evaluates state-action pairs.
- The Bellman Equation expresses value recursively using immediate and future rewards.
- The Bellman Optimality Equation uses the best possible future action.
- Q-Learning is model-free, off-policy, and value-based.
- Q-Learning learns an optimal action-value function.
- The Q-table stores Q-values for discrete state-action combinations.
- Q-Learning updates values using temporal-difference learning.
- The learning rate controls how strongly new experience changes Q-values.
- The discount factor controls the importance of future rewards.
- Ξ΅-greedy provides a simple exploration strategy.
- Q-Learning is off-policy because its target uses the maximum next-state Q-value.
- SARSA differs from Q-Learning because it uses the action actually selected by the behavior policy.
- Tabular Q-Learning becomes impractical for large or continuous state spaces.
- Deep Q-Networks replace the Q-table with a neural network.
- Bellman equations provide the mathematical foundation behind Q-Learning.
- Production RL requires more than an algorithmβit requires a well-designed environment, reward function, safety layer, monitoring, and policy lifecycle.
π Further Reading¶
Continue with:
- 34. Deep Reinforcement Learning and DQN
- 35. GPU Accelerated Deep Learning
- 36. Deep Learning Training and Model Lifecycle
- 37. Building Production Deep Learning Systems
β‘οΈ Next Chapter¶
34. Deep Reinforcement Learning and DQN
Enterprise AI Engineering Handbook
Building Production-Grade Enterprise AI Systems β One Chapter at a Time.