Создайте собственную 3D-среду для вашего RL-робота
Делиться
Вступление
Существует четыре типа машинного обучения:
- Контролируемый — когда все наблюдения в наборе данных помечены целевой переменной, и вы можете выполнить регрессию/классификацию, чтобы узнать, как их предсказывать.
- Неконтролируемый — когда целевая переменная отсутствует, поэтому можно выполнить кластеризацию для сегментации и группировки данных.
- Полуконтролируемый — когда целевая переменная неполная, поэтому модель должна научиться предсказывать и немаркированные данные. В этом случае используется сочетание контролируемых и неконтролируемых моделей.
- Подкрепление — когда вместо целевой переменной есть вознаграждение и вы не знаете, какое решение будет лучшим, поэтому это больше похоже на процесс проб и ошибок для достижения определенной цели.
Точнее, обучение с подкреплением изучает, как ИИ действует в интерактивной среде, чтобы максимизировать вознаграждение. Во время обучения с учителем вы уже знаете правильный ответ (целевую переменную) и подстраиваете модель для его воспроизведения. В отличие от этого, в задаче обучения с подкреплением вы априори не знаете правильный ответ; единственный способ узнать его — выполнить действие и получить обратную связь (вознаграждение), поэтому модель обучается, исследуя и совершая ошибки.
Обучение роботов с подкреплением (RL) широко используется для обучения роботов . Хорошим примером служит автономный пылесос: проходя по пыльному участку пола, он получает вознаграждение (+1), но наказывается (-1), если сталкивается со стеной. Таким образом, робот учится, как правильно действовать, а чего следует избегать.
В этой статье я покажу, как создавать пользовательские 3D-среды для обучения робота с использованием различных алгоритмов обучения с подкреплением. Я представлю несколько полезных примеров кода на Python, которые можно легко применить в других подобных случаях (просто скопируйте, вставьте и запустите), и прокомментирую каждую строку кода, чтобы вы могли повторить этот пример.
Настраивать
В то время как контролируемый вариант использования требует целевой переменной и обучающего набора, Для решения проблемы RL необходимо:
- Окружающая среда — окружение агента, назначает награды за действия и предоставляет новое состояние в результате принятого решения. По сути, это пространство, с которым может взаимодействовать ИИ (в примере с автономным пылесосом это была бы комната, которую нужно убрать).
- Действие — набор действий, которые ИИ может выполнять в данной среде. Пространство действий может быть « дискретным » (с фиксированным количеством ходов, как в шахматах) или « непрерывным » (с бесконечным количеством возможных состояний, например, вождение автомобиля и торговля).
- Награда — последствие действия (+1/-1).
- Агент — ИИ, изучающий наилучший курс действий в окружающей среде для максимизации вознаграждения.
Что касается окружающей среды, наиболее используемыми 3D-физическими симуляторами являются: PyBullet (начинающие) , Webots (средний), MuJoCo (для продвинутых) и Gazebo (для профессионалов). Вы можете использовать любой из них как отдельное программное обеспечение или через Gym — библиотеку OpenAI для разработки. Алгоритмы обучения с подкреплением, построенные на основе различных физических движков.
Я буду использовать Gym (pip install gymnasium) для загрузки одной из сред по умолчанию, созданных с помощью MuJoCo (динамика Multi-Joint с Contact, pip install mujoco).
import gymnasium as gym env = gym.make(«Ant-v4″) obs, info = env.reset() print(f»— INFO: {len(info)} —«) print(info, «n») print(f»— OBS: {obs.shape} —«) print(obs, «n») print(f»— ACTIONS: {env.action_space} —«) print(env.action_space.sample(), «n») print(f»— REWARD —«) obs, reward, terminated, truncated, info = env.step( env.action_space.sample() ) print(reward, «n»)
Робот «Муравей» — это трёхмерный четвероногий агент, состоящий из туловища и четырёх прикреплённых к нему ног. Каждая нога состоит из двух частей тела, таким образом, всего у робота 8 шарниров (гибких частей тела) и 9 звеньев (твёрдых частей тела). Цель этой среды — приложение силы (толкание/тяга) и крутящего момента (поворот/скручивание) для перемещения робота в определённом направлении.
Давайте проверим среду, запустив один эпизод с роботом, выполняющим случайные действия (эпизод — это полный цикл взаимодействия агента с окружающей средой, от начала до завершения).
import time env = gym.make(«Ant-v4″, render_mode=»human») obs, info = env.reset() reset = False #сбросить, если эпизод заканчивается episode = 1 total_reward, step = 0, 0 for _ in range(240): ## action step += 1 action = env.action_space.sample() #случайное действие obs, reward, terminated, truncated, info = env.step(action) ## reward total_reward += reward ## render env.render() #рендерить шаг физики (скорость ЦП = 0,1 секунды) time.sleep(1/240) #замедлить до реального времени (240 шагов × 1/240 секунды sleep = 1 секунда) if (step == 1) or (step % 100 == 0): #вывести первый шаг и каждые 100 шагов print(f»EPISODE {episode} — Шаг:{step}, Награда:{reward:.1f}, Итого:{total_reward:.1f}») ## сбросить, если сбросить: если завершено или усечено: #вывести последний шаг print(f»EPISODE {episode} — Шаг:{step}, Награда:{reward:.1f}, Итого:{total_reward:.1f}») obs, info = env.reset() episode += 1 total_reward, step = 0, 0 print(«——————————————«) env.close()
Пользовательская среда
Обычно среды имеют одинаковые свойства:
- Сброс — перезапуск в исходное состояние или в случайную точку данных.
- Рендеринг — для визуализации происходящего.
- Шаг — выполнение выбранного агентом действия и изменение состояния.
- Рассчитать вознаграждение — для назначения соответствующего вознаграждения/штрафа после действия.
- Получить информацию — для сбора информации об игре после действия.
- Terminated или Truncated — чтобы решить, закончен ли эпизод после действия (провала или успеха).
Загрузка стандартных сред в Gym — это удобно, но не всегда то, что нужно. Иногда приходится создавать собственную среду, отвечающую требованиям вашего проекта. Это самый сложный этап в сценарии использования обучения с подкреплением. Качество модели во многом зависит от качества проектирования среды.
Создать собственную среду можно несколькими способами:
- Создавайте с нуля : вы проектируете всё (физику, тело, окружение). У вас полный контроль, но это самый сложный способ, поскольку вы начинаете с пустого мира.
- Измените существующий XML-файл : каждый моделируемый агент создается с помощью XML-файла. Вы можете изменить физические характеристики (например, сделать робота выше или тяжелее), но логика останется прежней.
- Измените существующий класс Python : сохраните агента и физику как есть, но измените правила игры (например, новые награды и правила завершения). Можно даже превратить непрерывное окружение в дискретное пространство действий.
Я собираюсь настроить стандартную среду Ant, чтобы робот мог прыгать . Мне нужно изменить как физические свойства в XML-файле, так и функцию вознаграждения класса Python. По сути, мне нужно просто сделать ноги робота более сильными и наградить его за прыжки.
Сначала найдем XML-файл, сделаем его копию и отредактируем .
import os print(os.path.join(os.path.dirname(gym.__file__), «envs/mujoco/assets/ant.xml»))
Поскольку моя цель — создать более «прыгучего» Муравья, я могу уменьшить плотность его тела, чтобы сделать его легче…
…и добавьте силу к ногам, чтобы он мог прыгать выше (гравитация в симуляторе остается прежней).
Полный отредактированный XML-файл вы можете найти на моем GitHub.
Затем я хочу изменить функцию вознаграждения в среде Gym. Чтобы создать пользовательскую среду, нужно создать новый класс, который перезапишет исходную там, где это необходимо (в моём случае, в том, как рассчитывается вознаграждение). После регистрации новой среды её можно использовать как любую другую среду Gym.
from gymnasium.envs.mujoco.ant_v4 import AntEnv from gymnasium.envs.registration import register import numpy as np ## изменить класс class CustomAntEnv(AntEnv): def __init__(self, **kwargs): super().__init__(xml_file=os.getcwd()+»/assets/custom_ant.xml», **kwargs) # указать xml_file только при его изменении def CUSTOM_REWARD(self, action, info): torso_height = float(self.data.qpos[2]) # z-координата туловища = его высота reward = np.clip(a=torso_height-0.6, a_min=0, a_max=1) *10 # когда туловище высокое terminated = bool(torso_height < 0.2 ) # если туловище близко к земле info["torso_height"] = torso_height #добавьте информацию для регистрации return reward, terminated, info def step(self, action): obs, reward, terminated, truncated, info = super().step(action) #переопределите оригинальный step() new_reward, new_terminated, new_info = self.CUSTOM_REWARD(action, info) return obs, new_reward, new_terminated, truncated, new_info #должны вернуть те же данные def reset_model(self): return super().reset_model() #сохраните сброс как есть ## зарегистрируйте новую среду register(id="CustomAntEnv-v1", entry_point="__main__:CustomAntEnv") ## test env = gym.make("CustomAntEnv-v1", render_mode="human") obs, info = env.reset() for _ in диапазон (1000): действие = env.action_space.sample() obs, вознаграждение, прекращено, усечено, информация = env.step(действие) если прекращено или усечено: obs, информация = env.reset() env.close()
Если трёхмерный мир и его правила хорошо продуманы, вам просто нужна хорошая модель обучения с подкреплением, и робот сделает всё возможное, чтобы максимизировать вознаграждение. В сфере обучения с подкреплением доминируют два семейства моделей: модели Q-Learning (оптимальные для пространств дискретных действий) и модели Actor-Critic (оптимальные для пространств непрерывных действий). Помимо них, появляются новые экспериментальные подходы, такие как эволюционные алгоритмы и имитационное обучение.
Q Обучение
Q-обучение — это простейшая форма обучения с подкреплением, использующая Q-значения (где «Q» означает «качество») для представления того, насколько полезно действие для получения будущей награды. Проще говоря, если в конце игры агент получает определённую награду после набора действий, начальное Q-значение — это дисконтированная будущая награда.
По мере того, как агент исследует ситуацию и получает обратную связь, он обновляет Q-значения, хранящиеся в Q-матрице (уравнение Беллмана). Цель агента — определить оптимальные Q-значения для каждого состояния/действия, чтобы принимать наилучшие решения и максимизировать ожидаемую будущую награду за конкретное действие в конкретном состоянии.
В процессе обучения агент использует компромисс между исследованием и эксплуатацией . Изначально он исследует среду, совершая случайные действия, что позволяет ему накапливать опыт (информацию о вознаграждениях, связанных с различными действиями и состояниями). По мере обучения и снижения уровня исследования он начинает эксплуатировать свои знания, выбирая действия с наивысшими значениями Q для каждого состояния.
Обратите внимание, что Q-матрица может быть многомерной и гораздо более сложной. Например, представим себе торговый алгоритм:
В 2013 году в области обучения с подкреплением произошёл прорыв: Google представила Deep Q-Network (DQN) , разработанную для обучения игре в игры Atari по сырым пикселям. Она сочетает в себе концепции глубокого обучения и Q-обучения. Проще говоря, глубокое обучение используется для аппроксимации Q-значений вместо их явного хранения в таблице. Это достигается с помощью нейронной сети, обученной предсказывать Q-значения для каждого возможного действия, используя текущее состояние среды в качестве входных данных.
Семейство Q-Learning было разработано в основном для дискретных сред, поэтому оно не работает с роботом-муравьём. Альтернативным решением была бы дискретизация среды (даже если это не самый эффективный способ решения непрерывной задачи). Нам просто нужно создать обёртку для класса Python, которая ожидает дискретного действия (например, «двигаться вперёд») и, следовательно, прикладывает усилие к суставам в соответствии с этой командой.
class DiscreteEnvWrapper(gym.Env): def __init__(self, render_mode=None): super().__init__() self.env = gym.make(«CustomAntEnv-v1″, render_mode=render_mode) self.action_space = gym.spaces.Discrete(5) #будет 5 действий self.observation_space = self.env.observation_space #одно и то же пространство наблюдения n_joints = self.env.action_space.shape[0] self.action_map = [ ## действие 0 = стоять на месте np.zeros(n_joints), ## действие 1 = толкнуть все вперед 0.5*np.ones(n_joints), ## действие 2 = толкнуть все назад -0.5*np.ones(n_joints), ## действие 3 = передние ноги вперед + задние ноги назад 0.5*np.concatenate([np.ones(n_joints//2), -np.ones(n_joints//2)]), ## действие 4 = передние ноги назад + задние ноги вперед 0.5*np.concatenate([-np.ones(n_joints//2), np.ones(n_joints//2)]) ] def step(self, discrete_action): assert self.action_space.contains(discrete_action) continue_action = self.action_map[discrete_action] obs, reward, terminated, truncated, info = self.env.step(continuous_action) return obs, reward, terminated, truncated, info def reset(self, **kwargs): obs, info = self.env.reset(**kwargs) return obs, info def render(self): return self.env.render() def close(self): self.env.close() ## test env = DiscreteEnvWrapper() obs, info = env.reset() print(f»— INFO: {len(info)} —«) print(info, «n») print(f»— OBS: {obs.shape} —«) print(obs, «n») print(f»— ACTIONS: {env.action_space} —«) discret_action = env.action_space.sample() continuous_action = env.action_map[discrete_action] print(«discrete:», discret_action, «-> continuous:», continuous_action, «n») print(f»— REWARD —«) obs, reward, terminated, truncated, info = env.step( discret_action ) print(reward, «n»)
Теперь эта среда, содержащая всего 5 возможных действий, определённо будет работать с DQN. В Python проще всего использовать алгоритмы глубокого обучения с подкреплением (Deep RL) через StableBaseline (pip install stable-baselines3), набор самых известных моделей, уже реализованных и готовых к использованию, написанных на PyTorch (pip install torch). Кроме того, мне очень удобно отслеживать ход обучения на TensorBoard (pip install tensorboard). Я создал папку «logs» и могу просто запустить tensorboard —logdir=logs/ в терминале для локального доступа к панели мониторинга (http://localhost:6006/).
import stable_baselines3 as sb from stable_baselines3.common.vec_env import DummyVecEnv # TRAIN env = DiscreteEnvWrapper(render_mode=None) #без рендеринга для ускорения env = DummyVecEnv([lambda:env]) model_name = «ant_dqn» print(«НАЧАЛО ОБУЧЕНИЯ») model = sb.DQN(policy=»MlpPolicy», env=env, verbose=0, learning_rate=0.005, explore_fraction=0.2, explore_final_eps=0.05, #eps линейно убывает от 1 до 0.05 tensorboard_log=»logs/») #>tensorboard —logdir=logs/ model.learn(total_timesteps=1_000_000, #20 мин tb_log_name=model_name, log_interval=10) print(«Обучение ЗАВЕРШЕНО») model.save(model_name)
После завершения обучения мы можем загрузить новую модель и протестировать её в визуализированной среде. Теперь агент больше не будет обновлять предпочтительные действия. Вместо этого он будет использовать обученную модель для прогнозирования следующего оптимального действия с учётом текущего состояния.
# ТЕСТ env = DiscreteEnvWrapper(render_mode=»human») model = sb.DQN.load(path=model_name, env=env) obs, info = env.reset() reset = False #сброс, если эпизод заканчивается episode = 1 total_reward, step = 0, 0 for _ in range(1000): ## действие step += 1 action, _ = model.predict(obs) obs, reward, terminated, truncated, info = env.step(action) ## вознаграждение total_reward += reward ## рендер env.render() time.sleep(1/240) if (step == 1) or (step % 100 == 0): #вывести первый шаг и каждые 100 шагов print(f»EPISODE {episode} — Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}») ## сбросить, если сбросить: если завершено или усечено: #вывести последний шаг print(f»EPISODE {episode} — Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}») obs, info = env.reset() episode += 1 total_reward, step = 0, 0 print(«——————————————«) env.close()
Как видите, робот усвоил, что лучшая стратегия — прыгать, но движения не плавные, поскольку мы не использовали модель, рассчитанную на непрерывные действия.
Актер Критик
На практике наиболее часто используются алгоритмы « Актор-Критик» , поскольку они хорошо подходят для непрерывных сред. Основная идея заключается в совместной работе двух систем: функции политики («Актор») для выбора действий и функции оценки («Критик») для оценки ожидаемого вознаграждения. Модель обучается корректировать процесс принятия решений, сравнивая фактически получаемое вознаграждение с прогнозами.
Первый стабильный алгоритм глубокого обучения был представлен компанией OpenAI в 2016 году: Advantage Actor-Critic (A2C) . Он направлен на минимизацию разницы между фактическим вознаграждением, полученным после выполнения действия Актёром, и вознаграждением, оцененным Критиком. Нейронная сеть состоит из входного слоя, общего для Актёра и Критика, но они возвращают два отдельных выходных слоя: Q-значения действий (как DQN) и прогнозируемое вознаграждение (которое является суммой A2C).
С годами алгоритмы AC совершенствовались, появлялись более стабильные и эффективные варианты, такие как Proximal Policy Optimization (PPO) и Soft Actor Critic (SAC) . Последний использует не одну, а две сети Critic для получения «второго мнения». Стоит отметить, что эти модели можно использовать непосредственно в непрерывной среде.
# TRAIN env_name, model_name = «CustomAntEnv-v1», «ant_sac» env = gym.make(env_name) #без рендеринга для ускорения env = DummyVecEnv([lambda:env]) print(«НАЧАЛО ОБУЧЕНИЯ») model = sb.SAC(policy=»MlpPolicy», env=env, verbose=0, learning_rate=0.005, ent_coef=0.005, #исследование tensorboard_log=»logs/») #>tensorboard —logdir=logs/ model.learn(total_timesteps=100_000, #3h tb_log_name=model_name, log_interval=10) print(«ОБУЧЕНИЕ ЗАВЕРШЕНО») ## сохранить model.save(model_name)
Подготовка САК требует больше времени, но результаты гораздо лучше.
# ТЕСТ env = gym.make(env_name, render_mode=»human») model = sb.SAC.load(path=model_name, env=env) obs, info = env.reset() reset = False #сброс, если эпизод заканчивается episode = 1 total_reward, step = 0, 0 for _ in range(1000): ## действие step += 1 action, _ = model.predict(obs) obs, reward, terminated, truncated, info = env.step(action) ## вознаграждение total_reward += reward ## рендер env.render() time.sleep(1/240) if (step == 1) or (step % 100 == 0): #вывести первый шаг и каждые 100 шагов print(f»EPISODE {episode} — Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}») ## сбросить, если сбросить: если завершено или усечено: #вывести последний шаг print(f»EPISODE {episode} — Step:{step}, Reward:{reward:.1f}, Total:{total_reward:.1f}») obs, info = env.reset() episode += 1 total_reward, step = 0, 0 print(«——————————————«) env.close()
Учитывая популярность Q-Learning и Actor-Critic, появились более поздние гибридные адаптации, объединяющие эти два подхода. Таким образом, они также расширяют DQN до пространств непрерывных действий. Например, Deep Deterministic Policy Gradient (DDPG) и Twin Delayed DDPG (TD3) . Однако следует учитывать, что чем сложнее модель, тем сложнее обучение.
Экспериментальные модели
Помимо основных семейств (Q и AC), существуют и другие модели, которые реже используются на практике, но не менее интересны. В частности, они могут стать мощной альтернативой для задач, где награды редки и их сложно проектировать. Например:
- Эволюционные алгоритмы развивают стратегии посредством мутаций и отбора, а не градиента. Вдохновленные эволюционным законом Дарвина, они надежны, но требуют больших вычислительных ресурсов.
- Имитационный метод обучения исключает этап исследования и обучает агентов имитировать действия экспертов. Он основан на концепции «поведенческого клонирования», сочетающей контролируемое обучение с идеями обучения с подкреплением.
В экспериментальных целях попробуем первый вариант с EvoTorch, открытым набором инструментов для нейроэволюции. Я выбрал его, потому что он хорошо работает с PyTorch и Gym (pip install evotorch).
Лучшим эволюционным алгоритмом для обучения с подкреплением (RL) является алгоритм градиентов политики с исследованием параметров (PGPE) . По сути, он не обучает одну нейронную сеть напрямую, а строит распределение вероятностей (гауссово) по всем возможным весам (μ = средний набор весов, σ = исследование вокруг центра). В каждом поколении PGPE делает выборку из популяции весов, начиная со случайного выбора политики. Затем модель корректирует среднее значение и дисперсию на основе вознаграждения (эволюции популяции). PGPE считается параллельным RL, поскольку, в отличие от классических методов, таких как Q и AC, которые обновляют одну политику с помощью пакетов выборок, PGPE производит выборку множества вариаций политики параллельно.
Перед запуском обучения нам необходимо определить «проблему», то есть задачу, которую необходимо оптимизировать (по сути, нашу среду).
из evotorch.neuroevolution импорт GymNE из evotorch.algorithms импорт PGPE из evotorch.logging импорт StdOutLogger ## проблема train = GymNE(env=CustomAntEnv, #непосредственно класс, так как это пользовательская среда env_config={«render_mode»:None}, #без рендеринга для ускорения network=»Linear(obs_length, act_length)», #линейная политика observation_normalization=True, reduce_rewards_by=1, #трюк нормализации для стабилизации эволюции episode_length=200, #шагов на эпизод num_actors=»max») #использовать все доступные ядра ЦП ## модель model = PGPE(problem=train, popsize=20, stdev_init=0.1, #сохраняйте его небольшим center_learning_rate=0.005, stdev_learning_rate=0.1, optimizer_config={«max_speed»:0.015}) ## обучение StdOutLogger(searcher=model, interval=20) model.run(num_generations=100)
Для тестирования модели нам нужна ещё одна «задача», которая воспроизводит симуляцию. Затем мы просто извлекаем наиболее эффективный набор весов из распределительного центра (это связано с тем, что во время обучения гауссовская функция сместилась в сторону более эффективных областей пространства политики).
## проблема визуализации test = GymNE(env=CustomAntEnv, env_config={«render_mode»:»human»}, network=»Linear(obs_length, act_length)», observation_normalization=True, reduce_rewards_by=1, num_actors=1) #для визуализации нужен только 1 ## тест лучшей политики population_center = model.status[«center»] policy = test.to_policy(population_center) ## рендер test.visualize(policy)
Заключение
Эта статья представляет собой руководство по использованию обучения с подкреплением в робототехнике . Я показал, как создавать 3D-модели с помощью Gym и MuJoCo, как настраивать среду и какие алгоритмы обучения с подкреплением лучше всего подходят для различных сценариев использования. В будущем появятся новые руководства с более продвинутыми роботами.
Полный код для этой статьи: GitHub
Надеюсь, вам понравилось! Обращайтесь ко мне с вопросами и отзывами, а также просто делитесь своими интересными проектами.
👉 Давайте общаться 👈
(Все изображения принадлежат автору, если не указано иное)
Источник: towardsdatascience.com
