Змеиная игра на основе искусственного интеллекта с использованием глубокого Q-Learning | Тематический месяц Python

Эта статья участвует в "Месяце тем Python", подробнее см.Ссылка на мероприятие

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

Ниже приведен пример gif, чтобы дать вам представление о том, что мы собираемся построить.

Змея с искусственным интеллектом

Чтобы увидеть, как мы вручную создали эту симуляцию 2D-анимации змеи с помощью pygame, перейдите по ссылке:

Научите, как использовать Python для создания игры про змей | Месяц тем Python

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

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

1. окрестности(Игра, которую мы только что создали)
2. Модель(Расширенная модель прогнозирования движения)
3. играет роль(Посредник между средой и моделью)

ссылка на модуль

алгоритм:

Мы случайным образом разместили змей и еду на доске.

• Рассчитайте состояние змеи, используя 11 значений. Установите значение на 0, если какое-либо условие истинно, в противном случае установите на 1.

Как определить 11 состояний

На основе текущего положения головы агент вычислит 11 значений состояния, как описано выше.

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

• Награда рассчитывается после выполнения следующего состояния. Награды определяются следующим образом:

  • Съесть еду: +10
  • Игра окончена: -10
  • Другое: 0

• Обновите значение Q (обсуждается позже) и обучите модель.

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

Модель:

модель нейронной сети

Эта модель предназначена для использования Pytorch, но вы также можете использовать TensorFlow по своему усмотрению.

мы используем11 входных слоев размераиИмеет 256 нейронови3 нерва Юань вывод Плотный слойПлотная нейронная сеть.Вы можете настроить эти гиперпараметры для достижения наилучших результатов.

Как работает модель?

• Когда игра начинается, значение Q инициализируется случайным образом.
• Система получает текущее состояние s.
• Он выполняет действие на основе s либо случайным образом, либо на основе своей нейронной сети. На первом этапе обучения система часто выбирает случайные действия, чтобы максимизировать исследование. Позже система все больше полагалась на свою нейронную сеть.
• Когда ИИ выбирает и выполняет действия, среда дает вознаграждение. Затем агент достигает нового состояния и обновляет свое значение Q в соответствии с уравнением Беллмана.

Уравнение Беллмана

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

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

первая часть

1. Создайте класс Linear_Qnet для инициализации линейной нейронной сети.
2. Функция forward используется для получения ввода (11 векторов состояния), прохождения нейронной сети, применения функции активации relu и возврата вывода следующему. Переместите вектор размером 1 x 3. Короче говоря, это функция прогнозирования, которую будет вызывать агент.
3. Функция сохранения используется для сохранения обученной модели для последующего использования.

class Linear_QNet(nn.Module):
	def __init__(self, input_size, hidden_size, output_size):
		super().__init__()
		self.linear1 = nn.Linear(input_size, hidden_size)
		self.linear2 = nn.Linear(hidden_size, output_size)

	def forward(self, x):
		x = F.relu(self.linear1(x))
		x = self.linear2(x)
		return x

	def save(self, file_name='model_name.pth'):
		model_folder_path = 'Path'
		file_name = os.path.join(model_folder_path, file_name)
		torch.save(self.state_dict(), file_name)

Вторая часть

1. Инициализируйте класс QTrainer * Установите скорость обучения оптимизатора.

• Гамма — это значение ставки дисконтирования, используемое в уравнении Беллмана.
• Инициализируйте оптимизатор Adam для обновления весов и смещений.
• Критерием является среднеквадратическая функция потерь.

2. функция train_step

• Как вы знаете, PyTorch работает только с тензорами, поэтому мы конвертируем все входные данные в тензоры.
• Как и выше, мы делаем короткую тренировку памяти, затем просто передаем значение

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

• Получите состояние из модели и используйте следующую формулу для расчета нового значения Q:

Q_new = 奖励 + gamma * max(next_predicted Qvalue)

• Вычислить сумму среднеквадратичной ошибки между новым значением Q и предыдущим значением Q.

Обратно распространяйте эту потерю для обновлений веса.

