Итак, я сделал небольшую игру python, в которой игрок должен дойти до конца и избежать ловушек. И это выглядит так
Я пробовал много разных размеров пакетов, Награды, Формы ввода, Количество узлов в скрытом слое, Но сеть все еще не тренировалась.
Текущий способ, которым я тренирую его, использует размер 64 пакета с объемом памяти 100000. Ввод представляет собой одномерный массив, представляющий состояние игры + координаты игрока + количество ходов, оставшихся до окончания игры, И вознаграждение начинается с -distanceFromEnd + maxDistance / 2. Если вы достигнете конца, вы получите +500 вознаграждений, и игра закончена. Если вы дотронетесь до ловушки, вы получите вознаграждение -100, и игра закончится, если игра не Выполнив 64 хода, вы получите награду -200, и игра готова.
Я использую AdamOptimizer и функцию потери MSE, а для функций активации я использую ReLU для всех слоев, кроме последнего, я ничего не использую.
игрок, конец все позиции ловушек рандомизированы после каждого эпизода
Средний балл (сумма очков наград) за последние 100 игр составляет около -30 даже после 3000 эпизодов.
DQN работает нормально игра в тренажерный зал LunarLander-v2.
И, как я уже сказал, я пытался настроить значения, но это не помогло.
Сначала вот метки, которые я использую в состоянии
FLOOR = 1
END = 2
TRAP = 3
PLAYER = 4
Это моя пошаговая функция
def step(self, action):
isDone = False
if action == 0:
# Move Up
if self.playerY != 0:
self.playerY -= 1
elif action == 1:
# Move Down
if self.playerY != 7:
self.playerY += 1
elif action == 2:
# Move Right
if self.playerX != 0:
self.playerX -= 1
elif action == 3:
# Move Left
if self.playerX != 7:
self.playerX += 1
x = self.playerX - self.endX
x = x * x
y = self.playerY - self.endY
y = y * y
distance = math.sqrt(x + y)
reward = -distance + self.maxDist
#self.lastDist = distance
if self.state[self.playerX, self.playerY] == self.END:
reward = 500
isDone = True
elif self.state[self.playerX, self.playerY] == self.TRAP:
reward = -100
isDone = True
self.moves -= 1
if self.moves < 0:
reward = -200
isDone = True
return self.getFlatState(), reward, isDone, 0
Состояние Функция Getter
# Adding one to the players coordinates to avoid 0s as a try to fix the problem
def getFlatState(self):
return np.concatenate([np.ndarray.flatten(self.state), [self.playerX + 1, self.playerY + 1, self.moves]])
Вот сценарий DQN / Agent
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.models import load_model
class ReplayBuffer():
def __init__(self, max_size, input_dims):
self.mem_size = max_size
self.mem_cntr = 0
self.state_memory = np.zeros((self.mem_size, *input_dims),
dtype=np.float32)
self.new_state_memory = np.zeros((self.mem_size, *input_dims),
dtype=np.float32)
self.action_memory = np.zeros(self.mem_size, dtype=np.int32)
self.reward_memory = np.zeros(self.mem_size, dtype=np.float32)
self.terminal_memory = np.zeros(self.mem_size, dtype=np.int32)
def store_transition(self, state, action, reward, state_, done):
index = self.mem_cntr % self.mem_size
self.state_memory[index] = state
self.new_state_memory[index] = state_
self.reward_memory[index] = reward
self.action_memory[index] = action
self.terminal_memory[index] = 1 - int(done)
self.mem_cntr += 1
def sample_buffer(self, batch_size):
max_mem = min(self.mem_cntr, self.mem_size)
batch = np.random.choice(max_mem, batch_size, replace=False)
states = self.state_memory[batch]
states_ = self.new_state_memory[batch]
rewards = self.reward_memory[batch]
actions = self.action_memory[batch]
terminal = self.terminal_memory[batch]
return states, actions, rewards, states_, terminal
def build_dqn(lr, n_actions, input_dims, fc1_dims, fc2_dims):
model = keras.Sequential([
keras.layers.Dense(fc1_dims, activation='relu'),
keras.layers.Dense(fc2_dims, activation='relu'),
keras.layers.Dense(n_actions, activation=None)])
model.compile(optimizer=Adam(learning_rate=lr), loss='mean_squared_error')
return model
class Agent():
def __init__(self, lr, gamma, n_actions, epsilon, batch_size,
input_dims, epsilon_dec=1e-3, epsilon_end=0.01,
mem_size=1000000, fname='dqn_model.h5'):
self.action_space = [i for i in range(n_actions)]
self.gamma = gamma
self.epsilon = epsilon
self.eps_dec = epsilon_dec
self.eps_min = epsilon_end
self.batch_size = batch_size
self.model_file = fname
self.memory = ReplayBuffer(mem_size, input_dims)
self.q_eval = build_dqn(lr, n_actions, input_dims, 256, 128)
def store_transition(self, state, action, reward, new_state, done):
self.memory.store_transition(state, action, reward, new_state, done)
def choose_action(self, observation):
if np.random.random() < self.epsilon:
action = np.random.choice(self.action_space)
else:
state = np.array([observation])
actions = self.q_eval.predict(state)
action = np.argmax(actions)
return action
def learn(self):
if self.memory.mem_cntr < self.batch_size:
return
states, actions, rewards, states_, dones = \
self.memory.sample_buffer(self.batch_size)
q_eval = self.q_eval.predict(states)
q_next = self.q_eval.predict(states_)
q_target = np.copy(q_eval)
batch_index = np.arange(self.batch_size, dtype=np.int32)
q_target[batch_index, actions] = rewards + \
self.gamma * np.max(q_next, axis=1)*dones
self.q_eval.train_on_batch(states, q_target)
self.epsilon = self.epsilon - self.eps_dec if self.epsilon > \
self.eps_min else self.eps_min
def save_model(self):
self.q_eval.save(self.model_file)
def load_model(self):
self.q_eval = load_model(self.model_file)