Я не могу понять, как (например) DeepMinds Breakout бот учится, пока он играет - PullRequest
Новая
       32

Я не могу понять, как (например) DeepMinds Breakout бот учится, пока он играет

0 голосов
/ 28 февраля 2019

Я пытаюсь решить проблему с карполом в спортзале openAIs.Мой подход - глубокое изучение Q.

Я могу получить хороший результат, если сначала сгенерирую кучу тренировочных данных.Затем обучите мою сеть этим данным.И после этого я снова запускаю своего агента, на этот раз со 100% эксплойтом.

Разница в том, что моя модель не учится прогрессивно.Сначала я должен сгенерировать тренировочные данные, тренироваться, а потом уже учиться, поэтому это выглядит примерно так:

generate training data -> train -> play.

Я хочу сделать следующее:

play -> train -> play better и т. Д.

Следуя этому подходу, используя точно такую ​​же нейронную сеть и гиперпараметры, мой агент не улучшается.

Я предполагаю, что есть кое-что очень фундаментальное, что я упускаю.Итак, что я ищу, так это где моя логика может быть ошибочной.

Весь мой код, если вы хотите попробовать его. 

import gym
from gym import spaces
import numpy as np
import random
from keras.optimizers import Adam
from keras.models import Sequential
from keras.layers import Activation, Dense

# Deep Q-learning Model
class Model:
    def __init__(self, environment):
        self.env = gym.make(environment)
        self.amount_obs, self.amount_actions = self.environment()

        # Amount of episodes and steps per episode
        self.episodes = 1000

        self.gamma = 0.95  # Discount future rate
        self.alpha = 0.001 # Learning rate

        # Epsilon = explore/exploite factor
        self.epsilon       = 1.0    # 100% explore initally
        self.epsilon_min   = 0.01
        self.epsilon_decay = 0.995

        self.batch_size = 50
        self.model      = self.create_net()

    def create_net(self):
        # Neural-net
        model = Sequential()
        model.add(Dense(24, input_dim=self.amount_obs, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(24, activation='relu'))
        model.add(Dense(self.amount_actions, activation='linear'))
        model.compile(loss='mse', optimizer=Adam(lr=self.alpha))
        return model

    def environment(self):
        observation_space = len(self.env.observation_space.sample())
        # Space.n gets number of actions
        action_space = self.env.action_space.n
        return observation_space, action_space

    def act(self, state, always_exploit=False):
        # Explore or exploite
        if random.random() <= self.epsilon and not always_exploit:
            # Random action (explore)
            return random.randrange(self.amount_actions)
        # Predict an action (exploite)
        possible_actions = self.model.predict(state)
        return np.argmax(possible_actions[0])

    def train(self, episode):
        for steps in episode:
            state, action, reward, next_state, done = steps

            if done:
                target = reward
            else:
                target = reward + self.gamma * \
                       np.amax(self.model.predict(next_state)[0])

            target_state = self.model.predict(state)
            target_state[0][action] = target
            self.model.fit(state, target_state, epochs=2, verbose=0)

    def play(self):
        for i in range(self.episodes):

            state = self.env.reset()
            state = np.reshape(state, [1, self.amount_obs])
            episode = []
            episode_reward = 0
            done = False

            while not done:

                #self.env.render()

                # Decide action
                action = self.act(state)

                next_state, reward, done, _ = self.env.step(action)
                next_state = np.reshape(next_state,
                             [1, self.amount_obs])

                # save the previous state, action, reward, and done
                episode.append(
                        (state, action, reward, next_state, done))

                state = next_state

                episode_reward = episode_reward + reward

            print("Episode {} - totals {}".format(i, episode_reward))
            # Train the episode
            self.train(episode)

        # Decrease epsilon
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

# initialize gym environment and the agent
model = Model('CartPole-v0')
#model = Model('MountainCar-v0')
#model = Model('Acrobot-v1')
model.play()
...