Data Mining and Machine Learning Reinforcement Learning - xbdev.net 2000 - 2024 (c) - Tutorials - Demos - Software, Game Development, Engineering, Data Mining, File Formats,Programming, Machine Learning

import numpy as np
import tensorflow as tf

# Define the grid world environment
# 'S' denotes the starting point, 'G' is the goal, 'H' represents a hole, and '.' represents empty space
grid_world = [
    ['S', '.', '.', '.', '.'],
    ['.', 'H', '.', '.', '.'],
    ['.', '.', '.', 'H', '.'],
    ['.', '.', '.', '.', 'G']
]

# Define the rewards for each state
rewards = {
    'S': 0,
    '.': -1,
    'H': -10,
    'G': 10
}

# Define the actions (up, down, left, right)
actions = {
    'up': (-1, 0),
    'down': (1, 0),
    'left': (0, -1),
    'right': (0, 1)
}

# Convert state-action pairs to feature vectors
def state_action_to_features(state, action):
    return [state[0], state[1], actions[action][0], actions[action][1]]

# Convert grid world to state-action pairs
state_action_pairs = []
for i in range(len(grid_world)):
    for j in range(len(grid_world[0])):
        state = grid_world[i][j]
        if state != '#':
            for action in actions.keys():
                state_action_pairs.append((state, action))

# Create Q-network
model = tf.keras.Sequential([
    tf.keras.layers.Input(shape=(4,)),
    tf.keras.layers.Dense(32, activation='relu'),
    tf.keras.layers.Dense(1)
])

# Compile the model
model.compile(optimizer='adam', loss='mse')

# Train Q-network
X = np.array([state_action_to_features((i, j), action) for i in range(len(grid_world)) for j in range(len(grid_world[0])) for action in actions.keys()])
y = np.array([rewards[state] for state, _ in state_action_pairs])
model.fit(X, y, epochs=10)

# Print learned Q-values
print("Learned Q-values:")
for state, action in state_action_pairs:
    q_value = model.predict(np.array([state_action_to_features(state, action)]))[0][0]
    print(f"State: {state}, Action: {action}, Q-value: {q_value}")

Reinforcement Learning Algorithms
   |
   ├── Model-Free Methods
   │     ├── Value-Based Methods
   │     │     ├── Q-Learning
   │     │     ├── Deep Q-Networks (DQN)
   │     │     ├── Double Q-Learning
   │     │     └── Dueling Network Architectures
   │     │ 
   │     ├── Policy-Based Methods
   │     │     ├── Policy Gradient Methods
   │     │     │     ├── REINFORCE
   │     │     │     ├── Actor-Critic
   │     │     │     ├── Proximal Policy Optimization (PPO)
   │     │     │     └── Trust Region Policy Optimization (TRPO)
   │     │     │ 
   │     │     └── Deterministic Policy Gradient Methods
   │     │           ├── Deep Deterministic Policy Gradient (DDPG)
   │     │           └── Twin Delayed DDPG (TD3)
   │     │ 
   │     └── Actor-Critic Methods
   │           ├── Advantage Actor-Critic (A2C)
   │           └── Asynchronous Advantage Actor-Critic (A3C)
   │ 
   ├── Model-Based Methods
   │     ├── Monte Carlo Tree Search (MCTS)
   │     └── Dyna-Q
   │ 
   └── Multi-Agent Reinforcement Learning
         ├── Independent Q-Learning
         ├── Cooperative Q-Learning
         └── Multi-Agent Actor-Critic (MAAC)

Data Mining and Machine Learning > Reinforcement Learning