Усиленное обучение с Gymnasium: Практическое руководство

Настройка Gymnasium

Гимназия требует конкретные версии (не самые последние релизы) различных зависимых программ, таких как NumPy и PyTorch. Поэтому мы рекомендуем создать новое окружение Conda или venv или новый ноутбук для установки, использования Гимназии и запуска программ RL.

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

Установка Гимназии

Чтобы установить Гимназию на сервере или локальной машине, выполните:

$ pip install gymnasium 

Для установки с использованием блокнота, например, Google Colab или DataCamp’s DataLab, используйте:

!pip install gymnasium

Вышеприведенная команда устанавливает Gymnasium и правильные версии зависимостей.

Изучение сред Gymnasium

На ноябрь 2024 года в Gymnasium включено более 60 встроенных сред. Чтобы просмотреть доступные встроенные среды, используйте функцию gym.envs.registry.all(), как показано в примере ниже:

import gymnasium as gym
for i in gym.envs.registry.keys():
	print(i)

Вы также можете посетить домашнюю страницу Гимназии. Левая колонка содержит ссылки на все среды. Веб-страница каждой среды содержит подробности о ней, такие как действия, состояния и т. д. 

Среды организованы в категории, такие как Classic Control, Box2D и другие. Ниже я перечислю некоторые из общих сред в каждой группе:

• Classic Control: Это канонические среды, используемые в разработке RL; они являются основой для многих примеров в учебниках. Они предоставляют правильное сочетание сложности и простоты для тестирования и оценки новых алгоритмов RL. Классические среды управления в Гимназии включают: 
• Acrobot
• Cart Pole
• Mountain Car Discrete
• Mountain Car Continuous
• Pendulum
• Box2D: Box2D – это 2D физический движок для игр. Среди окружений на основе этого движка простые игры, такие как:
• Lunar Lander
• Гонки на машинах
• ToyText: Это маленькие и простые среды, часто используемые для отладки алгоритмов RL. Многие из этих сред основаны на модели небольшого сеточного мира и простых карточных игр. Примеры включают:
• Блэкджек
• Такси
• Замерзшее озеро
• MuJoCo: Multi-Joint dynamics with Contact (MuJoCo) – это открытый физический движок, который моделирует среды для приложений, таких как робототехника, биомеханика, машинное обучение и т. д. Среди сред MuJoCo в Gymnasium:
• Муравей
• Прыгун
• Человекоподобное существо
• Пловец
• И многое другое

Помимо встроенных сред, Gymnasium можно использовать с множеством внешних сред, используя тот же API.

В этом учебном пособии мы будем использовать одну из канонических сред Classic Control. Чтобы импортировать конкретную среду, используйте команду .make() и передайте имя среды в качестве аргумента. Например, чтобы создать новую среду на основе CartPole (версия 1), используйте команду ниже: 

import gymnasium as gym
env = gym.make("CartPole-v1")

Понимание концепций обучения с подкреплением в Gymnasium

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

Компоненты среды RL

Следующие ключевые компоненты среды RL:

