Обучение с подкреплением для машин для игр (с github)

обучение с подкреплением

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

Глубокое обучение с подкреплением в сочетании с глубоким обучением теперь более эффективно.

Марковский процесс принятия решений

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

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

элементы, связанные с принятием решений

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

Обучение с подкреплением в основном предназначено для расчета вознаграждения за различные действия в каждом состоянии, которое не выполняется мгновенно, а требует множества испытаний. Следующее состояние зависит от текущего состояния и действия, а состояние не зависит от предыдущего состояния, памяти нет и соответствует марковскому свойству.

Оптимизация марковских процессов

Обучение с подкреплением — это итеративное взаимодействие между агентом и окружающей средой.Есть несколько моментов, которые следует учитывать:

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

Q-обучение

Q-обучение заключается в изучении качества каждого действия в различных состояниях, которое определяется как

$Q_\pi(s,a) = E_\pi[C_t|S_t=s,A_t=a]$

Его также можно преобразовать в форму уравнения Беллмана,

$Q_\pi(s,a) = E_\pi[R_{t+1} +\gamma Q_\pi(S_{t+1},A_{t+1}) | S_t=s,A_t=a]$

Оптимальная функция ценности действия,

$Q_*(s,a) = Max_\pi Q_\pi(s,a)$

$Q_*(s,a) = E_\pi[MaxR_{t+1} +\gamma Max_{S_{t+1}} Q_\pi(S_{t+1},A_{t+1}) | S_t=s,A_t=a]$

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

Хотя функция значения действия может напрямую вычислять значение Q, оно не обновляется непосредственно значением Q во время фактического обучения, а обновляется постепенно. Метод обучения можно описать следующим псевдокодом: сначала инициализируйте массив набора состояний Q-обучения и набора действий, затем наблюдайте начальное состояние, а затем повторите выполнение: выберите действие, наблюдайте награду и перенесите в новое состояние и обновить значение массива Q-обучения, которое включает итеративное обновление, Поскольку мы не можем знать значение Q в следующий момент, значение Q предыдущей итерации используется для обновления значения Q этой итерации, где α представляет скорость обучения.

initialize Q[numstates,numactions] arbitrarily
observe initial state s
repeat
    select and carry out an action a
    observe reward R and new state s'
    Q[s,a] = Q[s,a] + α(R + γmaxa'Q[s',a'] - Q[s,a])
    s = s'
until terminated

Игры

Есть небольшая игра, как показано на рисунке ниже.После входа в вход начальная позиция A, а заштрихованная часть представляет собой большой кан.Если вы войдете, вы умрете, и вам придется начинать все сначала.

Внедрение Q-обучения

Сначала определитесь с размером карты, а также расположением, входом и выходом из ямы.

ROWS = 5
COLUMNS = 6
ENTRANCE = (0, 0)
EXIT = (4, 5)
BARRIERS = list()
BARRIERS.append((1, 1))
BARRIERS.append((2, 1))
BARRIERS.append((3, 1))
BARRIERS.append((4, 1))
BARRIERS.append((0, 3))
BARRIERS.append((1, 3))
BARRIERS.append((3, 3))
BARRIERS.append((4, 3))
BARRIERS.append((3, 4))
BARRIERS.append((1, 5))

Определите некоторые настройки параметров для Q-обучения, TIMES — количество попыток, R — случайный фактор, ALPHA — скорость обучения, GAMMA — коэффициент дисконтирования, q_values — таблица q-значений, а results — окончательный результат. .

TIMES = 200
R = 0.05
ALPHA = 0.1
GAMMA = 0.9
q_values = dict()
results = list()

Инициализируйте таблицу значений q и инициализируйте все значения q в соответствии с количеством строк, столбцов и действий.

def init_q_values():
    for row in range(0, ROWS):
        for col in range(0, COLUMNS):
            state = State(row, col)
            for action in Actions:
                q = (state.row, state.col, action)
                q_values[q] = 0

Определяет новое состояние, являющееся результатом состояния, выполняющего действие, с учетом границ карты.

def move(curr_state, action):
    new_state = State(curr_state.row, curr_state.col)
    # check borders
    if action == Actions.up:
        if (new_state.row - 1) >= 0:
            new_state.row -= 1
    elif action == Actions.down:
        if (new_state.row + 1) <= (ROWS - 1):
            new_state.row += 1
    elif action == Actions.left:
        if (new_state.col - 1) >= 0:
            new_state.col -= 1
    elif action == Actions.right:
        if (new_state.col + 1) <= (COLUMNS - 1):
            new_state.col += 1
    return new_state

Определите метод исследования каждого шага, выполняйте различные действия, чтобы найти оптимальное действие, а также требуйте случайного выбора действия с определенной вероятностью.

def explore(curr_state):
    rand = random.random()
    if rand <= R:
        return random.choice(list(Actions))
    else:
        best = list()
        best_action = Actions.up
        best_value = -10000000
        for action in Actions:
            q = (curr_state.row, curr_state.col, action)
            if q_values[q] > best_value:
                best_action = action
                best_value = q_values[q]
        best.append(best_action)
        # perhaps it has not only one best action
        for action in Actions:
            q = (curr_state.row, curr_state.col, action)
            if action != best_action:
                if q_values[q] == best_value:
                    best.append(action)
        return random.choice(best)

Определите операцию обновления состояния. После выбора оптимального действия состояние будет обновлено, то есть таблица значений q будет обновлена. Если он достигнет выхода, возврат будет 0, а если он упадет в большую яму , возврат будет -100.

def update(curr_state, last_action):
    q = (curr_state.row, curr_state.col, last_action)
    new_state = move(curr_state, last_action)
    position = (new_state.row, new_state.col)
    reward = -1
    if position == EXIT:
        reward = 0
    elif position in BARRIERS:
        reward = -100
    old_value = q_values[q]
    max_new = max([q_values[(new_state.row, new_state.col, a)] for a in Actions])
    q_values[q] = old_value + ALPHA * (reward + (GAMMA * max_new) - old_value)
    curr_state.row = new_state.row
    curr_state.col = new_state.col

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

Actions.right
Actions.right
Actions.down
Actions.down
Actions.right
Actions.right
Actions.right
Actions.down
Actions.down
Actions.down

github

GitHub.com/sea-boateng/MA…

------------- Рекомендуем прочитать ------------

Краткое изложение моих проектов с открытым исходным кодом (машинное и глубокое обучение, НЛП, сетевой ввод-вывод, AIML, протокол mysql, чат-бот)

Зачем писать «Анализ проектирования ядра Tomcat»

Резюме моей статьи за 2017 год — машинное обучение

Краткое изложение моих статей за 2017 год — Java и промежуточное ПО

Резюме моих статей 2017 года — глубокое обучение

Краткое изложение моих статей за 2017 год — исходный код JDK

Резюме моей статьи за 2017 год — обработка естественного языка

Резюме моих статей 2017 года — Java Concurrency

Поговори со мной, задай мне вопросы:

Добро пожаловать, чтобы следовать: