Модель DQN либо не работает, либо обучается очень медленно. ⇐ Python

[Anonymous]

Я пытаюсь построить модель DQN для своей докторской диссертации, и прежде чем реализовать ее на реальных данных, я хочу использовать фиктивные данные.
Используя тот же процесс с простым Q Learning, этот подход оказался эффективным, но как только я перешел на DQN, чтобы сделать его более продвинутым и адаптивным, я начал сталкиваться с проблемами на этапе обучения. Я также реализовал ускорение графического процессора, но это совсем не помогает. Интересно, связано ли это с размером фиктивного набора данных или с чем-то еще, чего я не могу понять.
Любая помощь или рекомендации приветствуются.
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import random
import pandas as pd
from collections import deque

# Set device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Running on device:", device)

# Dummy data setup
data = {
'message_size': np.random.randint(1000, 70000, size=1000),
'cpu_usage': np.random.uniform(40, 100, size=1000),
'submission_time': np.random.uniform(0, 300, size=1000)
}
dummy_data = pd.DataFrame(data)

# Parameters
MAX_BLOCK_SIZE = 32768
ALPHA = 0.1
GAMMA = 0.9
EPSILON = 1.0
EPSILON_MIN = 0.01
EPSILON_DECAY = 0.99
BATCH_SIZE = 32
EPISODES = 1000

# DQN model
class DQN(nn.Module):
def __init__(self, input_dim):
super(DQN, self).__init__()
self.fc1 = nn.Linear(input_dim, 64)
self.fc2 = nn.Linear(64, 64)
self.fc3 = nn.Linear(64, 1)

def forward(self, x):
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
return self.fc3(x)

# Initialize models and optimizer
dqn = DQN(input_dim=2).to(device)
target_model = DQN(input_dim=2).to(device)
target_model.load_state_dict(dqn.state_dict())
optimizer = optim.Adam(dqn.parameters(), lr=ALPHA)
memory = deque(maxlen=2000)

# Block choice function
def block_choice(state):
if random.random() < EPSILON:
return random.randint(1, int(state[0] // MAX_BLOCK_SIZE) + 1)
else:
state_tensor = torch.FloatTensor(state).to(device)
return torch.argmax(dqn(state_tensor)).item() + 1

# Reward function based on utility
def utility_function_rewarding(total_latency, cpu_per_block, max_latency=300, max_cpu=100):
latency_reward = max(0, 1 - (total_latency / max_latency))
cpu_reward = max(0, 1 - (cpu_per_block / max_cpu))
return latency_reward + cpu_reward

# Training function
def dqn_training(batch_size):
if len(memory) < batch_size:
return
batch = random.sample(memory, batch_size)
states, actions, rewards, next_states, dones = zip(*batch)

# Move data to device
states = torch.FloatTensor(states).to(device)
rewards = torch.FloatTensor(rewards).to(device)
next_states = torch.FloatTensor(next_states).to(device)
dones = torch.FloatTensor(dones).to(device)

state_action_values = dqn(states)
next_state_values = target_model(next_states).max(1)[0]
expected_values = rewards + (GAMMA * next_state_values * (1 - dones))

loss = nn.functional.mse_loss(state_action_values, expected_values)
optimizer.zero_grad()
loss.backward()
optimizer.step()

# Store transitions in memory
def store_transition(state, action, reward, next_state, done):
memory.append((state, action, reward, next_state, done))

# Main training loop
for episode in range(EPISODES):
print(f"Starting Episode {episode + 1}/{EPISODES}")
row = dummy_data.sample().iloc[0]
state = [row['submission_time'], row['cpu_usage']]
total_reward = 0
done = False

while not done:
action = block_choice(state)
next_row = dummy_data.sample().iloc[0]
next_latency = next_row['submission_time']
next_cpu = next_row['cpu_usage'] / action
next_state = [next_latency, next_cpu]

reward = utility_function_rewarding(next_latency, next_cpu)
total_reward += reward
done = episode == EPISODES - 1
store_transition(state, action, reward, next_state, done)

state = next_state
dqn_training(BATCH_SIZE)

# Update epsilon for exploration-exploitation balance
if EPSILON > EPSILON_MIN:
EPSILON *= EPSILON_DECAY

print(f"Episode {episode + 1}/{EPISODES} - Total Reward: {total_reward}")


Подробнее здесь: https://stackoverflow.com/questions/791 ... n-training