• Среда: Внешняя система, мир или контекст. Агент взаимодействует с окружающей средой в серии временных шагов. На каждом временном шаге, основываясь на действии агента, среда:
• Дает вознаграждение (или наказание)
• Определяет следующее состояние
• Состояние: Математическое представление текущей конфигурации окружающей среды.
• Например, состояние среды маятника может включать положение маятника и его угловую скорость на каждом временном шаге.
• Конечное состояние: состояние, которое не приводит к новым/другим состояниям.
• Агент: Алгоритм, который наблюдает за окружающей средой и принимает различные действия на основе этого наблюдения. Цель агента – максимизировать свои награды.
• Например, агент решает, с какой силой и в каком направлении оттолкнуть маятник.
• Наблюдение: Математическое представление взгляда агента на окружающую среду, полученное, например, с помощью датчиков.
• Действие: Решение, принимаемое агентом перед переходом к следующему шагу. Действие влияет на следующее состояние окружающей среды и приносит агенту вознаграждение.
• Вознаграждение: Обратная связь из окружающей среды агенту. Она может быть положительной или отрицательной в зависимости от действия и состояния окружающей среды.
• Возврат: Ожидаемый накопительный возврат за будущие временные шаги. Награды за будущие временные шаги могут быть дисконтированы с использованием коэффициента дисконтирования.
• Политика: Стратегия агента относительно действий, которые следует предпринять в различных состояниях. Обычно она представлена в виде матрицы вероятностей, P, которая отображает состояния на действия.
• Учитывая конечное множество m возможных состояний и n возможных действий, элемент Pmn в матрице обозначает вероятность выполнения действия an в состоянии sm.  
• Эпизод: Серия временных шагов от (рандомизированного) начального состояния до достижения агентом терминального состояния.

Пространство наблюдений и пространство действий

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

Пространство space аналогично математическому множеству. Пространство элементов X включает все возможные экземпляры X. Пространство X также определяет структуру (синтаксис и формат) всех элементов типа X. Каждая среда Gymnasium имеет два пространства: пространство действий action_space и пространство наблюдений observation_space. Оба пространства действий и наблюдений происходят от родительского gymnasium.spaces.Space суперкласса.

Пространство наблюдений 

Пространство наблюдений – это пространство, которое включает в себя все возможные наблюдения. Оно также определяет формат, в котором наблюдения хранятся. Пространство наблюдений обычно представлено в виде объекта типа Box. Это ndarray, который описывает параметры наблюдений. Box определяет границы каждого измерения. Вы можете просмотреть пространство наблюдений для среды, используя метод observation_space:

print("observation space: ", env.observation_space)

В случае среды CartPole-v1 вывод выглядит примерно так:

observation space:  Box([-4.8 -inf -0.41887903 -inf], [4.8 inf 0.41887903 inf], (4,), float32)

В этом примере CartPole-v1 пространство наблюдения имеет 4 измерения. 4 элемента массива наблюдения:

• Положение тележки – варьируется между -4.8 и +4.8
• Скорость тележки – колеблется между – и +
• Угол опоры – варьируется от -0.4189 до +0.4189
• Угловая скорость стержня – варьируется от – до +

Для просмотра примера массива индивидуальных наблюдений используйте команду .reset().

observation, info = env.reset()
print("observation: ", observation)

В случае среды CartPole-v1, вывод выглядит как в примере ниже:

[ 0.03481963 -0.0277232   0.01703267 -0.04870504]                                                                                                       

Четыре элемента этого массива соответствуют четырем наблюдаемым величинам (положение тележки, скорость тележки, угол шеста, угловая скорость шеста), как было объяснено ранее.

Пространство действий

Пространство действий включает все возможные действия, которые агент может совершить. Пространство действий также определяет формат, в котором представлены действия. Вы можете просмотреть пространство действий для среды, используя метод action_space:

print("action space: ", env.action_space)

В случае среды CartPole-v1 вывод выглядит следующим образом:

action space:  Discrete(2)

В случае среды CartPole-v1 пространство действий дискретно. Всего есть два действия, которые агент может выполнить:

• 0: Толкнуть тележку влево
• 1: Толкнуть тележку вправо

Создание вашего первого RL-агента с Gymnasium

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

Создание и сброс среды

Первый шаг – создать экземпляр среды. Для создания новых сред используйте метод .make().

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

Взаимодействия агента изменяют состояние среды. Метод .reset() сбрасывает среду в начальное состояние. По умолчанию среда инициализируется в случайном состоянии. Вы можете использовать параметр SEED с методом .reset(), чтобы инициализировать среду в одно и то же состояние каждый раз при запуске программы. Ниже приведен код, показывающий, как это сделать:

SEED = 1111
env.reset(seed=SEED)

Выборка действий также включает случайность. Чтобы контролировать эту случайность и получить полностью воспроизводимый обучающий путь, мы можем инициализировать генераторы случайных чисел NumPy и PyTorch:

np.random.seed(SEED)
torch.manual_seed(SEED)

Случайные против интеллектуальных действий

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

• Для достижения терминального состояния может потребоваться много времени.
• Суммарные вознаграждения намного ниже, чем они могли бы быть.

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

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

Существует различные методы оптимизации политики. Уравнения Беллмана описывают, как рассчитать значение политик RL и определить оптимальную политику. В этом руководстве мы используем простую технику, называемую градиенты политики. Существуют и другие методы, такие как Проксимальная оптимизация политики (PPO).

Реализация простого агента с градиентами политики.

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

Настройка сети политики

Мы используем нейронную сеть для реализации политики. Поскольку CartPole-v1 является простой средой, мы используем нейронную сеть с:

• Размером входного слоя, равным размерности пространства наблюдений среды.
• Одним скрытым слоем с 64 нейронами.
• Размер выходных данных равен размерности пространства действий среды.

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

class PolicyNetwork(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim, dropout):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
    def forward(self, x):
        x = self.layer1(x)
        x = self.dropout(x)
        x = F.relu(x)
        x = self.layer2(x)
        return x

Сбор вознаграждения и прямой проход

Как упоминалось, на каждом этапе Марковского процесса среда выдает вознаграждение на основе действия агента и состояния. Цель в обучении с подкреплением – максимизировать общий доход.

• Доход на каждом временном шаге является накопленной суммой вознаграждений, полученных с начала до этого шага.
• Общий возврат в каждом эпизоде получается путем накопления всех пошаговых вознаграждений из этого эпизода. Таким образом, общий возврат – это возврат в последний момент времени (когда агент достигает терминального состояния).

На практике при накоплении вознаграждений часто применяют:

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

Ниже приведен код, показывающий, как это сделать:

def calculate_stepwise_returns(rewards, discount_factor):
    returns = []
    R = 0
    for r in reversed(rewards):
        R = r + R * discount_factor
        returns.insert(0, R)
    returns = torch.tensor(returns)
    normalized_returns = (returns - returns.mean()) / returns.std()
    return normalized_returns

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

• Сбросить среду в начальное состояние.
• Инициализировать буферы для хранения вероятностей действий, вознаграждений и накопленного вознаграждения
• Используйте функцию .step() для итеративного запуска агента в среде до завершения:
• Получить наблюдение состояния среды.
• Получите действие, предсказанное политикой на основе наблюдения.
• Используйте функцию Softmax для оценки вероятности выполнения предсказанного действия.
• Смоделируйте категориальное вероятностное распределение на основе этих оцененных вероятностей.
• Выберите из этого распределения действие агента.
• Оцените логарифм вероятности выбранного действия из смоделированного распределения.
• Добавьте логарифм вероятности действий и вознаграждения с каждого шага в соответствующие буферы.
• Оцените нормализованные и дисконтированные значения возвратов на каждом шаге на основе вознаграждений.

def forward_pass(env, policy, discount_factor):
    log_prob_actions = []
    rewards = []
    done = False
    episode_return = 0
    policy.train()
    observation, info = env.reset()
    while not done:
        observation = torch.FloatTensor(observation).unsqueeze(0)
        action_pred = policy(observation)
        action_prob = F.softmax(action_pred, dim = -1)
        dist = distributions.Categorical(action_prob)
        action = dist.sample()
        log_prob_action = dist.log_prob(action)
        observation, reward, terminated, truncated, info = env.step(action.item())
        done = terminated or truncated
        log_prob_actions.append(log_prob_action)
        rewards.append(reward)
        episode_return += reward
    log_prob_actions = torch.cat(log_prob_actions)
    stepwise_returns = calculate_stepwise_returns(rewards, discount_factor)
    return episode_return, stepwise_returns, log_prob_actions

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

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

def calculate_loss(stepwise_returns, log_prob_actions):
    loss = -(stepwise_returns * log_prob_actions).sum()
    return loss

Чтобы обновить политику, вы запускаете обратное распространение относительно функции потерь. Метод update_policy() вызывает метод calculate_loss(). Затем он выполняет обратное распространение по этой потере, чтобы обновить параметры политики, т.е. веса модели сети политики.

def update_policy(stepwise_returns, log_prob_actions, optimizer):
    stepwise_returns = stepwise_returns.detach()
    loss = calculate_loss(stepwise_returns, log_prob_actions)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    return loss.item()

Обновление политики на основе градиента доходов называется методом градиента политики.

Обучение политики

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

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

• Объявите гиперпараметры как константы Python:
• MAX_EPOCHS – это максимальное количество итераций, на которое мы готовы запустить обучение политики.
• DISCOUNT_FACTOR определяет относительную значимость вознаграждений будущих временных шагов. Фактор дисконтирования 1 означает, что все вознаграждения одинаково важны, тогда как значение 0 означает, что важно только вознаграждение с текущего временного шага.
• N_TRIALS это количество эпизодов, по которым мы усредняем результаты для оценки производительности агента. Мы считаем обучение успешным, если средний результат за N_TRIALS эпизодов превышает пороговое значение.
• REWARD_THRESHOLD: Если политика может достичь возвращения, превышающего порог, она считается успешной.
• DROPOUT определяет долю весов, которые должны быть случайным образом обнулены. Функция дропаута случайным образом обнуляет долю весов модели. Это снижает зависимость от конкретных нейронов и предотвращает переобучение, делая сеть более устойчивой.
• LEARNING_RATE определяет, насколько параметры политики могут быть изменены на каждом шаге. Обновление параметров на каждой итерации является произведением градиента и скорости обучения.
• Определите политику как экземпляр класса PolicyNetwork (реализованного ранее).
• Создайте оптимизатор, используя алгоритм Adam и скорость обучения.

Чтобы обучить политику, мы итеративно выполняем шаги обучения, пока средний возврат (за N_TRIALS) не станет больше порога вознаграждения:

• Для каждого эпизода выполните прямой проход один раз. Соберите логарифмическую вероятность действий, пошаговые возвраты и общий возврат за этот эпизод. Накопите эпизодические возвраты в массиве.
• Вычислите потери, используя логарифмические вероятности и пошаговые возвраты. Запустите обратное распространение ошибки для определения потерь. Используйте оптимизатор для обновления параметров политики.
• Проверьте, превышает ли средний возврат за N_TRIALS пороговую награду.

Ниже приведен код, реализующий эти шаги:

def main(): 
    MAX_EPOCHS = 500
    DISCOUNT_FACTOR = 0.99
    N_TRIALS = 25
    REWARD_THRESHOLD = 475
    PRINT_INTERVAL = 10
    INPUT_DIM = env.observation_space.shape[0]
    HIDDEN_DIM = 128
    OUTPUT_DIM = env.action_space.n
    DROPOUT = 0.5
    episode_returns = []
    policy = PolicyNetwork(INPUT_DIM, HIDDEN_DIM, OUTPUT_DIM, DROPOUT)
    LEARNING_RATE = 0.01
    optimizer = optim.Adam(policy.parameters(), lr = LEARNING_RATE)
    for episode in range(1, MAX_EPOCHS+1):
        episode_return, stepwise_returns, log_prob_actions = forward_pass(env, policy, DISCOUNT_FACTOR)
        _ = update_policy(stepwise_returns, log_prob_actions, optimizer)
        episode_returns.append(episode_return)
        mean_episode_return = np.mean(episode_returns[-N_TRIALS:])
        if episode % PRINT_INTERVAL == 0:
            print(f'| Episode: {episode:3} | Mean Rewards: {mean_episode_return:5.1f} |')
        if mean_episode_return >= REWARD_THRESHOLD:
            print(f'Reached reward threshold in {episode} episodes')
            break

Наконец, вызовите функцию main() для обучения политики:

main()

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

Продвинутые техники в Gymnasium

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

Использование заранее созданных архитектур

Реализация алгоритмов RL с нуля — это длительный и трудный процесс, особенно для сложных сред и современных политик.

Более практичным вариантом является использование программного обеспечения, такого как Stable Baselines3. Он поставляется с проверенными реализациями алгоритмов обучения с подкреплением. Включает в себя предварительно обученных агентов, сценарии обучения, инструменты оценки и модули для построения графиков и записи видео.

Ray RLib – еще один популярный инструмент для обучения с подкреплением. RLib разработан как масштабируемое решение, что облегчает реализацию алгоритмов обучения с подкреплением на многографических системах. Он также поддерживает обучение множества агентов, что открывает новые возможности, например:

• Независимое обучение множества агентов: Каждый агент рассматривает других агентов как часть окружающей среды.
• Совместное обучение многопользовательских агентов: Группа агентов делит одни и те же политики и функции ценности и учится на опыте друг друга параллельно. 
• Соперническое обучение: Агенты (или группы агентов) соревнуются друг с другом в конкурентных игровых средах. 

С RLib и Stable Baselines3 вы можете импортировать и использовать среды из OpenAI Gymnasium. 

Пользовательские среды

Среды, упакованные вместе с Gymnasium, являются правильным выбором для тестирования новых стратегий обучения с подкреплением и обучения политикам. Однако для большинства практических применений вам нужно создать и использовать среду, которая точно отражает проблему, которую вы хотите решить. Вы можете использовать Gymnasium для создания пользовательской среды. Преимущество использования пользовательских сред Gymnasium заключается в том, что многие внешние инструменты, такие как RLib и Stable Baselines3, уже настроены для работы с структурой API Gymnasium.

Для создания пользовательской среды в Gymnasium вам нужно определить:

• Пространство наблюдения.
• Терминальные условия.
• Набор действий, из которого агент может выбирать.
• Как инициализировать среду (когда вызывается функция reset()).
• Как среда определяет следующее состояние, учитывая действия агента (когда вызывается функция step()).

Чтобы узнать больше, следуйте руководству по созданию пользовательских сред в Гимнастике.

Лучшие практики использования Гимнастики.

Экспериментируйте с разными средами

Код в этом учебнике показал, как реализовать алгоритм градиентной политики в среде CartPole. Это простая среда с дискретным пространством действий. Чтобы лучше понять обучение с подкреплением, мы советуем вам применить тот же алгоритм градиентной политики (и другие алгоритмы, такие как PPO) в других средах.

Например, среда Pendulum имеет непрерывное действие. Она состоит из одного входа, представленного в виде непрерывной переменной – (величина и направление) момент, приложенный к маятнику в любом данном состоянии. Этот момент может принимать любое значение между -2 и +2.

Экспериментирование с различными алгоритмами в различных средах помогает лучше понять различные виды решений RL и их вызовы.

Отслеживание прогресса обучения

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

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

Существуют четыре режима рендеринга: “человек”, “rgb_array”, “ansi” и “rgb_array_list”. Чтобы визуализировать производительность агента, используйте режим рендеринга “человек”. Режим рендеринга указывается при инициализации среды. Например:

env = gym.make(‘CartPole-v1’, render_mode=’human’)

Для выполнения рендеринга используйте метод .render() после каждого действия, выполненного агентом (путем вызова метода .step()). Приведенный ниже псевдокод иллюстрирует, как это сделать:

while not done:
    …
   step, reward, terminated, truncated, info = env.step(action.item())
   env.render()
    …

Устранение распространенных ошибок

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

Несоответствия версий