class QTrainer:
	def __init__(self,model,lr,gamma):
#Learning Rate for Optimizer
		self.lr = lr
#Discount Rate
		self.gamma = gamma
#Linear NN defined above.
		self.model = model
#optimizer for weight and biases updation
		self.optimer = optim.Adam(model.parameters(),lr = self.lr)
#Mean Squared error loss function
		self.criterion = nn.MSELoss()
		

	
	def train_step(self,state,action,reward,next_state,done):
		state = torch.tensor(state,dtype=torch.float)
		next_state = torch.tensor(next_state,dtype=torch.float)
		action = torch.tensor(action,dtype=torch.long)
		reward = torch.tensor(reward,dtype=torch.float)

#only one parameter to train,							 \
	Hence convert to tuple of shape(1, x)
		if(len(state.shape) == 1):
#(1, x)
			state = torch.unsqueeze(state,0)
			next_state = torch.unsqueeze(next_state,0)
			action = torch.unsqueeze(action,0)
			reward = torch.unsqueeze(reward,0)
			done = (done, )

# 1. Predicted Q value with current state
		pred = self.model(state)
		target = pred.clone()
		for idx in range(len(done)):
			Q_new = reward[idx]
			if not done[idx]:
				Q_new = reward[idx] +
				self.gamma * torch.max(self.model(next_state[idx]))
			target[idx][torch.argmax(action).item()] = Q_new
# 2. Q_new = reward + gamma * max(next_predicted Qvalue)
#pred.clone()
#preds[argmax(action)] = Q_new
		self.optimer.zero_grad()
		loss = self.criterion(target,pred)
		loss.backward() # backward propogation of loss

		self.optimer.step()

играет роль

• Получить текущее состояние змеи из окружения.

def get_state(self, game):
	head = game.snake[0]
	point_l = Point(head.x - BLOCK_SIZE, head.y)
	point_r = Point(head.x + BLOCK_SIZE, head.y)
	point_u = Point(head.x, head.y - BLOCK_SIZE)
	point_d = Point(head.x, head.y + BLOCK_SIZE)

	dir_l = game.direction == Direction.LEFT
	dir_r = game.direction == Direction.RIGHT
	dir_u = game.direction == Direction.UP
	dir_d = game.direction == Direction.DOWN

	state = [
		# Danger Straight
		(dir_u and game.is_collision(point_u))or
		(dir_d and game.is_collision(point_d))or
		(dir_l and game.is_collision(point_l))or
		(dir_r and game.is_collision(point_r)),

		# Danger right
		(dir_u and game.is_collision(point_r))or
		(dir_d and game.is_collision(point_l))or
		(dir_u and game.is_collision(point_u))or
		(dir_d and game.is_collision(point_d)),

		# Danger Left
		(dir_u and game.is_collision(point_r))or
		(dir_d and game.is_collision(point_l))or
		(dir_r and game.is_collision(point_u))or
		(dir_l and game.is_collision(point_d)),

		# Move Direction
		dir_l,
		dir_r,
		dir_u,
		dir_d,

		# Food Location
		game.food.x < game.head.x, # food is in left
		game.food.x > game.head.x, # food is in right
		game.food.y < game.head.y, # food is up
		game.food.y > game.head.y # food is down
	]
	return np.array(state, dtype=int)

• Вызовите модель, чтобы получить следующее состояние змеи

def get_action(self, state):
	# 随机移动: tradeoff explotation / exploitation
	self.epsilon = 80 - self.n_game
	final_move = [0, 0, 0]
	if(random.randint(0, 200) < self.epsilon):
		move = random.randint(0, 2)
		final_move[move] = 1
	else:
		state0 = torch.tensor(state, dtype=torch.float).cuda()
		prediction = self.model(state0).cuda() # prediction by model
		move = torch.argmax(prediction).item()
		final_move[move] = 1
	return final_move

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

• Шаг модель прогнозирует игру в окружающей среде.
• Сохраняет текущее состояние, выполненные ходы и награды.
• Модель обучается на основе выполняемых движений и вознаграждений, полученных от окружающей среды. (тренировка короткой памяти)

