Unity 机器学习代理工具包 (ML-Agents) 是一个开源项目,它使游戏和模拟能够作为训练智能代理的环境。
您最多选择25个主题 主题必须以中文或者字母或数字开头,可以包含连字符 (-),并且长度不得超过35个字符
 
 
 
 
 

172 行
9.0 KiB

import numpy as np
import tensorflow as tf
from ppo.history import *
class Trainer(object):
def __init__(self, ppo_model, sess, info, is_continuous, use_observations, use_states):
"""
Responsible for collecting experinces and training PPO model.
:param ppo_model: Tensorflow graph defining model.
:param sess: Tensorflow session.
:param info: Environment BrainInfo object.
:param is_continuous: Whether action-space is continuous.
:param use_observations: Whether agent takes image observations.
"""
self.model = ppo_model
self.sess = sess
stats = {'cumulative_reward': [], 'episode_length': [], 'value_estimate': [],
'entropy': [], 'value_loss': [], 'policy_loss': [], 'learning_rate': []}
self.stats = stats
self.training_buffer = vectorize_history(empty_local_history({}))
self.history_dict = empty_all_history(info)
self.is_continuous = is_continuous
self.use_observations = use_observations
self.use_states = use_states
def take_action(self, info, env, brain_name):
"""
Decides actions given state/observation information, and takes them in environment.
:param info: Current BrainInfo from environment.
:param env: Environment to take actions in.
:param brain_name: Name of brain we are learning model for.
:return: BrainInfo corresponding to new environment state.
"""
epsi = None
feed_dict = {self.model.batch_size: len(info.states)}
if self.is_continuous:
epsi = np.random.randn(len(info.states), env.brains[brain_name].action_space_size)
feed_dict[self.model.epsilon] = epsi
if self.use_observations:
feed_dict[self.model.observation_in] = np.vstack(info.observations)
if self.use_states:
feed_dict[self.model.state_in] = info.states
actions, a_dist, value, ent, learn_rate = self.sess.run([self.model.output, self.model.probs,
self.model.value, self.model.entropy,
self.model.learning_rate],
feed_dict=feed_dict)
self.stats['value_estimate'].append(value)
self.stats['entropy'].append(ent)
self.stats['learning_rate'].append(learn_rate)
new_info = env.step(actions, value={brain_name: value})[brain_name]
self.add_experiences(info, new_info, epsi, actions, a_dist, value)
return new_info
def add_experiences(self, info, next_info, epsi, actions, a_dist, value):
"""
Adds experiences to each agent's experience history.
:param info: Current BrainInfo.
:param next_info: Next BrainInfo.
:param epsi: Epsilon value (for continuous control)
:param actions: Chosen actions.
:param a_dist: Action probabilities.
:param value: Value estimates.
"""
for (agent, history) in self.history_dict.items():
if agent in info.agents:
idx = info.agents.index(agent)
if not info.local_done[idx]:
if self.use_observations:
history['observations'].append([info.observations[0][idx]])
if self.use_states:
history['states'].append(info.states[idx])
if self.is_continuous:
history['epsilons'].append(epsi[idx])
history['actions'].append(actions[idx])
history['rewards'].append(next_info.rewards[idx])
history['action_probs'].append(a_dist[idx])
history['value_estimates'].append(value[idx][0])
history['cumulative_reward'] += next_info.rewards[idx]
history['episode_steps'] += 1
def process_experiences(self, info, time_horizon, gamma, lambd):
"""
Checks agent histories for processing condition, and processes them as necessary.
Processing involves calculating value and advantage targets for model updating step.
:param info: Current BrainInfo
:param time_horizon: Max steps for individual agent history before processing.
:param gamma: Discount factor.
:param lambd: GAE factor.
"""
for l in range(len(info.agents)):
if (info.local_done[l] or len(self.history_dict[info.agents[l]]['actions']) > time_horizon) and len(
self.history_dict[info.agents[l]]['actions']) > 0:
if info.local_done[l]:
value_next = 0.0
else:
feed_dict = {self.model.batch_size: len(info.states)}
if self.use_observations:
feed_dict[self.model.observation_in] = np.vstack(info.observations)
if self.use_states:
feed_dict[self.model.state_in] = info.states
value_next = self.sess.run(self.model.value, feed_dict)[l]
history = vectorize_history(self.history_dict[info.agents[l]])
history['advantages'] = get_gae(rewards=history['rewards'],
value_estimates=history['value_estimates'],
value_next=value_next, gamma=gamma, lambd=lambd)
history['discounted_returns'] = history['advantages'] + history['value_estimates']
if len(self.training_buffer['actions']) > 0:
append_history(global_buffer=self.training_buffer, local_buffer=history)
else:
set_history(global_buffer=self.training_buffer, local_buffer=history)
self.history_dict[info.agents[l]] = empty_local_history(self.history_dict[info.agents[l]])
if info.local_done[l]:
self.stats['cumulative_reward'].append(history['cumulative_reward'])
self.stats['episode_length'].append(history['episode_steps'])
history['cumulative_reward'] = 0
history['episode_steps'] = 0
def update_model(self, batch_size, num_epoch):
"""
Uses training_buffer to update model.
:param batch_size: Size of each mini-batch update.
:param num_epoch: How many passes through data to update model for.
"""
total_v, total_p = 0, 0
advantages = self.training_buffer['advantages']
self.training_buffer['advantages'] = (advantages - advantages.mean()) / advantages.std()
for k in range(num_epoch):
training_buffer = shuffle_buffer(self.training_buffer)
for l in range(len(training_buffer['actions']) // batch_size):
start = l * batch_size
end = (l + 1) * batch_size
feed_dict = {self.model.returns_holder: training_buffer['discounted_returns'][start:end],
self.model.advantage: np.vstack(training_buffer['advantages'][start:end]),
self.model.old_probs: np.vstack(training_buffer['action_probs'][start:end])}
if self.is_continuous:
feed_dict[self.model.epsilon] = np.vstack(training_buffer['epsilons'][start:end])
else:
feed_dict[self.model.action_holder] = np.hstack(training_buffer['actions'][start:end])
if self.use_states:
feed_dict[self.model.state_in] = np.vstack(training_buffer['states'][start:end])
if self.use_observations:
feed_dict[self.model.observation_in] = np.vstack(training_buffer['observations'][start:end])
v_loss, p_loss, _ = self.sess.run([self.model.value_loss, self.model.policy_loss,
self.model.update_batch], feed_dict=feed_dict)
total_v += v_loss
total_p += p_loss
self.stats['value_loss'].append(total_v)
self.stats['policy_loss'].append(total_p)
self.training_buffer = vectorize_history(empty_local_history({}))
for key in self.history_dict:
self.history_dict[key] = empty_local_history(self.history_dict[key])
def write_summary(self, summary_writer, steps):
"""
Saves training statistics to Tensorboard.
:param summary_writer: writer associated with Tensorflow session.
:param steps: Number of environment steps in training process.
"""
print("Mean Reward: {0}".format(np.mean(self.stats['cumulative_reward'])))
summary = tf.Summary()
for key in self.stats:
if len(self.stats[key]) > 0:
stat_mean = float(np.mean(self.stats[key]))
summary.value.add(tag='Info/{}'.format(key), simple_value=stat_mean)
self.stats[key] = []
summary_writer.add_summary(summary, steps)
summary_writer.flush()