• Несоответствие версии Гимназии: Программный пакет Гимназии Farama был создан на основе Гимназии OpenAI с версии 0.26.2. Между старыми версиями Гимназии и новыми версиями Гимназии было внесено несколько изменений, которые могут привести к неполадкам. Многие публичные реализации основаны на старых версиях Гимназии и могут не работать непосредственно с последним выпуском. В таких случаях необходимо либо откатить установку на более старую версию, либо адаптировать код для работы с новым выпуском.
• Несоответствие версий среды: У многих сред среды Гимназии разные версии. Например, есть две среды CartPole – CartPole-v1 и CartPole-v0. Хотя поведение среды одинаково в обеих версиях, некоторые параметры, такие как длина эпизода, порог вознаграждения и т. д., могут отличаться. Политика, обученная на одной версии, может не так хорошо работать на другой версии той же среды. Вам необходимо обновить параметры обучения и переобучить политику для каждой версии среды. 
• Несоответствие версий зависимостей: Gymnasium зависит от таких библиотек, как NumPy и PyTorch. На декабрь 2024 года последними версиями этих зависимостей являются numpy 2.1.3 и torch 2.5.1. Однако Gymnasium лучше всего работает с torch 1.13.0 и numpy 1.23.3. Вы можете столкнуться с проблемами, если установите Gymnasium в окружение с предустановленными этими зависимостями. Мы рекомендуем устанавливать и работать с Gymnasium в новом окружении Conda.

Проблемы с сходимостью

• Гиперпараметры: Как и другие алгоритмы машинного обучения, политики RL чувствительны к гиперпараметрам, таким как скорость обучения, коэффициент дисконтирования и т. д. Мы рекомендуем экспериментировать и настраивать гиперпараметры вручную или использовать автоматизированные методы, такие как сеточный поиск и случайный поиск.
• Исследование против использования: Для некоторых классов политик (например, PPO) агент использует стратегию с двойным уклоном: исследовать окружающую среду для обнаружения новых путей и принимать жадный подход для максимизации вознаграждений на основе известных путей до сих пор. Если он слишком много исследует, политика не сходится. Напротив, если он не исследует достаточно, он никогда не попробует оптимальный путь. Поэтому нахождение правильного баланса между исследованием и использованием является важным. Также обычно приоритет отдается исследованию в начальных эпизодах и использованию в последующих эпизодах во время обучения.

Неустойчивость обучения

• Большие скорости обучения: Если скорость обучения слишком высокая, параметры политики подвергаются большим обновлениям на каждом шаге. Это может привести к тому, что оптимальный набор значений будет упущен. Распространённое решение — постепенно уменьшать скорость обучения, обеспечивая меньшие и более стабильные обновления по мере сходимости обучения. 
• Избыточная исследовательская активность: Слишком много случайности (энтропии) при выборе действий препятствует сходимости и приводит к большим колебаниям в функции потерь между последующими шагами. Для достижения стабильного и сходимого процесса обучения необходимо сбалансировать исследование и эксплуатацию. 
• Неверный выбор алгоритма: Простые алгоритмы, такие как градиент политики, могут привести к нестабильному обучению в сложных средах с большими пространствами действий и состояний. В таких случаях мы рекомендуем использовать более надежные алгоритмы, такие как PPO и TRPO. Эти алгоритмы избегают больших обновлений политики на каждом шаге и могут быть более стабильными.
• Случайность: Алгоритмы обучения с подкреплением чувствительны к начальным состояниям и случайности, присущей выбору действий. Когда обучение нестабильно, его иногда можно стабилизировать, используя другое случайное зерно или повторную инициализацию политики.

Заключение

В этом учебнике мы изучили основные принципы RL, обсудили Gymnasium как программный пакет с чистым API для взаимодействия с различными средами RL, и показали, как написать программу на Python для реализации простого алгоритма RL и применить его в среде Gymnasium.

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