Обучение с подкреплением: полное руководство

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

В этом блоге мы углубимся в основы RL и продемонстрируем его реализацию с использованием кода Python и библиотеки OpenAI Gym.

Для начала давайте разберемся с основными компонентами RL. Ключевыми элементами являются агент, среда, действия, состояния и вознаграждения. Агент — это сущность, которая взаимодействует с окружающей средой, предпринимая действия в зависимости от текущего состояния.

Позвольте мне объяснить это с помощью пятиэтапной схемы:

Вот схема из 5 пунктов для обучения с подкреплением:

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

Модели RL: глубокое погружение

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

MDP — это математическая основа для моделирования принятия решений в стохастических средах.
Он состоит из набора состояний, действий, вероятностей перехода, немедленных вознаграждений и коэффициента дисконтирования.
Агент взаимодействует со средой, выбирая действия, и среда переходит в новое состояние на основе вероятностей.
В MDP сохраняется марковское свойство, означающее, что будущее состояние зависит только от текущего состояния и действия, а не от истории.
Цель состоит в том, чтобы найти оптимальную политику π, которая максимизирует ожидаемое совокупное вознаграждение.
Уравнение Беллмана для функции значения состояния V(s) в MDP: V(s) = max_a {sum_s' [P(s' | s, a) * (R(s, a, s') + γ * V(s'))]
V(s) — значение состояния s.
P(s’ | s, a) — вероятность перехода в состояние s при заданном состоянии s и действии a.
R(s, a, s’) — немедленное вознаграждение, получаемое при переходе из состояния s в состояние s’ посредством выполнения действия a.
γ — коэффициент дисконтирования, уравновешивающий немедленные и будущие вознаграждения.

Q-обучение

Q-обучение — это безмодельный алгоритм обучения с подкреплением, который изучает оптимальную функцию действия-ценности, называемую Q-функцией.
Q-функция обозначает ожидаемое совокупное вознаграждение за выполнение определенного действия в данном состоянии.
Алгоритм итеративно обновляет значения Q на основе уравнения Беллмана.
Уравнение Беллмана: Q(s, a) = Q(s, a) + α * [r + γ * max(Q(s’, a’)) — Q(s, a)]
Q(s, a) — значение Q для состояния s и действия a.
α — скорость обучения, определяющая вес, придаваемый новой информации.
r — немедленная награда, полученная после совершения действия в состоянии s.
γ — коэффициент дисконтирования, уравновешивающий важность немедленных и будущих вознаграждений.
max(Q(s’, a’)) — максимальное значение Q среди всех действий в следующем состоянии s’.

DQN (глубокая Q-сеть)

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

Круто! Теперь давайте воспользуемся помощью Python, используя библиотеку OpenAI Gym, и творим чудеса

Чтобы проиллюстрировать RL в действии, мы будем использовать библиотеку OpenAI Gym, которая предоставляет широкий спектр предопределенных сред для задач RL. Начнем с простого примера с использованием среды CartPole. Цель этого задания — сбалансировать шест на тележке, применяя силы для перемещения тележки влево или вправо.

!pip установить тренажерный зал

импортный тренажерный зал

env = Gym.make('CartPole-v1')

импортировать numpy как np

num_states = env.observation_space.shape[0]

num_actions = env.action_space.n

q_table = np.zeros((num_states, num_actions))

Далее нам нужно определить гиперпараметры для нашего алгоритма RL, такие как скорость обучения, коэффициент дисконтирования, скорость исследования и количество эпизодов.

learning_rate = 0.1
discount_factor = 0.99
exploration_rate = 1.0
max_exploration_rate = 1.0
min_exploration_rate = 0.01
exploration_decay_rate = 0.01
num_episodes = 1000

Теперь мы можем реализовать алгоритм Q-обучения:

for episodes in range (num_episodes):
    state = env.reset()
    done = False
    
    while not done:
        exploration_rate_threshold = np.random.uniform(0, 1)
        
if exploration_rate_threshold > exploration_rate:
            action = np.argmax(q_table[state, :])
        else:
            action = env.action_space.sample()
        
        new_state, reward, done, _ = env.step(action)
        
        q_table[state, action] = q_table[state, action] + learning_rate * (reward + 
                            discount_factor * np.max(q_table[new_state, :]) - 
                            q_table[state, action])
        
        state = new_state
    
    exploration_rate = min_exploration_rate + (max_exploration_rate)
                        min_exploration_rate) * np.exp(-exploration_decay_rate * episode)

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

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

total_rewards = []
for episodes in range (num_episodes):
    state = env.reset()
    done = False
    episode_reward = 0
    
    while not done:
        action = np.argmax(q_table[state, :])
        new_state, reward, done, _ = env.step(action)
        
        state = new_state
        episode_reward += reward
    
    total_rewards.append(episode_reward)

Наконец, мы можем визуализировать работу нашего RL-агента, отобразив вознаграждения по эпизодам:

import matplotlib.pyplot as plt
plt.plot(total_rewards)
plt.xlabel('Episode')
plt.ylabel('Total Reward')
plt.title('RL Agent Performance')
plt.show()

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