def train_short_memory(self, state, action, reward, next_state, done):
	self.trainer.train_step(state, action, reward, next_state, done)

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

def train_long_memory(self):
	if (len(self.memory) > BATCH_SIZE):
		mini_sample = random.sample(self.memory, BATCH_SIZE)
	else:
		mini_sample = self.memory
	states, actions, rewards, next_states, dones = zip(*mini_sample)
	self.trainer.train_step(states, actions, rewards, next_states, dones)

Обучение модели занимает около 100 эпох, чтобы повысить производительность. Следите за моим прогрессом в обучении.

вывод:

• Чтобы запустить эту игру, сначала создайте среду в приглашении anaconda или (на любой платформе). Затем установите необходимые модули, такие как Pytorch (для моделей обучения DQ), Pygame (для визуальных эффектов для игр) и другие базовые модули.
• Затем запустите файл agent.py в среде, которую вы только что создали, чтобы начать обучение, вы увидите следующие два графических интерфейса: один — это ход обучения, а другой — игра в змейку, управляемую искусственным интеллектом.
• Набрав определенное количество очков, вы можете выйти из игры, и только что обученная вами модель будет сохранена по пути, указанному в функции сохранения в models.py.

В дальнейшем вы сможете использовать эту обученную модель, просто изменив код в файле agent.py следующим образом:

self.model.load_state_dict(torch.load('PATH'))

Уведомление:Закомментируйте все вызовы функций обучения.

прогресс обучения

версия первого поколения

Версия второго поколения

Исходный код: SnakeGameAI

применение:

Цель этого проекта — придумать, как можно применять обучение с подкреплением и как его можно использовать в реальных приложениях, таких как самоуправляемые автомобили (например, AWS DeepRacer), обучение роботов на сборочных линиях, и т.д…

намекать:

• Используйте отдельную среду и установите все необходимые модули. (можно использовать среду анаконды)
• Для обучения модели вы можете использовать GPU для более быстрого обучения.

Краткое резюме - AI-ориентированные игры Snake, узнали с использованием глубины Q

Я надеюсь, что эта серия уроков поможет вам, блогеры тоже учатся, если есть какие-то ошибки, пожалуйста, покритикуйте и исправьте их. Если вам понравилась эта статья и вы хотите увидеть больше, вы можете прочитать ее здесь (Github/Gitee) Вот сводка всего моего оригинального и рабочего исходного кода, следуйте за мной для получения дополнительной информации.

🧵 Другие статьи по теме

• Обработка исключений Python | Месяц темы Python
• Учебное пособие по многопоточности Python | Месяц темы Python
• Основы программирования сокетов Python｜Месяц тем Python
• 30 руководств и советов по Python | Месяц тем Python
• Операторы Python, выражения и отступы | Месяц тем Python
• Ключевые слова Python, идентификаторы и переменные | Месяц темы Python
• Как писать комментарии и многострочные комментарии в Python | Месяц тем Python
• Изучайте числа Python и преобразование типов на примерах | Месяц тем Python
• Типы данных Python — от базового до углубленного обучения | Месяц тем Python
• Объектно-ориентированное программирование на Python — классы, объекты и члены | Месяц тем Python

🍰Рекомендуемые статьи из прошлого:

• 20 советов по Python, которые должен знать каждый | Месяц тем Python
• 100 основных вопросов для интервью по Python, часть 1 (1–20) | Месяц тем Python
• 100 основных вопросов для интервью по Python, часть 2 (21–40) | Месяц тем Python
• 100 основных вопросов для интервью по Python, часть 3 (41–60) | Месяц темы Python
• 100 основных вопросов для интервью по Python, часть 4 (61–80) | Месяц тем Python
• 100 основных вопросов на собеседовании по Python, часть 5 (81–100) | Месяц темы Python

Если вы действительно узнали что-то новое из этой статьи, ставьте лайк, добавляйте в закладки и делитесь с друзьями. 🤗Наконец, не забудьте поддержать ❤ или 📑