Обучение с подкреплением часто кажется широким полем с таким большим количеством методов обучения. Один из таких методов известен как Q-обучение. Этот метод обучения с подкреплением в последнее время набирает обороты. Он оказался очень успешным во многих приложениях, некоторые из которых можно найти здесь. В этом руководстве мы подробно рассмотрим, что такое Q Learning. Мы также реализуем Q Learning Agent, чтобы играть в игру принятия решений с конечной цепью Маркова, которую мы создали ранее. Со всем этим вы получите твердое представление о том, как на самом деле работает метод Q Learning.

Что такое Q Learning?

Это просто относится к методу обучения с подкреплением, который позволяет агенту извлекать уроки из политики, которая определяет его решения при различных обстоятельствах в среде. Цель Q Learning - максимизировать совокупное значение вознаграждения на всех этапах, начиная с его начального состояния. Часто люди называют Q-обучение качественным обучением.

Q Learning основано на популярном математическом уравнении, называемом уравнением Беллмана. Он принимает два входа - состояние и действие.

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

Пошаговое руководство по внедрению Q Learning Agent

Теперь мы приступим к реализации класса агента Q Learning в Python. Для того, чтобы правильно следовать инструкциям, рекомендуем вам ознакомиться с классом игроков в Монте-Карло [Ссылка].

Обучающий класс Q наследуется от класса MonteCarloPlayer и, следовательно, содержит те же методы: getAction и learn в качестве своего базового класса.

Этот класс Q Learning имеет следующие свойства: сетка, эпсилон, гамма, альфа, гамма2, как описано для MonteCarloPlayer.

Далее мы реализуем функцию обучения. Обучение в проигрывателе Q Learning отличается от настройки Монте-Карло тем, что Q-обучение использует цель временной разницы вместо ожидания завершения эпизодов. Это делает его более применимым к непрерывным / неэпизодическим задачам. Функция обновления: Q (S, A) ‹== alpha * (R + max (Q (S’, A) - Q (S, A)))

Для реализации функции будут предприняты следующие шаги:

  • Функция принимает в качестве аргумента кортеж текущего состояния, действия, награды и следующего состояния.
  • Получите значение Q пары действий состояния, которое необходимо обновить
  • Сохраните наблюдаемую награду в исходном кортеже опыта.
  • Получите список значений Q для всех доступных действий с учетом следующего состояния
  • Обновите значение Q для пары действий состояния
def playGridWorld(agent, xDim, yDim, numBlocks, transitProb, episodes=200, gamma = 0.5):
    """playGridWorld function:
                arguments: 
                agent: (object) the agent: Agent(random policy) or MonteCarloPlayer
                xDim, yDim: (int) height and width dimensions of the grid
                numBlocks: (int) number of blocked positions
                transitProb: (float) transition probability...between 0 and 1
                episodes: (int) number of episodes to play 
                gamma: (float) Discount factor for future rewards, between 0 and 1
    """
    
    if agent == Agent:
        agentName = "Random policy" 
    elif agent == MonteCarloPlayer:
        agentName = "Monte Carlo Player"
    else:
        agentName = "Q Learning Agent"
    
    print("Playing with {}".format(agentName))
    totalRewards = []
    env = Environment(xDim, yDim, numBlocks, transitProb) #Create anvironment
    player = agent(env.grid) #Create the agent 
    for i in range(episodes):
        print("Episode {}".format(i))
        env.reset()
        stateActionValues = []
        env.reset()
        presentState = env.state
        totalReward = 0
        t = 0
        while not presentState.isTerminal(): #Play until terminal state (Goal or Fire)
            t+= 1
            print("timestep {}".format(t))
            action = player.getAction(presentState, i) #Agent takes action based on the present state
            print("Action selected: {}".format(action))
            nextState = env.nextStep(action) #Environment returns the next state based on the action
            print("Reward: {}".format(nextState.reward))
            reward = nextState.reward #Reward is returned based on the next state  
            totalReward +=reward
            if agent  == QLearningPlayer:
                stateActionValue = [presentState.loc, action, reward , nextState.loc] #Experience tuple
                #For the observed state Action Pair
                player.learn(stateActionValue) #Learn after every step based on temporal difference 
            else:
                #print("hello")
                stateActionValues.append([presentState.loc, action, 0 , t]) 
                #Append this experience gained 
            #to memory. this serves as the training set for the agent
                for stateActionValue in stateActionValues:
                    stateActionValue[2] += gamma**(t- stateActionValue[3])*reward #Update the discounted action 
                    #value for every past state encountered 
                    #print(stateActionValue)
            presentState = nextState #Update the state
            if t == 200: #End game if there is no terminal state in 200 moves
                break
        if env.goalAchieved():
            print("You got to the goal!")
        else:
            print("You lost")
        totalRewards.append(totalReward)
        print("Total score: {}".format(totalReward))
        print("Game over")
        if agent ==  MonteCarloPlayer:
            #print("hello")
            #print(learning)
            player.learn(stateActionValues)
    plt.plot(range(1, episodes+1), totalRewards, label = agentName)
    plt.xlabel("Episodes")
    plt.ylabel("Total rewards")
    plt.title("Total Rewards versus Episodes")

После того, как агент Q Learning был создан, пора воспроизвести Марковский процесс принятия решений, созданный ранее. С помощью созданной ранее функции Play Grid World был получен следующий результат:

playGridWorld(QLearningPlayer, 6,6,3,1) plt.legend()

Мы видим, что количество наград достигло примерно 80 серий.

Вот и все - краткое, но исчерпывающее введение в методы Q Learning в обучении с подкреплением. Мы начали с того, что подчеркнули, почему в последнее время наблюдается рост количества методов Q Learning. Затем мы приступили к объяснению основ Q Learning, а также математики, лежащей в основе этого. После этого мы реализовали агент Q Learning для игры в сетку мира. Со всем этим вы готовы приступить к изучению удивительного мира методов Q Learning.

Полный источник: https://github.com/deepakkumar1984/tech-quantum/blob/master/Python/Introduction%20To%20QLearning.ipynb

Первоначально опубликовано на www.tech-quantum.com 26 октября 2018 г.

Получайте лучшие предложения по программному обеспечению прямо в свой почтовый ящик