Обучение с подкреплением предлагает мощный подход к решению сложных проблем принятия решений. С помощью Python и библиотеки OpenAI Gym мы можем легко реализовывать алгоритмы RL и экспериментировать с ними.

Практический пример: проблема замерзшего озера, состояние и последствия

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

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

Определение состояний, действий и вознаграждений

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

Реализация и стратегии Python

Код Python с использованием OpenAI Gym для среды Frozen Lake, а также пошаговые объяснения:

import gym
# Create the FrozenLake environment
env = gym.make('FrozenLake-v0')
# Reset the environment to start a new episode
state = env.reset()
# Define the number of episodes to train
num_episodes = 10000
# Define the maximum number of steps per episode
max_steps = 100
# Define the learning rate and discount factor
learning_rate = 0.1
discount_factor = 0.99
# Initialize the Q-table with zeros
Q = [[0] * env.action_space.n for _ in range(env.observation_space.n)]
# Start the training loop
for episode in range(num_episodes):
    # Reset the environment for a new episode
    state = env.reset()
    done = False
    
    # Loop through the steps within the episode
    for step in range(max_steps):
        # Choose an action using the epsilon-greedy policy
        epsilon = 0.1  # Exploration rate
        if (np.random.uniform(0, 1) < epsilon) or (all(q == 0 for q in Q[state])):
            action = env.action_space.sample()  # Random action
        else:
            action = np.argmax(Q[state])  # Greedy action
        # Perform the chosen action and observe the next state and reward
        next_state, reward, done, _ = env.step(action)
        # Update the Q-table using the Q-learning equation
        Q[state][action] = (1 - learning_rate) * Q[state][action] + learning_rate * (reward + discount_factor * np.max(Q[next_state]))
        # Transition to the next state
        state = next_state
        # Break if the episode is finished
        if done:
            break
# Evaluate the agent's performance after training
total_rewards = 0
num_episodes = 100
for episode in range(num_episodes):
    state = env.reset()
    done = False
    
    # Loop through the steps within the episode
    for step in range(max_steps):
        # Choose the best action based on the learned Q-values
        action = np.argmax(Q[state])
        # Perform the chosen action
        next_state, reward, done, _ = env.step(action)
        
        # Accumulate the total rewards
        total_rewards += reward
        # Transition to the next state
        state = next_state
        # Break if the episode is finished
        if done:
            break
# Print the average rewards per episode
average_rewards = total_rewards / num_episodes
print("Average rewards per episode:", average_rewards)

Объяснение каждого шага:

Импортируйте необходимые библиотеки и модули, включая OpenAI Gym.
Создайте среду FrozenLake, используя gym.make('FrozenLake-v0').
Сбросьте среду, чтобы начать новый эпизод, используя env.reset().
Определите количество эпизодов для обучения (num_episodes) и максимальное количество шагов на эпизод (max_steps).
Определите скорость обучения (learning_rate) и коэффициент дисконтирования (discount_factor) для алгоритма Q-обучения.
Инициализируйте Q-таблицу нулями, где каждая строка представляет состояние, а каждый столбец представляет действие. (Q = [[0] * env.action_space.n for _ in range(env.observation_space.n)])
Запустите цикл обучения, перебирая эпизоды.
Сбросьте окружение в начале каждого эпизода, используя env.reset().
Пройдите этапы эпизода, используя for step in range(max_steps).
Выберите действие, используя эпсилон-жадную политику. С вероятностью выберите случайное действие для исследования. В противном случае выберите для эксплуатации действие с наибольшим значением Q.
Выполните выбранное действие, используя env.step(action), и наблюдайте за следующим состоянием, наградой и статусом завершения эпизода (done).
Обновите Q-таблицу, используя уравнение Q-обучения, обеспечив баланс между разведкой и эксплуатацией.
Переход в следующее состояние путем обновления state = next_state.
Разорвите цикл, если эпизод завершен (done имеет значение True).
После обучения оцените работу агента, запустив эпизоды без исследования.
Накопите общую сумму наград, полученных в каждом эпизоде.
Выведите средние вознаграждения за эпизод, чтобы оценить производительность агента.

Этот код обучает агента Q-learning ориентироваться в среде Frozen Lake и выводит среднее вознаграждение за эпизод как меру производительности агента.

Что такое обучение с подкреплением?

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

Как работает обучение с подкреплением?

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

Каковы ключевые компоненты обучения с подкреплением?

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

Каковы некоторые применения обучения с подкреплением?

Обучение с подкреплением имеет множество применений в различных областях. Некоторые примеры включают автономное вождение, робототехнику, системы рекомендаций, игры (например, AlphaGo), управление ресурсами и контроль запасов. Его можно применить к любой проблеме, когда агенту необходимо учиться и предпринимать действия, чтобы максимизировать вознаграждение или достичь определенной цели.

Каковы проблемы в обучении с подкреплением?

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

Исследование-эксплуатация относится к дилемме: предпринимать ли действия, которые, как известно, приносят высокие награды, или исследовать новые действия, которые могут привести к еще более высоким вознаграждениям. Проблема присвоения кредитов предполагает правильное приписывание вознаграждений действиям, предпринятым в последовательности событий.

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