2.1 Play State Space (khu vực không gian để chơi game này)#

# Observation vector 12 chiều:
observation = [
    norm_head_x, norm_head_y,  # Vị trí đầu rắn (2)
    *direction_one_hot,        # Hướng hiện tại (4) - one-hot encoding
    dx, dy,                    # Vị trí mồi tương đối (2)
    danger_left, danger_front, danger_right,  # Nguy hiểm (3)
    norm_length                # Độ dài rắn (1)
]

Giải thích chi tiết:

• Vị trí đầu rắn: Chuẩn hóa về [0,1] để neural network dễ học
• Hướng: One-hot encoding [UP, RIGHT, DOWN, LEFT] = [1,0,0,0]
• Vị trí mồi tương đối: Khoảng cách từ đầu rắn đến mồi
• Nguy hiểm: 1.0 = nguy hiểm, 0.0 = an toàn
• Độ dài: Chuẩn hóa theo kích thước lưới

2.2 Action Space (Không gian dỉ chuyên)#

action_space = 3  # 0=turn_left, 1=straight, 2=turn_right

Tại sao 3 actions thay vì 4?

• Rắn luôn di chuyển về phía trước
• Chỉ cần quyết định: rẽ trái, đi thẳng, rẽ phải
• Tránh được action “đi lùi” không hợp lý

2.3 Reward System (cấu trúc phần thưởng)#

# Từ config.yaml:
rewards:
  eat_food: 10.0      # Ăn mồi: +10 điểm
  die: -10.0          # Chết: -10 điểm  
  step: -0.01         # Mỗi bước: -0.01 điểm
  move_towards_food: 0.1    # Di chuyển về phía mồi: +0.1
  move_away_food: -0.1      # Di chuyển xa mồi: -0.1

Triết lý thiết kế reward:

• Sparse reward: Chỉ thưởng khi ăn mồi
• Dense reward: Penalty nhỏ cho mỗi bước để khuyến khích hiệu quả
• Shaping reward: Hướng dẫn AI di chuyển về phía mồi

3.1 Kiến trúc Neural Network#

# Từ config.yaml:
network:
  hidden_layers: [128, 128, 64]  # 3 layer ẩn
  activation: "relu"

Cấu trúc mạng:

Input (12) → Linear(128) → ReLU → Dropout(0.1) 
           → Linear(128) → ReLU → Dropout(0.1)
           → Linear(64)  → ReLU → Dropout(0.1)
           → Linear(3)   → Q-values

Giải thích:

• Input layer: 12 neurons (observation space)
• Hidden layers: 128 → 128 → 64 neurons
• Output layer: 3 neurons (Q-values cho 3 actions)
• Activation: ReLU (Rectified Linear Unit)
• Dropout: 0.1 để tránh overfitting

3.2 Q-Learning Theory#

Q-Function: Q(s,a) = giá trị kỳ vọng của tổng reward khi thực hiện action a ở state s

Bellman Equation:

Q(s,a) = r + γ * max Q(s',a')

Trong đó:

• r: immediate reward
• γ: discount factor (0.99)
• s': next state
• a': next action

Note: Ghi vậy thôi chứ cũng chằng hiểu lắm :)))))))))))))

4.1 Experience Replay Buffer#

Experience Replay Buffer lưu trữ các trải nghiệm của agent để training sau này, giúp:

• Phá vỡ correlation giữa các sample liên tiếp
• Tái sử dụng dữ liệu hiệu quả
• Ổn định quá trình training

4.2 Training Process#

Agent học thông qua việc:

1. Thu thập experience từ environment
2. Lưu vào replay buffer
3. Sample random batch để training
4. Cập nhật Q-network weights

5.1 Training Process Flow#

# Training loop chính:
for episode in range(episodes):
    state = env.reset()
    
    for step in range(max_steps):
        # 1. Chọn action
        action = agent.act(state, training=True)
        
        # 2. Thực hiện action
        next_state, reward, done, info = env.step(action)
        
        # 3. Lưu experience và train
        loss = agent.step(state, action, reward, next_state, done)
        
        # 4. Cập nhật state
        state = next_state
        
        if done:
            break
    
    # 5. Cập nhật epsilon
    agent.update_epsilon(episode)

5.2 Key Components#

Experience Replay Buffer:

• Lưu trữ (state, action, reward, next_state, done)
• Sample ngẫu nhiên để train (tránh correlation)
• Capacity: 50,000 experiences

Target Network:

• Copy của Q-network
• Cập nhật mỗi 1000 steps
• Giúp ổn định training

Epsilon-Greedy Policy:

epsilon = 1.0 → 0.05  # Exploration → Exploitation

7.1 Metrics Tracking#

Các metrics quan trọng để theo dõi:

• Episode Reward: Tổng reward mỗi episode
• Episode Length: Số steps mỗi episode
• Loss: Training loss của neural network
• Epsilon: Mức độ exploration hiện tại
• Average Score: Điểm trung bình trong window gần đây

8.1 Chạy Training và Quan sát#

# Training với render (chậm nhưng có thể quan sát)
python continue_training.py --latest --episodes 50

# Training không render (nhanh)
python continue_training.py --latest --episodes 100 --no-render

8.2 Quan sát AI chơi#

Khi training, các anh zai đồng môn có thể quan sát:

• AI ban đầu di chuyển ngẫu nhiên (high epsilon)
• Nó sẽ dần dần học được cách tránh tường và thân mình
• Cuối cùng học được strategy tối ưu để ăn mồi

9.1 Reinforcement Learning Flow#

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Environment   │    │   Agent         │    │   Neural Net    │
│                 │    │                 │    │                 │
│ State: 12 dim   │◄──►│ Action: 3 dim   │◄──►│ Q-values: 3 dim │
│ Reward: float   │    │ Policy: ε-greedy│    │ Loss: MSE       │
│ Done: bool      │    │ Buffer: 50k     │    │ Optimizer: Adam │
└─────────────────┘    └─────────────────┘    └─────────────────┘

9.2 Key Learning Points#

1. State Representation: 12-dimensional vector encoding game state
2. Action Space: 3 discrete actions (left, straight, right)
3. Reward Design: Sparse + dense rewards for effective learning
4. Experience Replay: Breaks temporal correlations
5. Target Network: Stabilizes training
6. Epsilon-Greedy: Balances exploration vs exploitation

9.3 Hyperparameters Impact#

• Learning Rate (0.0005): Too high → unstable, too low → slow learning
• Batch Size (128): Larger → more stable gradients, smaller → more updates
• Buffer Size (50k): Larger → more diverse experiences, smaller → faster updates
• Epsilon Decay (800 episodes): Faster → less exploration, slower → more exploration

Tài liệu tham khảo:

• Deep Q-Learning Paper
• OpenAI Gym Documentation
• PyTorch RL Tutorial

Chúc các đồng môn thành cmn công với Reinforcement Learning! 🚀🤖