Искусственный интеллект. Машинное обучение

Обучение с подкреплением (Reinforcement Learning)

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

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

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

Пример 1

Давайте рассмотрим пример задачи обучения с подкреплением на простом примере – агент играет в игру "Сетка мира" (Gridworld). В этой игре агент находится на игровом поле, представленном в виде сетки, и его целью является достижение целевой ячейки, избегая при этом препятствий.

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

```python

import numpy as np

# Создание игрового поля

grid_world = np.array([

[0, 0, 0, 0], # Пустая ячейка

[0, -1, 0, -1], # Препятствие (-1)

[0, 0, 0, -1], # Препятствие (-1)

[0, -1, 0, 1] # Целевая ячейка (1)

])

```

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

```python

import random

# Функция для выполнения действия в игре

def take_action(state):

row, col = state

if grid_world[row, col] == -1: # Если попали в препятствие, остаемся на месте

return state

action = random.choice(['up', 'down', 'left', 'right']) # Случайное действие

if action == 'up':

row = max(0, row – 1)

elif action == 'down':

row = min(grid_world.shape[0] – 1, row + 1)

elif action == 'left':

col = max(0, col – 1)

elif action == 'right':

col = min(grid_world.shape[1] – 1, col + 1)

return (row, col)

# Функция для проверки завершения игры и получения награды

def get_reward(state):

row, col = state

if grid_world[row, col] == 1: # Если достигли целевой ячейки

return 10, True

return 0, False # Игра продолжается

# Функция для запуска игры

def play_game:

state = (0, 0) # Начальное состояние агента

total_reward = 0

done = False

while not done:

state = take_action(state)

reward, done = get_reward(state)

total_reward += reward

return total_reward

# Запуск игры

total_reward = play_game

print("Total reward:", total_reward)

```

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

Пример 2

Рассмотрим пример задачи с использованием обучения с подкреплением. Давайте представим симуляцию игры в кости, где агент должен научиться выбирать наилучшие действия (выбор числа от 1 до 6) для максимизации своего выигрыша.

```python

import numpy as np

class DiceGame:

def __init__(self):

self.state = 0 # текущее состояние – результат броска кости

self.done = False # флаг окончания игры

self.reward = 0 # награда за текущий шаг

def step(self, action):

# Выполняем действие – бросаем кость

self.state = np.random.randint(1, 7)

# Вычисляем награду

if action == self.state:

self.reward = 10 # выигрыш, если действие совпало с результатом броска

else:

self.reward = 0 # нет выигрыша

# Устанавливаем флаг окончания игры (игра заканчивается после одного хода)

self.done = True

return self.state, self.reward, self.done

def reset(self):

# Сбрасываем состояние игры для нового эпизода

self.state = 0

self.done = False

self.reward = 0

return self.state

# Пример простой стратегии выбора действий – всегда выбираем число 3

def simple_strategy(state):

return 3

# Основной код обучения с подкреплением

env = DiceGame

total_episodes = 1000

learning_rate = 0.1

discount_rate = 0.99

q_table = np.zeros((6, 6)) # Q-таблица для хранения оценок ценности действий

for episode in range(total_episodes):

state = env.reset

done = False

while not done:

action = simple_strategy(state)

next_state, reward, done = env.step(action)

# Обновление Q-таблицы по формуле Q(s,a) = Q(s,a) + ? * (reward + ? * max(Q(s',a')) – Q(s,a))

q_table[state – 1, action – 1] += learning_rate * (reward + discount_rate * np.max(q_table[next_state – 1, :]) – q_table[state – 1, action – 1])

state = next_state

print("Q-таблица после обучения:")

print(q_table)

```

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