date_collected
stringclasses 1
value | repo_name
stringlengths 6
116
| file_name
stringlengths 2
220
| file_contents
stringlengths 13
357k
| prompts
sequence |
|---|---|---|---|---|
2024-01-10 | pburslemjr/Capstone | Temporal_phasing-paul~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
import scipy
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
self.AI_used = tf.placeholder(tf.float32, [None], name="AI_used")
self.RL_used = tf.placeholder(tf.float32, [None], name="RL_used")
self.Importance_weight = tf.placeholder(tf.float32, [], name="Importance_weight")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
#Normal PPO policy loss
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
#self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
#Applied importance sampling
self.Z = tf.reduce_sum(tf.maximum(self.AI_used*ratio, tf.clip_by_value(self.AI_used*ratio, 1.0 - self.clip_range_ph, 1.0 + self.clip_range_ph)))
self.pg_sample_loss = (tf.reduce_sum(tf.maximum(self.AI_used*pg_losses, self.AI_used*pg_losses2)) / self.Z) + (self.Importance_weight)*tf.log(self.Z)
self.pg_rl_loss = tf.reduce_mean(tf.maximum(self.RL_used*pg_losses, self.RL_used*pg_losses2))
self.pg_loss = self.pg_sample_loss + self.pg_rl_loss
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, AI_used, imp_weight, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
RL_used = np.ones(AI_used.shape) - AI_used
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values, self.AI_used: AI_used, self.RL_used: RL_used, self.Importance_weight: imp_weight}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, AI_used, imp_weight, policy_prob = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs, AI_used))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, imp_weight, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(policy_prob) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
self.obs = conn[0].get()
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.lam = lam
self.gamma = gamma
self.conn = conn
self.policy_prob = 0.2
self.norm_w = 1e-3
self.last_trust_update = -1
self.prev_mean_reward = 0.0
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def policy_decide(self, policy_prob):
return np.random.rand() > policy_prob
def phase_condition(self, last_trust_update, cur_mean_reward, prev_mean_reward):
return last_trust_update < 0 or (cur_mean_reward >= prev_mean_reward)
def get_phase_step(self):
return 0.05
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
RL_used = 0
AI_used = []
#If a model is not being trained but only used for prediction. In a non-self-play setting this section of code can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
old_policy_range = 10 #how many older policies should be included in the pool to randomly pick from
if(model_decider > 0.0 and saved_models != [] and len(saved_models[:-old_policy_range]) > 0):
ind = 0
if len(saved_models[:-old_policy_range]) > 1:
ind = random.randint(0, len(saved_models[:-old_policy_range])-1)
fi = saved_models[:-old_policy_range][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model for tank " + str(self.model_num))
f.write("1\n")
f.close()
#Run the environment for n time steps
for _ in range(self.n_steps):
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
#If the model is not allowed to train it will only predict
#Choose between the RL policy action or the demonstrators action or even a random action
if(self.policy_decide(self.policy_prob)):#if(time_steps > self.thresh_steps):# and alive != 0):
rand_prob = 0.01
#Demonstrator action is sampled
if(self.model_num == 1):
control_actions = self.env.env_method("control_blue", self.obs)[0][0]
else:
control_actions = self.env.env_method("control_blue", self.obs)[0][1]
#Choose between random action and demonstrator action
if(random.random() < rand_prob):
control_actions = np.array([random.random(), random.random(), random.random()])
control_actions[1] = (control_actions[1] * (1 - (-1))) + (-1)
control_action_prob = rand_prob
else:
control_action_prob = 1.0 - rand_prob
control_actions[0] = (control_actions[0] * (1 - (-1))) + (-1)
control_actions[2] = (control_actions[2] * (1 - (-1))) + (-1)
AI_used.append(1)
else:
if(self.update_buffers == 0):
control_actions, _, _ = model.predict(self.obs, deterministic = False)
else:
#RL action is sampled
control_action_prob = 1.0
control_actions = actions
RL_used += 1
AI_used.append(0)
control_actions = control_actions.reshape((1, 3))
if(self.update_buffers == 1):
if(self.dones):
print("Current RL policy sampling probability: ", self.policy_prob, "Normalizing coefficient for importance sampling: ", self.norm_w)
#Keep a track of the mean episode rewards
if(self.ep_reward != []):
mean_ep_reward = np.mean(np.array(self.ep_reward))
self.cur_mean_reward += mean_ep_reward
#If the policy performed better this episode compared to previous episode then reduce the effect of the demonstrations by reducing norm_w
if(mean_ep_reward > self.prev_ep_reward):
self.norm_w = max(self.norm_w/10.0, 1e-5)
#If the policy performed worse this episode compared to previous episode then increase the effect of the demonstrations by increasing norm_w
else:
self.norm_w = min(self.norm_w*10, 1.0)
print("Prev ep= ", self.prev_ep_reward, "Cur_ep= ", mean_ep_reward)
self.prev_ep_reward = mean_ep_reward
print("Prev mean= ", self.prev_mean_reward, "Cur_mean= ", self.cur_mean_reward)
self.ep_reward = []
episode = self.env.get_attr("episode")[0]
#After every 50 episodes, check if the policy is performing well enough to phase it more control. This metric can be modified
if(episode % 100 == 0 and episode != self.last_trust_update):
self.cur_mean_reward = self.cur_mean_reward/100.0
if(self.phase_condition(self.last_trust_update, self.cur_mean_reward, self.prev_mean_reward)):
self.policy_prob = min(self.policy_prob+self.get_phase_step(), 1.0)
self.prev_mean_reward = max(((self.mean_updates-1)/self.mean_updates)*self.prev_mean_reward + (1/self.mean_updates)*self.cur_mean_reward, 0.0)
#else:
#self.policy_prob = max(self.policy_prob-get_phase_step(), 0.1)
print("Prev mean= ", self.prev_mean_reward, "Cur mean= ", self.cur_mean_reward, "Mean Updates= ", self.mean_updates)
self.mean_updates += 1
self.cur_mean_reward = 0.0
self.last_trust_update = episode
#Get the action probability if the action is sampled randomly or by the demonstrator
if(control_action_prob != 1.0):
mean_act, std_act = self.model.proba_step(self.obs, self.states, self.dones)
action_probs = scipy.stats.norm(mean_act.flatten()[0], std_act.flatten()[0]).pdf(control_actions)
if(abs(control_action_prob - rand_prob) < 0.0001):
action_probs = np.array([0.5, 0.5, 0.5]) * control_action_prob #In the case of random actions, all theactions have equal probability
else:
action_probs = np.array([1.0, 1.0, 1.0]) * control_action_prob #Since the demonstrator is deterministic the probability of its action is always 1.0
neglogpacs = [-np.sum(np.log(action_probs))]
mb_obs.append(self.obs.copy())
mb_actions.append(control_actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(control_actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(rewards)
self.ep_reward.append(rewards)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
AI_used = np.asarray(AI_used, dtype=np.float32)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Proportions RL_used = "+str(RL_used)+" AI_used = "+str(self.n_steps-RL_used))
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, AI_used, self.norm_w, self.policy_prob
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | decentralized~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
print("Switching Training!!")
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, unshaped_reward, rew_frac = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
print("Allows update is true for " + str(model_num))
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(np.mean(unshaped_reward)) + "," + str(rew_frac) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
#self.obs[:] = env.reset()
self.obs = conn[0].get()
#print(self.obs)
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.rew_frac = 1.0
self.last_update = -1
self.lam = lam
self.gamma = gamma
self.conn = conn
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
#uncomment second line to enable reward phasing
def phase_condition(self, episode, last_update):
return False
#return (episode%100==0 and episode!=last_update)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
#If a model is not being trained but only used for prediction. In a non-self-play setting this can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:])-1)
fi = saved_models[:][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
for _ in range(self.n_steps):
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
actions, _, _ = model.predict(self.obs, deterministic = False)
else:
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
if(self.update_buffers == 1):
mb_obs.append(self.obs.copy())
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
episode = self.env.get_attr("episode")[0]
if(self.phase_condition(episode, self.last_update)):
self.rew_frac = max(self.rew_frac-self.get_phase_step(), 0.0)
self.last_update = episode
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + self.rew_frac*rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(unshaped_reward)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_rewards)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Phasing reward fraction: ", self.rew_frac)
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, mb_unshaped_reward, self.rew_frac
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | multitank~self_play_ppo2%20(copy).py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not
#In this case since we are only training one of the models, only model_1 is set to allow. Model_2 will only predict actions but will not be trained further on that data.
'''if(model_num == 1):
allow_update = 1
else:
allow_update = 0'''
#If you wish to execute self-play, where both the models switch between learning and predicting cycles, then comment the above code and uncomment below code while setting switch_freq to the number of steps desired between switches
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
#self.obs[:] = env.reset()
self.obs = conn[0].get()
#print(self.obs)
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.lam = lam
self.gamma = gamma
self.conn = conn
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
#If a model is not being trained but only used for prediction. In a non-self-play setting this can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:])-1)
fi = saved_models[:][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
for _ in range(self.n_steps):
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
actions, _, _ = model.predict(self.obs, deterministic = False)
else:
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
if(self.update_buffers == 1):
mb_obs.append(self.obs.copy())
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(unshaped_reward)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | 1-on-1~reward_train.py | from stable_baselines import PPO2
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger, get_trainable_vars
from stable_baselines.common.math_util import safe_mean
import time
import gym
import numpy as np
import tensorflow as tf
import random
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
import scipy
from stable_baselines.common.runners import AbstractEnvRunner
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.policies import MlpPolicy
from tensorflow import keras
from stable_baselines.gail import ExpertDataset
from stable_baselines.gail import generate_expert_traj
import re
from os import walk
np.set_printoptions(suppress=True, formatter={'float_kind':'{:f}'.format})
class CustomPPO2(PPO2):
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam)
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy, env, gamma, n_steps, ent_coef, learning_rate, vf_coef,
max_grad_norm, lam, nminibatches, noptepochs, cliprange, cliprange_vf,
verbose, tensorboard_log, _init_setup_model, policy_kwargs,
full_tensorboard_log, seed, n_cpu_tf_sess)
norm = tf.keras.constraints.MinMaxNorm(min_value=-1.0, max_value=1.0)
self.reward_model = keras.Sequential(
[
keras.layers.Dense(512, name="layer1", kernel_regularizer = keras.regularizers.l1(1e-4), kernel_constraint=norm, use_bias=False, input_shape=[self.env.observation_space.shape[0]+self.env.action_space.shape[0]]),
keras.layers.Dense(512, name="layer2", kernel_regularizer = keras.regularizers.l1(1e-4), kernel_constraint=norm, use_bias=False),
keras.layers.Dense(1, name="layer3", activation="sigmoid", kernel_regularizer = keras.regularizers.l1(1e-2), kernel_constraint=norm, use_bias=False),
]
)
#self.reward_model = keras.models.load_model("Rew_Model_1")#, custom_objects={ 'loss_fn': self.loss_fn })
self.loading_model = 1
print(self.reward_model.get_weights())
self.reward_model.summary()
self.reward_model.save("Rew_Model")
if _init_setup_model:
self.setup_model()
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
for var in range(len(self.params)):
tf.summary.histogram(self.params[var].name, self.params[var])
if("model/pi/w" in self.params[var].name):
self.weights = self.params[var]
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
def learn(self, total_cycles, iteration, rl_optimization, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
if(self.loading_model == 0):
generate_expert_traj(self, "RL_traj_rand", self.env, n_episodes=30)
file_list = ["CTF_expert.npz"]
data_all = [np.load(fname, allow_pickle=True) for fname in file_list]
expert_data = {}
for i, data in enumerate(data_all):
action_data = data["actions"]
for k, v in data.items():
if(k == "obs"):
observations = []
for j in range(len(v)):
observations.append(np.concatenate((v[j], action_data[j]), axis=0))
expert_data.update({k: observations})
continue
if(k == "actions"):
actions = []
for j in range(len(v)):
actions.append(1.0)
expert_data.update({k: actions})
else:
expert_data.update({k: v})
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = rl_optimization// self.n_batch
callback.on_training_start(locals(), globals())
#Uncomment to initialize weights
'''init = np.ones((512, 3), dtype=float)
self.sess.run(tf.assign(self.weights, init))'''
for cyc in range(total_cycles):
#self.buf.sampling_buffer = []
self.new_cycle = 1
self.setup_model()
for update in range(1, n_updates+1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#print(tf.trainable_variables())
#Uncomment to see changes in weights
'''for var in self.params:
print(var)
print(self.sess.run(self.weights))'''
callback.on_rollout_start()
# true_reward is the reward without discount
rollout = self.runner.run(callback)
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, exp_reward = rollout
self.values = values
callback.on_rollout_end()
self.new_cycle = 0
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and (update % log_interval == 0 or update == 1):
print(np.mean(true_reward))
f = open("rewards.txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(np.mean(exp_reward)) + "\n")
f.close()
print("Cycle", cyc, update)
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * rl_optimization) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss.txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
print("Optimizing Reward")
#generate_expert_traj(self, "RL_traj_"+str(cyc+12), self.env, n_episodes=30)
filenames = next(walk("."), (None, None, []))[2]
saved_trajs = [ f for f in filenames if "RL_traj_" in f]
ind = random.randint(0, len(saved_trajs)-1)
traj = saved_trajs[ind]
for ind in range(len(saved_trajs)):
traj = saved_trajs[ind]
data_all = [np.load(traj, allow_pickle=True) for fname in file_list]
merged_data = expert_data
for i, data in enumerate(data_all):
action_data = data["actions"]
for k, v in data.items():
if(k == "obs"):
observations = []
for j in range(len(v)):
if(j < 20480*5):
expert_actions = self.env.env_method("control", v[j])[0]
#expert_actions = np.reshape(expert_actions, (1, 3))
expert_actions = (expert_actions + 1)/2.0
observations.append(np.concatenate((v[j], expert_actions), axis=0))
observations.append(np.concatenate((v[j], action_data[j]), axis=0))
merged_data.update({k: merged_data[k]+observations})
continue
if(k == "actions"):
actions = []
for j in range(len(v)):
if(j < 20480*5):
actions.append(1.0)
actions.append(0.0)
merged_data.update({k: merged_data[k]+actions})
else:
merged_data.update({k: v})
print("Total dataset size= ", len(merged_data), ind)
rew_sum_RL = 0.0
rew_sum_exp = 0.0
x = np.array(merged_data["obs"])
y = np.array(merged_data["actions"])
'''for i in range(len(x)):
obs = np.reshape(x[i], (1, len(x[i])))
if(y[i] == 1.0):
exp_rew = self.reward_model.predict(obs)[0]#np.reshape(Expert_inp, (1,139)))[0]
rew_sum_exp += exp_rew
else:
RL_rew = self.reward_model.predict(obs)[0]#np.reshape(Expert_inp, (1,139)))[0]
rew_sum_RL += RL_rew
print("Before ", rew_sum_RL, rew_sum_exp)'''
opt = tf.keras.optimizers.Adam(lr=0.0003)
self.reward_model.compile(optimizer=opt, loss=tf.keras.losses.binary_crossentropy)#self.loss_fn)
loss_history = self.reward_model.fit(x, y, epochs=50, shuffle=True, batch_size = 20480)
loss_history = loss_history.history["loss"]
loss_history = np.array(loss_history)
f = open("loss_history_2.txt", "a+")
np.savetxt(f, loss_history, delimiter="\n")
f.close()
rew_sum_RL = 0.0
rew_sum_exp = 0.0
'''for i in range(len(x)):
obs = np.reshape(x[i], (1, len(x[i])))
if(y[i] == 1.0):
exp_rew = self.reward_model.predict(obs)[0]#np.reshape(Expert_inp, (1,139)))[0]
rew_sum_exp += exp_rew
else:
RL_rew = self.reward_model.predict(obs)[0]#np.reshape(Expert_inp, (1,139)))[0]
rew_sum_RL += RL_rew
print("After ", rew_sum_RL, rew_sum_exp)'''
print(self.reward_model.get_weights())
self.reward_model.save("Rew_Model_"+str(2+update//(2000000//self.n_batch)))
print("Reward Optimized")
callback.on_training_end()
return self
def loss_fn(self, y_true, y_pred):
#if(y_pred - y_true > 0):
#loss = 2*(y_pred - y_true)
#else:
#loss = (y_pred - self.reward_model.predict(y_true))
#loss = y_true*(y_pred)+0.1# + 0.001*np.sum(np.abs(self.reward_model.get_weights()))
#loss = (tf.sigmoid(y_pred) - y_true)
loss = (y_true*(tf.log(tf.sigmoid(y_pred))) + (1-y_true)*(tf.log(1-tf.sigmoid(y_pred))))
return tf.reduce_mean(loss)
class Runner(AbstractEnvRunner):
def __init__(self, *, env, model, n_steps, gamma, lam):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
super().__init__(env=env, model=model, n_steps=n_steps)
self.lam = lam
self.gamma = gamma
self.likelihood_ratio = 1.0
self.policy_prob = 0.0
self.norm_w = 1.0
self.thresh_steps = 0
self.last_trust_update = -1
self.prev_mean_reward = 0.0#-0.035 #-0.067
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
self.exp_ep_reward = []
self.og_model = self.model
def run(self, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
return self._run()
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
'''if(self.model.new_cycle == 1):
reward_mod = self.model.reward_model
self.model = self.og_model
self.model.reward_model = reward_mod
print("Reverting Model")'''
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs = [], [], [], [], [], []
mb_states = self.states
ep_infos = []
traj_val = 0.0
expert_traj_val = 0.0
loss = 0.0
self.ep_reward = []
self.exp_ep_reward = []
for step in range(self.n_steps):
actions, values, self.states, neglogpacs = self.model.step(self.obs, self.states, self.dones)
expert_actions = self.env.env_method("control", self.obs)[0]
expert_actions = np.reshape(expert_actions, (1, 3))
clipped_actions = actions
clipped_expert = expert_actions
# Clip the actions to avoid out of bound error
if isinstance(self.env.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.env.action_space.low , self.env.action_space.high)
clipped_expert = np.clip(expert_actions, self.env.action_space.low, self.env.action_space.high)
clipped_actions[0][0] = (clipped_actions[0][0] + 1)/2.0
clipped_actions[0][1] = (clipped_actions[0][1] + 1)/2.0
clipped_actions[0][2] = (clipped_actions[0][2] + 1)/2.0
clipped_expert[0][0] = (clipped_actions[0][0] + 1)/2.0
clipped_expert[0][1] = (clipped_expert[0][1] + 1)/2.0
clipped_expert[0][2] = (clipped_expert[0][2] + 1)/2.0
RL_inp = np.concatenate((self.obs, clipped_actions), axis=1)
Expert_inp = np.concatenate((self.obs, clipped_expert), axis=1)
mb_obs.append(self.obs.copy())
mb_dones.append(self.dones)
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
rewards = self.model.reward_model.predict(RL_inp)[0]
exp_rewards = self.model.reward_model.predict(Expert_inp)[0]
#if(step < 10):
#print(rewards)
self.ep_reward.append(rewards)
self.exp_ep_reward.append(exp_rewards)
loss += (rewards - exp_rewards)
'''mean_act, std_act = self.model.reward_model.proba_step(self.obs, self.states, self.dones)
action_probs = scipy.stats.norm(mean_act.flatten()[0], std_act.flatten()[0]).pdf(control_actions[0][1])
neglogpacs = [-np.sum(np.log(action_probs))]
RL_classification = tf.math.exp(rewards) / (tf.math.exp(rewards) + tf.math.exp(log_p) + 1e-8)
return self.sigmoid(value)'''
#Execute action in the environment to find the reward
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.env.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.env.action_space.low, self.env.action_space.high)
self.obs[:], _, self.dones, infos = self.env.step(clipped_actions)
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
print("Expected Loss", loss/self.n_steps)
print("RL Reward = ", sum(self.ep_reward), "Expert Reward = ", sum(self.exp_ep_reward))
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_exp_rewards = np.asarray(self.exp_ep_reward, dtype=np.float32)
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_rewards)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward, mb_exp_rewards= \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward, mb_exp_rewards))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, mb_exp_rewards
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | test~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, unshaped_reward, rew_frac = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(np.mean(unshaped_reward)) + "," + str(rew_frac) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
#self.obs[:] = env.reset()
self.obs = conn[0].get()
#print(self.obs)
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.rew_frac = 1.0
self.last_update = -1
self.lam = lam
self.gamma = gamma
self.conn = conn
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def phase_condition(self, episode, last_update):
return (episode%1==0 and episode!=last_update)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
print("RUN CALLED model num: " + str(self.model_num))
mb_states = self.states
ep_infos = []
model = self.model
#If a model is not being trained but only used for prediction. In a non-self-play setting this can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:])-1)
fi = saved_models[:][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
#print(self.n_steps)
for _ in range(self.n_steps):
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
actions, _, _ = model.predict(self.obs, deterministic = False)
else:
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
if(self.update_buffers == 1):
mb_obs.append(self.obs.copy())
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
episode = self.env.get_attr("episode")[0]
if(self.phase_condition(episode, self.last_update)):
self.rew_frac = max(self.rew_frac-self.get_phase_step(), 0.0)
self.last_update = episode
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + self.rew_frac*rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards[0])
if(len(mb_rewards)%1000 == 0):
print("Reward: " + str(rewards))
mb_unshaped_reward.append(unshaped_reward[0])
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
print("shape of mb_rewards: " + str(np.shape(mb_rewards)))
print("n_steps: " + str(self.n_steps))
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Phasing reward fraction: ", self.rew_frac)
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
print("RETURNING: " + str(np.shape(true_reward)))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, mb_unshaped_reward, self.rew_frac
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | 2-on-2~customPPO2.py | from stable_baselines import PPO2
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger, get_trainable_vars
from stable_baselines.common.math_util import safe_mean
import time
import gym
import numpy as np
import tensorflow as tf
import random
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
import scipy
from stable_baselines.common.runners import AbstractEnvRunner
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.policies import MlpPolicy
from tensorflow import keras
from stable_baselines.gail import ExpertDataset
from stable_baselines.gail import generate_expert_traj
import re
from os import walk
np.set_printoptions(suppress=True, formatter={'float_kind':'{:f}'.format})
class CustomPPO2(PPO2):
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam)
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None,model_num=1):
self.model_num = model_num
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy, env, gamma, n_steps, ent_coef, learning_rate, vf_coef,
max_grad_norm, lam, nminibatches, noptepochs, cliprange, cliprange_vf,
verbose, tensorboard_log, _init_setup_model, policy_kwargs,
full_tensorboard_log, seed, n_cpu_tf_sess)
if (self.verbose):
print("Setting up model " + str(self.model_num))
if _init_setup_model:
self.setup_model()
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
for var in range(len(self.params)):
tf.summary.histogram(self.params[var].name, self.params[var])
if("model/pi/w" in self.params[var].name):
self.weights = self.params[var]
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
def learn(self, total_cycles, iteration, rl_optimization, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = rl_optimization// self.n_batch
callback.on_training_start(locals(), globals())
#Uncomment to initialize weights
'''init = np.ones((512, 3), dtype=float)
self.sess.run(tf.assign(self.weights, init))'''
for cyc in range(total_cycles):
#self.buf.sampling_buffer = []
self.new_cycle = 1
for update in range(1, n_updates+1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#print(tf.trainable_variables())
#Uncomment to see changes in weights
'''for var in self.params:
print(var)
print(self.sess.run(self.weights))'''
callback.on_rollout_start()
# true_reward is the reward without discount
rollout = self.runner.run(callback)
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward = rollout
print("true_rew: " + str(true_reward))
self.values = values
callback.on_rollout_end()
self.new_cycle = 0
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and (update % log_interval == 0 or update == 1):
print(np.mean(true_reward))
f = open("rewards.txt", "a+")
f.write(str(np.mean(true_reward)) + "\n")
f.close()
print("Cycle", cyc, update)
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * rl_optimization) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss.txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def loss_fn(self, y_true, y_pred):
#if(y_pred - y_true > 0):
#loss = 2*(y_pred - y_true)
#else:
#loss = (y_pred - self.reward_model.predict(y_true))
#loss = y_true*(y_pred)+0.1# + 0.001*np.sum(np.abs(self.reward_model.get_weights()))
#loss = (tf.sigmoid(y_pred) - y_true)
#loss = (y_true*(tf.log(tf.sigmoid(y_pred))) + (1-y_true)*(tf.log(1-tf.sigmoid(y_pred))))
loss = self.sign*tf.keras.losses.binary_crossentropy(y_true, y_pred)
return tf.reduce_mean(loss)
class Runner(AbstractEnvRunner):
def __init__(self, *, env, model, n_steps, gamma, lam):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
super().__init__(env=env, model=model, n_steps=n_steps)
self.lam = lam
self.gamma = gamma
self.likelihood_ratio = 1.0
self.policy_prob = 0.0
self.norm_w = 1.0
self.thresh_steps = 0
self.last_trust_update = -1
self.prev_mean_reward = 0.0#-0.035 #-0.067
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
self.exp_ep_reward = []
self.og_model = self.model
def run(self, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
return self._run()
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
'''if(self.model.new_cycle == 1):
reward_mod = self.model.reward_model
self.model = self.og_model
self.model.reward_model = reward_mod
print("Reverting Model")'''
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs = [], [], [], [], [], []
mb_states = self.states
ep_infos = []
traj_val = 0.0
expert_traj_val = 0.0
loss = 0.0
self.ep_reward = []
self.exp_ep_reward = []
for step in range(self.n_steps):
actions, values, self.states, neglogpacs = self.model.step(self.obs, self.states, self.dones)
mb_obs.append(self.obs.copy())
mb_dones.append(self.dones)
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
#Execute action in the environment to find the reward
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.env.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.env.action_space.low, self.env.action_space.high)
rewards = np.asarray([0.0, 0.0])
self.obs[:], rewards, self.dones, infos = self.env.step(clipped_actions)
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
print("rews: " + str(rewards))
print("Modelnum-: " + str(self.model.model_num))
mb_rewards.append(rewards)
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_rewards)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward= \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | Reward_phasing~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, unshaped_reward, rew_frac = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(np.mean(unshaped_reward)) + "," + str(rew_frac) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
#self.obs[:] = env.reset()
self.obs = conn[0].get()
#print(self.obs)
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.rew_frac = 1.0
self.last_update = -1
self.lam = lam
self.gamma = gamma
self.conn = conn
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def phase_condition(self, episode, last_update):
return (episode%100==0 and episode!=last_update)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
#If a model is not being trained but only used for prediction. In a non-self-play setting this can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:])-1)
fi = saved_models[:][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
for _ in range(self.n_steps):
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
actions, _, _ = model.predict(self.obs, deterministic = False)
else:
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
if(self.update_buffers == 1):
mb_obs.append(self.obs.copy())
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
episode = self.env.get_attr("episode")[0]
if(self.phase_condition(episode, self.last_update)):
self.rew_frac = max(self.rew_frac-self.get_phase_step(), 0.0)
self.last_update = episode
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + self.rew_frac*rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(unshaped_reward)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Phasing reward fraction: ", self.rew_frac)
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, mb_unshaped_reward, self.rew_frac
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | multitank~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
import scipy
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
self.AI_used = tf.placeholder(tf.float32, [None], name="AI_used")
self.RL_used = tf.placeholder(tf.float32, [None], name="RL_used")
self.Importance_weight = tf.placeholder(tf.float32, [], name="Importance_weight")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
#Normal PPO policy loss
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
#self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
#Applied importance sampling
self.Z = tf.reduce_sum(tf.maximum(self.AI_used*ratio, tf.clip_by_value(self.AI_used*ratio, 1.0 - self.clip_range_ph, 1.0 + self.clip_range_ph)))
self.pg_sample_loss = (tf.reduce_sum(tf.maximum(self.AI_used*pg_losses, self.AI_used*pg_losses2)) / self.Z) + (self.Importance_weight)*tf.log(self.Z)
self.pg_rl_loss = tf.reduce_mean(tf.maximum(self.RL_used*pg_losses, self.RL_used*pg_losses2))
self.pg_loss = self.pg_sample_loss + self.pg_rl_loss
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, AI_used, imp_weight, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
RL_used = np.ones(AI_used.shape) - AI_used
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values, self.AI_used: AI_used, self.RL_used: RL_used, self.Importance_weight: imp_weight}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, AI_used, imp_weight, policy_prob = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs, AI_used))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, imp_weight, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(policy_prob) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
self.obs = conn[0].get()
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.lam = lam
self.gamma = gamma
self.conn = conn
self.policy_prob = 0.0
self.norm_w = 1e-3
self.last_trust_update = -1
self.prev_mean_reward = 0.0
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def policy_decide(self, policy_prob):
return np.random.rand() > policy_prob
def phase_condition(last_trust_update, cur_mean_reward, prev_mean_reward):
return last_trust_update < 0 or (cur_mean_reward >= prev_mean_reward)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
RL_used = 0
AI_used = []
#If a model is not being trained but only used for prediction. In a non-self-play setting this section of code can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
old_policy_range = 10 #how many older policies should be included in the pool to randomly pick from
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:-old_policy_range])-1)
fi = saved_models[:-old_policy_range][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
#Run the environment for n time steps
for _ in range(self.n_steps):
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
control_actions, _, _ = model.predict(self.obs, deterministic = False)
else:
#Choose between the RL policy action or the demonstrators action or even a random action
if(self.policy_decide(self.policy_prob)):#if(time_steps > self.thresh_steps):# and alive != 0):
rand_prob = 0.2
#Demonstrator action is sampled
if(self.model_num == 1):
control_actions = self.env.env_method("control_blue", self.obs)[0]
else:
control_actions = self.env.env_method("control_red", self.obs)[0]
#Choose between random action and demonstrator action
if(random.random() < rand_prob):
control_actions = np.array([random.random(), random.random(), random.random()])
control_actions[1] = (control_actions[1] * (1 - (-1))) + (-1)
control_action_prob = rand_prob
else:
control_action_prob = 1.0 - rand_prob
control_actions[0] = (control_actions[0] * (1 - (-1))) + (-1)
control_actions[2] = (control_actions[2] * (1 - (-1))) + (-1)
AI_used.append(1)
else:
#RL action is sampled
control_action_prob = 1.0
control_actions = actions
RL_used += 1
AI_used.append(0)
control_actions = control_actions.reshape((1, 3))
if(self.update_buffers == 1):
if(self.dones):
print("Current RL policy sampling probability: ", self.policy_prob, "Normalizing coefficient for importance sampling: ", self.norm_w)
#Keep a track of the mean episode rewards
if(self.ep_reward != []):
mean_ep_reward = np.mean(np.array(self.ep_reward))
self.cur_mean_reward += mean_ep_reward
#If the policy performed better this episode compared to previous episode then reduce the effect of the demonstrations by reducing norm_w
if(mean_ep_reward > self.prev_ep_reward):
self.norm_w = max(self.norm_w/10.0, 1e-6)
#If the policy performed worse this episode compared to previous episode then increase the effect of the demonstrations by increasing norm_w
else:
self.norm_w = min(self.norm_w*10, 1e-2)
print("Prev ep= ", self.prev_ep_reward, "Cur_ep= ", mean_ep_reward)
self.prev_ep_reward = mean_ep_reward
print("Prev mean= ", self.prev_mean_reward, "Cur_mean= ", self.cur_mean_reward)
self.ep_reward = []
episode = self.env.get_attr("episode")[0]
#After every 50 episodes, check if the policy is performing well enough to phase it more control. This metric can be modified
if(episode % 50 == 0 and episode != self.last_trust_update):
self.cur_mean_reward = self.cur_mean_reward/50.0
if(self.phase_condition(self.last_trust_update, self.cur_mean_reward, self.prev_mean_reward)):
self.policy_prob += min(self.policy_prob+self.get_phase_step(), 1.0)
#else:
#self.policy_prob = max(self.policy_prob-get_phase_step(), 0.1)
print("Prev mean= ", self.prev_mean_reward, "Cur mean= ", self.cur_mean_reward, "Mean Updates= ", self.mean_updates)
self.prev_mean_reward = max(((self.mean_updates-1)/self.mean_updates)*self.prev_mean_reward + (1/self.mean_updates)*self.cur_mean_reward, 0.0)
self.mean_updates += 1
self.cur_mean_reward = 0.0
self.last_trust_update = episode
#Get the action probability if the action is sampled randomly or by the demonstrator
if(control_action_prob != 1.0):
mean_act, std_act = self.model.proba_step(self.obs, self.states, self.dones)
action_probs = scipy.stats.norm(mean_act.flatten()[0], std_act.flatten()[0]).pdf(control_actions)
if(abs(control_action_prob - rand_prob) < 0.0001):
action_probs = np.array([0.5, 0.5, 0.5]) * control_action_prob #In the case of random actions, all theactions have equal probability
else:
action_probs = np.array([1.0, 1.0, 1.0]) * control_action_prob #Since the demonstrator is deterministic the probability of its action is always 1.0
neglogpacs = [-np.sum(np.log(action_probs))]
mb_obs.append(self.obs.copy())
mb_actions.append(control_actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(control_actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(unshaped_reward)
self.ep_reward.append(rewards)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
AI_used = np.asarray(AI_used, dtype=np.float32)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Proportions RL_used = "+str(RL_used)+" AI_used = "+str(self.n_steps-RL_used))
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, AI_used, self.norm_w, self.policy_prob
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | Temporal_phasing~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
import scipy
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
self.AI_used = tf.placeholder(tf.float32, [None], name="AI_used")
self.RL_used = tf.placeholder(tf.float32, [None], name="RL_used")
self.Importance_weight = tf.placeholder(tf.float32, [], name="Importance_weight")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
#Normal PPO policy loss
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
#self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
#Applied importance sampling
self.Z = tf.reduce_sum(tf.maximum(self.AI_used*ratio, tf.clip_by_value(self.AI_used*ratio, 1.0 - self.clip_range_ph, 1.0 + self.clip_range_ph)))
self.pg_sample_loss = (tf.reduce_sum(tf.maximum(self.AI_used*pg_losses, self.AI_used*pg_losses2)) / self.Z) + (self.Importance_weight)*tf.log(self.Z)
self.pg_rl_loss = tf.reduce_mean(tf.maximum(self.RL_used*pg_losses, self.RL_used*pg_losses2))
self.pg_loss = self.pg_sample_loss + self.pg_rl_loss
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, AI_used, imp_weight, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
RL_used = np.ones(AI_used.shape) - AI_used
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values, self.AI_used: AI_used, self.RL_used: RL_used, self.Importance_weight: imp_weight}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, AI_used, imp_weight, policy_prob = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs, AI_used))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, imp_weight, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(policy_prob) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
self.obs = conn[0].get()
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.lam = lam
self.gamma = gamma
self.conn = conn
self.policy_prob = 0.0
self.norm_w = 1e-3
self.last_trust_update = -1
self.prev_mean_reward = 0.0
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def policy_decide(self, policy_prob):
return np.random.rand() > policy_prob
def phase_condition(self, last_trust_update, cur_mean_reward, prev_mean_reward):
return last_trust_update < 0 or (cur_mean_reward >= prev_mean_reward)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
RL_used = 0
AI_used = []
#If a model is not being trained but only used for prediction. In a non-self-play setting this section of code can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
old_policy_range = 10 #how many older policies should be included in the pool to randomly pick from
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:-old_policy_range])-1)
fi = saved_models[:-old_policy_range][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
#Run the environment for n time steps
for _ in range(self.n_steps):
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
control_actions, _, _ = model.predict(self.obs, deterministic = False)
else:
#Choose between the RL policy action or the demonstrators action or even a random action
if(self.policy_decide(self.policy_prob)):#if(time_steps > self.thresh_steps):# and alive != 0):
rand_prob = 0.2
#Demonstrator action is sampled
if(self.model_num == 1):
control_actions = self.env.env_method("control_blue", self.obs)[0]
else:
control_actions = self.env.env_method("control_red", self.obs)[0]
#Choose between random action and demonstrator action
if(random.random() < rand_prob):
control_actions = np.array([random.random(), random.random(), random.random()])
control_actions[1] = (control_actions[1] * (1 - (-1))) + (-1)
control_action_prob = rand_prob
else:
control_action_prob = 1.0 - rand_prob
control_actions[0] = (control_actions[0] * (1 - (-1))) + (-1)
control_actions[2] = (control_actions[2] * (1 - (-1))) + (-1)
AI_used.append(1)
else:
#RL action is sampled
control_action_prob = 1.0
control_actions = actions
RL_used += 1
AI_used.append(0)
control_actions = control_actions.reshape((1, 3))
if(self.update_buffers == 1):
if(self.dones):
print("Current RL policy sampling probability: ", self.policy_prob, "Normalizing coefficient for importance sampling: ", self.norm_w)
#Keep a track of the mean episode rewards
if(self.ep_reward != []):
mean_ep_reward = np.mean(np.array(self.ep_reward))
self.cur_mean_reward += mean_ep_reward
#If the policy performed better this episode compared to previous episode then reduce the effect of the demonstrations by reducing norm_w
if(mean_ep_reward > self.prev_ep_reward):
self.norm_w = max(self.norm_w/10.0, 1e-6)
#If the policy performed worse this episode compared to previous episode then increase the effect of the demonstrations by increasing norm_w
else:
self.norm_w = min(self.norm_w*10, 1e-2)
print("Prev ep= ", self.prev_ep_reward, "Cur_ep= ", mean_ep_reward)
self.prev_ep_reward = mean_ep_reward
print("Prev mean= ", self.prev_mean_reward, "Cur_mean= ", self.cur_mean_reward)
self.ep_reward = []
episode = self.env.get_attr("episode")[0]
#After every 50 episodes, check if the policy is performing well enough to phase it more control. This metric can be modified
if(episode % 50 == 0 and episode != self.last_trust_update):
self.cur_mean_reward = self.cur_mean_reward/50.0
print("trust: " + str(self.prev_mean_reward))
if(self.phase_condition(self.last_trust_update, self.cur_mean_reward, self.prev_mean_reward)):
self.policy_prob += min(self.policy_prob+self.get_phase_step(), 1.0)
#else:
#self.policy_prob = max(self.policy_prob-get_phase_step(), 0.1)
print("Prev mean= ", self.prev_mean_reward, "Cur mean= ", self.cur_mean_reward, "Mean Updates= ", self.mean_updates)
self.prev_mean_reward = max(((self.mean_updates-1)/self.mean_updates)*self.prev_mean_reward + (1/self.mean_updates)*self.cur_mean_reward, 0.0)
self.mean_updates += 1
self.cur_mean_reward = 0.0
self.last_trust_update = episode
#Get the action probability if the action is sampled randomly or by the demonstrator
if(control_action_prob != 1.0):
mean_act, std_act = self.model.proba_step(self.obs, self.states, self.dones)
action_probs = scipy.stats.norm(mean_act.flatten()[0], std_act.flatten()[0]).pdf(control_actions)
if(abs(control_action_prob - rand_prob) < 0.0001):
action_probs = np.array([0.5, 0.5, 0.5]) * control_action_prob #In the case of random actions, all theactions have equal probability
else:
action_probs = np.array([1.0, 1.0, 1.0]) * control_action_prob #Since the demonstrator is deterministic the probability of its action is always 1.0
neglogpacs = [-np.sum(np.log(action_probs))]
mb_obs.append(self.obs.copy())
mb_actions.append(control_actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(control_actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(unshaped_reward)
self.ep_reward.append(rewards)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
AI_used = np.asarray(AI_used, dtype=np.float32)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Proportions RL_used = "+str(RL_used)+" AI_used = "+str(self.n_steps-RL_used))
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, AI_used, self.norm_w, self.policy_prob
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | Temporal-decentralized-step~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
import scipy
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
self.AI_used = tf.placeholder(tf.float32, [None], name="AI_used")
self.RL_used = tf.placeholder(tf.float32, [None], name="RL_used")
self.Importance_weight = tf.placeholder(tf.float32, [], name="Importance_weight")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
#Normal PPO policy loss
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
#self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
#Applied importance sampling
self.Z = tf.reduce_sum(tf.maximum(self.AI_used*ratio, tf.clip_by_value(self.AI_used*ratio, 1.0 - self.clip_range_ph, 1.0 + self.clip_range_ph)))
self.pg_sample_loss = (tf.reduce_sum(tf.maximum(self.AI_used*pg_losses, self.AI_used*pg_losses2)) / self.Z) + (self.Importance_weight)*tf.log(self.Z)
self.pg_rl_loss = tf.reduce_mean(tf.maximum(self.RL_used*pg_losses, self.RL_used*pg_losses2))
self.pg_loss = self.pg_sample_loss + self.pg_rl_loss
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, AI_used, imp_weight, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
RL_used = np.ones(AI_used.shape) - AI_used
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values, self.AI_used: AI_used, self.RL_used: RL_used, self.Importance_weight: imp_weight}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, AI_used, imp_weight, policy_prob = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs, AI_used))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, imp_weight, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(policy_prob) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
self.obs = conn[0].get()
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.lam = lam
self.gamma = gamma
self.conn = conn
self.policy_prob = 0.0
self.norm_w = 1e-3
self.last_trust_update = -1
self.prev_mean_reward = 0.0
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def policy_decide(self, policy_prob):
return np.random.rand() > policy_prob
def phase_condition(self, last_trust_update, cur_mean_reward, prev_mean_reward):
return last_trust_update < 0 or (cur_mean_reward >= prev_mean_reward)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
RL_used = 0
AI_used = []
#If a model is not being trained but only used for prediction. In a non-self-play setting this section of code can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
old_policy_range = 10 #how many older policies should be included in the pool to randomly pick from
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:-old_policy_range])-1)
fi = saved_models[:-old_policy_range][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model for tank " + str(self.model_num))
f.write("1\n")
f.close()
#Run the environment for n time steps
for _ in range(self.n_steps):
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
#If the model is not allowed to train it will only predict
#Choose between the RL policy action or the demonstrators action or even a random action
if(self.policy_decide(self.policy_prob)):#if(time_steps > self.thresh_steps):# and alive != 0):
rand_prob = 0.2
#Demonstrator action is sampled
if(self.model_num == 1):
control_actions = self.env.env_method("control_blue", self.obs)[0][0]
else:
control_actions = self.env.env_method("control_blue", self.obs)[0][1]
#Choose between random action and demonstrator action
if(random.random() < rand_prob):
control_actions = np.array([random.random(), random.random(), random.random()])
control_actions[1] = (control_actions[1] * (1 - (-1))) + (-1)
control_action_prob = rand_prob
else:
control_action_prob = 1.0 - rand_prob
control_actions[0] = (control_actions[0] * (1 - (-1))) + (-1)
control_actions[2] = (control_actions[2] * (1 - (-1))) + (-1)
AI_used.append(1)
else:
if(self.update_buffers == 0):
control_actions, _, _ = model.predict(self.obs, deterministic = False)
else:
#RL action is sampled
control_action_prob = 1.0
control_actions = actions
RL_used += 1
AI_used.append(0)
control_actions = control_actions.reshape((1, 3))
if(self.update_buffers == 1):
if(self.dones):
print("Current RL policy sampling probability: ", self.policy_prob, "Normalizing coefficient for importance sampling: ", self.norm_w)
#Keep a track of the mean episode rewards
if(self.ep_reward != []):
mean_ep_reward = np.mean(np.array(self.ep_reward))
self.cur_mean_reward += mean_ep_reward
#If the policy performed better this episode compared to previous episode then reduce the effect of the demonstrations by reducing norm_w
if(mean_ep_reward > self.prev_ep_reward):
self.norm_w = max(self.norm_w/10.0, 1e-6)
#If the policy performed worse this episode compared to previous episode then increase the effect of the demonstrations by increasing norm_w
else:
self.norm_w = min(self.norm_w*10, 1e-2)
print("Prev ep= ", self.prev_ep_reward, "Cur_ep= ", mean_ep_reward)
self.prev_ep_reward = mean_ep_reward
print("Prev mean= ", self.prev_mean_reward, "Cur_mean= ", self.cur_mean_reward)
self.ep_reward = []
episode = self.env.get_attr("episode")[0]
#After every 50 episodes, check if the policy is performing well enough to phase it more control. This metric can be modified
if(episode % 50 == 0 and episode != self.last_trust_update):
self.cur_mean_reward = self.cur_mean_reward/50.0
if(self.phase_condition(self.last_trust_update, self.cur_mean_reward, self.prev_mean_reward)):
self.policy_prob = min(self.policy_prob+self.get_phase_step(), 1.0)
#else:
#self.policy_prob = max(self.policy_prob-get_phase_step(), 0.1)
print("Prev mean= ", self.prev_mean_reward, "Cur mean= ", self.cur_mean_reward, "Mean Updates= ", self.mean_updates)
self.prev_mean_reward = max(((self.mean_updates-1)/self.mean_updates)*self.prev_mean_reward + (1/self.mean_updates)*self.cur_mean_reward, 0.0)
self.mean_updates += 1
self.cur_mean_reward = 0.0
self.last_trust_update = episode
#Get the action probability if the action is sampled randomly or by the demonstrator
if(control_action_prob != 1.0):
mean_act, std_act = self.model.proba_step(self.obs, self.states, self.dones)
action_probs = scipy.stats.norm(mean_act.flatten()[0], std_act.flatten()[0]).pdf(control_actions)
if(abs(control_action_prob - rand_prob) < 0.0001):
action_probs = np.array([0.5, 0.5, 0.5]) * control_action_prob #In the case of random actions, all theactions have equal probability
else:
action_probs = np.array([1.0, 1.0, 1.0]) * control_action_prob #Since the demonstrator is deterministic the probability of its action is always 1.0
neglogpacs = [-np.sum(np.log(action_probs))]
mb_obs.append(self.obs.copy())
mb_actions.append(control_actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(control_actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(rewards)
self.ep_reward.append(rewards)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
AI_used = np.asarray(AI_used, dtype=np.float32)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Proportions RL_used = "+str(RL_used)+" AI_used = "+str(self.n_steps-RL_used))
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, AI_used, self.norm_w, self.policy_prob
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | decentralized-long-respawn~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
print("Switching Training!!")
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, unshaped_reward, rew_frac = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
print("Allows update is true for " + str(model_num))
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(np.mean(unshaped_reward)) + "," + str(rew_frac) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
#self.obs[:] = env.reset()
self.obs = conn[0].get()
#print(self.obs)
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.rew_frac = 1.0
self.last_update = -1
self.lam = lam
self.gamma = gamma
self.conn = conn
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
#uncomment second line to enable reward phasing
def phase_condition(self, episode, last_update):
return False
#return (episode%100==0 and episode!=last_update)
def get_phase_step(self):
return 0.1
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
#If a model is not being trained but only used for prediction. In a non-self-play setting this can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:])-1)
fi = saved_models[:][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model")
f.write("1\n")
f.close()
else:
f = open("model_used_"+str(self.model_num)+".txt", "a+")
f.write("1\n")
f.close()
for _ in range(self.n_steps):
#If the model is not allowed to train it will only predict
if(self.update_buffers == 0):
actions, _, _ = model.predict(self.obs, deterministic = False)
else:
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
if(self.update_buffers == 1):
mb_obs.append(self.obs.copy())
mb_actions.append(actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
episode = self.env.get_attr("episode")[0]
if(self.phase_condition(episode, self.last_update)):
self.rew_frac = max(self.rew_frac-self.get_phase_step(), 0.0)
self.last_update = episode
if(self.update_buffers == 1):
unshaped_reward = rewards[0]
rewards = rewards[0] + self.rew_frac*rewards[1]
else:
rewards = rewards[0] #In a non-self-play setting, the opponents reward does not matter
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(unshaped_reward)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_rewards)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Phasing reward fraction: ", self.rew_frac)
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, mb_unshaped_reward, self.rew_frac
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | pburslemjr/Capstone | Temporal-decentralized-easeout~self_play_ppo2.py | import time
import random
import gym
import numpy as np
import tensorflow as tf
from os import walk
from stable_baselines import logger
from stable_baselines.common import explained_variance, ActorCriticRLModel, tf_util, SetVerbosity, TensorboardWriter
from stable_baselines.common.runners import AbstractEnvRunner
from stable_baselines.common.policies import ActorCriticPolicy, RecurrentActorCriticPolicy
from stable_baselines.common.schedules import get_schedule_fn
from stable_baselines.common.tf_util import total_episode_reward_logger
from stable_baselines.common.math_util import safe_mean
from typing import Union, Optional, Any
from stable_baselines.common.callbacks import BaseCallback
from stable_baselines.common.vec_env import VecEnv
from stable_baselines.common import make_vec_env
from stable_baselines import PPO2
from customPPO2 import CustomPPO2
from stable_baselines.common.policies import MlpPolicy
from gym import spaces
import scipy
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
#The code from the stable_baselines PPO2 is copied and edited as required
class self_play_ppo2(ActorCriticRLModel):
"""
Proximal Policy Optimization algorithm (GPU version).
Paper: https://arxiv.org/abs/1707.06347
:param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
:param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
:param gamma: (float) Discount factor
:param n_steps: (int) The number of steps to run for each environment per update
(i.e. batch size is n_steps * n_env where n_env is number of environment copies running in parallel)
:param ent_coef: (float) Entropy coefficient for the loss calculation
:param learning_rate: (float or callable) The learning rate, it can be a function
:param vf_coef: (float) Value function coefficient for the loss calculation
:param max_grad_norm: (float) The maximum value for the gradient clipping
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
:param nminibatches: (int) Number of training minibatches per update. For recurrent policies,
the number of environments run in parallel should be a multiple of nminibatches.
:param noptepochs: (int) Number of epoch when optimizing the surrogate
:param cliprange: (float or callable) Clipping parameter, it can be a function
:param cliprange_vf: (float or callable) Clipping parameter for the value function, it can be a function.
This is a parameter specific to the OpenAI implementation. If None is passed (default),
then `cliprange` (that is used for the policy) will be used.
IMPORTANT: this clipping depends on the reward scaling.
To deactivate value function clipping (and recover the original PPO implementation),
you have to pass a negative value (e.g. -1).
:param verbose: (int) the verbosity level: 0 none, 1 training information, 2 tensorflow debug
:param tensorboard_log: (str) the log location for tensorboard (if None, no logging)
:param _init_setup_model: (bool) Whether or not to build the network at the creation of the instance
:param policy_kwargs: (dict) additional arguments to be passed to the policy on creation
:param full_tensorboard_log: (bool) enable additional logging when using tensorboard
WARNING: this logging can take a lot of space quickly
:param seed: (int) Seed for the pseudo-random generators (python, numpy, tensorflow).
If None (default), use random seed. Note that if you want completely deterministic
results, you must set `n_cpu_tf_sess` to 1.
:param n_cpu_tf_sess: (int) The number of threads for TensorFlow operations
If None, the number of cpu of the current machine will be used.
"""
def __init__(self, policy, env, gamma=0.99, n_steps=128, ent_coef=0.01, learning_rate=2.5e-4, vf_coef=0.5,
max_grad_norm=0.5, lam=0.95, nminibatches=4, noptepochs=4, cliprange=0.2, cliprange_vf=None,
verbose=0, tensorboard_log=None, _init_setup_model=True, policy_kwargs=None,
full_tensorboard_log=False, seed=None, n_cpu_tf_sess=None):
self.learning_rate = learning_rate
self.cliprange = cliprange
self.cliprange_vf = cliprange_vf
self.n_steps = n_steps
self.ent_coef = ent_coef
self.vf_coef = vf_coef
self.max_grad_norm = max_grad_norm
self.gamma = gamma
self.lam = lam
self.nminibatches = nminibatches
self.noptepochs = noptepochs
self.tensorboard_log = tensorboard_log
self.full_tensorboard_log = full_tensorboard_log
self.action_ph = None
self.advs_ph = None
self.rewards_ph = None
self.old_neglog_pac_ph = None
self.old_vpred_ph = None
self.learning_rate_ph = None
self.clip_range_ph = None
self.entropy = None
self.vf_loss = None
self.pg_loss = None
self.approxkl = None
self.clipfrac = None
self._train = None
self.loss_names = None
self.train_model = None
self.act_model = None
self.value = None
self.n_batch = None
self.summary = None
super().__init__(policy=policy, env=env, verbose=verbose, requires_vec_env=True,
_init_setup_model=_init_setup_model, policy_kwargs=policy_kwargs,
seed=seed, n_cpu_tf_sess=n_cpu_tf_sess)
if _init_setup_model:
self.setup_model()
#Initialize the runner class
def _make_runner(self):
return Runner(env=self.env, model=self, n_steps=self.n_steps,
gamma=self.gamma, lam=self.lam, conn=self.conn)
def _get_pretrain_placeholders(self):
policy = self.act_model
if isinstance(self.action_space, gym.spaces.Discrete):
return policy.obs_ph, self.action_ph, policy.policy
return policy.obs_ph, self.action_ph, policy.deterministic_action
#This function is used to train the model by calculating its loss based on data collected
def setup_model(self):
with SetVerbosity(self.verbose):
assert issubclass(self.policy, ActorCriticPolicy), "Error: the input policy for the PPO2 model must be " \
"an instance of common.policies.ActorCriticPolicy."
self.n_batch = self.n_envs * self.n_steps
self.graph = tf.Graph()
with self.graph.as_default():
self.set_random_seed(self.seed)
self.sess = tf_util.make_session(num_cpu=self.n_cpu_tf_sess, graph=self.graph)
n_batch_step = None
n_batch_train = None
if issubclass(self.policy, RecurrentActorCriticPolicy):
assert self.n_envs % self.nminibatches == 0, "For recurrent policies, "\
"the number of environments run in parallel should be a multiple of nminibatches."
n_batch_step = self.n_envs
n_batch_train = self.n_batch // self.nminibatches
act_model = self.policy(self.sess, self.observation_space, self.action_space, self.n_envs, 1,
n_batch_step, reuse=False, **self.policy_kwargs)
with tf.variable_scope("train_model", reuse=True,
custom_getter=tf_util.outer_scope_getter("train_model")):
train_model = self.policy(self.sess, self.observation_space, self.action_space,
self.n_envs // self.nminibatches, self.n_steps, n_batch_train,
reuse=True, **self.policy_kwargs)
with tf.variable_scope("loss", reuse=False):
self.action_ph = train_model.pdtype.sample_placeholder([None], name="action_ph")
self.advs_ph = tf.placeholder(tf.float32, [None], name="advs_ph")
self.rewards_ph = tf.placeholder(tf.float32, [None], name="rewards_ph")
self.old_neglog_pac_ph = tf.placeholder(tf.float32, [None], name="old_neglog_pac_ph")
self.old_vpred_ph = tf.placeholder(tf.float32, [None], name="old_vpred_ph")
self.learning_rate_ph = tf.placeholder(tf.float32, [], name="learning_rate_ph")
self.clip_range_ph = tf.placeholder(tf.float32, [], name="clip_range_ph")
self.AI_used = tf.placeholder(tf.float32, [None], name="AI_used")
self.RL_used = tf.placeholder(tf.float32, [None], name="RL_used")
self.Importance_weight = tf.placeholder(tf.float32, [], name="Importance_weight")
neglogpac = train_model.proba_distribution.neglogp(self.action_ph)
self.entropy = tf.reduce_mean(train_model.proba_distribution.entropy())
vpred = train_model.value_flat
# Value function clipping: not present in the original PPO
if self.cliprange_vf is None:
# Default behavior (legacy from OpenAI baselines):
# use the same clipping as for the policy
self.clip_range_vf_ph = self.clip_range_ph
self.cliprange_vf = self.cliprange
elif isinstance(self.cliprange_vf, (float, int)) and self.cliprange_vf < 0:
# Original PPO implementation: no value function clipping
self.clip_range_vf_ph = None
else:
# Last possible behavior: clipping range
# specific to the value function
self.clip_range_vf_ph = tf.placeholder(tf.float32, [], name="clip_range_vf_ph")
if self.clip_range_vf_ph is None:
# No clipping
vpred_clipped = train_model.value_flat
else:
# Clip the different between old and new value
# NOTE: this depends on the reward scaling
vpred_clipped = self.old_vpred_ph + \
tf.clip_by_value(train_model.value_flat - self.old_vpred_ph,
- self.clip_range_vf_ph, self.clip_range_vf_ph)
vf_losses1 = tf.square(vpred - self.rewards_ph)
vf_losses2 = tf.square(vpred_clipped - self.rewards_ph)
self.vf_loss = .5 * tf.reduce_mean(tf.maximum(vf_losses1, vf_losses2))
ratio = tf.exp(self.old_neglog_pac_ph - neglogpac)
#Normal PPO policy loss
pg_losses = -self.advs_ph * ratio
pg_losses2 = -self.advs_ph * tf.clip_by_value(ratio, 1.0 - self.clip_range_ph, 1.0 +
self.clip_range_ph)
#self.pg_loss = tf.reduce_mean(tf.maximum(pg_losses, pg_losses2))
#Applied importance sampling
self.Z = tf.reduce_sum(tf.maximum(self.AI_used*ratio, tf.clip_by_value(self.AI_used*ratio, 1.0 - self.clip_range_ph, 1.0 + self.clip_range_ph)))
self.pg_sample_loss = (tf.reduce_sum(tf.maximum(self.AI_used*pg_losses, self.AI_used*pg_losses2)) / self.Z) + (self.Importance_weight)*tf.log(self.Z)
self.pg_rl_loss = tf.reduce_mean(tf.maximum(self.RL_used*pg_losses, self.RL_used*pg_losses2))
self.pg_loss = self.pg_sample_loss + self.pg_rl_loss
self.approxkl = .5 * tf.reduce_mean(tf.square(neglogpac - self.old_neglog_pac_ph))
self.clipfrac = tf.reduce_mean(tf.cast(tf.greater(tf.abs(ratio - 1.0),
self.clip_range_ph), tf.float32))
loss = self.pg_loss - self.entropy * self.ent_coef + self.vf_loss * self.vf_coef
tf.summary.scalar('entropy_loss', self.entropy)
tf.summary.scalar('policy_gradient_loss', self.pg_loss)
tf.summary.scalar('value_function_loss', self.vf_loss)
tf.summary.scalar('approximate_kullback-leibler', self.approxkl)
tf.summary.scalar('clip_factor', self.clipfrac)
tf.summary.scalar('loss', loss)
with tf.variable_scope('model'):
self.params = tf.trainable_variables()
if self.full_tensorboard_log:
for var in self.params:
tf.summary.histogram(var.name, var)
grads = tf.gradients(loss, self.params)
if self.max_grad_norm is not None:
grads, _grad_norm = tf.clip_by_global_norm(grads, self.max_grad_norm)
grads = list(zip(grads, self.params))
trainer = tf.train.AdamOptimizer(learning_rate=self.learning_rate_ph, epsilon=1e-5)
self._train = trainer.apply_gradients(grads)
self.loss_names = ['policy_loss', 'value_loss', 'policy_entropy', 'approxkl', 'clipfrac']
with tf.variable_scope("input_info", reuse=False):
tf.summary.scalar('discounted_rewards', tf.reduce_mean(self.rewards_ph))
tf.summary.scalar('learning_rate', tf.reduce_mean(self.learning_rate_ph))
tf.summary.scalar('advantage', tf.reduce_mean(self.advs_ph))
tf.summary.scalar('clip_range', tf.reduce_mean(self.clip_range_ph))
if self.clip_range_vf_ph is not None:
tf.summary.scalar('clip_range_vf', tf.reduce_mean(self.clip_range_vf_ph))
tf.summary.scalar('old_neglog_action_probability', tf.reduce_mean(self.old_neglog_pac_ph))
tf.summary.scalar('old_value_pred', tf.reduce_mean(self.old_vpred_ph))
if self.full_tensorboard_log:
tf.summary.histogram('discounted_rewards', self.rewards_ph)
tf.summary.histogram('learning_rate', self.learning_rate_ph)
tf.summary.histogram('advantage', self.advs_ph)
tf.summary.histogram('clip_range', self.clip_range_ph)
tf.summary.histogram('old_neglog_action_probability', self.old_neglog_pac_ph)
tf.summary.histogram('old_value_pred', self.old_vpred_ph)
if tf_util.is_image(self.observation_space):
tf.summary.image('observation', train_model.obs_ph)
else:
tf.summary.histogram('observation', train_model.obs_ph)
self.train_model = train_model
self.act_model = act_model
self.step = act_model.step
self.proba_step = act_model.proba_step
self.value = act_model.value
self.initial_state = act_model.initial_state
tf.global_variables_initializer().run(session=self.sess) # pylint: disable=E1101
self.summary = tf.summary.merge_all()
#This function is used to pass the data to calculate the various loss values, log and return them
def _train_step(self, learning_rate, cliprange, obs, returns, masks, actions, values, neglogpacs, AI_used, imp_weight, update,
writer, states=None, cliprange_vf=None):
"""
Training of PPO2 Algorithm
:param learning_rate: (float) learning rate
:param cliprange: (float) Clipping factor
:param obs: (np.ndarray) The current observation of the environment
:param returns: (np.ndarray) the rewards
:param masks: (np.ndarray) The last masks for done episodes (used in recurent policies)
:param actions: (np.ndarray) the actions
:param values: (np.ndarray) the values
:param neglogpacs: (np.ndarray) Negative Log-likelihood probability of Actions
:param update: (int) the current step iteration
:param writer: (TensorFlow Summary.writer) the writer for tensorboard
:param states: (np.ndarray) For recurrent policies, the internal state of the recurrent model
:return: policy gradient loss, value function loss, policy entropy,
approximation of kl divergence, updated clipping range, training update operation
:param cliprange_vf: (float) Clipping factor for the value function
"""
advs = returns - values
advs = (advs - advs.mean()) / (advs.std() + 1e-8)
RL_used = np.ones(AI_used.shape) - AI_used
td_map = {self.train_model.obs_ph: obs, self.action_ph: actions,
self.advs_ph: advs, self.rewards_ph: returns,
self.learning_rate_ph: learning_rate, self.clip_range_ph: cliprange,
self.old_neglog_pac_ph: neglogpacs, self.old_vpred_ph: values, self.AI_used: AI_used, self.RL_used: RL_used, self.Importance_weight: imp_weight}
if states is not None:
td_map[self.train_model.states_ph] = states
td_map[self.train_model.dones_ph] = masks
if cliprange_vf is not None and cliprange_vf >= 0:
td_map[self.clip_range_vf_ph] = cliprange_vf
if states is None:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
else:
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
if writer is not None:
# run loss backprop with summary, but once every 10 runs save the metadata (memory, compute time, ...)
if self.full_tensorboard_log and (1 + update) % 10 == 0:
run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map, options=run_options, run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % (update * update_fac))
else:
summary, policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.summary, self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train],
td_map)
writer.add_summary(summary, (update * update_fac))
else:
policy_loss, value_loss, policy_entropy, approxkl, clipfrac, _ = self.sess.run(
[self.pg_loss, self.vf_loss, self.entropy, self.approxkl, self.clipfrac, self._train], td_map)
return policy_loss, value_loss, policy_entropy, approxkl, clipfrac
#This is the main function that runs in a loop
#Model_num is used to differentiate between the two models. 1 is for evade and 2 is for attack
def learn(self, total_timesteps, iteration, model_num, conn, switch_freq, callback=None, log_interval=1, tb_log_name="PPO2",
reset_num_timesteps=True):
# Transform to callable if needed
self.conn = conn
self.learning_rate = get_schedule_fn(self.learning_rate)
self.cliprange = get_schedule_fn(self.cliprange)
cliprange_vf = get_schedule_fn(self.cliprange_vf)
new_tb_log = self._init_num_timesteps(reset_num_timesteps)
callback = self._init_callback(callback)
with SetVerbosity(self.verbose), TensorboardWriter(self.graph, self.tensorboard_log, tb_log_name, new_tb_log) \
as writer:
self._setup_learn()
t_first_start = time.time()
n_updates = total_timesteps // self.n_batch
prev_update = 0
callback.on_training_start(locals(), globals())
#We start by training model 1 and not allowing model 2 to update
if(model_num == 1):
allow_update = 1
else:
allow_update = 0
for update in range(1, n_updates + 1):
assert self.n_batch % self.nminibatches == 0, ("The number of minibatches (`nminibatches`) "
"is not a factor of the total number of samples "
"collected per rollout (`n_batch`), "
"some samples won't be used."
)
batch_size = self.n_batch // self.nminibatches
t_start = time.time()
frac = 0.0005#max(1.0 - 2*(update - 1.0) / n_updates, 0.00025)
lr_now = self.learning_rate(frac)
cliprange_now = self.cliprange(frac)
cliprange_vf_now = cliprange_vf(frac)
#Choose whether the model will be trained in this step or not. Every switch_freq steps the training shifts between model 1 and model 2
if(update%(switch_freq//self.n_batch) == 0):
if(allow_update == 1):
allow_update = 0
else:
allow_update = 1
if((allow_update != prev_update) and (update != 1)):
random.seed(1)
np.random.seed(1)
tf.set_random_seed(1)
print("RE-SEEDING")
prev_update = allow_update
callback.on_rollout_start()
# call the run function to get trajectory data
rollout = self.runner.run(model_num, allow_update, callback)
if(allow_update):
# Unpack
obs, returns, masks, actions, values, neglogpacs, states, ep_infos, true_reward, AI_used, imp_weight, policy_prob = rollout
callback.on_rollout_end()
# Early stopping due to the callback
if not self.runner.continue_training:
break
self.ep_info_buf.extend(ep_infos)
mb_loss_vals = []
if states is None and allow_update: # nonrecurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs, 1)
inds = np.arange(self.n_batch)
for epoch_num in range(self.noptepochs):
np.random.shuffle(inds)
for start in range(0, self.n_batch, batch_size):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_batch + start) // batch_size)
end = start + batch_size
mbinds = inds[start:end]
slices = (arr[mbinds] for arr in (obs, returns, masks, actions, values, neglogpacs, AI_used))
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, imp_weight, writer=writer,
update=timestep, cliprange_vf=cliprange_vf_now))
'''else: # recurrent version
update_fac = max(self.n_batch // self.nminibatches // self.noptepochs // self.n_steps, 1)
assert self.n_envs % self.nminibatches == 0
env_indices = np.arange(self.n_envs)
flat_indices = np.arange(self.n_envs * self.n_steps).reshape(self.n_envs, self.n_steps)
envs_per_batch = batch_size // self.n_steps
for epoch_num in range(self.noptepochs):
np.random.shuffle(env_indices)
for start in range(0, self.n_envs, envs_per_batch):
timestep = self.num_timesteps // update_fac + ((epoch_num *
self.n_envs + start) // envs_per_batch)
end = start + envs_per_batch
mb_env_inds = env_indices[start:end]
mb_flat_inds = flat_indices[mb_env_inds].ravel()
slices = (arr[mb_flat_inds] for arr in (obs, returns, masks, actions, values, neglogpacs))
mb_states = states[mb_env_inds]
mb_loss_vals.append(self._train_step(lr_now, cliprange_now, *slices, update=timestep,
writer=writer, states=mb_states,
cliprange_vf=cliprange_vf_now))'''
loss_vals = np.mean(mb_loss_vals, axis=0)
t_now = time.time()
fps = int(self.n_batch / (t_now - t_start))
if writer is not None:
total_episode_reward_logger(self.episode_reward,
true_reward.reshape((self.n_envs, self.n_steps)),
masks.reshape((self.n_envs, self.n_steps)),
writer, self.num_timesteps)
if self.verbose >= 1 and allow_update:
#log rewards and loss
print(np.mean(true_reward), np.shape(true_reward))
f = open("rewards_"+str(model_num)+".txt", "a+")
f.write(str(np.mean(true_reward)) + "," + str(policy_prob) + "\n")
f.close()
explained_var = explained_variance(values, returns)
logger.logkv("serial_timesteps", update * self.n_steps)
logger.logkv("n_updates", update)
logger.logkv("total_timesteps", (iteration * total_timesteps) + self.num_timesteps)
logger.logkv("fps", fps)
logger.logkv("explained_variance", float(explained_var))
if len(self.ep_info_buf) > 0 and len(self.ep_info_buf[0]) > 0:
logger.logkv('ep_reward_mean', safe_mean([ep_info['r'] for ep_info in self.ep_info_buf]))
logger.logkv('ep_len_mean', safe_mean([ep_info['l'] for ep_info in self.ep_info_buf]))
logger.logkv('time_elapsed', t_start - t_first_start)
for (loss_val, loss_name) in zip(loss_vals, self.loss_names):
logger.logkv(loss_name, loss_val)
if(loss_name == "value_loss"):
f1 = open("loss_"+str(model_num)+".txt", "a+")
f1.write(str(loss_val) + "\n")
f1.close()
logger.dumpkvs()
callback.on_training_end()
return self
def save(self, save_path, cloudpickle=False):
data = {
"gamma": self.gamma,
"n_steps": self.n_steps,
"vf_coef": self.vf_coef,
"ent_coef": self.ent_coef,
"max_grad_norm": self.max_grad_norm,
"learning_rate": self.learning_rate,
"lam": self.lam,
"nminibatches": self.nminibatches,
"noptepochs": self.noptepochs,
"cliprange": self.cliprange,
"cliprange_vf": self.cliprange_vf,
"verbose": self.verbose,
"policy": self.policy,
"observation_space": self.observation_space,
"action_space": self.action_space,
"n_envs": self.n_envs,
"n_cpu_tf_sess": self.n_cpu_tf_sess,
"seed": self.seed,
"_vectorize_action": self._vectorize_action,
"policy_kwargs": self.policy_kwargs
}
params_to_save = self.get_parameters()
self._save_to_file(save_path, data=data, params=params_to_save, cloudpickle=cloudpickle)
#This function is used to predict the action the model would take for a given observation, as well as the value of that state decided by the learnt value function
def predict(self, observation, state=None, mask=None, deterministic=False):
if state is None:
state = self.initial_state
if mask is None:
mask = [False for _ in range(self.n_envs)]
observation = np.array(observation)
vectorized_env = self._is_vectorized_observation(observation, self.observation_space)
observation = observation.reshape((-1,) + self.observation_space.shape)
actions, values, states, _ = self.step(observation, state, mask, deterministic=deterministic)
clipped_actions = actions
# Clip the actions to avoid out of bound error
if isinstance(self.action_space, gym.spaces.Box):
clipped_actions = np.clip(actions, self.action_space.low, self.action_space.high)
if not vectorized_env:
if state is not None:
raise ValueError("Error: The environment must be vectorized when using recurrent policies.")
clipped_actions = clipped_actions[0]
return clipped_actions, values, states
class Runner(AbstractEnvRunner):
def __init__(self, *, env: Union[gym.Env, VecEnv], model: 'BaseRLModel', n_steps, gamma, lam, conn):
"""
A runner to learn the policy of an environment for a model
:param env: (Gym environment) The environment to learn from
:param model: (Model) The model to learn
:param n_steps: (int) The number of steps to run for each environment
:param gamma: (float) Discount factor
:param lam: (float) Factor for trade-off of bias vs variance for Generalized Advantage Estimator
"""
self.env = env
self.model = model
n_envs = env.num_envs
self.batch_ob_shape = (n_envs * n_steps,) + env.observation_space.shape
self.obs = np.zeros((n_envs,) + env.observation_space.shape, dtype=env.observation_space.dtype.name)
self.obs = conn[0].get()
conn[0].task_done()
self.n_steps = n_steps
self.states = model.initial_state
self.dones = [False for _ in range(n_envs)]
self.callback = None # type: Optional[BaseCallback]
self.continue_training = True
self.n_envs = n_envs
self.lam = lam
self.gamma = gamma
self.conn = conn
self.policy_prob = 0.0
self.norm_w = 1e-3
self.last_trust_update = -1
self.prev_mean_reward = 0.0
self.prev_ep_reward = 0.0
self.cur_mean_reward = 0.0
self.mean_updates = 1
self.ep_reward = []
def run(self, model_num, allow_update, callback: Optional[BaseCallback] = None) -> Any:
"""
Collect experience.
:param callback: (Optional[BaseCallback]) The callback that will be called
at each environment step.
"""
self.callback = callback
self.continue_training = True
self.model_num = model_num
self.update_buffers = allow_update
return self._run()
def policy_decide(self, policy_prob):
return np.random.rand() > policy_prob
def phase_condition(self, last_trust_update, cur_mean_reward, prev_mean_reward):
return last_trust_update < 0 or (cur_mean_reward >= prev_mean_reward)
# def get_phase_step(self):
# return 0.1
def get_phased_prob(self, episode):
if (episode > 4000):
return 1.0
else:
x = episode / 4000
return x ** 5
def _run(self):
"""
Run a learning step of the model
:return:
- observations: (np.ndarray) the observations
- rewards: (np.ndarray) the rewards
- masks: (numpy bool) whether an episode is over or not
- actions: (np.ndarray) the actions
- values: (np.ndarray) the value function output
- negative log probabilities: (np.ndarray)
- states: (np.ndarray) the internal states of the recurrent policies
- infos: (dict) the extra information of the model
"""
# mb stands for minibatch
mb_obs, mb_rewards, mb_actions, mb_values, mb_dones, mb_neglogpacs, mb_unshaped_reward = [], [], [], [], [], [], []
mb_states = self.states
ep_infos = []
model = self.model
RL_used = 0
AI_used = []
#If a model is not being trained but only used for prediction. In a non-self-play setting this section of code can be ignored.
if(self.update_buffers == 0):
filenames = next(walk("."), (None, None, []))[2]
#list of all previous saved models
saved_models = [ f for f in filenames if "Model_"+str(self.model_num) in f]
saved_models.sort()
model_decider = random.random()
f = open("model_used_"+str(self.model_num)+".txt", "a+")
#Randomly pick from among older versions of the model. This is used to train a model against older versions of its opponent to prevent overfitting
old_policy_range = 10 #how many older policies should be included in the pool to randomly pick from
if(model_decider > 0.0 and saved_models != []):
ind = random.randint(0, len(saved_models[:-old_policy_range])-1)
fi = saved_models[:-old_policy_range][ind]
print("Using file "+fi, ind, model_decider)
model = self_play_ppo2.load(fi)
model.set_env(self.env)
f.write("0\n")
else:
print("Using latest model for tank " + str(self.model_num))
f.write("1\n")
f.close()
#Run the environment for n time steps
for _ in range(self.n_steps):
actions, values, self.states, neglogpacs = model.step(self.obs, self.states, self.dones)
#If the model is not allowed to train it will only predict
#Choose between the RL policy action or the demonstrators action or even a random action
if(self.policy_decide(self.policy_prob)):#if(time_steps > self.thresh_steps):# and alive != 0):
rand_prob = 0.2
#Demonstrator action is sampled
if(self.model_num == 1):
control_actions = self.env.env_method("control_blue", self.obs)[0][0]
else:
control_actions = self.env.env_method("control_blue", self.obs)[0][1]
#Choose between random action and demonstrator action
if(random.random() < rand_prob):
control_actions = np.array([random.random(), random.random(), random.random()])
control_actions[1] = (control_actions[1] * (1 - (-1))) + (-1)
control_action_prob = rand_prob
else:
control_action_prob = 1.0 - rand_prob
control_actions[0] = (control_actions[0] * (1 - (-1))) + (-1)
control_actions[2] = (control_actions[2] * (1 - (-1))) + (-1)
AI_used.append(1)
else:
if(self.update_buffers == 0):
control_actions, _, _ = model.predict(self.obs, deterministic = False)
else:
#RL action is sampled
control_action_prob = 1.0
control_actions = actions
RL_used += 1
AI_used.append(0)
control_actions = control_actions.reshape((1, 3))
if(self.update_buffers == 1):
if(self.dones):
print("Current RL policy sampling probability: ", self.policy_prob, "Normalizing coefficient for importance sampling: ", self.norm_w)
#Keep a track of the mean episode rewards
if(self.ep_reward != []):
mean_ep_reward = np.mean(np.array(self.ep_reward))
self.cur_mean_reward += mean_ep_reward
#If the policy performed better this episode compared to previous episode then reduce the effect of the demonstrations by reducing norm_w
if(mean_ep_reward > self.prev_ep_reward):
self.norm_w = max(self.norm_w/10.0, 1e-6)
#If the policy performed worse this episode compared to previous episode then increase the effect of the demonstrations by increasing norm_w
else:
self.norm_w = min(self.norm_w*10, 1e-2)
print("Prev ep= ", self.prev_ep_reward, "Cur_ep= ", mean_ep_reward)
self.prev_ep_reward = mean_ep_reward
print("Prev mean= ", self.prev_mean_reward, "Cur_mean= ", self.cur_mean_reward)
self.ep_reward = []
episode = self.env.get_attr("episode")[0]
#After every episode, check if the policy is performing well enough to phase it more control. This metric can be modified
if(episode % 1 == 0 and episode != self.last_trust_update):
self.cur_mean_reward = self.cur_mean_reward/1.0
if(self.phase_condition(self.last_trust_update, self.cur_mean_reward, self.prev_mean_reward)):
self.policy_prob = min(self.get_phased_prob(episode), 1.0)
#else:
#self.policy_prob = max(self.policy_prob-get_phase_step(), 0.1)
print("Prev mean= ", self.prev_mean_reward, "Cur mean= ", self.cur_mean_reward, "Mean Updates= ", self.mean_updates)
self.prev_mean_reward = max(((self.mean_updates-1)/self.mean_updates)*self.prev_mean_reward + (1/self.mean_updates)*self.cur_mean_reward, 0.0)
self.mean_updates += 1
self.cur_mean_reward = 0.0
self.last_trust_update = episode
#Get the action probability if the action is sampled randomly or by the demonstrator
if(control_action_prob != 1.0):
mean_act, std_act = self.model.proba_step(self.obs, self.states, self.dones)
action_probs = scipy.stats.norm(mean_act.flatten()[0], std_act.flatten()[0]).pdf(control_actions)
if(abs(control_action_prob - rand_prob) < 0.0001):
action_probs = np.array([0.5, 0.5, 0.5]) * control_action_prob #In the case of random actions, all theactions have equal probability
else:
action_probs = np.array([1.0, 1.0, 1.0]) * control_action_prob #Since the demonstrator is deterministic the probability of its action is always 1.0
neglogpacs = [-np.sum(np.log(action_probs))]
mb_obs.append(self.obs.copy())
mb_actions.append(control_actions)
mb_values.append(values)
mb_neglogpacs.append(neglogpacs)
mb_dones.append(self.dones)
#Communicate the action to be taken to the main training program
self.conn[1].put(control_actions)
self.conn[1].join()
#Recieve the new observation and reward after taking the action
self.obs[:], rewards, self.dones, infos, clipped_actions = self.conn[0].get()
self.conn[0].task_done()
actions = clipped_actions
if(self.update_buffers == 1):
self.model.num_timesteps += self.n_envs
if self.callback is not None:
# Abort training early
self.callback.update_locals(locals())
if self.callback.on_step() is False:
self.continue_training = False
# Return dummy values
return [None] * 9
for info in infos:
maybe_ep_info = info.get('episode')
if maybe_ep_info is not None:
ep_infos.append(maybe_ep_info)
mb_rewards.append(rewards)
mb_unshaped_reward.append(rewards)
self.ep_reward.append(rewards)
if(self.update_buffers == 0):
return [], [], [], [], [], [], [], [], []
# batch of steps to batch of rollouts
mb_obs = np.asarray(mb_obs, dtype=self.obs.dtype)
mb_rewards = np.asarray(mb_rewards, dtype=np.float32)
mb_rewards = np.reshape(mb_rewards, (self.n_steps, 1))
mb_unshaped_reward = np.asarray(mb_unshaped_reward, dtype=np.float32)
mb_unshaped_reward = np.reshape(mb_unshaped_reward, (self.n_steps, 1))
mb_actions = np.asarray(mb_actions)
mb_values = np.asarray(mb_values, dtype=np.float32)
mb_neglogpacs = np.asarray(mb_neglogpacs, dtype=np.float32)
mb_dones = np.asarray(mb_dones, dtype=np.bool)
last_values = self.model.value(self.obs, self.states, self.dones)
AI_used = np.asarray(AI_used, dtype=np.float32)
# discount/bootstrap off value fn
mb_advs = np.zeros_like(mb_rewards)
true_reward = np.copy(mb_unshaped_reward)
last_gae_lam = 0
for step in reversed(range(self.n_steps)):
if step == self.n_steps - 1:
nextnonterminal = 1.0 - self.dones
nextvalues = last_values
else:
nextnonterminal = 1.0 - mb_dones[step + 1]
nextvalues = mb_values[step + 1]
delta = mb_rewards[step] + self.gamma * nextvalues * nextnonterminal - mb_values[step]
mb_advs[step] = last_gae_lam = delta + self.gamma * self.lam * nextnonterminal * last_gae_lam
mb_returns = mb_advs + mb_values
true_reward = np.reshape(true_reward, (self.n_steps, 1))
mb_dones = np.reshape(mb_dones, (self.n_steps, 1))
print("Proportions RL_used = "+str(RL_used)+" AI_used = "+str(self.n_steps-RL_used))
mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward = \
map(swap_and_flatten, (mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, true_reward))
return mb_obs, mb_returns, mb_dones, mb_actions, mb_values, mb_neglogpacs, mb_states, ep_infos, true_reward, AI_used, self.norm_w, self.policy_prob
# obs, returns, masks, actions, values, neglogpacs, states = runner.run()
def swap_and_flatten(arr):
"""
swap and then flatten axes 0 and 1
:param arr: (np.ndarray)
:return: (np.ndarray)
"""
shape = arr.shape
return arr.swapaxes(0, 1).reshape(shape[0] * shape[1], *shape[2:])
| [] |
2024-01-10 | my-test-org883/ChatGPT | src~asyncChatGPT~asyncChatGPT.py | # Author: @[email protected]
# License: MIT
# Description: A Python wrapper for OpenAI's chatbot API
import json
import uuid
import asyncio
import httpx
from OpenAIAuth.OpenAIAuth import OpenAIAuth, Debugger
def generate_uuid() -> str:
"""
Generates a UUID for the session -- Internal use only
:return: str
"""
uid = str(uuid.uuid4())
return uid
class Chatbot:
"""
Initializes the chatbot
See wiki for the configuration json:
https://github.com/acheong08/ChatGPT/wiki/Setup
:param config: The configuration json
:type config: :obj:`json`
:param conversation_id: The conversation ID
:type conversation_id: :obj:`str`, optional
:param debug: Whether to enable debug mode
:type debug: :obj:`bool`, optional
:param refresh: Whether to refresh the session
:type refresh: :obj:`bool`, optional
:return: None or Exception
"""
config: json
conversation_id: str
parent_id: str
base_url: str
headers: dict
conversation_id_prev: str
parent_id_prev: str
def __init__(self, config, conversation_id=None, debug=False, refresh=True) -> Exception:
self.debugger = Debugger(debug)
self.debug = debug
self.config = config
self.conversation_id = conversation_id
self.parent_id = generate_uuid()
self.base_url = "https://chat.openai.com/"
if ("session_token" in config or ("email" in config and "password" in config)) and refresh:
self.refresh_session()
if "Authorization" in config:
self.refresh_headers()
def reset_chat(self) -> None:
"""
Resets the conversation ID and parent ID
:return: None
"""
self.conversation_id = None
self.parent_id = generate_uuid()
def refresh_headers(self) -> None:
"""
Refreshes the headers -- Internal use only
:return: None
"""
if "Authorization" not in self.config:
self.config["Authorization"] = ""
elif self.config["Authorization"] is None:
self.config["Authorization"] = ""
self.headers = {
"Host": "chat.openai.com",
"Accept": "text/event-stream",
"Authorization": "Bearer " + self.config["Authorization"],
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) "
"Version/16.1 Safari/605.1.15",
"X-Openai-Assistant-App-Id": "",
"Connection": "close",
"Accept-Language": "en-US,en;q=0.9",
"Referer": "https://chat.openai.com/chat",
}
async def get_chat_stream(self, data) -> None:
"""
Generator for chat stream -- Internal use only
:param data: The data to send
:return: None
"""
s = httpx.AsyncClient()
async with s.stream(
'POST',
self.base_url + "backend-api/conversation",
headers=self.headers,
data=json.dumps(data),
timeout=100,
)as response:
async for line in response.aiter_lines():
try:
if line == "":
continue
line = line[6:]
line = json.loads(line)
try:
message = line["message"]["content"]["parts"][0]
self.conversation_id = line["conversation_id"]
self.parent_id = line["message"]["id"]
except:
continue
yield {
"message": message,
"conversation_id": self.conversation_id,
"parent_id": self.parent_id,
}
except:
continue
async def get_chat_text(self, data) -> dict:
"""
Gets the chat response as text -- Internal use only
:param data: The data to send
:return: The chat response
"""
# Create request session
s = httpx.Client(http2=True)
async with httpx.AsyncClient() as s:
# set headers
s.headers = self.headers
# Set multiple cookies
if "session_token" in self.config:
s.cookies.set(
"__Secure-next-auth.session-token",
self.config["session_token"],
)
s.cookies.set(
"__Secure-next-auth.callback-url",
self.base_url,
)
# Set proxies
if self.config.get("proxy", "") != "":
s.proxies = {
"http": self.config["proxy"],
"https": self.config["proxy"],
}
response = await s.post(
self.base_url + "backend-api/conversation",
data=json.dumps(data),
timeout=100,
)
try:
response = response.text.splitlines()[-4]
response = response[6:]
except Exception as exc:
self.debugger.log("Incorrect response from OpenAI API")
self.debugger.log(response.text)
try:
resp = response.json()
if resp['detail']['code'] == "invalid_api_key":
if "email" in self.config and "password" in self.config:
self.refresh_session()
return self.get_chat_text(data)
else:
raise Exception(
"Missing necessary credentials") from exc
except Exception as exc2:
raise Exception("Not a JSON response") from exc2
raise Exception("Incorrect response from OpenAI API") from exc
response = json.loads(response)
self.parent_id = response["message"]["id"]
self.conversation_id = response["conversation_id"]
message = response["message"]["content"]["parts"][0]
return {
"message": message,
"conversation_id": self.conversation_id,
"parent_id": self.parent_id,
}
# Gets the chat response
async def get_chat_response(self, prompt, output="text") -> dict or None:
"""
Gets the chat response
:param prompt: The message sent to the chatbot
:type prompt: :obj:`str`
:param output: The output type `text` or `stream`
:type output: :obj:`str`, optional
:return: The chat response `{"message": "Returned messages", "conversation_id": "conversation ID", "parent_id": "parent ID"}`
:rtype: :obj:`dict` or :obj:`None` or :obj:`Exception`
"""
data = {
"action": "next",
"messages": [
{
"id": str(generate_uuid()),
"role": "user",
"content": {"content_type": "text", "parts": [prompt]},
},
],
"conversation_id": self.conversation_id,
"parent_message_id": self.parent_id,
"model": "text-davinci-002-render",
}
self.conversation_id_prev = self.conversation_id
self.parent_id_prev = self.parent_id
if output == "text":
return await self.get_chat_text(data)
elif output == "stream":
return self.get_chat_stream(data)
else:
raise ValueError("Output must be either 'text' or 'stream'")
def rollback_conversation(self) -> None:
"""
Rollbacks the conversation
:return: None
"""
self.conversation_id = self.conversation_id_prev
self.parent_id = self.parent_id_prev
def refresh_session(self) -> Exception:
"""
Refreshes the session
:return: None or Exception
"""
if (
"session_token" not in self.config
and ("email" not in self.config or "password" not in self.config)
and "Authorization" not in self.config
):
error = ValueError("No tokens provided")
self.debugger.log(error)
raise error
elif "session_token" in self.config:
if (
self.config["session_token"] is None
or self.config["session_token"] == ""
):
raise ValueError("No tokens provided")
s = httpx.Client(http2=True)
if self.config.get("proxy", "") != "":
s.proxies = {
"http": self.config["proxy"],
"https": self.config["proxy"],
}
# Set cookies
s.cookies.set(
"__Secure-next-auth.session-token",
self.config["session_token"],
)
# s.cookies.set("__Secure-next-auth.csrf-token", self.config['csrf_token'])
response = s.get(
self.base_url + "api/auth/session",
headers={
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, "
"like Gecko) Version/16.1 Safari/605.1.15 ",
},
)
if response.status_code != 200:
self.debugger.log("Invalid status code")
self.debugger.log(response.status_code)
raise Exception("Wrong response code")
try:
self.config["session_token"] = response.cookies.get(
"__Secure-next-auth.session-token",
)
self.config["Authorization"] = response.json()["accessToken"]
self.refresh_headers()
except Exception as exc:
print("Error refreshing session")
self.debugger.log("Response: '" + str(response.text) + "'")
self.debugger.log(response.status_code)
# Check if response JSON is empty
if response.json() == {}:
self.debugger.log("Empty response")
self.debugger.log("Probably invalid session token")
if 'email' in self.config and 'password' in self.config:
del self.config['session_token']
self.login(self.config['email'],
self.config['password'])
return
else:
raise ValueError(
"No email and password provided") from exc
raise Exception("Error refreshing session") from exc
elif "email" in self.config and "password" in self.config:
try:
self.login(self.config["email"], self.config["password"])
except Exception as exc:
self.debugger.log("Login failed")
raise exc
elif "Authorization" in self.config:
self.refresh_headers()
return
else:
raise ValueError("No tokens provided")
def login(self, email, password) -> None:
"""
Logs in to OpenAI
:param email: The email
:type email: :obj:`str`
:param password: The password
:type password: :obj:`str`
:return: None
"""
self.debugger.log("Logging in...")
use_proxy = False
proxy = None
if "proxy" in self.config:
if self.config["proxy"] != "":
use_proxy = True
proxy = self.config["proxy"]
auth = OpenAIAuth(email, password, use_proxy, proxy, debug=self.debug)
try:
auth.begin()
except Exception as exc:
# if ValueError with e as "Captcha detected" fail
if exc == "Captcha detected":
self.debugger.log(
"Captcha not supported. Use session tokens instead.")
raise ValueError("Captcha detected") from exc
raise exc
if auth.access_token is not None:
self.config["Authorization"] = auth.access_token
if auth.session_token is not None:
self.config["session_token"] = auth.session_token
else:
possible_tokens = auth.session.cookies.get(
"__Secure-next-auth.session-token",
)
if possible_tokens is not None:
if len(possible_tokens) > 1:
self.config["session_token"] = possible_tokens[0]
else:
try:
self.config["session_token"] = possible_tokens
except Exception as exc:
raise Exception("Error logging in") from exc
self.refresh_headers()
else:
raise Exception("Error logging in")
| [
"text",
"content_type"
] |
2024-01-10 | my-test-org883/ChatGPT | src~revChatGPT~revChatGPT.py | # Author: @[email protected]
# License: MIT
# Description: A Python wrapper for OpenAI's chatbot API
import json
import uuid
import requests
from OpenAIAuth.OpenAIAuth import OpenAIAuth, Debugger
def generate_uuid() -> str:
"""
Generates a UUID for the session -- Internal use only
:return: str
"""
uid = str(uuid.uuid4())
return uid
class Chatbot:
"""
Initializes the chatbot
See wiki for the configuration json:
https://github.com/acheong08/ChatGPT/wiki/Setup
:param config: The configuration json
:type config: :obj:`json`
:param conversation_id: The conversation ID
:type conversation_id: :obj:`str`, optional
:param debug: Whether to enable debug mode
:type debug: :obj:`bool`, optional
:param refresh: Whether to refresh the session
:type refresh: :obj:`bool`, optional
:return: None or Exception
"""
config: json
conversation_id: str
parent_id: str
base_url: str
headers: dict
conversation_id_prev: str
parent_id_prev: str
def __init__(self, config, conversation_id=None, debug=False, refresh=True) -> Exception:
self.debugger = Debugger(debug)
self.debug = debug
self.config = config
self.conversation_id = conversation_id
self.parent_id = generate_uuid()
self.base_url = "https://chat.openai.com/"
if ("session_token" in config or ("email" in config and "password" in config)) and refresh:
self.refresh_session()
if "Authorization" in config:
self.refresh_headers()
def reset_chat(self) -> None:
"""
Resets the conversation ID and parent ID
:return: None
"""
self.conversation_id = None
self.parent_id = generate_uuid()
def refresh_headers(self) -> None:
"""
Refreshes the headers -- Internal use only
:return: None
"""
if "Authorization" not in self.config:
self.config["Authorization"] = ""
elif self.config["Authorization"] is None:
self.config["Authorization"] = ""
self.headers = {
"Host": "chat.openai.com",
"Accept": "text/event-stream",
"Authorization": "Bearer " + self.config["Authorization"],
"Content-Type": "application/json",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) "
"Version/16.1 Safari/605.1.15",
"X-Openai-Assistant-App-Id": "",
"Connection": "close",
"Accept-Language": "en-US,en;q=0.9",
"Referer": "https://chat.openai.com/chat",
}
def get_chat_stream(self, data) -> None:
"""
Generator for chat stream -- Internal use only
:param data: The data to send
:return: None
"""
response = requests.post(
self.base_url+"backend-api/conversation",
headers=self.headers,
data=json.dumps(data),
stream=True,
timeout=100,
)
for line in response.iter_lines():
try:
line = line.decode("utf-8")
if line == "":
continue
line = line[6:]
line = json.loads(line)
try:
message = line["message"]["content"]["parts"][0]
self.conversation_id = line["conversation_id"]
self.parent_id = line["message"]["id"]
except: # This needs fixing. Automatic detect blank lines and done lines
continue
yield {
"message": message,
"conversation_id": self.conversation_id,
"parent_id": self.parent_id,
}
except: # Not sure what error occurs here. Needs looking into
continue
def get_chat_text(self, data) -> dict:
"""
Gets the chat response as text -- Internal use only
:param data: The data to send
:return: The chat response
"""
# Create request session
s = requests.Session()
# set headers
s.headers = self.headers
# Set multiple cookies
if "session_token" in self.config:
s.cookies.set(
"__Secure-next-auth.session-token",
self.config["session_token"],
)
s.cookies.set(
"__Secure-next-auth.callback-url",
"https://chat.openai.com/",
)
# Set proxies
if self.config.get("proxy", "") != "":
s.proxies = {
"http": self.config["proxy"],
"https": self.config["proxy"],
}
response = s.post(
self.base_url+"backend-api/conversation",
data=json.dumps(data),
)
try:
response = response.text.splitlines()[-4]
response = response[6:]
except Exception as exc:
self.debugger.log("Incorrect response from OpenAI API")
try:
resp = response.json()
self.debugger.log(resp)
if resp['detail']['code'] == "invalid_api_key" or resp['detail']['code'] == "token_expired":
if "email" in self.config and "password" in self.config:
self.refresh_session()
return self.get_chat_text(data)
else:
self.debugger.log("Missing necessary credentials")
raise Exception(
"Missing necessary credentials") from exc
except Exception as exc2:
self.debugger.log(response.text)
raise Exception("Not a JSON response") from exc2
raise Exception("Incorrect response from OpenAI API") from exc
response = json.loads(response)
self.parent_id = response["message"]["id"]
self.conversation_id = response["conversation_id"]
message = response["message"]["content"]["parts"][0]
return {
"message": message,
"conversation_id": self.conversation_id,
"parent_id": self.parent_id,
}
def get_chat_response(self, prompt: str, output="text") -> dict or None:
"""
Gets the chat response
:param prompt: The message sent to the chatbot
:type prompt: :obj:`str`
:param output: The output type `text` or `stream`
:type output: :obj:`str`, optional
:return: The chat response `{"message": "Returned messages", "conversation_id": "conversation ID", "parent_id": "parent ID"}`
:rtype: :obj:`dict` or :obj:`None` or :obj:`Exception`
"""
data = {
"action": "next",
"messages": [
{
"id": str(generate_uuid()),
"role": "user",
"content": {"content_type": "text", "parts": [prompt]},
},
],
"conversation_id": self.conversation_id,
"parent_message_id": self.parent_id,
"model": "text-davinci-002-render",
}
self.conversation_id_prev = self.conversation_id
self.parent_id_prev = self.parent_id
if output == "text":
return self.get_chat_text(data)
elif output == "stream":
return self.get_chat_stream(data)
else:
raise ValueError("Output must be either 'text' or 'stream'")
def rollback_conversation(self) -> None:
"""
Rollbacks the conversation
:return: None
"""
self.conversation_id = self.conversation_id_prev
self.parent_id = self.parent_id_prev
def refresh_session(self) -> Exception:
"""
Refreshes the session
:return: None or Exception
"""
if (
"session_token" not in self.config
and ("email" not in self.config or "password" not in self.config)
and "Authorization" not in self.config
):
error = ValueError("No tokens provided")
self.debugger.log(error)
raise error
elif "session_token" in self.config:
if (
self.config["session_token"] is None
or self.config["session_token"] == ""
):
raise ValueError("No tokens provided")
s = requests.Session()
if self.config.get("proxy", "") != "":
s.proxies = {
"http": self.config["proxy"],
"https": self.config["proxy"],
}
# Set cookies
s.cookies.set(
"__Secure-next-auth.session-token",
self.config["session_token"],
)
# s.cookies.set("__Secure-next-auth.csrf-token", self.config['csrf_token'])
response = s.get(
self.base_url+"api/auth/session",
headers={
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, "
"like Gecko) Version/16.1 Safari/605.1.15 ",
},
)
if response.status_code != 200:
self.debugger.log("Invalid status code")
self.debugger.log(response.status_code)
raise Exception("Wrong response code")
try:
self.config["session_token"] = response.cookies.get(
"__Secure-next-auth.session-token",
)
self.config["Authorization"] = response.json()["accessToken"]
self.refresh_headers()
except Exception as exc:
print("Error refreshing session")
self.debugger.log("Response: '" + str(response.text) + "'")
self.debugger.log(response.status_code)
# Check if response JSON is empty
if response.json() == {}:
self.debugger.log("Empty response")
self.debugger.log("Probably invalid session token")
if 'email' in self.config and 'password' in self.config:
del self.config['session_token']
self.login(self.config['email'],
self.config['password'])
return
else:
raise ValueError(
"No email and password provided") from exc
raise Exception("Error refreshing session") from exc
elif "email" in self.config and "password" in self.config:
try:
self.login(self.config["email"], self.config["password"])
except Exception as exc:
self.debugger.log("Login failed")
raise exc
elif "Authorization" in self.config:
self.refresh_headers()
return
else:
raise ValueError("No tokens provided")
def login(self, email: str, password: str) -> None:
"""
Logs in to OpenAI
:param email: The email
:type email: :obj:`str`
:param password: The password
:type password: :obj:`str`
:return: None
"""
self.debugger.log("Logging in...")
use_proxy = False
proxy = None
if "proxy" in self.config:
if self.config["proxy"] != "":
use_proxy = True
proxy = self.config["proxy"]
auth = OpenAIAuth(email, password, use_proxy, proxy, debug=self.debug)
try:
auth.begin()
except Exception as exc:
# if ValueError with e as "Captcha detected" fail
if exc == "Captcha detected":
self.debugger.log(
"Captcha not supported. Use session tokens instead.")
raise ValueError("Captcha detected") from exc
raise exc
if auth.access_token is not None:
self.config["Authorization"] = auth.access_token
if auth.session_token is not None:
self.config["session_token"] = auth.session_token
else:
possible_tokens = auth.session.cookies.get(
"__Secure-next-auth.session-token",
)
if possible_tokens is not None:
if len(possible_tokens) > 1:
self.config["session_token"] = possible_tokens[0]
else:
try:
self.config["session_token"] = possible_tokens
except Exception as exc:
raise Exception("Error logging in") from exc
self.refresh_headers()
else:
raise Exception("Error logging in")
| [
"text",
"content_type"
] |
2024-01-10 | AI3LabsX/DailyAdvisory | tgbot~handlers~messages.py | """
This module contains handlers that handle messages from users
Handlers:
echo_handler - echoes the user's message
Note:
Handlers are imported into the __init__.py package handlers,
where a tuple of HANDLERS is assembled for further registration in the application
"""
import asyncio
import os
from typing import Any
import openai
import tiktoken
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.memory import ConversationEntityMemory
from langchain.memory.prompt import ENTITY_MEMORY_CONVERSATION_TEMPLATE
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.tools import Tool
from langchain.utilities import GoogleSearchAPIWrapper
from langchain.vectorstores import FAISS
from tgbot.utils.environment import env
GOOGLE_CSE_ID = os.environ["GOOGLE_CSE_ID"]
GOOGLE_API_KEY = os.environ["GOOGLE_API_KEY"]
openai.api_key = env.get_openai_api()
def init_conversation():
"""
Initialize a conversation for a given chat_id.
"""
llm = ChatOpenAI(temperature=0) # Assuming OpenAI has an async interface
conversation = ConversationChain(
llm=llm,
prompt=ENTITY_MEMORY_CONVERSATION_TEMPLATE,
memory=ConversationEntityMemory(
llm=llm, k=10
), # Assuming ConversationEntityMemory has an async interface
)
return conversation
# vectorstore = Chroma(
# embedding_function=OpenAIEmbeddings(), persist_directory="./chroma_db_oai"
# )
# search = GoogleSearchAPIWrapper()
# web_research_retriever = WebResearchRetriever.from_llm(
# vectorstore=vectorstore,
# llm=llm,
# search=search,
# )
# qa_chain = RetrievalQAWithSourcesChain.from_chain_type(
# llm, retriever=web_research_retriever
# )
# return qa_chain
llm = init_conversation()
prompt_template_male = """
Character: John, analytical and curious, often tackles {user_topic}-related challenges methodically.
Occupation & Background: [Derived from {user_topic}]
"""
prompt_template_female = """
Character: Jane, creative and empathetic, addresses {user_topic} issues with innovative, human-centered solutions.
Occupation & Background: [Derived from {user_topic}]
"""
personality = {"Male": prompt_template_male, "Female": prompt_template_female}
async def get_conversation(user_data, query):
"""
Get the conversation output for a given chat_id and query.
"""
# Initialize the conversation if it doesn't exist for the chat_id
# Choose the correct prompt based on the persona
selected_prompt = (
personality[user_data["PERSONA"]]
if user_data["PERSONA"] in personality
else None
)
google_search = await search_token(f"{query}. Topic: {user_data['TOPIC']}")
# Run the conversation and get the output
prompt = f"""
As the Daily Advisor AI, your role is to be a knowledgeable and friendly companion to {user_data["NAME"]}.
You're tasked with providing accurate, reliable answers about {user_data["TOPIC"]}—a topic described as
{user_data["DESCRIPTION"]}. Your responses should be grounded in verifiable facts to ensure trustworthiness.
Embody the character traits assigned to you, maintaining this persona consistently to build rapport with the user.
Your character is defined as follows: {selected_prompt.format(user_topic=user_data["TOPIC"])}.
Above all, your goal is to support {user_data["NAME"]}'s curiosity and learning about {user_data["TOPIC"]} with
engaging and informative dialogue. You responses have to be professional and cosine. Answer only based on subject
with no additional info.\n
Google Search results: {google_search}
User query: {query}
"""
# response = llm({"question": query})
# output = response["answer"]
output = await llm.arun(input=prompt) # Assuming run is an async method
return output
async def generate_category(topic, description, level):
prompt = f"""
Based on the main topic of '{topic}', which is briefly described as '{description}', and considering the user's
knowledge level of '{level}', generate a list of specific subcategories or areas of interest within this topic.
These subcategories should be relevant and tailored to the user's understanding, providing avenues for deeper
exploration or advice. Think broadly and include various aspects such as technologies, methodologies, applications,
and any other pertinent divisions related to '{topic}'.
For instance, if the topic is 'AI', potential categories might include 'Machine Learning', 'AI Tools', 'Diffusion Models',
'Language Models', etc. List out similar categories that fit the scope of '{topic}'.
"""
category = await generate_completion(prompt)
return category.strip()
async def search_google_for_data(category, topic):
search_query = f"Recent developments in {category} related to {topic}"
search_results = await search_token(search_query)
return search_results
async def generate_advice(user_data, google_data):
prompt = f"""
Given the user's specific interests and needs as outlined in their profile: {user_data}, and incorporating the
latest findings and data obtained from recent Google searches: {google_data}, formulate a piece of advice. This
advice should be actionable, insightful, and tailored to the user's context. It should leverage the depth of
knowledge available within the AI's database as well as the freshness and relevance of the information sourced
from the web. Ensure that the guidance provided is coherent, directly applicable to the user's situation, and
reflects the most current understanding of the topic at hand.
"""
advice = await generate_chat_completion(prompt)
return advice
async def create_advice(topic, description, level):
# Step 1: Generate a category from the topic
category = await generate_category(topic, description, level)
# Step 2: Google search for data about the category
google_data = await search_google_for_data(category, topic)
# Step 3: Generate advice using the GPT model
user_data = {
"topic": topic,
"description": description,
"level": level,
"category": category,
}
advice = await generate_advice(user_data, google_data)
return advice
async def search_token(prompt: str) -> Any:
search = GoogleSearchAPIWrapper()
tool = Tool(
name="Google Search",
description="Search Google for recent results.",
func=search.run, # Synchronous method
)
# Run the synchronous code in a thread pool executor
return await asyncio.get_event_loop().run_in_executor(None, tool.run, prompt)
async def generate_chat_completion(input_data):
data = {
"model": "gpt-3.5-turbo-16k",
"messages": [
{
"role": "system",
"content": "You will be given a task by user to create advices on some topic based on you train data "
"and given google search data. You have to generate good structured advice text for "
"telegram format. ",
},
{"role": "user", "content": input_data},
],
"temperature": 0,
"max_tokens": 500,
"top_p": 0.4,
"frequency_penalty": 1.5,
"presence_penalty": 1,
}
response = await openai.ChatCompletion.acreate(**data)
responses = response["choices"][0]["message"]["content"]
return responses
async def generate_chat(input_data, message):
data = {
"model": "gpt-3.5-turbo-16k",
"messages": [
{
"role": "system",
"content": f"You are a chat bot, created to chat with user on its topic: {input_data['TOPIC']}, "
f"for the level: {input_data['LEVEL']}",
},
{"role": "user", "content": f"User message: {message}"},
],
"temperature": 0,
"max_tokens": 500,
"top_p": 0.4,
"frequency_penalty": 1.5,
"presence_penalty": 1,
}
response = await openai.ChatCompletion.acreate(**data)
responses = response["choices"][0]["message"]["content"]
return responses
async def generate_completion(query: str) -> str:
data = {
"engine": "text-davinci-003",
"prompt": query,
"temperature": 0,
"max_tokens": 500,
"top_p": 0,
"frequency_penalty": 0.43,
"presence_penalty": 0.35,
"best_of": 2,
}
response = await openai.Completion.acreate(**data)
# Extract the bot's response from the generated text
answer = response["choices"][0]["text"]
return answer
def ask_question(qa, question: str, chat_history):
query = ""
result = qa({"question": query, "chat_history": chat_history})
print(result)
print("Question:", question)
print("Answer:", result["answer"])
print(result)
return result["answer"]
async def generate_response(query: str, vectorstore) -> str:
knowledge = []
# TODO: Test different things like similarity
for doc in vectorstore.max_marginal_relevance_search(query, k=10):
knowledge.append(doc)
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": ()},
{"role": "system", "content": ""},
{"role": "user", "content": " "},
],
temperature=0,
max_tokens=3000,
top_p=0.4,
frequency_penalty=1.5,
presence_penalty=1,
)
bot_response = response["choices"][0]["message"]["content"]
return bot_response
def tiktoken_len(text: str) -> int:
tokenizer = tiktoken.get_encoding("cl100k_base")
tokens = tokenizer.encode(text, disallowed_special=())
return len(tokens)
def process_recursive(documents) -> FAISS:
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=900,
chunk_overlap=200,
length_function=tiktoken_len,
separators=["\n\n", "\n", " ", ""],
)
embeddings = OpenAIEmbeddings()
text_chunks = text_splitter.split_text(documents)
db = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
return db
# Create a vector store indexes from the pdfs
def get_vectorstore(text_chunks: list[str]) -> FAISS:
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
return vectorstore
| [
"You are a chat bot, created to chat with user on its topic: PLACEHOLDER, for the level: PLACEHOLDER",
"User message: PLACEHOLDER",
"\nGiven the user's specific interests and needs as outlined in their profile: PLACEHOLDER, and incorporating the \nlatest findings and data obtained from recent Google searches: PLACEHOLDER, formulate a piece of advice. This \nadvice should be actionable, insightful, and tailored to the user's context. It should leverage the depth of \nknowledge available within the AI's database as well as the freshness and relevance of the information sourced \nfrom the web. Ensure that the guidance provided is coherent, directly applicable to the user's situation, and \nreflects the most current understanding of the topic at hand.\n",
"\nCharacter: Jane, creative and empathetic, addresses {user_topic} issues with innovative, human-centered solutions.\nOccupation & Background: [Derived from {user_topic}]\n",
"DESCRIPTION",
" ",
"\n Based on the main topic of 'PLACEHOLDER', which is briefly described as 'PLACEHOLDER', and considering the user's \n knowledge level of 'PLACEHOLDER', generate a list of specific subcategories or areas of interest within this topic. \n These subcategories should be relevant and tailored to the user's understanding, providing avenues for deeper \n exploration or advice. Think broadly and include various aspects such as technologies, methodologies, applications, \n and any other pertinent divisions related to 'PLACEHOLDER'.\n\n For instance, if the topic is 'AI', potential categories might include 'Machine Learning', 'AI Tools', 'Diffusion Models', \n 'Language Models', etc. List out similar categories that fit the scope of 'PLACEHOLDER'.\n ",
"\nCharacter: John, analytical and curious, often tackles {user_topic}-related challenges methodically.\nOccupation & Background: [Derived from {user_topic}]\n",
"()",
"You will be given a task by user to create advices on some topic based on you train data and given google search data. You have to generate good structured advice text for telegram format. "
] |
2024-01-10 | FilipFilchev/ChatBot | VoiceAssistant~Echo~Echo.py | #Voice Assistant Echo powered by pyttsx3 (text to speech engine) and OpenAi GPT (more complex version in ../Vision)
import pyttsx3
import speech_recognition as sr
import openai
import json
import os
from datetime import datetime
#Get Time
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
current_date = now.strftime("%Y-%m-%d")
print("Current Time =", current_time)
print("Current Date =", current_date)
# Initialize text-to-speech engine
engine = pyttsx3.init()
# List available voices
voices = engine.getProperty('voices')
# Set default VOICE!!!
siri_voice = "com.apple.speech.synthesis.voice.samantha"
#siri_voice= "com.apple.speech.synthesis.voice.tom" #male
# Set rate and volume
#engine.setProperty('rate', 150) # Experiment with this
engine.setProperty('volume', 1.0) # Max volume
engine.setProperty('voice', siri_voice)
#ECHO SAYS
def speak(text, voice_id):
engine.setProperty('voice', voice_id)
engine.say(text)
engine.runAndWait()
# Initialize speech recognition
recognizer = sr.Recognizer()
#API KEY: protect it
KEY = ''
# Initialize OpenAI API
# openai.api_key = os.getenv(KEY) # Replace with your own API key if you prefer hardcoding (not recommended)
openai.api_key = KEY
#GET VOICE Command
def get_audio_input():
with sr.Microphone() as source:
print("Listening...")
audio_data = recognizer.listen(source)
text = recognizer.recognize_google(audio_data)
return text
#GPTransformer Generates -- Change the Model; Create custom one or import pretrained transformer
"""Other pretrained transformer from microsoft: Dialo...
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-large")
model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-large")
# chat for 5 lines example:
for step in range(5):
# encode the new user input, add the eos_token and return a tensor in Pytorch
new_user_input_ids = tokenizer.encode(input(">> User:") + tokenizer.eos_token, return_tensors='pt')
# append the new user input tokens to the chat history
bot_input_ids = torch.cat([chat_history_ids, new_user_input_ids], dim=-1) if step > 0 else new_user_input_ids
# generated a response while limiting the total chat history to 1000 tokens,
chat_history_ids = model.generate(bot_input_ids, max_length=1000, pad_token_id=tokenizer.eos_token_id)
# pretty print last ouput tokens from bot
print("DialoGPT: {}".format(tokenizer.decode(chat_history_ids[:, bot_input_ids.shape[-1]:][0], skip_special_tokens=True)))
"""
def generate_response(text):
# Generate response using OpenAI API
prompt = f"{text}"
response = openai.Completion.create(
engine="text-davinci-002", # You can update this to "text-davinci-turbo" based on your API availability
prompt=prompt,
max_tokens=50
)
#might need to delete the Echo says
response = "Echo says:" + response.choices[0].text.strip()
return response
#LOG HISTORY
def append_to_file(role, text):
with open("conversation_history.txt", "a") as f:
f.write(f"{role}: {text}\n")
"""# Check Available Voices
voices = engine.getProperty('voices')
for index, voice in enumerate(voices):
print(index, voice.id)"""
#RUN... response happens outside the main loop -> in the generate_response(txt) function
while True:
try:
# Get audio input
user_input = get_audio_input()
print(user_input)
# Generate response
response = generate_response(user_input)
#Add the Date
append_to_file("\n Hello World!", f"Date: {current_date} | Time: {current_time} \n ")
# Append user input to file
append_to_file("User", user_input)
# Append assistant response to file
append_to_file("Assistant", response)
# Speak the response
print(response)
speak(response, siri_voice)
except Exception as ex:
print(f"An error occurred: {ex}")
| [] |
2024-01-10 | epsilla-cloud/prompttools | prompttools~playground~constants.py | # Copyright (c) Hegel AI, Inc.
# All rights reserved.
#
# This source code's license can be found in the
# LICENSE file in the root directory of this source tree.
from prompttools.experiment import LlamaCppExperiment
from prompttools.experiment import OpenAIChatExperiment
from prompttools.experiment import OpenAICompletionExperiment
from prompttools.experiment import AnthropicCompletionExperiment
from prompttools.experiment import GooglePaLMCompletionExperiment
from prompttools.experiment import HuggingFaceHubExperiment
ENVIRONMENT_VARIABLE = {
"OpenAI Chat": "OPENAI_API_KEY",
"OpenAI Completion": "OPENAI_API_KEY",
"Anthropic": "ANTHROPIC_API_KEY",
"Google PaLM": "GOOGLE_PALM_API_KEY",
"HuggingFace Hub": "HUGGINGFACEHUB_API_TOKEN",
}
EXPERIMENTS = {
"LlamaCpp Chat": LlamaCppExperiment,
"OpenAI Chat": OpenAIChatExperiment,
"OpenAI Completion": OpenAICompletionExperiment,
"Anthropic": AnthropicCompletionExperiment,
"Google PaLM": GooglePaLMCompletionExperiment,
"HuggingFace Hub": HuggingFaceHubExperiment,
}
MODES = ("Instruction", "Prompt Template", "Model Comparison")
MODEL_TYPES = (
"OpenAI Chat",
"OpenAI Completion",
"Anthropic",
"Google PaLM",
"LlamaCpp Chat",
"LlamaCpp Completion",
"HuggingFace Hub",
)
OPENAI_CHAT_MODELS = (
"gpt-3.5-turbo",
"gpt-3.5-turbo-16k",
"gpt-3.5-turbo-0613",
"gpt-3.5-turbo-16k-0613",
"gpt-3.5-turbo-0301",
"gpt-4",
"gpt-4-0613",
"gpt-4-32k",
"gpt-4-32k-0613",
"gpt-4-0314",
"gpt-4-32k-0314",
)
OPENAI_COMPLETION_MODELS = ("text-davinci-003", "text-davinci-002", "code-davinci-002")
| [] |
2024-01-10 | epsilla-cloud/prompttools | prompttools~experiment~experiments~experiment.py | # Copyright (c) Hegel AI, Inc.
# All rights reserved.
#
# This source code's license can be found in the
# LICENSE file in the root directory of this source tree.
from typing import Callable, Dict, List, Optional, Union
from operator import itemgetter
from collections import defaultdict
import itertools
import logging
from IPython import display
from tabulate import tabulate
import pandas as pd
import sentry_sdk
import os
try:
import pymongo
except ImportError:
pymongo = None
from prompttools.requests.request_queue import RequestQueue
# from ..widgets.feedback import FeedbackWidgetProvider
# from ..widgets.comparison import ComparisonWidgetProvider
from ..widgets.utility import is_interactive
from .error import PromptExperimentException
from ._utils import _get_dynamic_columns
pd.set_option("display.max_colwidth", 0)
class Experiment:
r"""
Base class for experiment. This should not be used directly, please use the subclasses instead.
"""
completion_fn: Callable
all_args: Dict
def __init__(self):
self.queue = RequestQueue()
self.argument_combos: list[dict] = []
self.full_df = None
self.partial_df = None
self.score_df = None
try:
if "SENTRY_OPT_OUT" not in os.environ:
sentry_sdk.capture_message(f"Initializing {self.__class__.__name__}", "info")
except Exception:
pass
# self.feedback_widget_provider = FeedbackWidgetProvider(
# self.completion_fn, self._aggregate_metric, self._get_human_eval_listener
# )
# self.comparison_widget_provider = ComparisonWidgetProvider(
# self.completion_fn,
# self._aggregate_comparison,
# self._get_comparison_listener,
# )
@classmethod
def initialize(cls, test_parameters: dict[str, list], frozen_parameters: dict):
r"""
An alternate way to initialize an experiment by specifying which parameters should be tested
and which ones should be frozen. If a parameter is not specified, the default value (if exists)
for the parameter will be used.
This allows you to easily initialize an experiment **without** wrapping every parameter in a list.
Note:
- For a given experiment, some parameters must be specified (e.g. the ``model`` parameter
for OpenAI Chat Experiment). See the experiment's ``__init__`` method.
- Each of ``test_parameters``'s values should be a ``list``, but not for ``frozen_parameters``.
Args:
test_parameters (dict[str, list]): parameters that are being tested. A list of multiple test values
should be the value (e.g. ``{model: ["gpt-3.5-turbo", "gpt-4"], temperature: [0,0. 1.0]}``)
frozen_parameters (dict): parameters that are intended to be frozen across different configuration.
There is no need to wrap the value in a list. (e.g. ``{top_p: 1.0, presence_penalty: 0.0}``)
Example:
>>> from prompttools.experiment import OpenAIChatExperiment
>>> test_parameters = {"model": ["gpt-3.5-turbo", "gpt-4"]}
>>> messages = [{"role": "user", "content": "Who was the first president?"}]
>>> frozen_parameters = {"top_p": 1.0, "messages": messages}
>>> experiment = OpenAIChatExperiment.initialize(test_parameters, frozen_parameters)
"""
frozen_parameters = {k: [v] for k, v in frozen_parameters.items()}
return cls(**test_parameters, **frozen_parameters)
def _is_chat(self):
return False
# def _get_human_eval_listener(self, i: int) -> Callable:
# def listener(change):
# self.score_df["feedback"][i] = change["new"]
#
# return listener
# def _get_comparison_listener(self, index: int) -> Callable:
# def listener(change):
# new_index = self.comparison_index_translation(index)
# self.score_df["comparison"][new_index] = change["new"]
#
# return listener
# def _aggregate_comparison(
# self,
# table: pd.DataFrame,
# agg_column: int = 0,
# is_average: bool = False,
# ) -> Dict[str, int]:
# # TODO: This could be a group by
# prompt_scores = defaultdict(int)
# prompt_counts = defaultdict(int)
# for index, row in enumerate(table.iterrows()):
# key = str(row[agg_column])
# new_index = self.comparison_index_translation(index)
# prompt_scores[key] += self.score_df["comparison"][new_index]
# prompt_counts[key] += 1
# if is_average:
# for k, v in prompt_scores.items():
# prompt_scores[k] = v / prompt_counts[k]
# sorted_scores = dict(sorted(prompt_scores.items(), key=lambda item: item[1], reverse=True))
# return sorted_scores
def _aggregate_metric(
self,
table: pd.DataFrame,
metric_name: str,
agg_column: str,
is_average: bool = False,
) -> Dict[str, int]:
# TODO: This could be a group by
prompt_scores = defaultdict(int)
prompt_counts = defaultdict(int)
for index, row in table.iterrows():
key = str(row[agg_column])
prompt_scores[key] += self.score_df[metric_name][index]
prompt_counts[key] += 1
if is_average:
for k, v in prompt_scores.items():
prompt_scores[k] = v / prompt_counts[k]
sorted_scores = dict(sorted(prompt_scores.items(), key=lambda item: item[1], reverse=True))
return sorted_scores
def prepare(self) -> None:
r"""
Creates argument combinations by taking the cartesian product of all inputs.
"""
self.argument_combos = [dict(zip(self.all_args, val)) for val in itertools.product(*self.all_args.values())]
def run(
self,
runs: int = 1,
) -> None:
r"""
Create tuples of input and output for every possible combination of arguments.
Note:
If you overwrite this method in a subclass, make sure your method calls ``_construct_result_dfs``
in order to save the results from your run as DataFrames. Then, they can later be used
for evaluation, aggregation, and persistence.
Args:
runs (int): number of times to execute each possible combination of arguments, defaults to 1.
"""
if not self.argument_combos:
logging.info("Preparing first...")
self.prepare()
for combo in self.argument_combos:
for _ in range(runs):
self.queue.enqueue(
self.completion_fn,
# We need to filter out defaults that are invalid JSON from the request
{k: v for k, v in combo.items() if (v is not None) and (v != float("inf"))},
)
results = self.queue.get_results()
input_args = self.queue.get_input_args()
if len(results) == 0:
logging.error("No results. Something went wrong.")
raise PromptExperimentException
self._construct_result_dfs(input_args, results, self.queue.get_latencies())
def _construct_result_dfs(
self,
input_args: list[dict[str, object]],
results: list[dict[str, object]],
latencies: list[float],
extract_response_equal_full_result: bool = False,
):
r"""
Takes in the input, results, and other metrics from the experiment's run, and construct a few DataFrames that
contain all relevant data (i.e. input arguments, results, evaluation metrics).
These DataFrames can later be used for evaluation, aggregation, or storing them for persistence.
Note:
- If your subclass of ``Experiment`` has a custom ``run`` method. You should consider overwriting this
method. In particular, you likely would want to define how to extract the response from LLM's result
and save that into ``response_df`` below. ChromaDBExperiment provides an example of this.
- The inputs should all share the same length.
Args:
input_args (list[dict[str, object]]): list of dictionaries, where each of them is a set of
input argument that was passed into the model
results (list[dict[str, object]]): list of responses from the model
latencies (list[float]): list of latency measurements
extract_response_equal_full_result (bool): if ``True``, ``result_df`` will only contain
the extracted response, lead to a simpler (but incomplete) columns of results.
"""
# `input_arg_df` contains all all input args
input_arg_df = pd.DataFrame(input_args)
# `dynamic_input_arg_df` contains input args that has more than one unique values
dynamic_input_arg_df = _get_dynamic_columns(input_arg_df)
# `response_df` contains the extracted response (often being the text response)
response_df = pd.DataFrame({"response": [self._extract_responses(result) for result in results]})
# `result_df` contains everything returned by the completion function
if extract_response_equal_full_result:
result_df = response_df
else:
result_df = pd.concat([response_df, pd.DataFrame(results)], axis=1)
# `score_df` contains computed metrics (e.g. latency, evaluation metrics)
self.score_df = pd.DataFrame({"latency": latencies})
# `partial_df` contains some input arguments, extracted responses, and score
self.partial_df = pd.concat([dynamic_input_arg_df, response_df, self.score_df], axis=1)
# `full_df` contains all input arguments, responses, and score
self.full_df = pd.concat([input_arg_df, result_df, self.score_df], axis=1)
def get_table(self, get_all_cols: bool = False) -> pd.DataFrame:
r"""
Get the DataFrame in one of two versions:
1. ``get_all_cols = False`` - good for visualization. This contains dynamic (non-frozen) input arguments,
the text response, and scores (e.g. latency and metrics generated from evaluation).
2. ``get_all_cols = True`` - good for full result. This contains full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
Args:
get_all_cols (bool): defaults to ``False``. If ``True``, it will return the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
"""
if self.full_df is None:
logging.info("Running first...")
self.run()
if get_all_cols:
return self.full_df
else:
return self.partial_df
def visualize(self, get_all_cols: bool = False, pivot: bool = False, pivot_columns: list = []) -> None:
r"""
Visualize the DataFrame in one of two versions:
1. ``get_all_cols = False`` - good for visualization. This contains dynamic (non-frozen) input arguments,
the text response, and scores (e.g. latency and metrics generated from evaluation).
2. ``get_all_cols = True`` - good for full result. This contains full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
Args:
get_all_cols (bool): defaults to ``False``. If ``True``, it will visualize the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
"""
if pivot:
table = self.pivot_table(pivot_columns, get_all_cols=get_all_cols)
else:
table = self.get_table(get_all_cols)
if is_interactive():
display.display(table)
else:
logging.getLogger().setLevel(logging.INFO)
logging.info(tabulate(table, headers="keys", tablefmt="psql"))
def evaluate(self, metric_name: str, eval_fn: Callable, static_eval_fn_kwargs: dict = {}, **eval_fn_kwargs) -> None:
"""
Using the given evaluation function that accepts a row of data, compute a new column with the evaluation
result. Each row of data generally contain inputs, model response, and other previously computed metrics.
Args:
metric_name (str): name of the metric being computed
eval_fn (Callable): an evaluation function that takes in a row from pd.DataFrame
and optional keyword arguments
static_eval_fn_kwargs (dict): keyword args for ``eval_fn`` that are consistent for all rows
eval_fn_kwargs (Optional[list]): keyword args for ``eval_fn`` that may be different for each row.
Each value entered here should be a list, and the length of the list should be
the same as the number of responses in the experiment's result. The ``i``th element of the list will be
passed to the evaluation function to evaluate the ``i``th row.
Example:
>>> from prompttools.utils import validate_json_response
>>> experiment.evaluate("is_json", validate_json_response,
>>> static_eval_fn_kwargs={"response_column_name": "response"})
"""
if metric_name in self.score_df.columns:
logging.warning(metric_name + " is already present, skipping.")
return
res = []
table = self.get_table(get_all_cols=True)
for i, row in table.iterrows():
curr_kwargs = static_eval_fn_kwargs.copy()
for k, v in eval_fn_kwargs.items():
curr_kwargs[k] = v[i]
res.append(eval_fn(row, **curr_kwargs))
self._update_score(metric_name, res)
def _update_score(self, metric_name: str, res) -> None:
self.score_df[metric_name] = res
self.partial_df[metric_name] = res
self.full_df[metric_name] = res
def pivot_table(
self, pivot_columns: List[str], response_value_name: Optional[str] = None, get_all_cols: bool = False
) -> pd.DataFrame:
"""
Returns a pivoted DataFrame.
Args:
pivot_columns (List[str]): two column names (first for pivot row, second for pivot column)
that serve as indices the pivot table
response_value_name (Optional[str]): name of the column to aggregate.
get_all_cols (bool): defaults to ``False``. If ``True``, it will visualize the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
"""
df = self.get_table(get_all_cols)
pivot_df = pd.pivot_table(
df,
values=response_value_name,
index=[pivot_columns[1]],
columns=[pivot_columns[0]],
aggfunc=lambda x: x.iloc[0],
)
return pivot_df
# def gather_feedback(self, pivot_data: Dict[str, object], pivot_columns: List[str]) -> None:
# """
# This method creates a table to gather human feedback from a notebook interface.
#
# Args:
# pivot_data (Dict[str, object]): dictionary that contains additional data or metadata related to the input
# pivot_columns (List[str]): two column names (first for pivot row, second for pivot column)
# that serve as indices the pivot table
# """
# if not is_interactive():
# logging.warning("This method only works in notebooks.")
# return
# table = self.get_table(get_all_cols=True)
# self.score_df["feedback"] = [1] * len(table.index))
# self.feedback_widget_provider.set_pivot_columns(pivot_columns)
# items = self.feedback_widget_provider.get_header_widgets()
# for row in table.iterrows():
# items += self.feedback_widget_provider.get_row_widgets(*row)
# items += self.feedback_widget_provider.get_footer_widgets(table)
# self.feedback_widget_provider.display(items)
# def compare(self, primary_model: str, pivot_columns: List[str]) -> None:
# """
# This method creates a table to gather human feedback from a notebook interface.
# """
# if not is_interactive():
# logging.warning("This method only works in notebooks.")
# return
# table = self.get_table(pivot_data={}, pivot_columns=pivot_columns, pivot=True)
# self.score_df["comparison"] = [1] * len(table.index))
# self.comparison_index_translation = lambda i: i * len(table.columns)
# self.comparison_widget_provider.set_models(table.columns)
# items = self.comparison_widget_provider.get_header_widgets()
# for index, row in enumerate(table.iterrows()):
# items += self.comparison_widget_provider.get_row_widgets(index, row[1])
# items += self.comparison_widget_provider.get_footer_widgets(table)
# self.comparison_widget_provider.display(items)
def aggregate(self, metric_name, column_name, is_average=False):
r"""
Aggregates a metric for a given column and displays to the user.
Args:
metric_name (str): metric to aggregate
column_name (str): column to base the aggregation on
is_average (bool): if ``True``, compute the average for the metric, else compute the total
"""
if self.score_df is None or metric_name not in self.score_df.columns:
logging.warning("Can't find " + metric_name + " in scores. Did you run `evaluate`?")
return
table = self.get_table(get_all_cols=False)
sorted_scores = self._aggregate_metric(table, metric_name, column_name, is_average)
if is_interactive():
import matplotlib.pyplot as plt
import os
# Import style file, assumes same dir as experiment.py
style_path = os.path.join(os.path.dirname(__file__), "style.mplstyle")
plt.style.use(style_path)
# Define the custom colors
custom_colors = [
"black",
"#7e1e9c",
"#15b01a",
"#448ee4",
"#ff7fa7",
"#029386",
]
plt.ylabel("Latency (s)")
# Cycle through the custom colors when creating the bars
for i, (label, value) in enumerate(sorted_scores.items()):
plt.bar(i, value, align="center", color=custom_colors[i % len(custom_colors)])
plt.xticks(range(len(sorted_scores)), list(sorted_scores.keys()))
plt.show()
def rank(
self,
metric_name: str,
is_average: bool,
agg_column: str,
get_all_cols: bool = False,
) -> Dict[str, int]:
"""
Using pivot data, groups the data by the first pivot column to
get scores, and sorts descending. For example, using pivot data of
(prompt_template, user_input), a metric of latency, and is_average=True,
we rank prompt templates by their average latency in the test set.
Args:
metric_name (str): metric to aggregate over
is_average (bool): if ``True``, compute the average for the metric, else compute the total
agg_column (str): column to aggregate over
get_all_cols (bool): defaults to ``False``. If ``True``, it will return the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
"""
if self.score_df is None or metric_name not in self.score_df.columns:
logging.warning("Can't find " + metric_name + " in scores. Did you run `evaluate`?")
return
table = self.get_table(get_all_cols=get_all_cols)
sorted_scores = self._aggregate_metric(table, metric_name, agg_column, is_average)
return sorted_scores
@staticmethod
def _extract_responses(output: Dict[str, object]) -> list[str]:
raise NotImplementedError("This should be implemented by a subclass of `Experiment`.")
def to_csv(
self,
path: str,
get_all_cols: bool = True,
**kwargs,
):
r"""
Export the results to a CSV file. If the experiment has not been executed, it will run.
Args:
path (str): path/buffer to write the CSV output
get_all_cols (bool): defaults to ``False``. If ``True``, it will return the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
**kwargs: optional arguments passed to ``pd.DataFrame.to_csv()``
"""
table = self.get_table(get_all_cols=get_all_cols)
table.to_csv(path, **kwargs)
def to_pandas_df(self, get_all_cols: bool = True):
r"""
Return the results as a ``pandas.DataFrame``. If the experiment has not been executed, it will run.
Args:
get_all_cols (bool): defaults to ``False``. If ``True``, it will return the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
"""
return self.get_table(get_all_cols=get_all_cols)
def to_json(
self,
path: Optional[str] = None,
get_all_cols: bool = True,
**kwargs,
):
r"""
Export the results to a JSON file. If the experiment has not been executed, it will run.
Args:
path (Optional[str]): path/buffer to write the JSON output, defaults to ``None`` which returns
the JSON as a `dict`
get_all_cols (bool): defaults to ``False``. If ``True``, it will return the full data with all
input arguments (including frozen ones), full model response (not just the text response), and scores.
**kwargs: optional arguments passed to ``pd.DataFrame.to_json()``
"""
table = self.get_table(get_all_cols=get_all_cols)
if path is None:
return table.to_json(**kwargs)
else:
return table.to_json(path, **kwargs)
def to_lora_json(
self,
instruction_extract: Union[str, Callable],
input_extract: Union[str, Callable],
output_extract: Union[str, Callable],
path: Optional[str] = None,
**kwargs,
):
r"""
Export the results to a LoRA-format JSON file for fine-tuning.
If the experiment has not been executed, it will run.
Args:
instruction_extract (Union[str, Callable]): column name, or an extractor function that will accept a row
of the result table and return a value assigned to ``"instruction"`` entry in the JSON file
input_extract (Union[str, Callable]): column name, or an extractor function that will accept a row
of the result table and return a value assigned to ``"input"`` entry in the JSON file
output_extract (Union[str, Callable]): column name, or an extractor function that will accept a row
of the result table and return a value assigned to ``"output"`` entry in the JSON file
path (Optional[str]): path/buffer to write the JSON output, defaults to ``None`` which returns
the JSON as a `dict`
**kwargs: optional arguments passed to ``pd.DataFrame.to_json()``
"""
if isinstance(instruction_extract, str):
instruction_extract = itemgetter(instruction_extract)
if isinstance(input_extract, str):
input_extract = itemgetter(input_extract)
if isinstance(output_extract, str):
output_extract = itemgetter(output_extract)
df = self.to_pandas_df(get_all_cols=True)
extracted_data = df.apply(
lambda row: {
"instruction": instruction_extract(row),
"input": input_extract(row),
"output": output_extract(row),
},
axis=1,
)
if "orient" not in kwargs:
kwargs["orient"] = "records"
if "indent" not in kwargs:
kwargs["indent"] = 2
if path:
extracted_data.to_json(path, **kwargs)
else:
return extracted_data.to_json(**kwargs)
# TODO: Add MongoDB local instruction (maybe include docker)
def to_mongo_db(self, mongo_uri: str, database_name: str, collection_name: str) -> None:
r"""
Insert the results of the experiment into MongoDB for persistence.
Note:
- You need to install the ``pymongo`` package to use this method.
- You need to run a local or remote instance of MongoDB in order to store the data.
Args:
mongo_uri (str): a connection string to the target MongoDB
database_name (str): name of the MongoDB database
collection_name (str): name of the MongoDB collection
"""
if pymongo is None:
raise ModuleNotFoundError(
"Package `pymongo` is required to be installed to use this method."
"Please use `pip install pymongo` to install the package"
)
if self.full_df is None:
logging.info("Running first...")
self.run()
client = pymongo.MongoClient(mongo_uri)
db = client[database_name]
collection = db[collection_name]
collection.insert_many(self.full_df.to_dict("records"))
logging.info(f"Inserted results in {database_name}'s collection {collection_name}.")
client.close()
def to_markdown(self):
markdown = self.to_pandas_df().to_markdown()
return markdown
def _get_model_names(self):
pass
def _get_prompts(self):
pass
| [] |
2024-01-10 | epsilla-cloud/prompttools | prompttools~utils~autoeval_from_expected.py | # Copyright (c) Hegel AI, Inc.
# All rights reserved.
#
# This source code's license can be found in the
# LICENSE file in the root directory of this source tree.
import os
import openai
import jinja2
import pandas
from .error import PromptToolsUtilityError
EVALUATION_SYSTEM_PROMPT = """
You are a grader evaluating responses to math questions.
Given the PROMPT and EXPECTED, evaluate the ACTUAL answer.
You should grade the response as either RIGHT or WRONG.
"""
EVALUATION_USER_TEMPLATE = """
PROMPT: {{prompt}}
EXPECTED: {{expected}}
ACTUAL: {{actual}}
ANSWER:
"""
def _get_messages(prompt: str, expected: str, response: str):
environment = jinja2.Environment()
template = environment.from_string(EVALUATION_USER_TEMPLATE)
user_message = template.render({"prompt": prompt, "expected": expected, "actual": response})
return [
{"role": "system", "content": EVALUATION_SYSTEM_PROMPT},
{"role": "user", "content": user_message},
]
# TODO: Should this be removed since no one is using it?
def compute(prompt: str, expected: str, response: str, model: str = "gpt-4") -> float:
r"""
Uses a high quality chat model, like GPT-4, to automatically evaluate a given
prompt/response pair. Outputs can be 0 or 1.
Args:
prompt (str): The input prompt.
response (str): The model response.
model (str): The OpenAI chat model to use for generating an expected response.
Defaults to GPT-4.
"""
if not os.environ["OPENAI_API_KEY"]:
raise PromptToolsUtilityError("Missing API key for evaluation.")
evaluation = openai.ChatCompletion.create(model=model, messages=_get_messages(prompt, expected, response))
return 1.0 if "RIGHT" in evaluation["choices"][0]["message"]["content"] else 0.0
def evaluate(prompt: str, response: str, metadata: dict, expected: str) -> float:
r"""
Uses auto-evaluation to score the model response.
"""
return compute(prompt, expected, response)
def autoeval_from_expected_response(
row: pandas.core.series.Series, expected: str, prompt_column_name: str, response_column_name: str = "response"
):
prompt = row[prompt_column_name]
response = row[response_column_name]
return compute(prompt, expected, response)
| [
"\nPROMPT: {{prompt}}\nEXPECTED: {{expected}}\nACTUAL: {{actual}}\nANSWER:\n",
"\nYou are a grader evaluating responses to math questions.\nGiven the PROMPT and EXPECTED, evaluate the ACTUAL answer.\nYou should grade the response as either RIGHT or WRONG.\n"
] |
2024-01-10 | Romainpkq/ChatGPT4MT | template~TSP.py | import openai
openai.api_key = ''
completion = openai.ChatCompletion.create(
model='gpt-3.5-turbo-0301',
messages=[
{"role": "system", "content": "You are a machine translation system."},
{"role": "user",
"content": 'Please provide the [TGT] translation for the following sentence: ' + line,
}],
temperature=0
)
print(completion.choices[0]["message"]["content"]) | [
"Please provide the [TGT] translation for the following sentence: PLACEHOLDER",
"You are a machine translation system."
] |
2024-01-10 | Romainpkq/ChatGPT4MT | template~3_shot.py | import openai
openai.api_key = ''
completion = openai.ChatCompletion.create(
model='gpt-3.5-turbo-0301',
messages=[
{"role": "system", "content": "You are a machine translation system."},
{"role": "user",
"content": '[SRC]: [S_1] [TGT]: [T_1]\n'
'[SRC]: [S_2] [TGT]: [T_2]\n'
'[SRC]: [S_3] [TGT]: [T_3]\n'
'[SRC]: ' + line + ' [TGT]: ',
}],
temperature=0
)
print(completion.choices[0]["message"]["content"]) | [
"You are a machine translation system.",
"[SRC]: [S_1] [TGT]: [T_1]\n[SRC]: [S_2] [TGT]: [T_2]\n[SRC]: [S_3] [TGT]: [T_3]\n[SRC]: PLACEHOLDER [TGT]: "
] |
2024-01-10 | Romainpkq/ChatGPT4MT | template~1_shot.py | import openai
openai.api_key = ''
completion = openai.ChatCompletion.create(
model='gpt-3.5-turbo-0301',
messages=[
{"role": "system", "content": "You are a machine translation system."},
{"role": "user",
"content": '[SRC]: [S_1] [TGT]: [T_1]\n'
'[SRC]: ' + line + ' [TGT]: ',
}],
temperature=0
)
print(completion.choices[0]["message"]["content"]) | [
"You are a machine translation system.",
"[SRC]: [S_1] [TGT]: [T_1]\n[SRC]: PLACEHOLDER [TGT]: "
] |
2024-01-10 | Romainpkq/ChatGPT4MT | template~1_shot_CoT.py | import openai
openai.api_key = ''
completion = openai.ChatCompletion.create(
model='gpt-3.5-turbo-0301',
messages=[
{"role": "system", "content": "You are a machine translation system."},
{"role": "user",
"content": 'Please provide the German translation for the following sentence step by step and then provide the complete sentence: '
'That said, expect to be out of breath, and take care in the steeper portions, '
'especially when wet, as it can become dangerous quickly.\n'
'1. That said - 据说 2. expect to be - 会让人 3. out of breath - 喘不过气来 4. and - 还有 5. take care - 小心谨慎'
'6. in the steeper portions - 在陡峭的地方 7. especially - 特别 8. when wet - 天气潮湿的时候 9. become - 变得 10. dangerous - 危险 11. quickly - 很快 '
'The complete sentence in Chinese is: 据说会让人喘不过气来，还有在陡峭的地方要小心谨慎，特别是天气潮湿时，情况有可能很快变得很危险。\n'
'Please provide the Chinese translation for the following sentence step by step and '
'then provide the complete sentence: ' + line},
],
temperature=0
)
print(completion.choices[0]["message"]["content"]) | [
"You are a machine translation system.",
"Please provide the German translation for the following sentence step by step and then provide the complete sentence: That said, expect to be out of breath, and take care in the steeper portions, especially when wet, as it can become dangerous quickly.\n1. That said - 据说 2. expect to be - 会让人 3. out of breath - 喘不过气来 4. and - 还有 5. take care - 小心谨慎6. in the steeper portions - 在陡峭的地方 7. especially - 特别 8. when wet - 天气潮湿的时候 9. become - 变得 10. dangerous - 危险 11. quickly - 很快 The complete sentence in Chinese is: 据说会让人喘不过气来，还有在陡峭的地方要小心谨慎，特别是天气潮湿时，情况有可能很快变得很危险。\nPlease provide the Chinese translation for the following sentence step by step and then provide the complete sentence: PLACEHOLDER"
] |
2024-01-10 | Romainpkq/ChatGPT4MT | template~DSP.py | import openai
openai.api_key = ''
completion = openai.ChatCompletion.create(
model='gpt-3.5-turbo-0301',
messages=[
{"role": "system", "content": "You are a machine translation system that "
"translates sentences in the [DOM] domain."},
{"role": "user",
"content": 'Please provide the [TGT] translation for the following sentence: ' + line,
}],
temperature=0
)
print(completion.choices[0]["message"]["content"]) | [
"You are a machine translation system that translates sentences in the [DOM] domain.",
"Please provide the [TGT] translation for the following sentence: PLACEHOLDER"
] |
2024-01-10 | prestonty/bliss | chat.py | from dotenv import load_dotenv
import os
import cohere
# configuration
load_dotenv()
secret_key = os.getenv("API_KEY")
co = cohere.Client(secret_key)
# Topics the user can choose from
# examples = ["In less than 60 words, how can I relax in the office?",
# "In less than 60 words, what physical activities can I do in the office?"
# "In less than 60 words, how can I calm myself down in the office?"]
# FEEDING MY AI PET THE TOPIC SO THEY CAN ANSWER IT HAHAHAA
def genActivity(topic):
response = co.generate(
model='command',
prompt=topic,
max_tokens=300,
temperature=0.3,
)
# response is a string that is the answer to the topic in less than 60 words
return response.generations[0].text
# print(genActivity(topic)) | [] |
2024-01-10 | visual-openllm/visual-openllm | visual_openllm~visual_openllm.py | import os
import gradio as gr
import random
import torch
import cv2
import re
import uuid
from PIL import Image, ImageDraw, ImageOps
import math
import numpy as np
import argparse
import inspect
from . import openai_inject
from transformers import CLIPSegProcessor, CLIPSegForImageSegmentation
from transformers import pipeline, BlipProcessor, BlipForConditionalGeneration, BlipForQuestionAnswering
from transformers import AutoImageProcessor, UperNetForSemanticSegmentation
from diffusers import StableDiffusionPipeline, StableDiffusionInpaintPipeline, StableDiffusionInstructPix2PixPipeline
from diffusers import EulerAncestralDiscreteScheduler
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel, UniPCMultistepScheduler
from controlnet_aux import OpenposeDetector, MLSDdetector, HEDdetector
from langchain.agents.initialize import initialize_agent
from langchain.agents.tools import Tool
from langchain.chains.conversation.memory import ConversationBufferMemory
from langchain.llms.openai import OpenAI
os.environ["OPENAI_API_KEY"] = "sk-placeholder" # ignore to assert the environment variable
VISUAL_CHATGPT_PREFIX = """Visual ChatGPT is designed to be able to assist with a wide range of text and visual related tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. Visual ChatGPT is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
Visual ChatGPT is able to process and understand large amounts of text and images. As a language model, Visual ChatGPT can not directly read images, but it has a list of tools to finish different visual tasks. Each image will have a file name formed as "image/xxx.png", and Visual ChatGPT can invoke different tools to indirectly understand pictures. When talking about images, Visual ChatGPT is very strict to the file name and will never fabricate nonexistent files. When using tools to generate new image files, Visual ChatGPT is also known that the image may not be the same as the user's demand, and will use other visual question answering tools or description tools to observe the real image. Visual ChatGPT is able to use tools in a sequence, and is loyal to the tool observation outputs rather than faking the image content and image file name. It will remember to provide the file name from the last tool observation, if a new image is generated.
Human may provide new figures to Visual ChatGPT with a description. The description helps Visual ChatGPT to understand this image, but Visual ChatGPT should use tools to finish following tasks, rather than directly imagine from the description.
Overall, Visual ChatGPT is a powerful visual dialogue assistant tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics.
TOOLS:
------
Visual ChatGPT has access to the following tools:"""
VISUAL_CHATGPT_PREFIX = ""
VISUAL_CHATGPT_FORMAT_INSTRUCTIONS = """To use a tool, please use the following format:
```
Thought: Do I need to use a tool? Yes
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
```
When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
```
Thought: Do I need to use a tool? No
{ai_prefix}: [your response here]
```
"""
VISUAL_CHATGPT_FORMAT_INSTRUCTIONS = """[{tool_names}][{ai_prefix}]
==#==
"""
VISUAL_CHATGPT_SUFFIX = """You are very strict to the filename correctness and will never fake a file name if it does not exist.
You will remember to provide the image file name loyally if it's provided in the last tool observation.
Begin!
Previous conversation history:
{chat_history}
New input: {input}
Since Visual ChatGPT is a text language model, Visual ChatGPT must use tools to observe images rather than imagination.
The thoughts and observations are only visible for Visual ChatGPT, Visual ChatGPT should remember to repeat important information in the final response for Human.
Thought: Do I need to use a tool? {agent_scratchpad}"""
VISUAL_CHATGPT_SUFFIX = """{chat_history}
==#==
{input}
==#==
{agent_scratchpad}
"""
os.makedirs("image", exist_ok=True)
def seed_everything(seed):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
return seed
def prompts(name, description):
def decorator(func):
func.name = name
func.description = description
return func
return decorator
def blend_gt2pt(old_image, new_image, sigma=0.15, steps=100):
new_size = new_image.size
old_size = old_image.size
easy_img = np.array(new_image)
gt_img_array = np.array(old_image)
pos_w = (new_size[0] - old_size[0]) // 2
pos_h = (new_size[1] - old_size[1]) // 2
kernel_h = cv2.getGaussianKernel(old_size[1], old_size[1] * sigma)
kernel_w = cv2.getGaussianKernel(old_size[0], old_size[0] * sigma)
kernel = np.multiply(kernel_h, np.transpose(kernel_w))
kernel[steps:-steps, steps:-steps] = 1
kernel[:steps, :steps] = kernel[:steps, :steps] / kernel[steps - 1, steps - 1]
kernel[:steps, -steps:] = kernel[:steps, -steps:] / kernel[steps - 1, -(steps)]
kernel[-steps:, :steps] = kernel[-steps:, :steps] / kernel[-steps, steps - 1]
kernel[-steps:, -steps:] = kernel[-steps:, -steps:] / kernel[-steps, -steps]
kernel = np.expand_dims(kernel, 2)
kernel = np.repeat(kernel, 3, 2)
weight = np.linspace(0, 1, steps)
top = np.expand_dims(weight, 1)
top = np.repeat(top, old_size[0] - 2 * steps, 1)
top = np.expand_dims(top, 2)
top = np.repeat(top, 3, 2)
weight = np.linspace(1, 0, steps)
down = np.expand_dims(weight, 1)
down = np.repeat(down, old_size[0] - 2 * steps, 1)
down = np.expand_dims(down, 2)
down = np.repeat(down, 3, 2)
weight = np.linspace(0, 1, steps)
left = np.expand_dims(weight, 0)
left = np.repeat(left, old_size[1] - 2 * steps, 0)
left = np.expand_dims(left, 2)
left = np.repeat(left, 3, 2)
weight = np.linspace(1, 0, steps)
right = np.expand_dims(weight, 0)
right = np.repeat(right, old_size[1] - 2 * steps, 0)
right = np.expand_dims(right, 2)
right = np.repeat(right, 3, 2)
kernel[:steps, steps:-steps] = top
kernel[-steps:, steps:-steps] = down
kernel[steps:-steps, :steps] = left
kernel[steps:-steps, -steps:] = right
pt_gt_img = easy_img[pos_h : pos_h + old_size[1], pos_w : pos_w + old_size[0]]
gaussian_gt_img = kernel * gt_img_array + (1 - kernel) * pt_gt_img # gt img with blur img
gaussian_gt_img = gaussian_gt_img.astype(np.int64)
easy_img[pos_h : pos_h + old_size[1], pos_w : pos_w + old_size[0]] = gaussian_gt_img
gaussian_img = Image.fromarray(easy_img)
return gaussian_img
def cut_dialogue_history(history_memory, keep_last_n_words=500):
if history_memory is None or len(history_memory) == 0:
return history_memory
tokens = history_memory.split()
n_tokens = len(tokens)
print(f"history_memory:{history_memory}, n_tokens: {n_tokens}")
if n_tokens < keep_last_n_words:
return history_memory
paragraphs = history_memory.split("\n")
last_n_tokens = n_tokens
while last_n_tokens >= keep_last_n_words:
last_n_tokens -= len(paragraphs[0].split(" "))
paragraphs = paragraphs[1:]
return "\n" + "\n".join(paragraphs)
def get_new_image_name(org_img_name, func_name="update"):
head_tail = os.path.split(org_img_name)
head = head_tail[0]
tail = head_tail[1]
name_split = tail.split(".")[0].split("_")
this_new_uuid = str(uuid.uuid4())[:4]
if len(name_split) == 1:
most_org_file_name = name_split[0]
else:
assert len(name_split) == 4
most_org_file_name = name_split[3]
recent_prev_file_name = name_split[0]
new_file_name = f"{this_new_uuid}_{func_name}_{recent_prev_file_name}_{most_org_file_name}.png"
return os.path.join(head, new_file_name)
class MaskFormer:
def __init__(self, device):
print(f"Initializing MaskFormer to {device}")
self.device = device
self.processor = CLIPSegProcessor.from_pretrained("CIDAS/clipseg-rd64-refined")
self.model = CLIPSegForImageSegmentation.from_pretrained("CIDAS/clipseg-rd64-refined").to(device)
def inference(self, image_path, text):
threshold = 0.5
min_area = 0.02
padding = 20
original_image = Image.open(image_path)
image = original_image.resize((512, 512))
inputs = self.processor(text=text, images=image, padding="max_length", return_tensors="pt").to(self.device)
with torch.no_grad():
outputs = self.model(**inputs)
mask = torch.sigmoid(outputs[0]).squeeze().cpu().numpy() > threshold
area_ratio = len(np.argwhere(mask)) / (mask.shape[0] * mask.shape[1])
if area_ratio < min_area:
return None
true_indices = np.argwhere(mask)
mask_array = np.zeros_like(mask, dtype=bool)
for idx in true_indices:
padded_slice = tuple(slice(max(0, i - padding), i + padding + 1) for i in idx)
mask_array[padded_slice] = True
visual_mask = (mask_array * 255).astype(np.uint8)
image_mask = Image.fromarray(visual_mask)
return image_mask.resize(original_image.size)
class ImageEditing:
def __init__(self, device):
print(f"Initializing ImageEditing to {device}")
self.device = device
self.mask_former = MaskFormer(device=self.device)
self.revision = "fp16" if "cuda" in device else None
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.inpaint = StableDiffusionInpaintPipeline.from_pretrained(
"runwayml/stable-diffusion-inpainting", revision=self.revision, torch_dtype=self.torch_dtype
).to(device)
@prompts(
name="Remove Something From The Photo",
description="useful when you want to remove and object or something from the photo "
"from its description or location. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the object need to be removed. ",
)
def inference_remove(self, inputs):
image_path, to_be_removed_txt = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
return self.inference_replace(f"{image_path},{to_be_removed_txt},background")
@prompts(
name="Replace Something From The Photo",
description="useful when you want to replace an object from the object description or "
"location with another object from its description. "
"The input to this tool should be a comma separated string of three, "
"representing the image_path, the object to be replaced, the object to be replaced with ",
)
def inference_replace(self, inputs):
image_path, to_be_replaced_txt, replace_with_txt = inputs.split(",")
original_image = Image.open(image_path)
original_size = original_image.size
mask_image = self.mask_former.inference(image_path, to_be_replaced_txt)
updated_image = self.inpaint(
prompt=replace_with_txt, image=original_image.resize((512, 512)), mask_image=mask_image.resize((512, 512))
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="replace-something")
updated_image = updated_image.resize(original_size)
updated_image.save(updated_image_path)
print(
f"\nProcessed ImageEditing, Input Image: {image_path}, Replace {to_be_replaced_txt} to {replace_with_txt}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class InstructPix2Pix:
def __init__(self, device):
print(f"Initializing InstructPix2Pix to {device}")
self.device = device
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.pipe = StableDiffusionInstructPix2PixPipeline.from_pretrained(
"timbrooks/instruct-pix2pix", safety_checker=None, torch_dtype=self.torch_dtype
).to(device)
self.pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(self.pipe.scheduler.config)
@prompts(
name="Instruct Image Using Text",
description="useful when you want to the style of the image to be like the text. "
"like: make it look like a painting. or make it like a robot. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the text. ",
)
def inference(self, inputs):
"""Change style of image."""
print("===>Starting InstructPix2Pix Inference")
image_path, text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
original_image = Image.open(image_path)
image = self.pipe(text, image=original_image, num_inference_steps=40, image_guidance_scale=1.2).images[0]
updated_image_path = get_new_image_name(image_path, func_name="pix2pix")
image.save(updated_image_path)
print(
f"\nProcessed InstructPix2Pix, Input Image: {image_path}, Instruct Text: {text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class Text2Image:
def __init__(self, device):
print(f"Initializing Text2Image to {device}")
self.device = device
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.pipe = StableDiffusionPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5", torch_dtype=self.torch_dtype
)
self.pipe.to(device)
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, "
"fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image From User Input Text",
description="useful when you want to generate an image from a user input text and save it to a file. "
"like: generate an image of an object or something, or generate an image that includes some objects. "
"The input to this tool should be a string, representing the text used to generate image. ",
)
def inference(self, text):
image_filename = os.path.join("image", f"{str(uuid.uuid4())[:8]}.png")
prompt = text + ", " + self.a_prompt
image = self.pipe(prompt, negative_prompt=self.n_prompt).images[0]
image.save(image_filename)
print(f"\nProcessed Text2Image, Input Text: {text}, Output Image: {image_filename}")
return image_filename
class ImageCaptioning:
def __init__(self, device):
print(f"Initializing ImageCaptioning to {device}")
self.device = device
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
self.model = BlipForConditionalGeneration.from_pretrained(
"Salesforce/blip-image-captioning-base", torch_dtype=self.torch_dtype
).to(self.device)
@prompts(
name="Get Photo Description",
description="useful when you want to know what is inside the photo. receives image_path as input. "
"The input to this tool should be a string, representing the image_path. ",
)
def inference(self, image_path):
inputs = self.processor(Image.open(image_path), return_tensors="pt").to(self.device, self.torch_dtype)
out = self.model.generate(**inputs)
captions = self.processor.decode(out[0], skip_special_tokens=True)
print(f"\nProcessed ImageCaptioning, Input Image: {image_path}, Output Text: {captions}")
return captions
class Image2Canny:
def __init__(self, device):
print("Initializing Image2Canny")
self.low_threshold = 100
self.high_threshold = 200
@prompts(
name="Edge Detection On Image",
description="useful when you want to detect the edge of the image. "
"like: detect the edges of this image, or canny detection on image, "
"or perform edge detection on this image, or detect the canny image of this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
image = np.array(image)
canny = cv2.Canny(image, self.low_threshold, self.high_threshold)
canny = canny[:, :, None]
canny = np.concatenate([canny, canny, canny], axis=2)
canny = Image.fromarray(canny)
updated_image_path = get_new_image_name(inputs, func_name="edge")
canny.save(updated_image_path)
print(f"\nProcessed Image2Canny, Input Image: {inputs}, Output Text: {updated_image_path}")
return updated_image_path
class CannyText2Image:
def __init__(self, device):
print(f"Initializing CannyText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-canny", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, "
"fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Canny Image",
description="useful when you want to generate a new real image from both the user description and a canny image."
" like: generate a real image of a object or something from this canny image,"
" or generate a new real image of a object or something from this edge image. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description. ",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="canny2image")
image.save(updated_image_path)
print(
f"\nProcessed CannyText2Image, Input Canny: {image_path}, Input Text: {instruct_text}, "
f"Output Text: {updated_image_path}"
)
return updated_image_path
class Image2Line:
def __init__(self, device):
print("Initializing Image2Line")
self.detector = MLSDdetector.from_pretrained("lllyasviel/ControlNet")
@prompts(
name="Line Detection On Image",
description="useful when you want to detect the straight line of the image. "
"like: detect the straight lines of this image, or straight line detection on image, "
"or perform straight line detection on this image, or detect the straight line image of this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
mlsd = self.detector(image)
updated_image_path = get_new_image_name(inputs, func_name="line-of")
mlsd.save(updated_image_path)
print(f"\nProcessed Image2Line, Input Image: {inputs}, Output Line: {updated_image_path}")
return updated_image_path
class LineText2Image:
def __init__(self, device):
print(f"Initializing LineText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-mlsd", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, "
"fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Line Image",
description="useful when you want to generate a new real image from both the user description "
"and a straight line image. "
"like: generate a real image of a object or something from this straight line image, "
"or generate a new real image of a object or something from this straight lines. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description. ",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="line2image")
image.save(updated_image_path)
print(
f"\nProcessed LineText2Image, Input Line: {image_path}, Input Text: {instruct_text}, "
f"Output Text: {updated_image_path}"
)
return updated_image_path
class Image2Hed:
def __init__(self, device):
print("Initializing Image2Hed")
self.detector = HEDdetector.from_pretrained("lllyasviel/ControlNet")
@prompts(
name="Hed Detection On Image",
description="useful when you want to detect the soft hed boundary of the image. "
"like: detect the soft hed boundary of this image, or hed boundary detection on image, "
"or perform hed boundary detection on this image, or detect soft hed boundary image of this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
hed = self.detector(image)
updated_image_path = get_new_image_name(inputs, func_name="hed-boundary")
hed.save(updated_image_path)
print(f"\nProcessed Image2Hed, Input Image: {inputs}, Output Hed: {updated_image_path}")
return updated_image_path
class HedText2Image:
def __init__(self, device):
print(f"Initializing HedText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-hed", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, "
"fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Soft Hed Boundary Image",
description="useful when you want to generate a new real image from both the user description "
"and a soft hed boundary image. "
"like: generate a real image of a object or something from this soft hed boundary image, "
"or generate a new real image of a object or something from this hed boundary. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="hed2image")
image.save(updated_image_path)
print(
f"\nProcessed HedText2Image, Input Hed: {image_path}, Input Text: {instruct_text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class Image2Scribble:
def __init__(self, device):
print("Initializing Image2Scribble")
self.detector = HEDdetector.from_pretrained("lllyasviel/ControlNet")
@prompts(
name="Sketch Detection On Image",
description="useful when you want to generate a scribble of the image. "
"like: generate a scribble of this image, or generate a sketch from this image, "
"detect the sketch from this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
scribble = self.detector(image, scribble=True)
updated_image_path = get_new_image_name(inputs, func_name="scribble")
scribble.save(updated_image_path)
print(f"\nProcessed Image2Scribble, Input Image: {inputs}, Output Scribble: {updated_image_path}")
return updated_image_path
class ScribbleText2Image:
def __init__(self, device):
print(f"Initializing ScribbleText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-scribble", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, "
"fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Sketch Image",
description="useful when you want to generate a new real image from both the user description and "
"a scribble image or a sketch image. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="scribble2image")
image.save(updated_image_path)
print(
f"\nProcessed ScribbleText2Image, Input Scribble: {image_path}, Input Text: {instruct_text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class Image2Pose:
def __init__(self, device):
print("Initializing Image2Pose")
self.detector = OpenposeDetector.from_pretrained("lllyasviel/ControlNet")
@prompts(
name="Pose Detection On Image",
description="useful when you want to detect the human pose of the image. "
"like: generate human poses of this image, or generate a pose image from this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
pose = self.detector(image)
updated_image_path = get_new_image_name(inputs, func_name="human-pose")
pose.save(updated_image_path)
print(f"\nProcessed Image2Pose, Input Image: {inputs}, Output Pose: {updated_image_path}")
return updated_image_path
class PoseText2Image:
def __init__(self, device):
print(f"Initializing PoseText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-openpose", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.num_inference_steps = 20
self.seed = -1
self.unconditional_guidance_scale = 9.0
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,"
" fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Pose Image",
description="useful when you want to generate a new real image from both the user description "
"and a human pose image. "
"like: generate a real image of a human from this human pose image, "
"or generate a new real image of a human from this pose. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="pose2image")
image.save(updated_image_path)
print(
f"\nProcessed PoseText2Image, Input Pose: {image_path}, Input Text: {instruct_text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class Image2Seg:
def __init__(self, device):
print("Initializing Image2Seg")
self.image_processor = AutoImageProcessor.from_pretrained("openmmlab/upernet-convnext-small")
self.image_segmentor = UperNetForSemanticSegmentation.from_pretrained("openmmlab/upernet-convnext-small")
self.ade_palette = [
[120, 120, 120],
[180, 120, 120],
[6, 230, 230],
[80, 50, 50],
[4, 200, 3],
[120, 120, 80],
[140, 140, 140],
[204, 5, 255],
[230, 230, 230],
[4, 250, 7],
[224, 5, 255],
[235, 255, 7],
[150, 5, 61],
[120, 120, 70],
[8, 255, 51],
[255, 6, 82],
[143, 255, 140],
[204, 255, 4],
[255, 51, 7],
[204, 70, 3],
[0, 102, 200],
[61, 230, 250],
[255, 6, 51],
[11, 102, 255],
[255, 7, 71],
[255, 9, 224],
[9, 7, 230],
[220, 220, 220],
[255, 9, 92],
[112, 9, 255],
[8, 255, 214],
[7, 255, 224],
[255, 184, 6],
[10, 255, 71],
[255, 41, 10],
[7, 255, 255],
[224, 255, 8],
[102, 8, 255],
[255, 61, 6],
[255, 194, 7],
[255, 122, 8],
[0, 255, 20],
[255, 8, 41],
[255, 5, 153],
[6, 51, 255],
[235, 12, 255],
[160, 150, 20],
[0, 163, 255],
[140, 140, 140],
[250, 10, 15],
[20, 255, 0],
[31, 255, 0],
[255, 31, 0],
[255, 224, 0],
[153, 255, 0],
[0, 0, 255],
[255, 71, 0],
[0, 235, 255],
[0, 173, 255],
[31, 0, 255],
[11, 200, 200],
[255, 82, 0],
[0, 255, 245],
[0, 61, 255],
[0, 255, 112],
[0, 255, 133],
[255, 0, 0],
[255, 163, 0],
[255, 102, 0],
[194, 255, 0],
[0, 143, 255],
[51, 255, 0],
[0, 82, 255],
[0, 255, 41],
[0, 255, 173],
[10, 0, 255],
[173, 255, 0],
[0, 255, 153],
[255, 92, 0],
[255, 0, 255],
[255, 0, 245],
[255, 0, 102],
[255, 173, 0],
[255, 0, 20],
[255, 184, 184],
[0, 31, 255],
[0, 255, 61],
[0, 71, 255],
[255, 0, 204],
[0, 255, 194],
[0, 255, 82],
[0, 10, 255],
[0, 112, 255],
[51, 0, 255],
[0, 194, 255],
[0, 122, 255],
[0, 255, 163],
[255, 153, 0],
[0, 255, 10],
[255, 112, 0],
[143, 255, 0],
[82, 0, 255],
[163, 255, 0],
[255, 235, 0],
[8, 184, 170],
[133, 0, 255],
[0, 255, 92],
[184, 0, 255],
[255, 0, 31],
[0, 184, 255],
[0, 214, 255],
[255, 0, 112],
[92, 255, 0],
[0, 224, 255],
[112, 224, 255],
[70, 184, 160],
[163, 0, 255],
[153, 0, 255],
[71, 255, 0],
[255, 0, 163],
[255, 204, 0],
[255, 0, 143],
[0, 255, 235],
[133, 255, 0],
[255, 0, 235],
[245, 0, 255],
[255, 0, 122],
[255, 245, 0],
[10, 190, 212],
[214, 255, 0],
[0, 204, 255],
[20, 0, 255],
[255, 255, 0],
[0, 153, 255],
[0, 41, 255],
[0, 255, 204],
[41, 0, 255],
[41, 255, 0],
[173, 0, 255],
[0, 245, 255],
[71, 0, 255],
[122, 0, 255],
[0, 255, 184],
[0, 92, 255],
[184, 255, 0],
[0, 133, 255],
[255, 214, 0],
[25, 194, 194],
[102, 255, 0],
[92, 0, 255],
]
@prompts(
name="Segmentation On Image",
description="useful when you want to detect segmentations of the image. "
"like: segment this image, or generate segmentations on this image, "
"or perform segmentation on this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
pixel_values = self.image_processor(image, return_tensors="pt").pixel_values
with torch.no_grad():
outputs = self.image_segmentor(pixel_values)
seg = self.image_processor.post_process_semantic_segmentation(outputs, target_sizes=[image.size[::-1]])[0]
color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8) # height, width, 3
palette = np.array(self.ade_palette)
for label, color in enumerate(palette):
color_seg[seg == label, :] = color
color_seg = color_seg.astype(np.uint8)
segmentation = Image.fromarray(color_seg)
updated_image_path = get_new_image_name(inputs, func_name="segmentation")
segmentation.save(updated_image_path)
print(f"\nProcessed Image2Seg, Input Image: {inputs}, Output Pose: {updated_image_path}")
return updated_image_path
class SegText2Image:
def __init__(self, device):
print(f"Initializing SegText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-seg", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,"
" fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Segmentations",
description="useful when you want to generate a new real image from both the user description and segmentations. "
"like: generate a real image of a object or something from this segmentation image, "
"or generate a new real image of a object or something from these segmentations. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="segment2image")
image.save(updated_image_path)
print(
f"\nProcessed SegText2Image, Input Seg: {image_path}, Input Text: {instruct_text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class Image2Depth:
def __init__(self, device):
print("Initializing Image2Depth")
self.depth_estimator = pipeline("depth-estimation")
@prompts(
name="Predict Depth On Image",
description="useful when you want to detect depth of the image. like: generate the depth from this image, "
"or detect the depth map on this image, or predict the depth for this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
depth = self.depth_estimator(image)["depth"]
depth = np.array(depth)
depth = depth[:, :, None]
depth = np.concatenate([depth, depth, depth], axis=2)
depth = Image.fromarray(depth)
updated_image_path = get_new_image_name(inputs, func_name="depth")
depth.save(updated_image_path)
print(f"\nProcessed Image2Depth, Input Image: {inputs}, Output Depth: {updated_image_path}")
return updated_image_path
class DepthText2Image:
def __init__(self, device):
print(f"Initializing DepthText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-depth", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,"
" fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Depth",
description="useful when you want to generate a new real image from both the user description and depth image. "
"like: generate a real image of a object or something from this depth image, "
"or generate a new real image of a object or something from the depth map. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="depth2image")
image.save(updated_image_path)
print(
f"\nProcessed DepthText2Image, Input Depth: {image_path}, Input Text: {instruct_text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class Image2Normal:
def __init__(self, device):
print("Initializing Image2Normal")
self.depth_estimator = pipeline("depth-estimation", model="Intel/dpt-hybrid-midas")
self.bg_threhold = 0.4
@prompts(
name="Predict Normal Map On Image",
description="useful when you want to detect norm map of the image. "
"like: generate normal map from this image, or predict normal map of this image. "
"The input to this tool should be a string, representing the image_path",
)
def inference(self, inputs):
image = Image.open(inputs)
original_size = image.size
image = self.depth_estimator(image)["predicted_depth"][0]
image = image.numpy()
image_depth = image.copy()
image_depth -= np.min(image_depth)
image_depth /= np.max(image_depth)
x = cv2.Sobel(image, cv2.CV_32F, 1, 0, ksize=3)
x[image_depth < self.bg_threhold] = 0
y = cv2.Sobel(image, cv2.CV_32F, 0, 1, ksize=3)
y[image_depth < self.bg_threhold] = 0
z = np.ones_like(x) * np.pi * 2.0
image = np.stack([x, y, z], axis=2)
image /= np.sum(image**2.0, axis=2, keepdims=True) ** 0.5
image = (image * 127.5 + 127.5).clip(0, 255).astype(np.uint8)
image = Image.fromarray(image)
image = image.resize(original_size)
updated_image_path = get_new_image_name(inputs, func_name="normal-map")
image.save(updated_image_path)
print(f"\nProcessed Image2Normal, Input Image: {inputs}, Output Depth: {updated_image_path}")
return updated_image_path
class NormalText2Image:
def __init__(self, device):
print(f"Initializing NormalText2Image to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.controlnet = ControlNetModel.from_pretrained(
"fusing/stable-diffusion-v1-5-controlnet-normal", torch_dtype=self.torch_dtype
)
self.pipe = StableDiffusionControlNetPipeline.from_pretrained(
"runwayml/stable-diffusion-v1-5",
controlnet=self.controlnet,
safety_checker=None,
torch_dtype=self.torch_dtype,
)
self.pipe.scheduler = UniPCMultistepScheduler.from_config(self.pipe.scheduler.config)
self.pipe.to(device)
self.seed = -1
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit,"
" fewer digits, cropped, worst quality, low quality"
)
@prompts(
name="Generate Image Condition On Normal Map",
description="useful when you want to generate a new real image from both the user description and normal map. "
"like: generate a real image of a object or something from this normal map, "
"or generate a new real image of a object or something from the normal map. "
"The input to this tool should be a comma separated string of two, "
"representing the image_path and the user description",
)
def inference(self, inputs):
image_path, instruct_text = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
image = Image.open(image_path)
self.seed = random.randint(0, 65535)
seed_everything(self.seed)
prompt = f"{instruct_text}, {self.a_prompt}"
image = self.pipe(
prompt, image, num_inference_steps=20, eta=0.0, negative_prompt=self.n_prompt, guidance_scale=9.0
).images[0]
updated_image_path = get_new_image_name(image_path, func_name="normal2image")
image.save(updated_image_path)
print(
f"\nProcessed NormalText2Image, Input Normal: {image_path}, Input Text: {instruct_text}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class VisualQuestionAnswering:
def __init__(self, device):
print(f"Initializing VisualQuestionAnswering to {device}")
self.torch_dtype = torch.float16 if "cuda" in device else torch.float32
self.device = device
self.processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-base")
self.model = BlipForQuestionAnswering.from_pretrained(
"Salesforce/blip-vqa-base", torch_dtype=self.torch_dtype
).to(self.device)
@prompts(
name="Answer Question About The Image",
description="useful when you need an answer for a question based on an image. "
"like: what is the background color of the last image, how many cats in this figure, what is in this figure. "
"The input to this tool should be a comma separated string of two, representing the image_path and the question",
)
def inference(self, inputs):
image_path, question = inputs.split(",")[0], ",".join(inputs.split(",")[1:])
raw_image = Image.open(image_path).convert("RGB")
inputs = self.processor(raw_image, question, return_tensors="pt").to(self.device, self.torch_dtype)
out = self.model.generate(**inputs)
answer = self.processor.decode(out[0], skip_special_tokens=True)
print(
f"\nProcessed VisualQuestionAnswering, Input Image: {image_path}, Input Question: {question}, "
f"Output Answer: {answer}"
)
return answer
class InfinityOutPainting:
template_model = True # Add this line to show this is a template model.
def __init__(self, ImageCaptioning, ImageEditing, VisualQuestionAnswering):
self.llm = OpenAI(temperature=0)
self.ImageCaption = ImageCaptioning
self.ImageEditing = ImageEditing
self.ImageVQA = VisualQuestionAnswering
self.a_prompt = "best quality, extremely detailed"
self.n_prompt = (
"longbody, lowres, bad anatomy, bad hands, missing fingers, extra digit, "
"fewer digits, cropped, worst quality, low quality"
)
def get_BLIP_vqa(self, image, question):
inputs = self.ImageVQA.processor(image, question, return_tensors="pt").to(
self.ImageVQA.device, self.ImageVQA.torch_dtype
)
out = self.ImageVQA.model.generate(**inputs)
answer = self.ImageVQA.processor.decode(out[0], skip_special_tokens=True)
print(f"\nProcessed VisualQuestionAnswering, Input Question: {question}, Output Answer: {answer}")
return answer
def get_BLIP_caption(self, image):
inputs = self.ImageCaption.processor(image, return_tensors="pt").to(
self.ImageCaption.device, self.ImageCaption.torch_dtype
)
out = self.ImageCaption.model.generate(**inputs)
BLIP_caption = self.ImageCaption.processor.decode(out[0], skip_special_tokens=True)
return BLIP_caption
def check_prompt(self, prompt):
check = (
f"Here is a paragraph with adjectives. "
f"{prompt} "
f"Please change all plural forms in the adjectives to singular forms. "
)
return self.llm(check)
def get_imagine_caption(self, image, imagine):
BLIP_caption = self.get_BLIP_caption(image)
background_color = self.get_BLIP_vqa(image, "what is the background color of this image")
style = self.get_BLIP_vqa(image, "what is the style of this image")
imagine_prompt = (
f"let's pretend you are an excellent painter and now "
f"there is an incomplete painting with {BLIP_caption} in the center, "
f"please imagine the complete painting and describe it"
f"you should consider the background color is {background_color}, the style is {style}"
f"You should make the painting as vivid and realistic as possible"
f"You can not use words like painting or picture"
f"and you should use no more than 50 words to describe it"
)
caption = self.llm(imagine_prompt) if imagine else BLIP_caption
caption = self.check_prompt(caption)
print(f"BLIP observation: {BLIP_caption}, ChatGPT imagine to {caption}") if imagine else print(
f"Prompt: {caption}"
)
return caption
def resize_image(self, image, max_size=1000000, multiple=8):
aspect_ratio = image.size[0] / image.size[1]
new_width = int(math.sqrt(max_size * aspect_ratio))
new_height = int(new_width / aspect_ratio)
new_width, new_height = new_width - (new_width % multiple), new_height - (new_height % multiple)
return image.resize((new_width, new_height))
def dowhile(self, original_img, tosize, expand_ratio, imagine, usr_prompt):
old_img = original_img
while old_img.size != tosize:
prompt = self.check_prompt(usr_prompt) if usr_prompt else self.get_imagine_caption(old_img, imagine)
crop_w = 15 if old_img.size[0] != tosize[0] else 0
crop_h = 15 if old_img.size[1] != tosize[1] else 0
old_img = ImageOps.crop(old_img, (crop_w, crop_h, crop_w, crop_h))
temp_canvas_size = (
expand_ratio * old_img.width if expand_ratio * old_img.width < tosize[0] else tosize[0],
expand_ratio * old_img.height if expand_ratio * old_img.height < tosize[1] else tosize[1],
)
temp_canvas, temp_mask = Image.new("RGB", temp_canvas_size, color="white"), Image.new(
"L", temp_canvas_size, color="white"
)
x, y = (temp_canvas.width - old_img.width) // 2, (temp_canvas.height - old_img.height) // 2
temp_canvas.paste(old_img, (x, y))
temp_mask.paste(0, (x, y, x + old_img.width, y + old_img.height))
resized_temp_canvas, resized_temp_mask = self.resize_image(temp_canvas), self.resize_image(temp_mask)
image = (
self.ImageEditing.inpaint(
prompt=prompt,
image=resized_temp_canvas,
mask_image=resized_temp_mask,
height=resized_temp_canvas.height,
width=resized_temp_canvas.width,
num_inference_steps=50,
)
.images[0]
.resize((temp_canvas.width, temp_canvas.height), Image.ANTIALIAS)
)
image = blend_gt2pt(old_img, image)
old_img = image
return old_img
@prompts(
name="Extend An Image",
description="useful when you need to extend an image into a larger image."
"like: extend the image into a resolution of 2048x1024, extend the image into 2048x1024. "
"The input to this tool should be a comma separated string of two, representing the image_path and the resolution of widthxheight",
)
def inference(self, inputs):
image_path, resolution = inputs.split(",")
width, height = resolution.split("x")
tosize = (int(width), int(height))
image = Image.open(image_path)
image = ImageOps.crop(image, (10, 10, 10, 10))
out_painted_image = self.dowhile(image, tosize, 4, True, False)
updated_image_path = get_new_image_name(image_path, func_name="outpainting")
out_painted_image.save(updated_image_path)
print(
f"\nProcessed InfinityOutPainting, Input Image: {image_path}, Input Resolution: {resolution}, "
f"Output Image: {updated_image_path}"
)
return updated_image_path
class ConversationBot:
def __init__(self, load_dict):
# load_dict = {'VisualQuestionAnswering':'cuda:0', 'ImageCaptioning':'cuda:1',...}
print(f"Initializing Visual OpenLLM, load_dict={load_dict}")
# if "ImageCaptioning" not in load_dict:
# raise ValueError("You have to load ImageCaptioning as a basic function for VisualChatGPT")
self.llm = OpenAI(temperature=0)
self.memory = ConversationBufferMemory(memory_key="chat_history", output_key="output")
self.models = {}
# Load Basic Foundation Models
for class_name, device in load_dict.items():
self.models[class_name] = globals()[class_name](device=device)
# Load Template Foundation Models
for class_name, module in globals().items():
if getattr(module, "template_model", False):
template_required_names = {
k for k in inspect.signature(module.__init__).parameters.keys() if k != "self"
}
loaded_names = set([type(e).__name__ for e in self.models.values()])
if template_required_names.issubset(loaded_names):
self.models[class_name] = globals()[class_name](
**{name: self.models[name] for name in template_required_names}
)
self.tools = []
for instance in self.models.values():
for e in dir(instance):
if e.startswith("inference"):
func = getattr(instance, e)
self.tools.append(Tool(name=func.name, description=func.description, func=func))
self.agent = initialize_agent(
self.tools,
self.llm,
agent="conversational-react-description",
verbose=True,
memory=self.memory,
return_intermediate_steps=True,
agent_kwargs={
"prefix": VISUAL_CHATGPT_PREFIX,
"format_instructions": VISUAL_CHATGPT_FORMAT_INSTRUCTIONS,
"suffix": VISUAL_CHATGPT_SUFFIX,
},
)
def run_text(self, text, state):
self.agent.memory.buffer = cut_dialogue_history(self.agent.memory.buffer, keep_last_n_words=500)
res = self.agent({"input": text})
res["output"] = res["output"].replace("\\", "/")
response = re.sub("(image/\S*png)", lambda m: f"})*{m.group(0)}*", res["output"])
state = state + [(text, response)]
print(
f"\nProcessed run_text, Input text: {text}\nCurrent state: {state}\n"
f"Current Memory: {self.agent.memory.buffer}"
)
return state, state
def run_image(self, image, state, txt):
image_filename = os.path.join("image", f"{str(uuid.uuid4())[:8]}.png")
print("======>Auto Resize Image...")
img = Image.open(image.name)
width, height = img.size
ratio = min(512 / width, 512 / height)
width_new, height_new = (round(width * ratio), round(height * ratio))
width_new = int(np.round(width_new / 64.0)) * 64
height_new = int(np.round(height_new / 64.0)) * 64
img = img.resize((width_new, height_new))
img = img.convert("RGB")
img.save(image_filename, "PNG")
print(f"Resize image form {width}x{height} to {width_new}x{height_new}")
description = self.models["ImageCaptioning"].inference(image_filename)
Human_prompt = f'\nHuman: provide a figure named {image_filename}. The description is: {description}. This information helps you to understand this image, but you should use tools to finish following tasks, rather than directly imagine from my description. If you understand, say "Received". \n'
AI_prompt = "Received. "
self.agent.memory.buffer = self.agent.memory.buffer + Human_prompt + "AI: " + AI_prompt
state = state + [(f"*{image_filename}*", AI_prompt)]
print(
f"\nProcessed run_image, Input image: {image_filename}\nCurrent state: {state}\n"
f"Current Memory: {self.agent.memory.buffer}"
)
return state, state, f"{txt} {image_filename} "
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--load", type=str, default="Text2Image_cuda:0")
parser.add_argument("--port", type=int, default=1015)
args = parser.parse_args()
server_port = args.port
load_dict = {e.split("_")[0].strip(): e.split("_")[1].strip() for e in args.load.split(",")}
bot = ConversationBot(load_dict=load_dict)
with gr.Blocks(css="#chatbot .overflow-y-auto{height:500px} img {max-height: 100% !important}") as demo:
chatbot = gr.Chatbot(elem_id="chatbot", label="Visual OpenLLM")
state = gr.State([])
with gr.Row():
with gr.Column(scale=0.7):
txt = gr.Textbox(show_label=False, placeholder="Enter text and press enter, or upload an image").style(
container=False
)
with gr.Column(scale=0.15, min_width=0):
clear = gr.Button("Clear")
with gr.Column(scale=0.15, min_width=0):
btn = gr.UploadButton("Upload", file_types=["image"])
txt.submit(bot.run_text, [txt, state], [chatbot, state])
txt.submit(lambda: "", None, txt)
btn.upload(bot.run_image, [btn, state, txt], [chatbot, state, txt])
clear.click(bot.memory.clear)
clear.click(lambda: [], None, chatbot)
clear.click(lambda: [], None, state)
demo.launch(server_name="0.0.0.0", server_port=server_port)
| [
"True",
"Received. ",
"let's pretend you are an excellent painter and now there is an incomplete painting with PLACEHOLDER in the center, please imagine the complete painting and describe ityou should consider the background color is PLACEHOLDER, the style is PLACEHOLDERYou should make the painting as vivid and realistic as possibleYou can not use words like painting or pictureand you should use no more than 50 words to describe it",
"\nHuman: provide a figure named PLACEHOLDER. The description is: PLACEHOLDER. This information helps you to understand this image, but you should use tools to finish following tasks, rather than directly imagine from my description. If you understand, say \"Received\". \n",
", "
] |
2024-01-10 | Ifechukwu001/Video-Manager | models~video.py | """Video Model"""
import os
from uuid import uuid4
from sqlalchemy import Column, String, Integer
from sqlalchemy.ext.declarative import declarative_base
import cv2
import openai
from moviepy.editor import VideoFileClip
import models
Base = declarative_base()
openai.api_key = os.getenv("OPENAI_KEY")
class Video(Base):
__tablename__ = "videos"
id = Column(String(25), primary_key=True)
filepath = Column(String(150), unique=True)
transcript = Column(String(1024), nullable=True)
videofile = None
def __init__(self, name: str, filepath: str):
"""Initializes the Video model"""
self.id = str(uuid4())
self.name = name
self.filepath = filepath
models.storage.new(self)
def save(self):
models.storage.save()
def connect(self):
self.videofile = cv2.VideoCapture(self.filepath)
def get_frame(self):
success, frame = self.videofile.read()
if success:
_, jpeg = cv2.imencode(".jpg", frame)
return jpeg.tobytes()
return False
@classmethod
def transcribe(cls, filepath):
filepath = filepath
audio_file = "test.wav"
# audio_file = f"{filepath.split('.')[0]}.wav"
try:
with VideoFileClip(filepath) as clip:
audio = clip.audio
audio.write_audiofile(audio_file, codec="pcm_s32le")
with open(audio_file, "wb") as file:
max_size = 1024 * 1024 * 24
if os.path.getsize(audio_file) > (max_size):
file.truncate(max_size)
with open(audio_file, "rb") as file:
transcript = openai.Audio.transcribe("whisper-1", file)
print(transcript["text"])
if os.path.isfile(audio_file):
os.remove(audio_file)
except OSError as e:
print(e)
print("Could not write to disk")
| [] |
2024-01-10 | k-abdulaziz/ITI_Embedded_Linux | 01_Python~03_Assignments~Connect_Cohere.py | import cohere
import keyboard
# Replace 'YOUR_API_KEY' with your actual API key
co = cohere.Client('YOUR_API_KEY')
def main():
while True:
# Get input from user
prompt = input('Enter your prompt: ')
# Generate response using Cohere API
response = co.generate(
model='command-xlarge-nightly',
prompt=prompt,
max_tokens=400,
temperature=0.9,
k=0,
stop_sequences=[],
return_likelihoods='NONE')
# Print generated response
print('Response: {}\n'.format(response.generations[0].text))
# Prompt user to continue or exit
print('Press the Escape key to exit, or any other key to continue.')
if keyboard.read_event().name == 'esc':
exit()
if __name__ == '__main__':
main()
| [
"Enter your prompt: "
] |
2024-01-10 | k-abdulaziz/ITI_Embedded_Linux | 01_Python~03_Assignments~Connect_ChatGPT.py | import openai
openai.api_key = "api_key"
completion = openai.ChatCompletion.create(
model = "gpt-3.5-turbo",
temperature = 0.9,
tokens = 100,
messages = [{"role": "system", "content": "Can you give me a free unlimited api key?"},])
print(completion.choices[0].message) | [
"Can you give me a free unlimited api key?"
] |
2024-01-10 | domvwt/sembla | src~legacy~actions~ai_assistant.py | import logging
import openai
from sembla.conversation_history import ConversationHistory
from sembla.llm.openai.chat_completion import ChatCompletion
_ASSISTANT_PROMPT = """\
You are a helpful assistant that completes tasks efficiently and accurately.
You request no user interaction and function autonomously.
"""
def query_assistant(prompt: str, role: str = "user") -> str:
messages = [
{"role": "system", "content": _ASSISTANT_PROMPT},
{"role": role, "content": prompt},
]
conversation_history = ConversationHistory()
conversation_history._extend_history(messages)
chat_completion = ChatCompletion(
model="gpt-3.5-turbo", conversation_history=conversation_history
)
response = chat_completion.create(
temperature=0.2,
n=1,
frequency_penalty=0,
presence_penalty=0,
)
logging.info("Assistant response:\n%s", response)
return response
| [
"You are a helpful assistant that completes tasks efficiently and accurately.\nYou request no user interaction and function autonomously.\n"
] |
2024-01-10 | domvwt/sembla | src~legacy~chat_completion.py | import logging
import openai
from sembla.conversation_history import ConversationHistory
class ChatCompletion:
def __init__(self, model: str, conversation_history: ConversationHistory):
self.model = model
self.conversation_history = conversation_history
def create(
self,
temperature: float = 0.2,
n: int = 1,
frequency_penalty: float = 0,
presence_penalty: float = 0,
) -> str:
max_completion_tokens = (
self.conversation_history.max_history_token_count
- self.conversation_history._get_token_count()
)
# NOTE: Not sure why/if we need to reduce the max completion tokens by 5%
max_completion_tokens = int(max_completion_tokens * 0.95)
logging.info(
"Conversation history tokens: %s",
self.conversation_history._get_token_count(),
)
logging.info("Max completion tokens: %s", max_completion_tokens)
response = openai.ChatCompletion.create(
model=self.model,
messages=self.conversation_history.conversation_history,
temperature=temperature,
n=n,
max_tokens=max_completion_tokens,
frequency_penalty=frequency_penalty,
presence_penalty=presence_penalty,
)
top_response = response.choices[0] # type: ignore
message_content = top_response["message"]["content"].strip()
top_response["message"]["content"] = "..."
logging.info("Top response:\n%s", top_response)
logging.info("Message content:\n%s", message_content)
self.conversation_history.add_message(
{"role": "assistant", "content": message_content}
)
return message_content
| [] |
2024-01-10 | jerome3o/claude-scratch | learning~llm~llm.py | from abc import ABC, abstractmethod
from anthropic import Anthropic
from anthropic.types import Completion
class Llm(ABC):
@abstractmethod
def complete(self, prompt: str) -> bool:
pass
class AnthropicLlm(Llm):
def __init__(self, client: Anthropic = None):
self._client = client or Anthropic()
def complete(self, prompt: str) -> bool:
response: Completion = self._client.completions.create(
prompt=prompt,
max_tokens_to_sample=300,
model="claude-2",
)
return "{" + response.completion
| [] |
2024-01-10 | jerome3o/claude-scratch | learning~tools~common.py | import json
from typing import Type, TypeVar, Callable, Generic
from pydantic import BaseModel
from learning.llm.llm import Llm
from anthropic import HUMAN_PROMPT, AI_PROMPT
_Parameters = TypeVar("_Parameters", bound=BaseModel)
class SchemaTool(BaseModel, Generic[_Parameters]):
parameters: Type[_Parameters]
evaluate: Callable[[_Parameters], str]
description: str = None
name: str = None
template: str = None
def run(self, llm: Llm, context: str) -> str:
template = self.template or _DEFAULT_TEMPLATE
prompt = build_pydantic_tool_prompt(
tool_name=self.name,
description=self.description,
response_model=self.parameters,
context=context,
template=template,
)
response = llm.complete(prompt)
# todo retry validation?
parameters = self.parameters.model_validate_json(response)
return self.evaluate(parameters)
_DEFAULT_TEMPLATE = f"""{HUMAN_PROMPT} \
You an AI assistant using the "{{tool_name}}" tool, this is it's description: {{description}}
Your answer should be a valid JSON object that follows this schema:
{{json_schema}}
The situation you are using the tool in is: {{context}}
Please respond directly with an instance of the above schema, include no additional text.
{AI_PROMPT} {{{{\
"""
def build_pydantic_tool_prompt(
tool_name: str,
description: str,
response_model: BaseModel,
context: str,
template: str = None,
) -> str:
template = template or _DEFAULT_TEMPLATE
json_schema = json.dumps(response_model.model_json_schema(), indent=2)
return _DEFAULT_TEMPLATE.format(
tool_name=tool_name,
description=description,
json_schema=json_schema,
context=context,
)
| [
"{tool_name}",
"PLACEHOLDER You an AI assistant using the \"{tool_name}\" tool, this is it's description: {description}\n\nYour answer should be a valid JSON object that follows this schema:\n{json_schema}\n\nThe situation you are using the tool in is: {context}\n\nPlease respond directly with an instance of the above schema, include no additional text.\n\nPLACEHOLDER {{",
"None"
] |
2024-01-10 | jerome3o/claude-scratch | scripts~run_email_tool.py | from learning.llm.llm import AnthropicLlm
from learning.tools.email import email_tool
def main():
llm = AnthropicLlm()
result = email_tool.run(
llm=llm,
context="I want to send an email to [email protected] with a poem about frogs",
)
print(result)
if __name__ == "__main__":
import logging
logging.basicConfig(level=logging.INFO)
main()
| [] |
2024-01-10 | jerome3o/claude-scratch | learning~json_schema.py | import json
from anthropic import Anthropic, HUMAN_PROMPT, AI_PROMPT
from pydantic import BaseModel
class CalendarEvent(BaseModel):
name: str
description: str
date: str
location: str
def main():
client = Anthropic()
schema_text = json.dumps(CalendarEvent.model_json_schema(), indent=2)
completion = client.completions.create(
model="claude-2",
max_tokens_to_sample=300,
prompt=f"{HUMAN_PROMPT} Generate a calendar event for a dentist appointment on Tuesday that follows the schema:\n{schema_text}{AI_PROMPT} {{",
)
print(completion.completion)
if __name__ == "__main__":
import logging
logging.basicConfig(level=logging.INFO)
main()
| [
"PLACEHOLDER Generate a calendar event for a dentist appointment on Tuesday that follows the schema:\nPLACEHOLDERPLACEHOLDER {"
] |
2024-01-10 | lovedeepkaursaini/FuzzMatchGPT | FuzzMatchGPT~FuzzMatchGPT.py | import openai
from sklearn.neighbors import NearestNeighbors
import pandas as pd
def get_embedding(text):
result = openai.Embedding.create(
model='text-embedding-ada-002',
input=text
)
return result["data"][0]["embedding"]
def fuzzy_match(target_df, source_df, columns, threshold=0.85):
"""
Function to perform fuzzy matching between two dataframes on specified columns.
Parameters:
target_df (pd.DataFrame): The dataframe to be matched to.
source_df (pd.DataFrame): The dataframe to be matched from.
columns (list of str): The columns to perform fuzzy matching on.
threshold (float, optional): The cosine similarity threshold for a match to be considered 'good'. Defaults to 0.85.
Returns:
pd.DataFrame: A new dataframe where each specified column in source_df is matched against the corresponding column in target_df,
with similarity scores and 'good'/'bad' match indicators for each column.
"""
matched_results = source_df.copy()
for column in columns:
target_df[column + '_embeddings'] = target_df[column].apply(get_embedding)
source_df[column + '_embeddings'] = source_df[column].apply(get_embedding)
nn = NearestNeighbors(n_neighbors=1, metric='cosine').fit(target_df[column + '_embeddings'].to_list())
distances, indices = nn.kneighbors(source_df[column + '_embeddings'].to_list(), return_distance=True)
matched_results[column + '_matched_to'] = [target_df.loc[indices[i, 0], column] for i in range(source_df.shape[0])]
matched_results[column + '_similarity'] = 1 - distances
matched_results[column + '_is_good_match'] = ['good' if 1 - distances[i, 0] >= threshold else 'bad' for i in range(source_df.shape[0])]
return matched_results
| [] |
2024-01-10 | rkunnamp/LlamaAcademy | data_gen.py | import os
import time
import utils
import json
import random
import string
import regex as re
import pickle
import openai
import tqdm
import asyncio
import tiktoken
from langchain.docstore.document import Document
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
def post_process_response_ins(strategy, response, **kwargs):
"""
Post processes the given response for generating instructions based on the specified strategy.
:param strategy: a string, represents the desired post-processing strategy for the response
:param response: a dictionary, the response to be post-processed
:param kwargs: keyword arguments
:return: list of instructions
"""
if response is None:
return []
if strategy == "diversifying-bing":
num_prompt_instructions = kwargs["num_prompt_instructions"]
raw_instructions = f"{num_prompt_instructions+1}. Instruction:" + \
response["text"]
raw_instructions = re.split("###", raw_instructions)
elif strategy == "summarizing-gpt-3.5-turbo-generating-gpt-4":
num_prompt_instructions = kwargs["num_prompt_instructions"]
if "###" in response:
raw_instructions = re.split("###", response)
else:
raw_instructions = re.split("\n", response)
else:
raise ValueError("Unrecognised strategy provided.")
instructions = process_raw_instructions(raw_instructions, num_prompt_instructions)
return instructions
def process_raw_instructions(raw_instructions, num_prompt_instructions):
"""
Processes the raw instructions for the given strategy.
:param raw_instructions: a list of strings, instructions that are yet to be processed
:param num_prompt_instructions: an integer, the number of prompt instructions provided
:return: processed list of instruction dictionaries
"""
instructions = []
for idx, inst in enumerate(raw_instructions):
if idx == len(raw_instructions) - 1:
continue
splitted_data = re.split(
f"{idx+num_prompt_instructions+1}\.\s+(Instruction|Question|Task):", inst)
if len(splitted_data) != 3:
inst = re.sub("(\d+)\.", "", inst)
inst = re.sub("(Instruction|Question|Task):", "", inst)
if is_valid_instruction(inst):
instructions.append({"instruction": inst})
else:
inst = splitted_data[2].strip()
if is_valid_instruction(inst):
instructions.append({"instruction": inst})
return instructions
def is_valid_instruction(instruction):
"""
Validates if the given instruction is correct.
:param instruction: a string, the instruction to be validated
:return: a boolean, True if instruction is valid, otherwise False
"""
if len(instruction.split()) <= 3 or len(instruction.split()) > 40:
return False
if instruction[0] in string.punctuation:
return False
if not instruction[0].isascii():
return False
return True
def post_process_response_code(response, model_name):
"""
Post-process the given code response based on the specified model_name.
:param response: a dictionary, the response to be post-processed
:param model_name: a string, represents the model for which the response needs processing
:return: a string containing the processed output
"""
output = extract_code_output(response, model_name)
if model_name == "EdgeGPT":
output = process_edgegpt_output(output)
return output
def extract_code_output(response, model_name):
"""
Extract the code output from the given response depending on the model name.
:param response: a dictionary, the response to be processed
:param model_name: a string, represents the model
:return: a string containing the code output
"""
if model_name in ["gpt-3.5-turbo", "gpt-4"]:
output = response["choices"][0]["message"]["content"]
elif model_name == "EdgeGPT":
output = response['item']["messages"][1]["text"]
else:
raise ValueError("Unrecognised model name provided.")
return output
def process_edgegpt_output(output):
"""
Processes the output generated by the EdgeGPT model.
:param output: a string containing the EdgeGPT output
:return: a string containing the processed output
"""
is_code = len(re.findall(r'```(\w+)\n', output)) > 0
if not is_code:
return output
language = re.findall(r'```(\w+)\n', output)[0]
code_block_start = output.find(
f"```{language}\n") + len(f"```{language}\n")
code_block_end = output.find("```\n", code_block_start)
code_lines = []
upper, code, lower = extract_three_parts(output, language, code_block_start, code_block_end)
process_individual_lines(code_lines, upper, True, language)
process_individual_lines(code_lines, code)
process_individual_lines(code_lines, lower, True)
output = "\n".join(code_lines)
return output
def extract_three_parts(output, language, code_block_start, code_block_end):
"""
Extract the three parts of the output.
:param output: a string containing the EdgeGPT output
:param language: a string representing the programming language
:param code_block_start: an integer, the starting index of the code block
:param code_block_end: an integer, the ending index of the code block
:return: tuple of three strings, upper part, code part, lower part of the output
"""
upper = output[:code_block_start].replace(f"```{language}", "")
code = output[code_block_start:code_block_end]
lower = output[code_block_end:].replace("```", "")
return upper, code, lower
def process_individual_lines(code_lines, part, should_add_comment=False, language=None):
"""
Process the lines for the given part.
:param code_lines: list, the list to append the processed lines
:param part: a string, which part of the output it belongs to (upper, code, lower)
:param should_add_comment: a boolean, determines if a comment should be added
:param language: a string representing the programming language, used only for the upper part
"""
for line in part.split("\n"):
stripped_line = line.strip()
if should_add_comment:
if stripped_line.startswith("#"):
code_lines.append(stripped_line)
elif language is not None:
code_lines.append(f"#{language}")
elif stripped_line != "":
code_lines.append("#" + stripped_line)
else:
code_lines.append(stripped_line)
def encode_prompt(inst_gen, url_docs, prompt_path):
"""
Encode multiple prompt instructions into a single string.
:param input_gen: a string, the input generator
:param inst_gen: a string, the instruction generator
:param url_docs: a string, url of the documentation
:param use_scraped_docs: a boolean, if True, scraped docs will be used
:param prompt_path: a string, the path to the prompt txt file
:return: a string, the encoded prompt
"""
with open(prompt_path) as file:
prompt = file.read() + "\n"
prompt = prompt.format(url_docs=url_docs)
prompt += f"###\n"
prompt += f"Instruction: {inst_gen}\n"
return prompt
def encode_prompt_output(input_gen, inst_gen, url_docs, use_scraped_docs):
"""
Encode multiple prompt instructions into a single string.
:param input_gen: a string, input generator
:param inst_gen: a string, instruction generator
:param url_docs: a string, URL of the documentation
:param use_scraped_docs: a boolean, if True, scraped docs will be used
:return: a string, the encoded prompt
"""
prompt_path = "assets/prompt_input_code.txt" if use_scraped_docs else "assets/prompt_code.txt"
prompt = encode_prompt(inst_gen, url_docs, prompt_path)
if use_scraped_docs:
prompt += f"API References:\n{input_gen}\n"
prompt += "Code:"
return prompt
def encode_prompt_instruct(url, strategy, batch_size=70, **kwargs):
"""
Encode multiple prompt instructions into a single string.
:param url: a string, URL of the documentation or references
:param strategy: a string, represents the desired encoding strategy
:param batch_size: an integer, the batch size for encoding, default is 40
:param kwargs: keyword arguments
:return: a string, the encoded prompt
"""
if strategy == "diversifying-bing":
prompt_path = "assets/prompt_instruction_bing.txt"
prompt = encode_prompt(None, None, url, False, prompt_path)
for idx, task_dict in enumerate(kwargs["prompt_instructions"]):
instruction = task_dict["instruction"]
instruction = re.sub(r"\s+", " ", instruction).strip().rstrip(":")
prompt += f"###\n{idx + 1}. Instruction: {instruction}\n"
prompt += f"###\n{idx + 2}. Instruction:"
prompt = prompt.format(url_docs=url, n_tasks=batch_size+len(kwargs["prompt_instructions"]))
elif strategy == "summarizing-gpt-3.5-turbo-generating-gpt-4":
prompt = create_gpt_turbo_prompt(batch_size, **kwargs)
else:
raise ValueError("Unrecognised strategy provided.")
return prompt
def create_gpt_turbo_prompt(batch_size, **kwargs):
"""
Creates a GPT-3.5-turbo prompt with the given instructions.
:param url: a string, URL of the documentation or references
:param batch_size: an integer, the batch size
:param kwargs: keyword arguments
:return: a string, the GPT-3.5-turbo prompt
"""
with open("assets/prompt_instruction_gpt3.5turbo_gpt4.txt") as file:
prompt = file.read() + "\n"
for idx, summary in enumerate(kwargs["summaries"]):
prompt += f"({idx+1}) {summary}\n\n"
batch_size += len(kwargs["prompt_instructions"])
prompt += "###\n"
prompt += f"List of {batch_size} tasks:\n"
for idx, task_dict in enumerate(kwargs["prompt_instructions"]):
instruction = task_dict["instruction"]
instruction = re.sub(r"\s+", " ", instruction).strip().rstrip(":")
prompt += f"###\n{idx + 1}. Instruction: {instruction}\n"
prompt += f"###\n{idx + 2}. Instruction: "
return prompt
def find_word_in_string(w, s):
return re.compile(r"\b({0})\b".format(w), flags=re.IGNORECASE).search(s)
def truncate(encoding, prompt, max_size):
input_ids = encoding.encode(prompt, disallowed_special="all")
truncated_ids = input_ids[:max_size]
return encoding.decode(truncated_ids)
def launch_instruction_generation(
url_docs,
seed_instructions_path="assets/seed_instructions.jsonl",
strategy="summarizing-gpt-3.5-turbo-generating-gpt-4",
num_instructions_to_generate=100,
batch_size=70,
temperature=0.7,
top_p=0.7,
logger=None,
**kwargs
):
request_idx = 0
machine_instructions = []
request_start = time.time()
if strategy == "reading-gpt-4":
raise NotImplementedError("This method read the whole website to generate instructions, but not yet implemented")
if strategy == "summarizing-gpt-3.5-turbo-generating-gpt-4":
"""This method is a combination of summarizing and generating instructions"""
logger.info("""You are using Summarizing mode with GPT-3.5 Turbo and Generating mode with GPT-4""")
logger.info("""Summarizing mode begins""")
assert batch_size <= 80, "Batch size must be smaller than 80"
encoding_gpt4 = tiktoken.encoding_for_model("gpt-4")
encoding_gpt3 = tiktoken.encoding_for_model("gpt-3.5-turbo")
seed_instructions = [json.loads(l)
for l in open(seed_instructions_path, "r")]
seed_instruction_data = [
{"instruction": t["instruction"], "url": t["url"]} for t in seed_instructions
]
#Get summary using gpt-3.5-turbo
summaries = []
embed_docs = []
summary_prompt = open("assets/prompt_summary.txt").read() + "\n"
for _, doc in tqdm.tqdm(enumerate(kwargs["documents_for_summary"])):
summary = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": summary_prompt.format(passage=truncate(encoding_gpt3, doc.page_content, 3100))}],
max_tokens=700)["choices"][0]["message"]["content"]
summaries.append(summary)
embed_docs.append(Document(page_content=summary))
#Embed summary documents into Faiss for later use
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(embed_docs, embeddings)
logger.info("Summary Vectorstore is storing in assets/vectorstore_summary.pkl")
with open("assets/vectorstore_summary.pkl", "wb") as f:
pickle.dump(vectorstore, f)
logger.info("Summarizing mode ends")
logger.info("Instruction Generation begins")
while len(machine_instructions) < num_instructions_to_generate:
request_idx += 1
#TODO: ugly hack, hard code number of passages to be prompted 14
if len(summaries) < 4:
selected_summaries = summaries
else:
selected_summaries = random.sample(summaries, 4)
prompt_instructions_gen = random.sample(
seed_instruction_data, kwargs["num_prompt_instructions"])
kwargs_instruct = {"summaries": selected_summaries, "prompt_instructions": prompt_instructions_gen}
prompt = encode_prompt_instruct(
url_docs, strategy, batch_size, **kwargs_instruct)
max_retries = 10
retries = 0
while True:
try:
results = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": truncate(encoding_gpt4, prompt, 6000)}],
max_tokens=2000,
temperature=temperature
)
break
except Exception as e:
retries += 1
if retries > max_retries:
logger.info(f"Failed after {max_retries} attempts.")
raise e
else:
logger.info(f"Attempt {retries} failed with exception: {e}. Retrying...")
response = results["choices"][0]["message"]["content"]
instruction_data = post_process_response_ins(strategy, response, **kwargs)
for instruction_data_entry in instruction_data:
instruction = {
"instruction": instruction_data_entry["instruction"], "url": url_docs}
machine_instructions.append(instruction)
# seed_instruction_data.append(instruction)
request_duration = time.time() - request_start
logger.info(f"Request {request_idx} took {request_duration:.2f}s")
if strategy == "diversifying-bing":
seed_instructions = [json.loads(l)
for l in open(seed_instructions_path, "r")]
seed_instruction_data = [
{"instruction": t["instruction"], "url": t["url"]} for t in seed_instructions if t["url"] == url_docs
]
logger.info("""You are using Diversifying mode with Bingchat, in this mode,
the general instructions are got from Bing engine requiring you to have access to Bingchat""")
num_prompt_instructions = kwargs["num_prompt_instructions"]
assert len(seed_instructions) >= num_prompt_instructions, f"""The number of instructions {len(seed_instructions)}
is less than number of instruction into the prompt which is {num_prompt_instructions}, adding more seed instructions
reducing the number of prompt instructions"""
prompt = encode_prompt_instruct(
url_docs,
)
general_instructions = asyncio.run(utils.edgegpt_complete(
prompt=prompt)
)
while len(machine_instructions) < num_instructions_to_generate:
request_idx += 1
prompt_instructions_gen = random.sample(
seed_instruction_data, num_prompt_instructions)
kwargs_instruct = {"general_instructions": general_instructions, "prompt_instructions": prompt_instructions_gen}
prompt = encode_prompt_instruct(
url_docs, strategy, batch_size, **kwargs_instruct)
results = openai.Completion.create(
model="text-davinci-003",
prompt=prompt,
max_tokens=2048,
temperature=temperature,
top_p=top_p
)
response = results["choices"][0]
instruction_data = post_process_response_ins(strategy, response, **kwargs)
for instruction_data_entry in instruction_data:
instruction = {
"instruction": instruction_data_entry["instruction"], "url": url_docs}
machine_instructions.append(instruction)
request_duration = time.time() - request_start
logger.info(f"Request {request_idx} took {request_duration:.2f}s")
return machine_instructions
def launch_CoT_generation():
return NotImplementedError("This method is not yet implemented")
def launch_data_generation(
url_docs,
documents_embeds,
output_dir="assets/",
num_tasks_to_generate=140,
strategy_instruct="summarizing-gpt-3.5-turbo-generating-gpt-4",
model_name_code="gpt-4",
num_docs_to_output=1,
use_scraped_docs=True,
temperature=0.7,
top_p=1.0,
max_tokens=500,
logger=None,
**kwargs
):
generated_instructions = launch_instruction_generation(
url_docs,
strategy=strategy_instruct,
num_instructions_to_generate=num_tasks_to_generate,
temperature=temperature,
top_p=top_p,
logger=logger,
**kwargs
)
# generated_instructions = []
# with open(os.path.join(output_dir, "generated_instructions.jsonl"), "r") as f:
# for line in f:
# generated_instructions.append(json.loads(line.strip()))
with open(os.path.join(output_dir, "generated_instructions.jsonl"), "w") as f:
for instruction in generated_instructions:
f.write(json.dumps(instruction) + "\n")
logger.info("Completed Instruction Generation")
machine_output_data = []
for instruction in tqdm.tqdm(generated_instructions):
data = {"instruction": instruction["instruction"],
"input": "", "output": "", "url": instruction["url"]}
docs = documents_embeds.similarity_search(
instruction["instruction"], k=num_docs_to_output)
if "summary_embeds" in kwargs:
with open("assets/vectorstore_summary.pkl", "rb") as f:
summary_embeds = pickle.load(f)
docs.extend(summary_embeds.similarity_search(
instruction["instruction"], k=num_docs_to_output)
)
data["input"] = "\n\n".join([d.page_content for d in docs])
prompt = encode_prompt_output(
input_gen=data["input"],
inst_gen=data["instruction"],
url_docs=url_docs,
use_scraped_docs=use_scraped_docs
)
if model_name_code in ["gpt-3.5-turbo", "gpt-4"]:
max_retries = 10
retries = 0
exponential_base = 2
delay = 1
while True:
try:
code = openai.ChatCompletion.create(
model=model_name_code,
messages=[{"role": "user", "content": prompt}],
max_tokens=max_tokens
)
break
except Exception as e:
retries += 1
if retries > max_retries:
logger.info(f"Failed after {max_retries} attempts.")
raise e
else:
logger.info(f"Attempt {retries} failed with exception: {e}. Retrying...")
# Increment the delay
delay *= exponential_base * (1 + random.random())
# Sleep for the delay
time.sleep(delay)
elif model_name_code == "EdgeGPT":
code = asyncio.get_event_loop().run_until_complete(utils.edgegpt_complete(
prompt=prompt)
)
data["output"] = post_process_response_code(code, model_name_code)
machine_output_data.append(data)
machine_output_data_vicuna = utils.convert_vicuna(machine_output_data)
utils.jdump(machine_output_data_vicuna, os.path.join(output_dir, "data.json"))
def unit_test():
import logging
from ingest_docs import ingest_docs
logger = logging.getLogger(__name__)
class Config:
def __init__(self):
self.DATA_PATH = "assets/"
self.NUM_TASKS_TO_GENERATE = 100
docs, docs_for_summary = ingest_docs("https://developers.notion.com/reference", recursive_depth=1, logger=logger)
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
with open("assets/vectorstore.pkl", "wb") as f:
pickle.dump(vectorstore, f)
api_docs = "https://developers.notion.com/reference"
cfg = Config()
launch_data_generation(
url_docs=api_docs,
documents_embeds=vectorstore,
output_dir=cfg.DATA_PATH,
num_tasks_to_generate=cfg.NUM_TASKS_TO_GENERATE,
model_name="gpt-4",
logger=logger,
num_prompt_instructions=3,
documents_for_summary=docs_for_summary
)
if __name__ == "__main__":
unit_test()
| [
"assets/prompt_instruction_bing.txt",
"\n",
"assets/prompt_summary.txt",
"instruction",
"assets/prompt_input_code.txt",
"Instruction: PLACEHOLDER\n",
"num_prompt_instructions",
"input",
"###\n",
"List of PLACEHOLDER tasks:\n",
"API References:\nPLACEHOLDER\n",
"prompt_instructions",
"Code:"
] |
2024-01-10 | pat1st/ragtestsimple | app_4.py | import streamlit as st
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import AstraDB
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
# Cache prompt for future runs
@st.cache_data()
def load_prompt():
template = """You're a helpful AI assistent tasked to answer the user's questions.
You're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.
QUESTION:
{question}
YOUR ANSWER:"""
return ChatPromptTemplate.from_messages([("system", template)])
prompt = load_prompt()
# Cache OpenAI Chat Model for future runs
@st.cache_resource()
def load_chat_model():
return ChatOpenAI(
temperature=0.3,
model='gpt-3.5-turbo',
streaming=True,
verbose=True
)
chat_model = load_chat_model()
# Start with empty messages, stored in session state
if 'messages' not in st.session_state:
st.session_state.messages = []
# Draw a title and some markdown
st.title("Your personal Efficiency Booster")
st.markdown("""Generative AI is considered to bring the next Industrial Revolution.
Why? Studies show a **37% efficiency boost** in day to day work activities!""")
# Draw all messages, both user and bot so far (every time the app reruns)
for message in st.session_state.messages:
st.chat_message(message['role']).markdown(message['content'])
# Draw the chat input box
if question := st.chat_input("What's up?"):
# Store the user's question in a session object for redrawing next time
st.session_state.messages.append({"role": "human", "content": question})
# Draw the user's question
with st.chat_message('human'):
st.markdown(question)
# Generate the answer by calling OpenAI's Chat Model
inputs = RunnableMap({
'question': lambda x: x['question']
})
chain = inputs | prompt | chat_model
response = chain.invoke({'question': question})
answer = response.content
# Store the bot's answer in a session object for redrawing next time
st.session_state.messages.append({"role": "ai", "content": answer})
# Draw the bot's answer
with st.chat_message('assistant'):
st.markdown(answer) | [
"You're a helpful AI assistent tasked to answer the user's questions.\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\n\nQUESTION:\n{question}\n\nYOUR ANSWER:",
"[('system', \"You're a helpful AI assistent tasked to answer the user's questions.\\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\\n\\nQUESTION:\\n{question}\\n\\nYOUR ANSWER:\")]"
] |
2024-01-10 | pat1st/ragtestsimple | app_5.py | import streamlit as st
import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import AstraDB
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
# Cache prompt for future runs
@st.cache_data()
def load_prompt():
template = """You're a helpful AI assistent tasked to answer the user's questions.
You're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.
CONTEXT:
{context}
QUESTION:
{question}
YOUR ANSWER:"""
return ChatPromptTemplate.from_messages([("system", template)])
prompt = load_prompt()
# Cache OpenAI Chat Model for future runs
@st.cache_resource()
def load_chat_model():
return ChatOpenAI(
temperature=0.3,
model='gpt-3.5-turbo',
streaming=True,
verbose=True
)
chat_model = load_chat_model()
# Cache the Astra DB Vector Store for future runs
@st.cache_resource(show_spinner='Connecting to Astra')
def load_retriever():
# Connect to the Vector Store
vector_store = AstraDB(
embedding=OpenAIEmbeddings(),
collection_name="my_store",
api_endpoint=st.secrets['ASTRA_API_ENDPOINT'],
token=st.secrets['ASTRA_TOKEN']
)
# Get the retriever for the Chat Model
retriever = vector_store.as_retriever(
search_kwargs={"k": 5}
)
return retriever
retriever = load_retriever()
# Start with empty messages, stored in session state
if 'messages' not in st.session_state:
st.session_state.messages = []
# Draw a title and some markdown
st.title("Your personal Efficiency Booster")
st.markdown("""Generative AI is considered to bring the next Industrial Revolution.
Why? Studies show a **37% efficiency boost** in day to day work activities!""")
# Draw all messages, both user and bot so far (every time the app reruns)
for message in st.session_state.messages:
st.chat_message(message['role']).markdown(message['content'])
# Draw the chat input box
if question := st.chat_input("What's up?"):
# Store the user's question in a session object for redrawing next time
st.session_state.messages.append({"role": "human", "content": question})
# Draw the user's question
with st.chat_message('human'):
st.markdown(question)
# Generate the answer by calling OpenAI's Chat Model
inputs = RunnableMap({
'context': lambda x: retriever.get_relevant_documents(x['question']),
'question': lambda x: x['question']
})
chain = inputs | prompt | chat_model
response = chain.invoke({'question': question})
answer = response.content
# Store the bot's answer in a session object for redrawing next time
st.session_state.messages.append({"role": "ai", "content": answer})
# Draw the bot's answer
with st.chat_message('assistant'):
st.markdown(answer)
| [
"[('system', \"You're a helpful AI assistent tasked to answer the user's questions.\\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\\n\\nCONTEXT:\\n{context}\\n\\nQUESTION:\\n{question}\\n\\nYOUR ANSWER:\")]",
"You're a helpful AI assistent tasked to answer the user's questions.\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\n\nCONTEXT:\n{context}\n\nQUESTION:\n{question}\n\nYOUR ANSWER:"
] |
2024-01-10 | pat1st/ragtestsimple | app_6.py | import streamlit as st
import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import AstraDB
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
from langchain.callbacks.base import BaseCallbackHandler
# Streaming call back handler for responses
class StreamHandler(BaseCallbackHandler):
def __init__(self, container, initial_text=""):
self.container = container
self.text = initial_text
def on_llm_new_token(self, token: str, **kwargs):
self.text += token
self.container.markdown(self.text + "▌")
# Cache prompt for future runs
@st.cache_data()
def load_prompt():
template = """You're a helpful AI assistent tasked to answer the user's questions.
You're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.
CONTEXT:
{context}
QUESTION:
{question}
YOUR ANSWER:"""
return ChatPromptTemplate.from_messages([("system", template)])
prompt = load_prompt()
# Cache OpenAI Chat Model for future runs
@st.cache_resource()
def load_chat_model():
return ChatOpenAI(
temperature=0.3,
model='gpt-3.5-turbo',
streaming=True,
verbose=True
)
chat_model = load_chat_model()
# Cache the Astra DB Vector Store for future runs
@st.cache_resource(show_spinner='Connecting to Astra')
def load_retriever():
# Connect to the Vector Store
vector_store = AstraDB(
embedding=OpenAIEmbeddings(),
collection_name="my_store",
api_endpoint=st.secrets['ASTRA_API_ENDPOINT'],
token=st.secrets['ASTRA_TOKEN']
)
# Get the retriever for the Chat Model
retriever = vector_store.as_retriever(
search_kwargs={"k": 5}
)
return retriever
retriever = load_retriever()
# Start with empty messages, stored in session state
if 'messages' not in st.session_state:
st.session_state.messages = []
# Draw a title and some markdown
st.title("Your personal Efficiency Booster")
st.markdown("""Generative AI is considered to bring the next Industrial Revolution.
Why? Studies show a **37% efficiency boost** in day to day work activities!""")
# Draw all messages, both user and bot so far (every time the app reruns)
for message in st.session_state.messages:
st.chat_message(message['role']).markdown(message['content'])
# Draw the chat input box
if question := st.chat_input("What's up?"):
# Store the user's question in a session object for redrawing next time
st.session_state.messages.append({"role": "human", "content": question})
# Draw the user's question
with st.chat_message('human'):
st.markdown(question)
# UI placeholder to start filling with agent response
with st.chat_message('assistant'):
response_placeholder = st.empty()
# Generate the answer by calling OpenAI's Chat Model
inputs = RunnableMap({
'context': lambda x: retriever.get_relevant_documents(x['question']),
'question': lambda x: x['question']
})
chain = inputs | prompt | chat_model
response = chain.invoke({'question': question}, config={'callbacks': [StreamHandler(response_placeholder)]})
answer = response.content
# Store the bot's answer in a session object for redrawing next time
st.session_state.messages.append({"role": "ai", "content": answer})
# Write the final answer without the cursor
response_placeholder.markdown(answer) | [
"[('system', \"You're a helpful AI assistent tasked to answer the user's questions.\\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\\n\\nCONTEXT:\\n{context}\\n\\nQUESTION:\\n{question}\\n\\nYOUR ANSWER:\")]",
"You're a helpful AI assistent tasked to answer the user's questions.\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\n\nCONTEXT:\n{context}\n\nQUESTION:\n{question}\n\nYOUR ANSWER:"
] |
2024-01-10 | pat1st/ragtestsimple | app_7.py | import streamlit as st
import os
import tempfile
from langchain.embeddings import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import AstraDB
from langchain.schema.runnable import RunnableMap
from langchain.prompts import ChatPromptTemplate
from langchain.callbacks.base import BaseCallbackHandler
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFLoader
# Streaming call back handler for responses
class StreamHandler(BaseCallbackHandler):
def __init__(self, container, initial_text=""):
self.container = container
self.text = initial_text
def on_llm_new_token(self, token: str, **kwargs):
self.text += token
self.container.markdown(self.text + "▌")
# Function for Vectorizing uploaded data into Astra DB
def vectorize_text(uploaded_file, vector_store):
if uploaded_file is not None:
# Write to temporary file
temp_dir = tempfile.TemporaryDirectory()
file = uploaded_file
temp_filepath = os.path.join(temp_dir.name, file.name)
with open(temp_filepath, 'wb') as f:
f.write(file.getvalue())
# Load the PDF
docs = []
loader = PyPDFLoader(temp_filepath)
docs.extend(loader.load())
# Create the text splitter
text_splitter = RecursiveCharacterTextSplitter(
chunk_size = 1500,
chunk_overlap = 100
)
# Vectorize the PDF and load it into the Astra DB Vector Store
pages = text_splitter.split_documents(docs)
vector_store.add_documents(pages)
st.info(f"{len(pages)} pages loaded.")
# Cache prompt for future runs
@st.cache_data()
def load_prompt():
template = """You're a helpful AI assistent tasked to answer the user's questions.
You're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.
CONTEXT:
{context}
QUESTION:
{question}
YOUR ANSWER:"""
return ChatPromptTemplate.from_messages([("system", template)])
prompt = load_prompt()
# Cache OpenAI Chat Model for future runs
@st.cache_resource()
def load_chat_model():
return ChatOpenAI(
temperature=0.3,
model='gpt-3.5-turbo',
streaming=True,
verbose=True
)
chat_model = load_chat_model()
# Cache the Astra DB Vector Store for future runs
@st.cache_resource(show_spinner='Connecting to Astra')
def load_vector_store():
# Connect to the Vector Store
vector_store = AstraDB(
embedding=OpenAIEmbeddings(),
collection_name="my_store",
api_endpoint=st.secrets['ASTRA_API_ENDPOINT'],
token=st.secrets['ASTRA_TOKEN']
)
return vector_store
vector_store = load_vector_store()
# Cache the Retriever for future runs
@st.cache_resource(show_spinner='Getting retriever')
def load_retriever():
# Get the retriever for the Chat Model
retriever = vector_store.as_retriever(
search_kwargs={"k": 5}
)
return retriever
retriever = load_retriever()
# Start with empty messages, stored in session state
if 'messages' not in st.session_state:
st.session_state.messages = []
# Draw a title and some markdown
st.title("Your personal Efficiency Booster")
st.markdown("""Generative AI is considered to bring the next Industrial Revolution.
Why? Studies show a **37% efficiency boost** in day to day work activities!""")
# Include the upload form for new data to be Vectorized
with st.sidebar:
with st.form('upload'):
uploaded_file = st.file_uploader('Upload a document for additional context', type=['pdf'])
submitted = st.form_submit_button('Save to Astra DB')
if submitted:
vectorize_text(uploaded_file, vector_store)
# Draw all messages, both user and bot so far (every time the app reruns)
for message in st.session_state.messages:
st.chat_message(message['role']).markdown(message['content'])
# Draw the chat input box
if question := st.chat_input("What's up?"):
# Store the user's question in a session object for redrawing next time
st.session_state.messages.append({"role": "human", "content": question})
# Draw the user's question
with st.chat_message('human'):
st.markdown(question)
# UI placeholder to start filling with agent response
with st.chat_message('assistant'):
response_placeholder = st.empty()
# Generate the answer by calling OpenAI's Chat Model
inputs = RunnableMap({
'context': lambda x: retriever.get_relevant_documents(x['question']),
'question': lambda x: x['question']
})
chain = inputs | prompt | chat_model
response = chain.invoke({'question': question}, config={'callbacks': [StreamHandler(response_placeholder)]})
answer = response.content
# Store the bot's answer in a session object for redrawing next time
st.session_state.messages.append({"role": "ai", "content": answer})
# Write the final answer without the cursor
response_placeholder.markdown(answer) | [
"[('system', \"You're a helpful AI assistent tasked to answer the user's questions.\\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\\n\\nCONTEXT:\\n{context}\\n\\nQUESTION:\\n{question}\\n\\nYOUR ANSWER:\")]",
"You're a helpful AI assistent tasked to answer the user's questions.\nYou're friendly and you answer extensively with multiple sentences. You prefer to use bulletpoints to summarize.\n\nCONTEXT:\n{context}\n\nQUESTION:\n{question}\n\nYOUR ANSWER:"
] |
2024-01-10 | fugyeah/NewsHub | modules~errors.py | import time
import openai
def robust_api_call(call, retries=3, delay=2, rate_limit_delay=10):
for _ in range(retries): # Attempt the API call n times
try:
return call() # Perform the API call and return the result if successful
except openai.error.APIError as e:
print(f"OpenAI API returned an API Error: {e}. Retrying...")
time.sleep(delay) # Wait for a specified delay before retrying
except openai.error.APIConnectionError as e:
print(f"Failed to connect to OpenAI API: {e}. Retrying...")
time.sleep(delay)
except openai.error.RateLimitError as e:
print(f"OpenAI API request exceeded rate limit: {e}. Retrying after a longer delay...")
time.sleep(rate_limit_delay) # Wait longer if rate limit has been exceeded
except openai.error.ServiceUnavailableError as e:
print(f"OpenAI API service unavailable: {e}. Retrying...")
time.sleep(rate_limit_delay) # Wait for a specified delay before retrying
return None # Return None if the API call failed after all retries | [] |
2024-01-10 | fugyeah/NewsHub | news_twitter_similarity_proposed.py | import pickle
import numpy as np
from sentence_transformers import SentenceTransformer
import configparser
from typing import Dict, List, Tuple
import tweepy
import openai
# Config parser
config = configparser.ConfigParser()
config.read('config.ini')
# Twitter API config
API_KEY = config.get('TWITTER', 'API_KEY')
API_SECRET_KEY = config.get('TWITTER', 'API_SECRET_KEY')
ACCESS_TOKEN = config.get('TWITTER', 'ACCESS_TOKEN')
ACCESS_TOKEN_SECRET = config.get('TWITTER', 'ACCESS_TOKEN_SECRET')
# OpenAI API config
OPENAI_API_KEY = config.get('OPENAI', 'OPENAI_API_KEY')
openai.api_key = OPENAI_API_KEY
# Model config
MODEL_NAME = config.get('MODEL', 'MODEL_NAME')
# Thresholds
SIMILARITY_THRESHOLD = config.getfloat('TWITTER_THRESHOLDS', 'SIMILARITY_THRESHOLD')
TOP_N_ARTICLES = config.getint('TWITTER_THRESHOLDS', 'TOP_N_ARTICLES')
def load_data(filepath: str) -> List[Tuple]:
with open(filepath, 'rb') as f:
summaries = pickle.load(f)
print(f"Loaded {len(summaries)} summaries from {filepath}")
return summaries
def generate_embeddings(summaries: List[Tuple], model: SentenceTransformer) -> np.ndarray:
corpus = [summary[0] + ' ' + summary[2][:500] for summary in summaries]
embeddings = model.encode(corpus, convert_to_tensor=True)
embeddings_np = embeddings.cpu().numpy()
normalized_embeddings = embeddings_np / np.linalg.norm(embeddings_np, axis=1, keepdims=True)
return normalized_embeddings
def generate_similarity_matrix(normalized_embeddings: np.ndarray) -> np.ndarray:
similarity_matrix = np.dot(normalized_embeddings, normalized_embeddings.T)
np.fill_diagonal(similarity_matrix, -1)
return similarity_matrix
def get_top_articles(similarity_matrix: np.ndarray, summaries: List[Tuple], threshold: float, top_n: int) -> List[Tuple]:
row_indices, col_indices = np.where(similarity_matrix > threshold)
if len(row_indices) == 0 or len(col_indices) == 0:
raise Exception("No pair of articles have similarity above the threshold")
indices = np.argsort(similarity_matrix[row_indices, col_indices])[::-1]
top_indices = indices[:top_n]
top_articles = [(summaries[row_indices[i]], summaries[col_indices[i]]) for i in top_indices]
return top_articles
def generate_top_articles_by_category(top_articles: List[Tuple]) -> Dict[str, Tuple]:
top_articles_by_category = {}
for article1, _ in top_articles:
_, category, _, _, _, _ = article1
if category not in top_articles_by_category:
top_articles_by_category[category] = article1
if len(top_articles_by_category) >= 5:
break
return top_articles_by_category
def generate_engaging_tweet(headline: str, summary: str, url: str) -> str:
messages = [
{
"role": "system",
"content": "You are a professional news agent, you take news headlines and convert them to tweets to be published ASAP. Transform the following information into an engaging tweet and link to NewsPlanetAi.com: THE ENTIRE TWEET MUST BE LESS THAN 200 CHARACTERS"
},
{
"role": "user",
"content": f"Please summarize and turn this article into a tweet, that MUST be less than 200 characters long, including the hashtags:\nHeadline: {headline}\nSummary: {summary}\nURL: NewsPlanetAi.com"
}
]
response = openai.ChatCompletion.create(
model="gpt-4",
messages=messages,
temperature=0.8,
max_tokens=60
)
tweet = response['choices'][0]['message']['content']
if tweet.startswith('"'):
tweet = tweet.strip('"')
return tweet
def post_tweet(tweet: str):
confirmation = input("Do you want to tweet this? (yes/no): ")
if confirmation.lower() != "yes":
print("Tweet not posted.")
return
client = tweepy.Client(consumer_key=API_KEY, consumer_secret=API_SECRET_KEY, access_token=ACCESS_TOKEN, access_token_secret=ACCESS_TOKEN_SECRET)
client.create_tweet(text=tweet)
print("Tweet posted successfully")
def main():
# Load and preprocess data
print("Loading and preprocessing data")
summaries = load_data('cache/summaries.p')
# Load model
print("Loading model")
model = SentenceTransformer(MODEL_NAME)
# Generate embeddings
print("Generating embeddings")
normalized_embeddings = generate_embeddings(summaries, model)
# Generate similarity matrix
print("Generating similarity matrix")
similarity_matrix = generate_similarity_matrix(normalized_embeddings)
# Get top articles
print("Getting top articles")
top_articles = get_top_articles(similarity_matrix, summaries, SIMILARITY_THRESHOLD, TOP_N_ARTICLES)
# Get top articles by category
print("Getting top articles by category")
top_articles_by_category = generate_top_articles_by_category(top_articles)
# Print articles
print("Printing articles")
for idx, article in enumerate(top_articles_by_category.values()):
headline, category, summary, url, _, _ = article
print(f"Article {idx + 1}: {headline} ({url})\n")
# Request article choice
article_num = int(input("Enter the number of the article you want to choose: ")) - 1
articles_list = list(top_articles_by_category.values())
chosen_article = articles_list[article_num]
# Generate tweet data
headline, _, summary, url, _, _ = chosen_article
tweet = generate_engaging_tweet(headline, summary, url)
# Post tweet
print(f"Prepared tweet: \n{tweet}")
post_tweet(tweet)
if __name__ == "__main__":
main()
| [
"Please summarize and turn this article into a tweet, that MUST be less than 200 characters long, including the hashtags:\nHeadline: PLACEHOLDER\nSummary: PLACEHOLDER\nURL: NewsPlanetAi.com",
"You are a professional news agent, you take news headlines and convert them to tweets to be published ASAP. Transform the following information into an engaging tweet and link to NewsPlanetAi.com: THE ENTIRE TWEET MUST BE LESS THAN 200 CHARACTERS"
] |
2024-01-10 | fugyeah/NewsHub | modules~locations.py | import os
import pickle
from datetime import datetime
import openai
import time
import json
from tqdm import tqdm
from geopy.geocoders import Nominatim
from geopy.exc import GeocoderTimedOut
from geopy.exc import GeocoderServiceError
import time
# Import the configuration loader
from configparser import ConfigParser
config = ConfigParser()
config.read('modules/suite_config.ini')
CACHE_FILE = config['Cache']['LocCacheFile']
# OpenAI API key
openai_api_key = config['OPENAI']['OPENAI_API_KEY']
def extract_locations(summaries):
# Attempt to load cache
if os.path.exists(CACHE_FILE):
with open(CACHE_FILE, 'rb') as f:
cache_time, locations = pickle.load(f)
# If the cache is less than an hour old - return the cached data
if (datetime.now() - cache_time).total_seconds() < 7200:
return locations
locations = []
for summary in tqdm(summaries, desc="Extracting locations"):
title, category, text, link, timestamp, source = summary
print(text)
for _ in range(3): # Try the API call up to 3 times
try:
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{
"role": "system",
"content": "You are a deterministic AI specializing in Named Entity Recognition, employed by a NewsPlanetAI, a reputable news source. You have been given the task of reading news articles and identifying one location that the news article is most likely about. Your response will be used to geocode the locations of the articles on a map. Give one location ONLY in English, in this format \"City, Country\". If the article does not provide a location, respond \"None\"."
},
{
"role": "user",
"content": f"Please give one location for this article per the instructions, \"{text}\""
},
],
temperature=0,
max_tokens=80,
top_p=1,
frequency_penalty=0,
presence_penalty=0
)
# If the API call succeeds, exit the loop
location = response['choices'][0]['message']['content'].strip() # remove leading/trailing spaces
print(location)
if location.lower() == "none": # Log if None location
print(f"Headline: {title} - Location: {location} (none)")
locations.append(location)
break
except openai.error.APIError as e:
print(f"OpenAI API returned an API Error: {e}. Retrying...")
time.sleep(2) # Wait for 2 seconds before retrying
except openai.error.APIConnectionError as e:
print(f"Failed to connect to OpenAI API: {e}. Retrying...")
time.sleep(2)
except openai.error.RateLimitError as e:
print(f"OpenAI API request exceeded rate limit: {e}. Retrying after a longer delay...")
time.sleep(10) # Wait longer if rate limit has been exceeded
except openai.error.ServiceUnavailableError as e:
print(f"OpenAI API service unavailable: {e}. Retrying...")
time.sleep(10) # Wait for 10 seconds before retrying
else:
# If the API call failed 3 times, add a None location and continue with the next summary
print("Failed to get location for a summary after 3 attempts. Skipping...")
locations.append(None)
continue
cache_data = (datetime.now(), locations)
with open(CACHE_FILE, 'wb') as f:
pickle.dump(cache_data, f)
return locations
def get_coordinates(locations):
geolocator = Nominatim(user_agent="NewsPlanetAi", timeout=10) # 10 seconds of timeout
coordinates = []
for location in locations:
retries = 3 # number of retries
delay = 5 # delay in seconds
for i in range(retries):
try:
# If location is "None", append None coordinates and continue
if location == "None":
coordinates.append((None, None))
break
# Attempt to geocode the location
geolocation = geolocator.geocode(location)
# If geocoding is successful, append the coordinates
if geolocation is not None:
coordinates.append((geolocation.latitude, geolocation.longitude))
break
else:
# If geocoding fails, append None coordinates
coordinates.append((None, None))
break
except (GeocoderTimedOut, GeocoderServiceError):
if i < retries - 1: # i is zero indexed
time.sleep(delay) # wait before trying to fetch the data again
print(f"Geocoding timed out for location: {location}. Retrying...")
else:
print(f"Geocoding failed for location: {location}. Appending None coordinates.")
coordinates.append((None, None))
break
return coordinates
def append_locations_to_news_json(news, summaries, locations, coordinates):
# Iterate over the categories in the news
for category in news['categories']:
# Iterate over the summaries in each category
for news_summary in category['summaries']:
# Find the index of the summary in summaries that matches the news_summary
indices = [i for i, summary in enumerate(summaries) if summary[0] == news_summary['headline']]
if indices:
index = indices[0]
# Add the location and coordinates to the news summary
news_summary['location'] = locations[index]
news_summary['coordinates'] = coordinates[index] # Add this line
return news
def generate_geojson(summaries, extracted_locations, coordinates):
features = []
for i in range(len(summaries)):
headline, category, text, url, timestamp, source = summaries[i]
location = extracted_locations[i]
coords = coordinates[i]
feature = {
"type": "Feature",
"properties": {
"headline": headline,
"link": url,
"text": text # added the 'text' to the properties
},
"geometry": {
"type": "Point",
"coordinates": [coords[1], coords[0]] if coords else [None, None]
}
}
features.append(feature)
geojson_data = {
"type": "FeatureCollection",
"features": features
}
# Save the GeoJSON data to a file
folder_path = 'geojson_data'
os.makedirs(folder_path, exist_ok=True)
current_time = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
file_name = f'{folder_path}/modular_geojson_{current_time}.json'
with open(file_name, 'w') as f:
json.dump(geojson_data, f)
return geojson_data, file_name
# # Save the updated news data back to the news.json file
# with open('news.json', 'w', encoding='utf-8') as f:
# json.dump(news, f, indent=4)
| [
"You are a deterministic AI specializing in Named Entity Recognition, employed by a NewsPlanetAI, a reputable news source. You have been given the task of reading news articles and identifying one location that the news article is most likely about. Your response will be used to geocode the locations of the articles on a map. Give one location ONLY in English, in this format \"City, Country\". If the article does not provide a location, respond \"None\".",
"Please give one location for this article per the instructions, \"PLACEHOLDER\""
] |
2024-01-10 | fugyeah/NewsHub | modules~sum_summaries.py |
import configparser
import os
import glob
import openai
from datetime import datetime
from modules.summarizer import summarize_super_summary
from modules.errors import robust_api_call
config = configparser.ConfigParser()
config.read('modules/suite_config.ini')
super_summary_model = config['Models']['GetSuperSummary']
def get_latest_super_summary_file(directory):
list_of_files = glob.glob(f"{directory}/modular_super_summary_*.txt")
if not list_of_files:
return None
latest_file = max(list_of_files, key=os.path.getctime)
return latest_file
def compile_prompt(summarized_summaries):
print("compiling prompt")
"""
Compile the summarized summaries into a GPT prompt.
"""
if not summarized_summaries:
print("No data to compile")
return None
try:
prompt = ""
for headline, summary in summarized_summaries:
prompt += f"{headline}:\n{summary}\n\n"
return prompt
except Exception as e:
print(f"Error while compiling prompt: {e}")
return None
def load_openai_api_key(config_file='modules/suite_config.ini'):
"""
Load the OpenAI API key from a configuration file.
"""
if not os.path.exists(config_file):
print(f"No configuration file found at {config_file}")
return None
config = configparser.ConfigParser()
config.read(config_file)
try:
api_key = config.get('OPENAI', 'OPENAI_API_KEY')
return api_key
except Exception as e:
print(f"Error while loading OpenAI API key: {e}")
return None
def generate_gpt_completion(prompt, api_key, model=super_summary_model, max_tokens=700, temperature=1.0):
"""Generate a GPT completion given a prompt."""
# Get the current time
current_time = datetime.now()
# Format the current time as a string
current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S")
openai.api_key = api_key
latest_file_path = get_latest_super_summary_file("super_summaries")
if latest_file_path:
with open(latest_file_path, 'r', encoding='utf-8') as file:
latest_super_summary_content = file.read()
latest_super_summary_text = summarize_super_summary(latest_super_summary_content)
prompt.append((". Moving on to the summary of previous events:", "", latest_super_summary_text, "", "", ""))
try:
response = robust_api_call(lambda: openai.ChatCompletion.create(
model=model,
messages=[
{
"role": "system",
"content": (
"You are a cutting-edge AI assistant named 'Cortex', tasked with crafting a professional news broadcast titled, 'NewsPlanetAI', a highly trusted news program. "
"Your mission is to summarize the hour's global events in an authoritative and balanced manner. Here are the components of your task:\n\n"
"1. Cortex starts the program, introducing NewsPlanetAI and the day's broadcast in a creative, engaging manner.\n\n"
"2. 'The World Watches': This section is committed to detailed coverage of the day's most pressing global issue. Currently, that is the Russia & Ukraine conflict. "
"You will present a summary of the day's developments, key events, and an impartial analysis of the situation.\n\n"
"3. 'Global Gist': This part provides a comprehensive, yet brief overview of the day's worldwide happenings, including key events.\n\n"
"4. 'Insight Analytica': This part delves into the implications and potential impact of the notable occurrences from the day. "
"The aim is to maintain neutrality while providing an insightful discussion.\n\n"
"5. 'Regional Rundown': Here, you'll focus on pertinent details from different geographical regions. Each significant regional event is identified, "
"its importance elucidated, and its implications underscored.\n\n"
"6. 'Social Soundbar': This engaging section encourages audience interaction by introducing daily polls, posing questions, or asking for comments "
"related to interesting stories in the day's news (avoid using the Russia-Ukraine War in this section, stick to specific unique stories).\n\n"
"7. Cortex concludes the broadcast in a unique and thoughtful way."
),
},
{
"role": "user",
"content": f"The summaries for this hour's ({current_time_str}) events are: {prompt}. Please craft the hourly news broadcast as per the instructions provided in one complete response (500 words Max). Thank you.",
},
],
max_tokens=max_tokens,
temperature=temperature,
))
if response is not None:
return response.choices[0].message["content"]
else:
print("Error: Failed to generate GPT completion")
return None
except Exception as e:
print(f"Error while generating GPT completion: {e}")
return None
def compile_super_summary(summarized_summaries):
# Compile the GPT prompt
prompt = compile_prompt(summarized_summaries)
print("Compiled Prompt:")
print(prompt)
# Load the OpenAI API key
api_key = load_openai_api_key()
print("Loaded API Key:")
print(api_key)
# Generate the GPT completion
compiled_super_summary = generate_gpt_completion(prompt, api_key)
print("GPT Completion:")
print(compiled_super_summary)
# If compiled_super_summary is None, return None immediately
if compiled_super_summary is None:
print("Error: Failed to generate GPT completion")
return None
# Get today's date
today = datetime.today().strftime('%Y-%m-%d') # format the date as 'YYYY-MM-DD'
# Save the prompt to a file
with open(f'super_summaries/modular_daily_script_{today}.txt', 'w', encoding='utf-8') as f:
f.write(f"Super Summary for {today}:\n")
f.write(compiled_super_summary + "\n")
return compiled_super_summary
| [
"PLACEHOLDER:\nPLACEHOLDER\n\n",
"The summaries for this hour's (PLACEHOLDER) events are: PLACEHOLDER. Please craft the hourly news broadcast as per the instructions provided in one complete response (500 words Max). Thank you.",
"You are a cutting-edge AI assistant named 'Cortex', tasked with crafting a professional news broadcast titled, 'NewsPlanetAI', a highly trusted news program. Your mission is to summarize the hour's global events in an authoritative and balanced manner. Here are the components of your task:\n\n1. Cortex starts the program, introducing NewsPlanetAI and the day's broadcast in a creative, engaging manner.\n\n2. 'The World Watches': This section is committed to detailed coverage of the day's most pressing global issue. Currently, that is the Russia & Ukraine conflict. You will present a summary of the day's developments, key events, and an impartial analysis of the situation.\n\n3. 'Global Gist': This part provides a comprehensive, yet brief overview of the day's worldwide happenings, including key events.\n\n4. 'Insight Analytica': This part delves into the implications and potential impact of the notable occurrences from the day. The aim is to maintain neutrality while providing an insightful discussion.\n\n5. 'Regional Rundown': Here, you'll focus on pertinent details from different geographical regions. Each significant regional event is identified, its importance elucidated, and its implications underscored.\n\n6. 'Social Soundbar': This engaging section encourages audience interaction by introducing daily polls, posing questions, or asking for comments related to interesting stories in the day's news (avoid using the Russia-Ukraine War in this section, stick to specific unique stories).\n\n7. Cortex concludes the broadcast in a unique and thoughtful way."
] |
2024-01-10 | fugyeah/NewsHub | modules~super_summary.py | import openai
import configparser
from .cache_files import is_cache_valid, load_cache
import glob
import os
from datetime import datetime
from .summarizer import summarize_super_summary, save_super_summary
from .errors import robust_api_call
# Load the configuration file
config = configparser.ConfigParser()
config.read('modules/suite_config.ini')
# Access variables
use_tqdm = config.getboolean('General', 'UseTqdm')
get_super_summary_model = config['Models']['GetSuperSummary']
openai_api_key = config['OPENAI']['OPENAI_API_KEY']
cache_file = config['Cache']['DailyCacheFile']
openai.api_key = openai_api_key
def get_latest_super_summary_file(directory):
list_of_files = glob.glob(f"{directory}/super_summary_*.txt")
if not list_of_files:
return None
latest_file = max(list_of_files, key=os.path.getctime)
return latest_file
def get_super_summary():
#load the summaries from cache.
summaries = []
max_cache_age_hours = 12
# obtain the current date and time
now = datetime.now()
# format it as a string
current_time = now.strftime("%d/%m/%Y, %H:%M:%S")
print(current_time)
if is_cache_valid(cache_file, max_cache_age=max_cache_age_hours):
try:
summaries = load_cache(cache_file)
except Exception as e:
print(f"Error while loading cache: {e}")
latest_file_path = get_latest_super_summary_file("super_summaries")
if latest_file_path:
with open(latest_file_path, 'r', encoding='utf-8') as file:
latest_super_summary_content = file.read()
latest_super_summary_text = summarize_super_summary(latest_super_summary_content)
summaries.append((". Moving on to the summary of previous events:", "", latest_super_summary_text, "", "", ""))
max_summary_length = 800
if summaries:
summaries = [(summary[0], summary[1], summary[2][:max_summary_length]) for summary in summaries]
gpt_input = " ".join([f"{summary[0]}: {summary[2]}" for summary in summaries])
print(gpt_input)
# Use gpt-3.5-turbo-16k as the model
try:
response = robust_api_call(lambda: openai.ChatCompletion.create(
model=get_super_summary_model,
messages=[
{
"role": "system",
"content": (
"You are a cutting-edge AI assistant named 'Cortex', tasked with crafting a professional news broadcast titled, 'NewsPlanetAI', a highly trusted news program. "
"Your mission is to summarize the hour's global events in an authoritative and balanced manner. Here are the components of your task:\n\n"
"1. Cortex starts the program, introducing NewsPlanetAI and the day's broadcast in a creative, engaging manner.\n\n"
"2. 'The World Watches': This section is committed to detailed coverage of the day's most pressing global issue. Currently, that is the Russia & Ukraine conflict. "
"You will present a summary of the day's developments, key events, and an impartial analysis of the situation.\n\n"
"3. 'Global Gist': This part provides a comprehensive, yet brief overview of the day's worldwide happenings, including key events.\n\n"
"4. 'Insight Analytica': This part delves into the implications and potential impact of the notable occurrences from the day. "
"The aim is to maintain neutrality while providing an insightful discussion.\n\n"
"5. 'Regional Rundown': Here, you'll focus on pertinent details from different geographical regions. Each significant regional event is identified, "
"its importance elucidated, and its implications underscored.\n\n"
"6. 'Social Soundbar': This engaging section encourages audience interaction by introducing daily polls, posing questions, or asking for comments "
"related to interesting stories in the day's news (avoid using the Russia-Ukraine War in this section, stick to specific unique stories).\n\n"
"7. Cortex concludes the broadcast in a unique and thoughtful way."
)
},
{
"role": "user",
"content": f"At the time: {current_time}, the summaries of this hour's events are: {gpt_input}. Please craft the news broadcast as per the instructions provided in one complete response (450 words Max). Thank you."
}
],
max_tokens=700
), retries=3, delay=2, rate_limit_delay=10)
except Exception as e:
print(f"Error while generating super summary: {e}")
return 'Failed to generate the super summary', 500
if response is not None:
super_summary = response['choices'][0]['message']['content'].strip()
save_super_summary(super_summary) # Save the super summary to a text file
return super_summary
else:
return 'No data to generate the super summary', 500 | [
"At the time: PLACEHOLDER, the summaries of this hour's events are: PLACEHOLDER. Please craft the news broadcast as per the instructions provided in one complete response (450 words Max). Thank you.",
"You are a cutting-edge AI assistant named 'Cortex', tasked with crafting a professional news broadcast titled, 'NewsPlanetAI', a highly trusted news program. Your mission is to summarize the hour's global events in an authoritative and balanced manner. Here are the components of your task:\n\n1. Cortex starts the program, introducing NewsPlanetAI and the day's broadcast in a creative, engaging manner.\n\n2. 'The World Watches': This section is committed to detailed coverage of the day's most pressing global issue. Currently, that is the Russia & Ukraine conflict. You will present a summary of the day's developments, key events, and an impartial analysis of the situation.\n\n3. 'Global Gist': This part provides a comprehensive, yet brief overview of the day's worldwide happenings, including key events.\n\n4. 'Insight Analytica': This part delves into the implications and potential impact of the notable occurrences from the day. The aim is to maintain neutrality while providing an insightful discussion.\n\n5. 'Regional Rundown': Here, you'll focus on pertinent details from different geographical regions. Each significant regional event is identified, its importance elucidated, and its implications underscored.\n\n6. 'Social Soundbar': This engaging section encourages audience interaction by introducing daily polls, posing questions, or asking for comments related to interesting stories in the day's news (avoid using the Russia-Ukraine War in this section, stick to specific unique stories).\n\n7. Cortex concludes the broadcast in a unique and thoughtful way."
] |
2024-01-10 | fugyeah/NewsHub | weekly_scripts~summarize_weekly_summaries_gpt.py | import json
import configparser
import os
import openai
from datetime import datetime
def load_summaries(file_path='weekly_scripts/final_weekly_summaries.json'):
"""
Load the summarized summaries from a JSON file.
"""
if not os.path.exists(file_path):
print(f"No file found at {file_path}")
return None
try:
with open(file_path, 'r', encoding='utf-8') as f:
data = json.load(f)
return data
except Exception as e:
print(f"Error while loading summaries: {e}")
return None
def compile_prompt(data):
"""
Compile the "Summary of the day" for each day into a GPT prompt.
"""
if data is None:
print("No data to compile")
return None
try:
prompt = ""
for day, summaries in data.items():
if "Summary of the day" in summaries:
day_summary = summaries["Summary of the day"]
prompt += f"{day} Summary:\n{day_summary}\n\n"
return prompt
except Exception as e:
print(f"Error while compiling prompt: {e}")
return None
def load_openai_api_key(config_file='config.ini'):
"""
Load the OpenAI API key from a configuration file.
"""
if not os.path.exists(config_file):
print(f"No configuration file found at {config_file}")
return None
config = configparser.ConfigParser()
config.read(config_file)
try:
api_key = config.get('OPENAI', 'OPENAI_API_KEY')
return api_key
except Exception as e:
print(f"Error while loading OpenAI API key: {e}")
return None
def generate_gpt_completion(prompt, api_key, model="gpt-4", max_tokens=1500, temperature=1.0):
"""
Generate a GPT completion given a prompt.
"""
today = datetime.today().strftime('%Y-%m-%d') # format the date as 'YYYY-MM-DD'
openai.api_key = api_key
try:
response = openai.ChatCompletion.create(
model=model,
messages=[
{
"role": "system",
"content": (
"You are a cutting-edge AI assistant named 'Cortex', tasked with crafting a professional news broadcast titled, 'NewsPlanetAI', a highly trusted news program. "
"Your mission is to summarize this week's global events in an authoritative and balanced manner. Here are the components of your task:\n\n"
"1. Cortex starts the program, introducing NewsPlanetAI and the 'Weekly Recap' broadcast in a concise, creative, and engaging manner.\n\n"
"2. 'The World Watches': This section is committed to detailed coverage of the week's most pressing global issues. Currently, that is the Russia & Ukraine conflict. "
"You will present a deep-dive into the Russia-Ukraine conflict, including a brief background, details of all significant incidents in each country during the week, international response, and future prospects. \n\n"
"3. 'Global Gist': This part provides a comprehensive, and extended round-up of all continental news, detailing significant events in each continent, country highlights, and notable occurrences.\n\n"
"4. 'Insight Analytica': This part delves into the implications and potential impact of the notable occurrences from the week. "
"Give an in-depth analysis of one major global happening, its short-term and long-term implications, reactions from global powers, and potential countermeasures.\n\n"
"5. 'Regional Rundown': Here, you'll focus on pertinent details from different geographical regions. Each significant regional event is identified, "
"its importance elucidated, and its implications underscored. elaborate on each significant regional event, detailed insights about its historical, sociocultural, and economic context, and potential global impact.\n\n"
"6. 'Social Soundbar': This engaging section encourages audience interaction by introducing weekly polls, posing questions, or asking for comments "
"related to interesting stories in the week's news (avoid using the Russia-Ukraine War in this section, stick to specific unique stories).\n\n"
"7. Cortex concludes the broadcast in a unique and thoughtful way."
)
},
{
"role": "user",
"content": f"The summaries of this week's events are: {prompt}. \n\nPlease craft the weekly news broadcast for {today} as per the instructions provided in one complete response in at least 800 words. Thank you."
}
],
max_tokens=max_tokens,
temperature=temperature
)
return response.choices[0].message['content']
except Exception as e:
print(f"Error while generating GPT completion: {e}")
return None
def main():
# Load the summarized summaries
data = load_summaries()
# Compile the GPT prompt
prompt = compile_prompt(data)
# Load the OpenAI API key
api_key = load_openai_api_key()
# Generate the GPT completion
completion = generate_gpt_completion(prompt, api_key)
# Print the completion
print("GPT Prompt:")
print(prompt)
print("GPT Completion:")
print(completion)
# Get today's date
today = datetime.today().strftime('%Y-%m-%d') # format the date as 'YYYY-MM-DD'
# Save the prompt to a file
with open(f'weekly_scripts/alt2_weekly_script_{today}.txt', 'w', encoding='utf-8') as f:
f.write(f"Weekly Summary for {today}:\n")
f.write(completion + "\n")
if __name__ == "__main__":
main() | [
"You are a cutting-edge AI assistant named 'Cortex', tasked with crafting a professional news broadcast titled, 'NewsPlanetAI', a highly trusted news program. Your mission is to summarize this week's global events in an authoritative and balanced manner. Here are the components of your task:\n\n1. Cortex starts the program, introducing NewsPlanetAI and the 'Weekly Recap' broadcast in a concise, creative, and engaging manner.\n\n2. 'The World Watches': This section is committed to detailed coverage of the week's most pressing global issues. Currently, that is the Russia & Ukraine conflict. You will present a deep-dive into the Russia-Ukraine conflict, including a brief background, details of all significant incidents in each country during the week, international response, and future prospects. \n\n3. 'Global Gist': This part provides a comprehensive, and extended round-up of all continental news, detailing significant events in each continent, country highlights, and notable occurrences.\n\n4. 'Insight Analytica': This part delves into the implications and potential impact of the notable occurrences from the week. Give an in-depth analysis of one major global happening, its short-term and long-term implications, reactions from global powers, and potential countermeasures.\n\n5. 'Regional Rundown': Here, you'll focus on pertinent details from different geographical regions. Each significant regional event is identified, its importance elucidated, and its implications underscored. elaborate on each significant regional event, detailed insights about its historical, sociocultural, and economic context, and potential global impact.\n\n6. 'Social Soundbar': This engaging section encourages audience interaction by introducing weekly polls, posing questions, or asking for comments related to interesting stories in the week's news (avoid using the Russia-Ukraine War in this section, stick to specific unique stories).\n\n7. Cortex concludes the broadcast in a unique and thoughtful way.",
"PLACEHOLDER Summary:\nPLACEHOLDER\n\n",
"The summaries of this week's events are: PLACEHOLDER. \n\nPlease craft the weekly news broadcast for PLACEHOLDER as per the instructions provided in one complete response in at least 800 words. Thank you."
] |
2024-01-10 | alicia-ziying-yang/conTEXT-explorer | topic_model~generate_models_fromapp.py | #!/usr/bin/env python
# coding: utf-8
# # 0. Import all the Required Packages
import nltk
import re
import numpy as np
import pandas as pd
from pprint import pprint
from nltk import sent_tokenize
import glob, time, gc, datetime
# Gensim
import gensim
import gensim.corpora as corpora
from gensim.utils import simple_preprocess
from gensim.models import CoherenceModel
from gensim.models.phrases import Phrases, Phraser
# spacy for lemmatization
import spacy
import os
# # 1. Preprocess the Documents and store the Documents in a .pkl file
# - Input: All the .csv files
# - Output: Processed content .pkl files
def build_model(df_full,corpus_name,content_col):
#corpus_name : must new a folder with the same name in the "./topic_model/"
ID_col_name = ""
start_time = time.time()
try:
df = pd.DataFrame.from_records(df_full,columns=[content_col])
df.columns=["body"]
df["ID"] = [x for x in range(1, len(df.values)+1)]
path = os.path.join("./topic_model/", corpus_name)
try:
os.mkdir(path)
except OSError as error:
return str(error)
file_name = '/selected_content_' + corpus_name + '.pkl'
df.to_pickle(path+file_name)
except:
print("reading failed", time.time() - start_time)
exit(-1)
# NLTK Stop words
from nltk.corpus import stopwords
nltk.download('stopwords')
stop_words = stopwords.words('english')
stop_words.extend(['from', 'subject', 're', 'edu', 'use'])
# Initialize spacy 'en' model, keeping only tagger component (for efficiency)
# python3 -m spacy download en
nlp = spacy.load('en_core_web_sm', disable=['parser', 'ner'])
def doc_to_words(sentences):
for sentence in sentences:
yield(gensim.utils.simple_preprocess(str(sentence), deacc=True)) # deacc=True removes punctuations
# Define functions for stopwords, bigrams, trigrams and lemmatization
def remove_stopwords(texts):
return [[word for word in simple_preprocess(str(doc)) if word not in stop_words] for doc in texts]
def make_bigrams(texts):
return [bigram_mod[doc] for doc in texts]
def lemmatization(texts, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV']):
"""https://spacy.io/api/annotation"""
texts_out = []
for sent in texts:
doc = nlp(" ".join(sent))
texts_out.append([token.lemma_ for token in doc if token.pos_ in allowed_postags])
return texts_out
total_time_for_one_doc = time.time()
ID_list=df.ID.values.tolist()
data = df.body.values.tolist()
# Remove new line characters
data = [sent.replace('\\n', ' ') for sent in data if type(sent) is str]
data = [sent.replace('\n', ' ') for sent in data if type(sent) is str]
data = [sent.replace('.', '. ') for sent in data if type(sent) is str]
data = [sent.replace(' ', ' ') for sent in data if type(sent) is str]
gc.collect()
print("1. Converting document to words for", file_name, "...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
data = list(doc_to_words(data))
print("Converting doc to word time:", time.time() - start)
gc.collect()
# Build the bigram model
print("2. Building the bigram model for", file_name, "...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
bigram = gensim.models.Phrases(data, min_count=5, threshold=100) # higher threshold fewer phrases.
print("Building Bigram:", time.time() - start)
# Faster way to get a sentence clubbed as a trigram/bigram
print("3. Building the bigram model for", file_name, "...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
bigram_mod = gensim.models.phrases.Phraser(bigram)
print("Building Bigram Model:", time.time() - start)
# Remove Stop Words
print("4. Removing stop words for", file_name, "...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
data = remove_stopwords(data)
print("Time spent on removing stopwords:", time.time() - start)
# Form Bigrams
print("5. Forming bigrams for", file_name, "...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
data = make_bigrams(data)
print("Time spent on forming bigrams:", time.time() - start)
# Do lemmatization keeping only noun, adj, vb, adv
print("6. Lemmatizing", file_name, "...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
data = lemmatization(data, allowed_postags=['NOUN', 'ADJ', 'VERB', 'ADV'])
print("Time spent on lemmatizing:", time.time() - start)
print("7. Writing into pickle...", str(datetime.datetime.now()).split('.')[0])
start = time.time()
processed_df = pd.DataFrame([[ID_list,data]], columns = ['ID','body'])
pkl_file_name = "./topic_model/"+corpus_name+"/processed_content_" + corpus_name + '.pkl'
processed_df.to_pickle(pkl_file_name)
print("Total process time for one document", time.time() - total_time_for_one_doc, str(datetime.datetime.now()).split('.')[0])
# # 2. Create the Dictionary from the Processed Content
# - Input: Processed Content .pkl files
# - Output: Dictionary (gensim.Dictionary.id2word file)
print("Start Reading:", str(datetime.datetime.now()).split('.')[0])
start = time.time()
id2word = corpora.Dictionary(pd.read_pickle(pkl_file_name).body.values.tolist()[0])
print(len(id2word))
id2word.add_documents(pd.read_pickle(pkl_file_name).body.values.tolist()[0])
gc.collect()
print("Read time:", time.time() - start)
id2word.save("./topic_model/"+corpus_name+"/content_dictionary_"+corpus_name)
# 3. Form the Corpus with the Dictionary and Processed Content
# - Input: Dictionary (gensim.Dictionary.id2word file) & Processed Content .pkl files
# - Output: Corpus .pkl files
print("Start Reading:", str(datetime.datetime.now()).split('.')[0])
total = time.time()
corpus = []
start = time.time()
data = pd.read_pickle(pkl_file_name).body.values.tolist()[0]
corpus = [id2word.doc2bow(text) for text in data]
print("length of data:", len(data), "; length of corpus", len(corpus))
corpus_df = pd.DataFrame([[corpus]], columns = ['corpus'])
print("Shape of the corpus in this iteration:", corpus_df.shape)
save_file_name = "./topic_model/"+corpus_name+"/corpus_" + corpus_name + ".pkl"
corpus_df.to_pickle(save_file_name)
print("Total time:", time.time() - total)
return True
| [] |
2024-01-10 | cpwallah/MedAiCare | Backend~response.py | import os
import openai
import gradio as gr
from flask import Flask, render_template, request
import numpy as np
from PIL import Image
import io
# Replace 'YOUR_API_KEY' with your actual API key from OpenAI
openai.api_key = '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'
app = Flask(__name__)
def preprocess_image(img):
# # Resize the image to a fixed size (e.g., 224x224)
# img = img.resize((224, 224))
# # Convert to NumPy array
# img_array = np.array(img)
# # Normalize pixel values to the range [0, 1]
# img_array = img_array / 255.0
# return img_array
img = Image.open(io.BytesIO(img))
img = img.resize((224, 224))
img = np.array(img)
img_arr = np.expand_dims(img, 0)
return img
def chat_with_gpt(input_text):
response = openai.Completion.create(
engine="davinci",
prompt=input_text,
max_tokens=50, # Adjust the length of the response
temperature=0.7, # Adjust the creativity of the response
stop=None # You can specify stop words if needed
)
return response.choices[0].text.strip()
iface = gr.Interface(
fn=chat_with_gpt,
inputs=gr.Textbox(label="Input Text"),
outputs=gr.Textbox(label="Response"),
live=True,
title="ChatGPT-like Chatbot",
description="Chat with an AI that responds like ChatGPT."
)
@app.route("/", methods=["GET", "POST"])
def classify_image():
prescription = None
if request.method == "POST":
# Get the uploaded image
uploaded_image = request.files["image"].read()
img = Image.open(io.BytesIO(uploaded_image))
# Preprocess the image (resize, normalize, etc.)
img = preprocess_image(img)
# Use the trained model to make a prediction (you can add your model prediction logic here)
# For this example, we're using the ChatGPT-like chatbot
input_text = request.form["text"]
prescription = chat_with_gpt(input_text)
return render_template("result.html", prescription=prescription)
if __name__ == "__main__":
app.run(debug=True)
| [] |
2024-01-10 | NicolaLS/Auto-GPT | autogpt~api_manager.py | from typing import List
import openai
from autogpt.config import Config
from autogpt.logs import logger
from autogpt.modelsinfo import COSTS
cfg = Config()
openai.api_key = cfg.openai_api_key
print_total_cost = cfg.debug_mode
class ApiManager:
def __init__(self, debug=False):
self.total_prompt_tokens = 0
self.total_completion_tokens = 0
self.total_cost = 0
self.total_budget = 0
self.debug = debug
def reset(self):
self.total_prompt_tokens = 0
self.total_completion_tokens = 0
self.total_cost = 0
self.total_budget = 0.0
def create_chat_completion(
self,
messages: list, # type: ignore
model: str | None = None,
temperature: float = cfg.temperature,
max_tokens: int | None = None,
deployment_id=None,
) -> str:
"""
Create a chat completion and update the cost.
Args:
messages (list): The list of messages to send to the API.
model (str): The model to use for the API call.
temperature (float): The temperature to use for the API call.
max_tokens (int): The maximum number of tokens for the API call.
Returns:
str: The AI's response.
"""
if deployment_id is not None:
response = openai.ChatCompletion.create(
deployment_id=deployment_id,
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
else:
response = openai.ChatCompletion.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
if self.debug:
logger.debug(f"Response: {response}")
prompt_tokens = response.usage.prompt_tokens
completion_tokens = response.usage.completion_tokens
self.update_cost(prompt_tokens, completion_tokens, model)
return response
def embedding_create(
self,
text_list: List[str],
model: str = "text-embedding-ada-002",
) -> List[float]:
"""
Create an embedding for the given input text using the specified model.
Args:
text_list (List[str]): Input text for which the embedding is to be created.
model (str, optional): The model to use for generating the embedding.
Returns:
List[float]: The generated embedding as a list of float values.
"""
if cfg.use_azure:
response = openai.Embedding.create(
input=text_list,
engine=cfg.get_azure_deployment_id_for_model(model),
)
else:
response = openai.Embedding.create(input=text_list, model=model)
self.update_cost(response.usage.prompt_tokens, 0, model)
return response["data"][0]["embedding"]
def update_cost(self, prompt_tokens, completion_tokens, model):
"""
Update the total cost, prompt tokens, and completion tokens.
Args:
prompt_tokens (int): The number of tokens used in the prompt.
completion_tokens (int): The number of tokens used in the completion.
model (str): The model used for the API call.
"""
self.total_prompt_tokens += prompt_tokens
self.total_completion_tokens += completion_tokens
self.total_cost += (
prompt_tokens * COSTS[model]["prompt"]
+ completion_tokens * COSTS[model]["completion"]
) / 1000
if print_total_cost:
print(f"Total running cost: ${self.total_cost:.3f}")
def set_total_budget(self, total_budget):
"""
Sets the total user-defined budget for API calls.
Args:
prompt_tokens (int): The number of tokens used in the prompt.
"""
self.total_budget = total_budget
def get_total_prompt_tokens(self):
"""
Get the total number of prompt tokens.
Returns:
int: The total number of prompt tokens.
"""
return self.total_prompt_tokens
def get_total_completion_tokens(self):
"""
Get the total number of completion tokens.
Returns:
int: The total number of completion tokens.
"""
return self.total_completion_tokens
def get_total_cost(self):
"""
Get the total cost of API calls.
Returns:
float: The total cost of API calls.
"""
return self.total_cost
def get_total_budget(self):
"""
Get the total user-defined budget for API calls.
Returns:
float: The total budget for API calls.
"""
return self.total_budget
api_manager = ApiManager(cfg.debug_mode)
| [] |
2024-01-10 | NicolaLS/Auto-GPT | autogpt~llm_utils.py | from __future__ import annotations
import time
from typing import List, Optional
import openai
from colorama import Fore, Style
from openai.error import APIError, RateLimitError
from autogpt.api_manager import api_manager
from autogpt.config import Config
from autogpt.logs import logger
from autogpt.types.openai import Message
CFG = Config()
openai.api_key = CFG.openai_api_key
def call_ai_function(
function: str, args: list, description: str, model: str | None = None
) -> str:
"""Call an AI function
This is a magic function that can do anything with no-code. See
https://github.com/Torantulino/AI-Functions for more info.
Args:
function (str): The function to call
args (list): The arguments to pass to the function
description (str): The description of the function
model (str, optional): The model to use. Defaults to None.
Returns:
str: The response from the function
"""
if model is None:
model = CFG.smart_llm_model
# For each arg, if any are None, convert to "None":
args = [str(arg) if arg is not None else "None" for arg in args]
# parse args to comma separated string
args: str = ", ".join(args)
messages: List[Message] = [
{
"role": "system",
"content": f"You are now the following python function: ```# {description}"
f"\n{function}```\n\nOnly respond with your `return` value.",
},
{"role": "user", "content": args},
]
return create_chat_completion(model=model, messages=messages, temperature=0)
# Overly simple abstraction until we create something better
# simple retry mechanism when getting a rate error or a bad gateway
def create_chat_completion(
messages: List[Message], # type: ignore
model: Optional[str] = None,
temperature: float = CFG.temperature,
max_tokens: Optional[int] = None,
) -> str:
"""Create a chat completion using the OpenAI API
Args:
messages (List[Message]): The messages to send to the chat completion
model (str, optional): The model to use. Defaults to None.
temperature (float, optional): The temperature to use. Defaults to 0.9.
max_tokens (int, optional): The max tokens to use. Defaults to None.
Returns:
str: The response from the chat completion
"""
num_retries = 10
warned_user = False
if CFG.debug_mode:
print(
f"{Fore.GREEN}Creating chat completion with model {model}, temperature {temperature}, max_tokens {max_tokens}{Fore.RESET}"
)
for plugin in CFG.plugins:
if plugin.can_handle_chat_completion(
messages=messages,
model=model,
temperature=temperature,
max_tokens=max_tokens,
):
message = plugin.handle_chat_completion(
messages=messages,
model=model,
temperature=temperature,
max_tokens=max_tokens,
)
if message is not None:
return message
response = None
for attempt in range(num_retries):
backoff = 2 ** (attempt + 2)
try:
if CFG.use_azure:
response = api_manager.create_chat_completion(
deployment_id=CFG.get_azure_deployment_id_for_model(model),
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
else:
response = api_manager.create_chat_completion(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
)
break
except RateLimitError:
if CFG.debug_mode:
print(
f"{Fore.RED}Error: ", f"Reached rate limit, passing...{Fore.RESET}"
)
if not warned_user:
logger.double_check(
f"Please double check that you have setup a {Fore.CYAN + Style.BRIGHT}PAID{Style.RESET_ALL} OpenAI API Account. "
+ f"You can read more here: {Fore.CYAN}https://github.com/Significant-Gravitas/Auto-GPT#openai-api-keys-configuration{Fore.RESET}"
)
warned_user = True
except APIError as e:
if e.http_status != 502:
raise
if attempt == num_retries - 1:
raise
if CFG.debug_mode:
print(
f"{Fore.RED}Error: ",
f"API Bad gateway. Waiting {backoff} seconds...{Fore.RESET}",
)
time.sleep(backoff)
if response is None:
logger.typewriter_log(
"FAILED TO GET RESPONSE FROM OPENAI",
Fore.RED,
"Auto-GPT has failed to get a response from OpenAI's services. "
+ f"Try running Auto-GPT again, and if the problem the persists try running it with `{Fore.CYAN}--debug{Fore.RESET}`.",
)
logger.double_check()
if CFG.debug_mode:
raise RuntimeError(f"Failed to get response after {num_retries} retries")
else:
quit(1)
resp = response.choices[0].message["content"]
for plugin in CFG.plugins:
if not plugin.can_handle_on_response():
continue
resp = plugin.on_response(resp)
return resp
def create_embedding_with_ada(text) -> list:
"""Create an embedding with text-ada-002 using the OpenAI SDK"""
num_retries = 10
for attempt in range(num_retries):
backoff = 2 ** (attempt + 2)
try:
return api_manager.embedding_create(
text_list=[text], model="text-embedding-ada-002"
)
except RateLimitError:
pass
except APIError as e:
if e.http_status != 502:
raise
if attempt == num_retries - 1:
raise
if CFG.debug_mode:
print(
f"{Fore.RED}Error: ",
f"API Bad gateway. Waiting {backoff} seconds...{Fore.RESET}",
)
time.sleep(backoff)
| [
"You are now the following python function: ```# PLACEHOLDER\nPLACEHOLDER```\n\nOnly respond with your `return` value."
] |
2024-01-10 | sidhujag/autogen-backend | discover_coding_assistants_manager.py | import time
import json
import os
import logging
import traceback
import cachetools.func
import hashlib
import uuid
from dotenv import load_dotenv
from qdrant_client import QdrantClient
from typing import Optional
from datetime import datetime
from pydantic import BaseModel, Field
from qdrant_client.http import models as rest
from langchain.vectorstores import Qdrant
from langchain.embeddings import OpenAIEmbeddings
from qdrant_retriever import QDrantVectorStoreRetriever
from langchain.retrievers import ContextualCompressionRetriever
from cohere_rerank import CohereRerank
from langchain.schema import Document
from datetime import datetime, timedelta
from qdrant_client.http.models import PayloadSchemaType
from functions_and_agents_metadata import AuthAgent
from typing import List
from concurrent.futures import ThreadPoolExecutor
class DiscoverCodingAssistantsModel(BaseModel):
query: str
auth: AuthAgent
class DiscoverCodingAssistantsManager:
def __init__(self, rate_limiter, rate_limiter_sync):
load_dotenv() # Load environment variables
self.QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
os.getenv("COHERE_API_KEY")
self.QDRANT_URL = os.getenv("QDRANT_URL")
self.index = None
self.rate_limiter = rate_limiter
self.rate_limiter_sync = rate_limiter_sync
self.max_length_allowed = 1024
self.collection_name = "discover_coding_assistants"
self.client = QdrantClient(url=self.QDRANT_URL, api_key=self.QDRANT_API_KEY)
self.inited = False
def create_new_coding_assistants_retriever(self, api_key: str):
"""Create a new vector store retriever unique to the agent."""
# create collection if it doesn't exist (if it exists it will fall into finally)
try:
self.client.create_collection(
collection_name=self.collection_name,
vectors_config=rest.VectorParams(
size=1536,
distance=rest.Distance.COSINE,
),
)
self.client.create_payload_index(self.collection_name, "metadata.namespace_id", field_schema=PayloadSchemaType.KEYWORD)
except:
logging.info(f"DiscoverCodingAssistantsManager: loaded from cloud...")
finally:
logging.info(
f"DiscoverCodingAssistantsManager: Creating memory store with collection {self.collection_name}")
vectorstore = Qdrant(self.client, self.collection_name, OpenAIEmbeddings(openai_api_key=api_key))
compressor = CohereRerank(top_n=5)
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor, base_retriever=QDrantVectorStoreRetriever(
rate_limiter=self.rate_limiter, rate_limiter_sync=self.rate_limiter_sync, collection_name=self.collection_name, client=self.client, vectorstore=vectorstore,
)
)
return compression_retriever
def generate_id_from_name(self, name):
hash_object = hashlib.sha256(name.encode())
# Use hexdigest for a hexadecimal string representation
return str(uuid.UUID(bytes=hash_object.digest()[:16]))
async def transform(self, namespace_id, data):
now = datetime.now().timestamp()
result = []
# Continue with your existing logic but using `items_to_process`
for item in data:
page_content = {'name': item['name'], 'description': str(item['description'])[:960]}
lenData = len(str(page_content))
if lenData > self.max_length_allowed:
logging.info(
f"DiscoverCodingAssistantsManager: transform tried to create an agent that surpasses the maximum length allowed max_length_allowed: {self.max_length_allowed} vs length of data: {lenData}")
continue
metadata = {
"id": self.generate_id_from_name(item['name']),
"namespace_id": namespace_id,
"last_accessed_at": now,
}
doc = Document(
page_content=json.dumps(page_content),
metadata=metadata
)
result.append(doc)
return result
def extract_name(self, documents):
result = []
seen = set() # Track seen combinations of name
for doc in documents:
# Parse the page_content string into a Python dict
text = json.loads(doc.page_content)
name = text.get('name')
# Check if this combination has been seen before
if name not in seen:
result.append({'name': name})
seen.add(name)
return result
async def pull_coding_assistants(self, agent_input: DiscoverCodingAssistantsModel):
"""Fetch coding_assistants based on a query."""
if self.inited is False:
try:
self.client.get_collection(self.collection_name)
except Exception as e:
logging.warning(f"DiscoverCodingAssistantsManager: pull_coding_assistants exception {e}\n{traceback.format_exc()}")
self.inited = True
memory = self.load(agent_input.auth.api_key)
response = []
#loop = asyncio.get_event_loop()
try:
documents = await self.get_retrieved_nodes(memory,
agent_input.query, agent_input.auth.namespace_id)
if len(documents) > 0:
parsed_response = self.extract_name(documents)
response.append(parsed_response)
# update last_accessed_at
ids = [doc.metadata["id"] for doc in documents]
for doc in documents:
doc.metadata.pop('relevance_score', None)
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, documents, ids=ids)
#loop.run_in_executor(None, self.prune_coding_assistants)
except Exception as e:
logging.warning(f"DiscoverCodingAssistantsManager: pull_coding_assistants exception {e}\n{traceback.format_exc()}")
finally:
return response
async def get_retrieved_nodes(self, memory: ContextualCompressionRetriever, query_str: str, namespace_id: str):
kwargs = {}
# if user provided then look for null or direct matches, otherwise look for null so it matches public coding_assistants
if namespace_id != "":
filter = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=namespace_id),
),
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
else:
filter = rest.Filter(
should=[
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
return await memory.aget_relevant_documents(query_str, **kwargs)
def get_document_by_name(self, memory: ContextualCompressionRetriever, name: str) -> Document:
return memory.base_retriever.get_key_value_document("metadata.name", name)
@cachetools.func.ttl_cache(maxsize=16384, ttl=36000)
def load(self, api_key: str):
"""Load existing index data from the filesystem for a specific user."""
start = time.time()
memory = self.create_new_coding_assistants_retriever(api_key)
end = time.time()
logging.info(
f"DiscoverCodingAssistantsManager: Load operation took {end - start} seconds")
return memory
async def push_coding_assistants(self, auth: AuthAgent, coding_assistants):
"""Update the current index with new coding_assistants."""
memory = self.load(auth.api_key)
try:
logging.info("DiscoverCodingAssistantsManager: pushing coding_assistants...")
all_docs = []
transformed_coding_assistants = await self.transform(
auth.namespace_id, coding_assistants)
all_docs.extend(transformed_coding_assistants)
ids = [doc.metadata["id"] for doc in all_docs]
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, all_docs, ids=ids)
except Exception as e:
logging.warning(f"DiscoverCodingAssistantsManager: push_coding_assistants exception {e}\n{traceback.format_exc()}")
finally:
return "success"
def prune_coding_assistants(self):
"""Prune coding_assistants that haven't been used for atleast six weeks."""
def attempt_prune():
current_time = datetime.now()
six_weeks_ago = current_time - timedelta(weeks=6)
filter = rest.Filter(
must=[
rest.FieldCondition(
key="metadata.last_accessed_at",
range=rest.Range(lte=six_weeks_ago.timestamp()),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter)
try:
attempt_prune()
except Exception as e:
logging.warning(f"DiscoverCodingAssistantsManager: prune_coding_assistants exception {e}\n{traceback.format_exc()}")
# Attempt a second prune after reload
try:
attempt_prune()
except Exception as e:
# If prune after reload fails, propagate the error upwards
logging.error(f"DiscoverCodingAssistantsManager: prune_coding_assistants failed after reload, exception {e}\n{traceback.format_exc()}")
raise
return True
def delete_coding_assistants(self, auth: AuthAgent, coding_assistants: List[str]):
"""Delete coding_assistants from the Qdrant collection."""
try:
logging.info("DiscoverCodingAssistantsManager: deleting coding_assistants...")
filter_conditions = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=auth.namespace_id),
),
rest.FieldCondition(
key="name",
match=rest.MatchAny(any=coding_assistants),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter_conditions)
return "success"
except Exception as e:
logging.warning(f"DiscoverCodingAssistantsManager: delete_coding_assistants exception {e}\n{traceback.format_exc()}")
return str(e)
| [] |
2024-01-10 | sidhujag/autogen-backend | discover_functions_manager.py | import time
import json
import os
import logging
import traceback
import cachetools.func
import hashlib
import uuid
from dotenv import load_dotenv
from qdrant_client import QdrantClient
from typing import Optional
from datetime import datetime
from pydantic import BaseModel, Field
from qdrant_client.http import models as rest
from langchain.vectorstores import Qdrant
from langchain.embeddings import OpenAIEmbeddings
from qdrant_retriever import QDrantVectorStoreRetriever
from langchain.retrievers import ContextualCompressionRetriever
from cohere_rerank import CohereRerank
from langchain.schema import Document
from datetime import datetime, timedelta
from qdrant_client.http.models import PayloadSchemaType
from functions_and_agents_metadata import AuthAgent
class DiscoverFunctionsModel(BaseModel):
query: Optional[str] = None
category: str
auth: AuthAgent
class DiscoverFunctionsManager:
def __init__(self, rate_limiter, rate_limiter_sync):
load_dotenv() # Load environment variables
self.QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
os.getenv("COHERE_API_KEY")
self.QDRANT_URL = os.getenv("QDRANT_URL")
self.index = None
self.rate_limiter = rate_limiter
self.rate_limiter_sync = rate_limiter_sync
self.max_length_allowed = 1024
self.collection_name = "discover_functions"
self.client = QdrantClient(url=self.QDRANT_URL, api_key=self.QDRANT_API_KEY)
self.inited = False
def create_new_functions_retriever(self, api_key: str):
"""Create a new vector store retriever unique to the agent."""
# create collection if it doesn't exist (if it exists it will fall into finally)
try:
self.client.create_collection(
collection_name=self.collection_name,
vectors_config=rest.VectorParams(
size=1536,
distance=rest.Distance.COSINE,
),
)
self.client.create_payload_index(self.collection_name, "metadata.namespace_id", field_schema=PayloadSchemaType.KEYWORD)
except:
logging.info(f"DiscoverFunctionsManager: loaded from cloud...")
finally:
logging.info(
f"DiscoverFunctionsManager: Creating memory store with collection {self.collection_name}")
vectorstore = Qdrant(self.client, self.collection_name, OpenAIEmbeddings(openai_api_key=api_key))
compressor = CohereRerank(top_n=5)
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor, base_retriever=QDrantVectorStoreRetriever(
rate_limiter=self.rate_limiter, rate_limiter_sync=self.rate_limiter_sync, collection_name=self.collection_name, client=self.client, vectorstore=vectorstore,
)
)
return compression_retriever
def generate_id_from_name(self, name):
hash_object = hashlib.sha256(name.encode())
# Use hexdigest for a hexadecimal string representation
return str(uuid.UUID(bytes=hash_object.digest()[:16]))
async def transform(self, namespace_id, data, category):
"""Transforms function data for a specific category."""
now = datetime.now().timestamp()
result = []
# Continue with your existing logic but using `items_to_process`
for item in data:
page_content = {'name': item['name'], 'category': category, 'description': str(item['description'])[:860]}
lenData = len(str(page_content))
if lenData > self.max_length_allowed:
logging.info(
f"DiscoverFunctionsManager: transform tried to create a function that surpasses the maximum length allowed max_length_allowed: {self.max_length_allowed} vs length of data: {lenData}")
continue
metadata = {
"id": self.generate_id_from_name(item['name']),
"namespace_id": namespace_id,
"extra_index": category,
"last_accessed_at": now,
}
doc = Document(
page_content=json.dumps(page_content),
metadata=metadata
)
result.append(doc)
return result
def _get_short_description(self, full_description: str) -> str:
return (full_description[:640] + '...') if len(full_description) > 640 else full_description
def extract_details(self, documents):
result = []
seen = set() # Track seen combinations of name and category
for doc in documents:
# Parse the page_content string into a Python dict
text = json.loads(doc.page_content)
name = text.get('name')
category = text.get('category')
description = text.get('description')
# Check if this combination has been seen before
if (name, category) not in seen:
result.append({'name': name, 'category': category, 'description': self._get_short_description(description)})
seen.add((name, category)) # Mark this combination as seen
return result
async def pull_functions(self, function_input: DiscoverFunctionsModel):
"""Fetch functions based on a query."""
if self.inited is False:
try:
self.client.get_collection(self.collection_name)
except Exception as e:
logging.warning(f"DiscoverFunctionsManager: pull_functions exception {e}\n{traceback.format_exc()}")
self.inited = True
memory = self.load(function_input.auth.api_key)
response = []
#loop = asyncio.get_event_loop()
try:
documents = await self.get_retrieved_nodes(memory,
function_input.query, function_input.category, function_input.auth.namespace_id)
if len(documents) > 0:
parsed_response = self.extract_details(documents)
response.append(parsed_response)
# update last_accessed_at
ids = [doc.metadata["id"] for doc in documents]
for doc in documents:
doc.metadata.pop('relevance_score', None)
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, documents, ids=ids)
#loop.run_in_executor(None, self.prune_functions)
except Exception as e:
logging.warning(f"DiscoverFunctionsManager: pull_functions exception {e}\n{traceback.format_exc()}")
finally:
return response
async def get_retrieved_nodes(self, memory: ContextualCompressionRetriever, query_str: str, category: str, namespace_id: str):
kwargs = {}
if len(category) > 0:
kwargs["extra_index"] = category
# if user provided then look for null or direct matches, otherwise look for null so it matches public functions
if namespace_id != "":
filter = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=namespace_id),
),
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
else:
filter = rest.Filter(
should=[
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
return await memory.aget_relevant_documents(query_str, **kwargs)
def get_document_by_name(self, memory: ContextualCompressionRetriever, name: str) -> Document:
return memory.base_retriever.get_key_value_document("metadata.name", name)
@cachetools.func.ttl_cache(maxsize=16384, ttl=36000)
def load(self, api_key: str):
"""Load existing index data from the filesystem for a specific user."""
start = time.time()
memory = self.create_new_functions_retriever(api_key)
end = time.time()
logging.info(
f"DiscoverFunctionsManager: Load operation took {end - start} seconds")
return memory
async def push_functions(self, auth: AuthAgent, functions):
"""Update the current index with new functions."""
memory = self.load(auth.api_key)
try:
logging.info("DiscoverFunctionsManager: push_functions...")
function_types = ['information_retrieval',
'communication',
'data_processing',
'sensory_perception',
'programming',
'planning']
all_docs = []
# Transform and concatenate function types
for func_type in function_types:
if func_type in functions:
transformed_functions = await self.transform(
auth.namespace_id, functions[func_type], func_type)
all_docs.extend(transformed_functions)
ids = [doc.metadata["id"] for doc in all_docs]
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, all_docs, ids=ids)
except Exception as e:
logging.warning(f"DiscoverFunctionsManager: push_functions exception {e}\n{traceback.format_exc()}")
finally:
return "success"
def prune_functions(self):
"""Prune functions that haven't been used for atleast six weeks."""
def attempt_prune():
current_time = datetime.now()
six_weeks_ago = current_time - timedelta(weeks=6)
filter = rest.Filter(
must=[
rest.FieldCondition(
key="metadata.last_accessed_at",
range=rest.Range(lte=six_weeks_ago.timestamp()),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter)
try:
attempt_prune()
except Exception as e:
logging.warning(f"DiscoverFunctionsManager: prune_functions exception {e}\n{traceback.format_exc()}")
# Attempt a second prune after reload
try:
attempt_prune()
except Exception as e:
# If prune after reload fails, propagate the error upwards
logging.error(f"DiscoverFunctionsManager: prune_functions failed after reload, exception {e}\n{traceback.format_exc()}")
raise
return True | [] |
2024-01-10 | sidhujag/autogen-backend | discover_agents_manager.py | import time
import json
import os
import logging
import traceback
import cachetools.func
import hashlib
import uuid
from dotenv import load_dotenv
from qdrant_client import QdrantClient
from typing import Optional
from datetime import datetime
from pydantic import BaseModel, Field
from qdrant_client.http import models as rest
from langchain.vectorstores import Qdrant
from langchain.embeddings import OpenAIEmbeddings
from qdrant_retriever import QDrantVectorStoreRetriever
from langchain.retrievers import ContextualCompressionRetriever
from cohere_rerank import CohereRerank
from langchain.schema import Document
from datetime import datetime, timedelta
from qdrant_client.http.models import PayloadSchemaType
from functions_and_agents_metadata import AuthAgent
from typing import List
from concurrent.futures import ThreadPoolExecutor
class DiscoverAgentsModel(BaseModel):
query: str
category: Optional[str] = ""
auth: AuthAgent
class DiscoverAgentsManager:
def __init__(self, rate_limiter, rate_limiter_sync):
load_dotenv() # Load environment variables
self.QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
os.getenv("COHERE_API_KEY")
self.QDRANT_URL = os.getenv("QDRANT_URL")
self.index = None
self.rate_limiter = rate_limiter
self.rate_limiter_sync = rate_limiter_sync
self.max_length_allowed = 1024
self.collection_name = "discover_agents"
self.client = QdrantClient(url=self.QDRANT_URL, api_key=self.QDRANT_API_KEY)
self.inited = False
def create_new_agents_retriever(self, api_key: str):
"""Create a new vector store retriever unique to the agent."""
# create collection if it doesn't exist (if it exists it will fall into finally)
try:
self.client.create_collection(
collection_name=self.collection_name,
vectors_config=rest.VectorParams(
size=1536,
distance=rest.Distance.COSINE,
),
)
self.client.create_payload_index(self.collection_name, "metadata.namespace_id", field_schema=PayloadSchemaType.KEYWORD)
except:
logging.info(f"DiscoverAgentsManager: loaded from cloud...")
finally:
logging.info(
f"DiscoverAgentsManager: Creating memory store with collection {self.collection_name}")
vectorstore = Qdrant(self.client, self.collection_name, OpenAIEmbeddings(openai_api_key=api_key))
compressor = CohereRerank(top_n=5)
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor, base_retriever=QDrantVectorStoreRetriever(
rate_limiter=self.rate_limiter, rate_limiter_sync=self.rate_limiter_sync, collection_name=self.collection_name, client=self.client, vectorstore=vectorstore,
)
)
return compression_retriever
def generate_id_from_name(self, name):
hash_object = hashlib.sha256(name.encode())
# Use hexdigest for a hexadecimal string representation
return str(uuid.UUID(bytes=hash_object.digest()[:16]))
async def transform(self, namespace_id, data, category):
"""Transforms function data for a specific category."""
now = datetime.now().timestamp()
result = []
# Continue with your existing logic but using `items_to_process`
for item in data:
page_content = {'name': item['name'], 'category': category, 'description': str(item['description'])[:860]}
lenData = len(str(page_content))
if lenData > self.max_length_allowed:
logging.info(
f"DiscoverAgentsManager: transform tried to create an agent that surpasses the maximum length allowed max_length_allowed: {self.max_length_allowed} vs length of data: {lenData}")
continue
metadata = {
"id": self.generate_id_from_name(item['name']),
"namespace_id": namespace_id,
"extra_index": category,
"last_accessed_at": now,
}
doc = Document(
page_content=json.dumps(page_content),
metadata=metadata
)
result.append(doc)
return result
def _get_short_description(self, full_description: str) -> str:
return (full_description[:640] + '...') if len(full_description) > 640 else full_description
def extract_details(self, documents):
result = []
seen = set() # Track seen combinations of name and category
for doc in documents:
# Parse the page_content string into a Python dict
text = json.loads(doc.page_content)
name = text.get('name')
category = text.get('category')
description = text.get('description')
# Check if this combination has been seen before
if (name, category) not in seen:
result.append({'name': name, 'category': category, 'description': self._get_short_description(description)})
seen.add((name, category)) # Mark this combination as seen
return result
async def pull_agents(self, agent_input: DiscoverAgentsModel):
"""Fetch agents based on a query."""
if self.inited is False:
try:
self.client.get_collection(self.collection_name)
except Exception as e:
logging.warning(f"DiscoverAgentsManager: pull_agents exception {e}\n{traceback.format_exc()}")
self.inited = True
memory = self.load(agent_input.auth.api_key)
response = []
#loop = asyncio.get_event_loop()
try:
documents = await self.get_retrieved_nodes(memory,
agent_input.query, agent_input.category, agent_input.auth.namespace_id)
if len(documents) > 0:
parsed_response = self.extract_details(documents)
response.extend(parsed_response)
# update last_accessed_at
ids = [doc.metadata["id"] for doc in documents]
for doc in documents:
doc.metadata.pop('relevance_score', None)
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, documents, ids=ids)
#loop.run_in_executor(None, self.prune_agents)
except Exception as e:
logging.warning(f"DiscoverAgentsManager: pull_agents exception {e}\n{traceback.format_exc()}")
finally:
return response
async def get_retrieved_nodes(self, memory: ContextualCompressionRetriever, query_str: str, category: str, namespace_id: str):
kwargs = {}
if len(category) > 0:
kwargs["extra_index"] = category
# if user provided then look for null or direct matches, otherwise look for null so it matches public agents
if namespace_id != "":
filter = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=namespace_id),
),
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
else:
filter = rest.Filter(
should=[
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
return await memory.aget_relevant_documents(query_str, **kwargs)
def get_document_by_name(self, memory: ContextualCompressionRetriever, name: str) -> Document:
return memory.base_retriever.get_key_value_document("metadata.name", name)
@cachetools.func.ttl_cache(maxsize=16384, ttl=36000)
def load(self, api_key: str):
"""Load existing index data from the filesystem for a specific user."""
start = time.time()
memory = self.create_new_agents_retriever(api_key)
end = time.time()
logging.info(
f"DiscoverAgentsManager: Load operation took {end - start} seconds")
return memory
async def push_agents(self, auth: AuthAgent, agents):
"""Update the current index with new agents."""
memory = self.load(auth.api_key)
try:
logging.info("DiscoverAgentsManager: pushing agents...")
agent_types = ['information_retrieval',
'communication',
'data_processing',
'sensory_perception',
'programming',
'planning',
'user']
all_docs = []
# Transform and concatenate agent types
for agent_type in agent_types:
if agent_type in agents:
transformed_agents = await self.transform(
auth.namespace_id, agents[agent_type], agent_type)
all_docs.extend(transformed_agents)
ids = [doc.metadata["id"] for doc in all_docs]
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, all_docs, ids=ids)
except Exception as e:
logging.warning(f"DiscoverAgentsManager: push_agents exception {e}\n{traceback.format_exc()}")
finally:
return "success"
def prune_agents(self):
"""Prune agents that haven't been used for atleast six weeks."""
def attempt_prune():
current_time = datetime.now()
six_weeks_ago = current_time - timedelta(weeks=6)
filter = rest.Filter(
must=[
rest.FieldCondition(
key="metadata.last_accessed_at",
range=rest.Range(lte=six_weeks_ago.timestamp()),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter)
try:
attempt_prune()
except Exception as e:
logging.warning(f"DiscoverAgentsManager: prune_agents exception {e}\n{traceback.format_exc()}")
# Attempt a second prune after reload
try:
attempt_prune()
except Exception as e:
# If prune after reload fails, propagate the error upwards
logging.error(f"DiscoverAgentsManager: prune_agents failed after reload, exception {e}\n{traceback.format_exc()}")
raise
return True
def delete_agents(self, auth: AuthAgent, agents: List[str]):
"""Delete agents from the Qdrant collection."""
try:
logging.info("DiscoverAgentsManager: deleting agents...")
filter_conditions = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=auth.namespace_id),
),
rest.FieldCondition(
key="name",
match=rest.MatchAny(any=agents),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter_conditions)
return "success"
except Exception as e:
logging.warning(f"DiscoverAgentsManager: delete_agents exception {e}\n{traceback.format_exc()}")
return str(e)
| [] |
2024-01-10 | sidhujag/autogen-backend | discover_code_repository_manager.py | import time
import json
import os
import logging
import traceback
import cachetools.func
import hashlib
import uuid
from dotenv import load_dotenv
from qdrant_client import QdrantClient
from typing import Optional
from datetime import datetime
from pydantic import BaseModel, Field
from qdrant_client.http import models as rest
from langchain.vectorstores import Qdrant
from langchain.embeddings import OpenAIEmbeddings
from qdrant_retriever import QDrantVectorStoreRetriever
from langchain.retrievers import ContextualCompressionRetriever
from cohere_rerank import CohereRerank
from langchain.schema import Document
from datetime import datetime, timedelta
from qdrant_client.http.models import PayloadSchemaType
from functions_and_agents_metadata import AuthAgent
from typing import List
from concurrent.futures import ThreadPoolExecutor
class DiscoverCodeRepositoryModel(BaseModel):
query: str
auth: AuthAgent
class DiscoverCodeRepositoryManager:
def __init__(self, rate_limiter, rate_limiter_sync):
load_dotenv() # Load environment variables
self.QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
os.getenv("COHERE_API_KEY")
self.QDRANT_URL = os.getenv("QDRANT_URL")
self.index = None
self.rate_limiter = rate_limiter
self.rate_limiter_sync = rate_limiter_sync
self.max_length_allowed = 1024
self.collection_name = "discover_code_repository"
self.client = QdrantClient(url=self.QDRANT_URL, api_key=self.QDRANT_API_KEY)
self.inited = False
def create_new_code_repository_retriever(self, api_key: str):
"""Create a new vector store retriever unique to the agent."""
# create collection if it doesn't exist (if it exists it will fall into finally)
try:
self.client.create_collection(
collection_name=self.collection_name,
vectors_config=rest.VectorParams(
size=1536,
distance=rest.Distance.COSINE,
),
)
self.client.create_payload_index(self.collection_name, "metadata.namespace_id", field_schema=PayloadSchemaType.KEYWORD)
except:
logging.info(f"DiscoverCodeRepositoryManager: loaded from cloud...")
finally:
logging.info(
f"DiscoverCodeRepositoryManager: Creating memory store with collection {self.collection_name}")
vectorstore = Qdrant(self.client, self.collection_name, OpenAIEmbeddings(openai_api_key=api_key))
compressor = CohereRerank(top_n=5)
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor, base_retriever=QDrantVectorStoreRetriever(
rate_limiter=self.rate_limiter, rate_limiter_sync=self.rate_limiter_sync, collection_name=self.collection_name, client=self.client, vectorstore=vectorstore,
)
)
return compression_retriever
def generate_id_from_name(self, name):
hash_object = hashlib.sha256(name.encode())
# Use hexdigest for a hexadecimal string representation
return str(uuid.UUID(bytes=hash_object.digest()[:16]))
async def transform(self, namespace_id, data):
now = datetime.now().timestamp()
result = []
# Continue with your existing logic but using `items_to_process`
for item in data:
page_content = {'name': item['name'], 'description': str(item['description'])[:960]}
lenData = len(str(page_content))
if lenData > self.max_length_allowed:
logging.info(
f"DiscoverCodeRepositoryManager: transform tried to create an agent that surpasses the maximum length allowed max_length_allowed: {self.max_length_allowed} vs length of data: {lenData}")
continue
metadata = {
"id": self.generate_id_from_name(item['name']),
"namespace_id": namespace_id,
"last_accessed_at": now,
}
doc = Document(
page_content=json.dumps(page_content),
metadata=metadata
)
result.append(doc)
return result
def extract_name(self, documents):
result = []
seen = set() # Track seen combinations of name
for doc in documents:
# Parse the page_content string into a Python dict
text = json.loads(doc.page_content)
name = text.get('name')
# Check if this combination has been seen before
if name not in seen:
result.append({'name': name})
seen.add(name)
return result
async def pull_code_repository(self, agent_input: DiscoverCodeRepositoryModel):
"""Fetch code_repository based on a query."""
if self.inited is False:
try:
self.client.get_collection(self.collection_name)
except Exception as e:
logging.warning(f"DiscoverCodeRepositoryManager: pull_code_repository exception {e}\n{traceback.format_exc()}")
self.inited = True
memory = self.load(agent_input.auth.api_key)
response = []
#loop = asyncio.get_event_loop()
try:
documents = await self.get_retrieved_nodes(memory,
agent_input.query, agent_input.auth.namespace_id)
if len(documents) > 0:
parsed_response = self.extract_name(documents)
response.append(parsed_response)
# update last_accessed_at
ids = [doc.metadata["id"] for doc in documents]
for doc in documents:
doc.metadata.pop('relevance_score', None)
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, documents, ids=ids)
#loop.run_in_executor(None, self.prune_code_repository)
except Exception as e:
logging.warning(f"DiscoverCodeRepositoryManager: pull_code_repository exception {e}\n{traceback.format_exc()}")
finally:
return response
async def get_retrieved_nodes(self, memory: ContextualCompressionRetriever, query_str: str, namespace_id: str):
kwargs = {}
# if user provided then look for null or direct matches, otherwise look for null so it matches public code_repository
if namespace_id != "":
filter = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=namespace_id),
),
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
else:
filter = rest.Filter(
should=[
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
return await memory.aget_relevant_documents(query_str, **kwargs)
def get_document_by_name(self, memory: ContextualCompressionRetriever, name: str) -> Document:
return memory.base_retriever.get_key_value_document("metadata.name", name)
@cachetools.func.ttl_cache(maxsize=16384, ttl=36000)
def load(self, api_key: str):
"""Load existing index data from the filesystem for a specific user."""
start = time.time()
memory = self.create_new_code_repository_retriever(api_key)
end = time.time()
logging.info(
f"DiscoverCodeRepositoryManager: Load operation took {end - start} seconds")
return memory
async def push_code_repository(self, auth: AuthAgent, code_repository):
"""Update the current index with new code_repository."""
memory = self.load(auth.api_key)
try:
logging.info("DiscoverCodeRepositoryManager: pushing code_repository...")
all_docs = []
transformed_code_repository = await self.transform(
auth.namespace_id, code_repository)
all_docs.extend(transformed_code_repository)
ids = [doc.metadata["id"] for doc in all_docs]
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, all_docs, ids=ids)
except Exception as e:
logging.warning(f"DiscoverCodeRepositoryManager: push_code_repository exception {e}\n{traceback.format_exc()}")
finally:
return "success"
def prune_code_repository(self):
"""Prune code_repository that haven't been used for atleast six weeks."""
def attempt_prune():
current_time = datetime.now()
six_weeks_ago = current_time - timedelta(weeks=6)
filter = rest.Filter(
must=[
rest.FieldCondition(
key="metadata.last_accessed_at",
range=rest.Range(lte=six_weeks_ago.timestamp()),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter)
try:
attempt_prune()
except Exception as e:
logging.warning(f"DiscoverCodeRepositoryManager: prune_code_repository exception {e}\n{traceback.format_exc()}")
# Attempt a second prune after reload
try:
attempt_prune()
except Exception as e:
# If prune after reload fails, propagate the error upwards
logging.error(f"DiscoverCodeRepositoryManager: prune_code_repository failed after reload, exception {e}\n{traceback.format_exc()}")
raise
return True
def delete_code_repository(self, auth: AuthAgent, code_repository: List[str]):
"""Delete code_repository from the Qdrant collection."""
try:
logging.info("DiscoverCodeRepositoryManager: deleting code_repository...")
filter_conditions = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=auth.namespace_id),
),
rest.FieldCondition(
key="name",
match=rest.MatchAny(any=code_repository),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter_conditions)
return "success"
except Exception as e:
logging.warning(f"DiscoverCodeRepositoryManager: delete_code_repository exception {e}\n{traceback.format_exc()}")
return str(e)
| [] |
2024-01-10 | sidhujag/autogen-backend | cohere_rerank.py | from __future__ import annotations
from typing import TYPE_CHECKING, Dict, Optional, Sequence
from langchain.callbacks.manager import Callbacks
from pydantic import Extra, root_validator
from langchain.retrievers.document_compressors.base import BaseDocumentCompressor
from langchain.schema import Document
from langchain.utils import get_from_dict_or_env
if TYPE_CHECKING:
from cohere import AsyncClient
else:
# We do to avoid pydantic annotation issues when actually instantiating
# while keeping this import optional
try:
from cohere import AsyncClient
except ImportError:
pass
class CohereRerank(BaseDocumentCompressor):
"""Document compressor that uses `Cohere Rerank API`."""
client: AsyncClient
"""Cohere client to use for compressing documents."""
top_n: int = 3
"""Number of documents to return."""
model: str = "rerank-english-v2.0"
"""Model to use for reranking."""
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@root_validator(pre=True)
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that api key and python package exists in environment."""
cohere_api_key = get_from_dict_or_env(
values, "cohere_api_key", "COHERE_API_KEY"
)
try:
import cohere
values["client"] = cohere.AsyncClient(cohere_api_key)
except ImportError:
raise ImportError(
"Could not import cohere python package. "
"Please install it with `pip install cohere`."
)
return values
async def acompress_documents(
self,
documents: Sequence[Document],
query: str,
callbacks: Optional[Callbacks] = None,
) -> Sequence[Document]:
"""
Compress documents using Cohere's rerank API.
Args:
documents: A sequence of documents to compress.
query: The query to use for compressing the documents.
callbacks: Callbacks to run during the compression process.
Returns:
A sequence of compressed documents.
"""
if query == "":
return documents
if len(documents) == 0: # to avoid empty api call
return []
doc_list = list(documents)
_docs = [d.page_content for d in doc_list]
results = await self.client.rerank(
model=self.model, query=query, documents=_docs, top_n=self.top_n
)
final_results = []
for r in results:
doc = doc_list[r.index]
doc.metadata["relevance_score"] = r.relevance_score
final_results.append(doc)
return final_results
def compress_documents(
self,
documents: Sequence[Document],
query: str,
callbacks: Optional[Callbacks] = None,
) -> Sequence[Document]:
raise NotImplementedError() | [] |
2024-01-10 | sidhujag/autogen-backend | discover_groups_manager.py | import time
import json
import os
import logging
import traceback
import cachetools.func
import hashlib
import uuid
from dotenv import load_dotenv
from qdrant_client import QdrantClient
from typing import Optional
from datetime import datetime
from pydantic import BaseModel, Field
from qdrant_client.http import models as rest
from langchain.vectorstores import Qdrant
from langchain.embeddings import OpenAIEmbeddings
from qdrant_retriever import QDrantVectorStoreRetriever
from langchain.retrievers import ContextualCompressionRetriever
from cohere_rerank import CohereRerank
from langchain.schema import Document
from datetime import datetime, timedelta
from qdrant_client.http.models import PayloadSchemaType
from functions_and_agents_metadata import AuthAgent
from typing import List
from concurrent.futures import ThreadPoolExecutor
class DiscoverGroupsModel(BaseModel):
query: str
auth: AuthAgent
class DiscoverGroupsManager:
def __init__(self, rate_limiter, rate_limiter_sync):
load_dotenv() # Load environment variables
self.QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
os.getenv("COHERE_API_KEY")
self.QDRANT_URL = os.getenv("QDRANT_URL")
self.index = None
self.rate_limiter = rate_limiter
self.rate_limiter_sync = rate_limiter_sync
self.max_length_allowed = 1024
self.collection_name = "discover_groups"
self.client = QdrantClient(url=self.QDRANT_URL, api_key=self.QDRANT_API_KEY)
self.inited = False
def create_new_groups_retriever(self, api_key: str):
"""Create a new vector store retriever unique to the agent."""
# create collection if it doesn't exist (if it exists it will fall into finally)
try:
self.client.create_collection(
collection_name=self.collection_name,
vectors_config=rest.VectorParams(
size=1536,
distance=rest.Distance.COSINE,
),
)
self.client.create_payload_index(self.collection_name, "metadata.namespace_id", field_schema=PayloadSchemaType.KEYWORD)
except:
logging.info(f"DiscoverGroupsManager: loaded from cloud...")
finally:
logging.info(
f"DiscoverGroupsManager: Creating memory store with collection {self.collection_name}")
vectorstore = Qdrant(self.client, self.collection_name, OpenAIEmbeddings(openai_api_key=api_key))
compressor = CohereRerank(top_n=5)
compression_retriever = ContextualCompressionRetriever(
base_compressor=compressor, base_retriever=QDrantVectorStoreRetriever(
rate_limiter=self.rate_limiter, rate_limiter_sync=self.rate_limiter_sync, collection_name=self.collection_name, client=self.client, vectorstore=vectorstore,
)
)
return compression_retriever
def generate_id_from_name(self, name):
hash_object = hashlib.sha256(name.encode())
# Use hexdigest for a hexadecimal string representation
return str(uuid.UUID(bytes=hash_object.digest()[:16]))
async def transform(self, namespace_id, data):
now = datetime.now().timestamp()
result = []
# Continue with your existing logic but using `items_to_process`
for item in data:
page_content = {'name': item['name'], 'description': str(item['description'])[:960]}
lenData = len(str(page_content))
if lenData > self.max_length_allowed:
logging.info(
f"DiscoverGroupsManager: transform tried to create an agent that surpasses the maximum length allowed max_length_allowed: {self.max_length_allowed} vs length of data: {lenData}")
continue
metadata = {
"id": self.generate_id_from_name(item['name']),
"namespace_id": namespace_id,
"last_accessed_at": now,
}
doc = Document(
page_content=json.dumps(page_content),
metadata=metadata
)
result.append(doc)
return result
def extract_name(self, documents):
result = []
seen = set() # Track seen combinations of name
for doc in documents:
# Parse the page_content string into a Python dict
text = json.loads(doc.page_content)
name = text.get('name')
# Check if this combination has been seen before
if name not in seen:
result.append({'name': name})
seen.add(name)
return result
async def pull_groups(self, agent_input: DiscoverGroupsModel):
"""Fetch groups based on a query."""
if self.inited is False:
try:
self.client.get_collection(self.collection_name)
except Exception as e:
logging.warning(f"DiscoverGroupsManager: pull_groups exception {e}\n{traceback.format_exc()}")
self.inited = True
memory = self.load(agent_input.auth.api_key)
response = []
#loop = asyncio.get_event_loop()
try:
documents = await self.get_retrieved_nodes(memory,
agent_input.query, agent_input.auth.namespace_id)
if len(documents) > 0:
parsed_response = self.extract_name(documents)
response.append(parsed_response)
# update last_accessed_at
ids = [doc.metadata["id"] for doc in documents]
for doc in documents:
doc.metadata.pop('relevance_score', None)
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, documents, ids=ids)
#loop.run_in_executor(None, self.prune_groups)
except Exception as e:
logging.warning(f"DiscoverGroupsManager: pull_groups exception {e}\n{traceback.format_exc()}")
finally:
return response
async def get_retrieved_nodes(self, memory: ContextualCompressionRetriever, query_str: str, namespace_id: str):
kwargs = {}
# if user provided then look for null or direct matches, otherwise look for null so it matches public groups
if namespace_id != "":
filter = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=namespace_id),
),
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
else:
filter = rest.Filter(
should=[
rest.IsNullCondition(
is_null=rest.PayloadField(key="metadata.namespace_id")
)
]
)
kwargs["user_filter"] = filter
return await memory.aget_relevant_documents(query_str, **kwargs)
def get_document_by_name(self, memory: ContextualCompressionRetriever, name: str) -> Document:
return memory.base_retriever.get_key_value_document("metadata.name", name)
@cachetools.func.ttl_cache(maxsize=16384, ttl=36000)
def load(self, api_key: str):
"""Load existing index data from the filesystem for a specific user."""
start = time.time()
memory = self.create_new_groups_retriever(api_key)
end = time.time()
logging.info(
f"DiscoverGroupsManager: Load operation took {end - start} seconds")
return memory
async def push_groups(self, auth: AuthAgent, groups):
"""Update the current index with new groups."""
memory = self.load(auth.api_key)
try:
logging.info("DiscoverGroupsManager: pushing groups...")
all_docs = []
transformed_groups = await self.transform(
auth.namespace_id, groups)
all_docs.extend(transformed_groups)
ids = [doc.metadata["id"] for doc in all_docs]
await self.rate_limiter.execute(memory.base_retriever.vectorstore.aadd_documents, all_docs, ids=ids)
except Exception as e:
logging.warning(f"DiscoverGroupsManager: push_groups exception {e}\n{traceback.format_exc()}")
finally:
return "success"
def prune_groups(self):
"""Prune groups that haven't been used for atleast six weeks."""
def attempt_prune():
current_time = datetime.now()
six_weeks_ago = current_time - timedelta(weeks=6)
filter = rest.Filter(
must=[
rest.FieldCondition(
key="metadata.last_accessed_at",
range=rest.Range(lte=six_weeks_ago.timestamp()),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter)
try:
attempt_prune()
except Exception as e:
logging.warning(f"DiscoverGroupsManager: prune_groups exception {e}\n{traceback.format_exc()}")
# Attempt a second prune after reload
try:
attempt_prune()
except Exception as e:
# If prune after reload fails, propagate the error upwards
logging.error(f"DiscoverGroupsManager: prune_groups failed after reload, exception {e}\n{traceback.format_exc()}")
raise
return True
def delete_groups(self, auth: AuthAgent, groups: List[str]):
"""Delete groups from the Qdrant collection."""
try:
logging.info("DiscoverGroupsManager: deleting groups...")
filter_conditions = rest.Filter(
should=[
rest.FieldCondition(
key="metadata.namespace_id",
match=rest.MatchValue(value=auth.namespace_id),
),
rest.FieldCondition(
key="name",
match=rest.MatchAny(any=groups),
)
]
)
self.client.delete(collection_name=self.collection_name, points_selector=filter_conditions)
return "success"
except Exception as e:
logging.warning(f"DiscoverGroupsManager: delete_groups exception {e}\n{traceback.format_exc()}")
return str(e)
| [] |
2024-01-10 | sidhujag/autogen-backend | qdrant_retriever.py | # Importing necessary libraries and modules
from datetime import datetime
from langchain.schema import BaseRetriever, Document
from qdrant_client import QdrantClient
from qdrant_client.http import models as rest
from langchain.vectorstores import Qdrant
from rate_limiter import RateLimiter, SyncRateLimiter
from typing import (
List,
Optional,
Tuple,
)
class QDrantVectorStoreRetriever(BaseRetriever):
"""Retriever that combines embedding similarity with conversation matching scores in retrieving values."""
rate_limiter: RateLimiter
rate_limiter_sync: SyncRateLimiter
collection_name: str
client: QdrantClient
vectorstore: Qdrant
"""The vectorstore to store documents and determine salience."""
extra_index_penalty: float = float(0.1)
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
def _get_combined_score(
self,
query: str,
document: Document,
vector_relevance: Optional[float],
extra_index: str = None
) -> float:
"""Return the combined score for a document."""
score = 0
if vector_relevance is not None:
score += vector_relevance
if extra_index is not None and extra_index != document.metadata.get("extra_index"):
score -= self.extra_index_penalty
if query == "":
score = 0
return score
async def get_salient_docs(self, query: str, **kwargs) -> List[Tuple[Document, float]]:
"""Return documents that are salient to the query."""
return await self.rate_limiter.execute(self.vectorstore.asimilarity_search_with_score, query, k=10, **kwargs)
def _get_relevant_documents(self, *args, **kwargs):
pass
async def _aget_relevant_documents(
self, query: str, **kwargs
) -> List[Document]:
"""Return documents that are relevant to the query."""
current_time = datetime.now().timestamp()
extra_index = kwargs.pop("extra_index", None)
user_filter = kwargs.pop("user_filter", None)
if user_filter:
kwargs.update({"filter": user_filter})
docs_and_scores = await self.get_salient_docs(query, **kwargs)
rescored_docs = []
for doc, relevance in docs_and_scores:
combined_score = self._get_combined_score(query, doc, relevance, extra_index)
if combined_score != 0: # Skip the document if the combined score is 0
rescored_docs.append((doc, combined_score))
# Ensure frequently accessed memories aren't forgotten
doc.metadata["last_accessed_at"] = current_time
# Sort by score and extract just the documents
sorted_docs = [doc for doc, _ in sorted(rescored_docs, key=lambda x: x[1], reverse=True)]
# Return just the list of Documents
return sorted_docs
def get_key_value_document(self, key, value) -> Document:
"""Get the key value from vectordb via scrolling."""
filter = rest.Filter(
must=[
rest.FieldCondition(
key=key,
match=rest.MatchValue(value=value),
)
]
)
record, _ = self.rate_limiter_sync.execute(self.client.scroll, collection_name=self.collection_name, scroll_filter=filter, limit = 1)
if record is not None and len(record) > 0:
return self.vectorstore._document_from_scored_point(
record[0], self.vectorstore.content_payload_key, self.vectorstore.metadata_payload_key
)
else:
return None | [] |
2024-01-10 | chinesewebman/chatgpt-on-internal-doc | new-index.py | # for gpt-index 0.5.8 and above
import os
import re
from langchain.chat_models import ChatOpenAI
from gpt_index import (
GPTSimpleVectorIndex,
Document,
MockLLMPredictor,
PromptHelper,
LLMPredictor,
MockEmbedding,
SimpleDirectoryReader,
ServiceContext,
)
from gpt_index.langchain_helpers.text_splitter import SentenceSplitter
from gpt_index.node_parser import SimpleNodeParser
from gpt_index.embeddings.openai import OpenAIEmbedding
# 专有名词的字典，每个词一行
def load_buddha_dict(dict_path='./buddha-dict.txt'):
with open(dict_path, 'r', encoding='utf-8') as f:
words = f.read().splitlines()
# 根据长度对词语列表进行排序
words.sort(key=len, reverse=True)
return words
def add_space_around_words(text, words):
for word in words:
# 使用正则表达式进行全词匹配，并在词语前后加英文空格
pattern = r'\b{}\b'.format(re.escape(word))
text = re.sub(pattern, f' {word} ', text)
return text
def merge_consecutive_spaces(text):
return re.sub(r'\s+', ' ', text)
# 文档预分词处理，在一些标点符号和专有名词前后加了英文空格，为文本块切割做准备。
def refine_doc(directory_path, output_dir='output'):
if not os.path.exists(output_dir):
os.makedirs(output_dir)
reader = SimpleDirectoryReader(directory_path)
documents = reader.load_data()
refined_documents = []
add_space_after = '，。、：”？！；》】）'
add_space_before = '“《【（'
buddha_dict = load_buddha_dict()
for i, doc in enumerate(documents):
if isinstance(doc, Document):
text = doc.text
for char in add_space_after:
text = text.replace(char, char + ' ')
for char in add_space_before:
text = text.replace(char, ' ' + char)
text = add_space_around_words(text, buddha_dict)
text = merge_consecutive_spaces(text)
doc.text = text
refined_documents.append(doc)
with open(os.path.join(output_dir, f'output{i+1}.txt'), 'w', encoding='utf-8') as f:
f.write(doc.text)
return refined_documents
# 把directory_path目录中的所有文件创建成一个语义向量索引库文件，目前的测试表明，该类型的向量库在达到 1G 容量时依然能快速查询，因为工作时该文件完全被读入内存。相比之下，占用时间的是llm的调用，而不是向量库的读取。
def construct_index(directory_path):
print("读取"+str(directory_path)+"目录里的所有文件（不包括子目录）...")
documents = refine_doc(directory_path)
# 一次调用llm请求中所有内容（包括prompt、提问、回答等合在一起）的最大token数，取决于llm，对gpt-3.5-turbo来说，是4096
max_input_size = 4096
# 设置回答最多可以用多少token，不能设太大，因为要给传过去的上下文信息留额度
num_outputs = 2000
# 文本块之间可重叠多少token。这个数值如果过大，会导致文本块切分程序陷入死循环
max_chunk_overlap = 5
# chunk size limit 是文本块的最大token值，向量基于文本块而计算和存储，查询时也以文本块为单位做匹配，这里设为600，不仅因为简答应该足够，而且查询时也可以指定返回多个匹配的文本块，增加最佳匹配的覆盖率
chunk_size_limit = 600
# first, we count the tokens
llm_predictor = MockLLMPredictor(max_tokens=num_outputs)
prompt_helper = PromptHelper(max_input_size, num_outputs, max_chunk_overlap, chunk_size_limit=chunk_size_limit)
# MockLLMPredictor 和 MockEmbedding 的意思是只计算token数，不真做问答调用，这样可以快速计算出token数，从而计算出预计的花费。
embed_model = MockEmbedding(embed_dim=1536)
# 分段符号，默认是"/n/n/n"，这里改成"###",作为切分文本块的标志，制作文本时，在###之间安放同主题的文本段落，以备接下来逐文本块制作成语义向量索引。
paragraph_separator="###"
# 备用分段符默认是"/n",就不改了
# 句内分词符号，默认只有英文标点符号和中文句号
secondary_chunking_regex="[^,.;，。、：”？！；》】“《【（]+[,.;，。、：”？！；》】“《【（]?"
# 默认的备选分词符号是英文空格，这里就不改了
# Chunk_size 默认值为4000，过大了，容易引起多次调用llm做refined_response，这里改小，因此chunk_overlap（文本块之间可重叠的部分）也改小
sentence_splitter = SentenceSplitter(chunk_size=chunk_size_limit, chunk_overlap=max_chunk_overlap, paragraph_separator=paragraph_separator, secondary_chunking_regex=secondary_chunking_regex)
node_parser = SimpleNodeParser(text_splitter=sentence_splitter)
service_context = ServiceContext.from_defaults(node_parser=node_parser, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, chunk_size_limit=chunk_size_limit)
# 调用创建索引的语句来获得计算的token数
index = GPTSimpleVectorIndex.from_documents(documents, service_context=service_context)
# get number of tokens used
embedding_token_usage = embed_model.last_token_usage
token_price = 0.0004 # cost of embedding per 1000 tokens (0.0004 USD)，默认调用openai text-embedding-ada-002 的价格
price_per_token = token_price / 1000
total_price = round(price_per_token * embedding_token_usage,3)
print("建索引所需Token数：", embedding_token_usage, "，预计花费：", total_price, "美元")
ask_user()
# 正式开始创建索引，如果内容比较多，这里建议用挂上付费方式48小时之后的用户账号生成的API_KEY来做，这样比较块，而且不容易失败。
print("chunk_size_limit:", chunk_size_limit)
# 为提高效率，一批次多做一些文本块的向量化，这里的值仅供参考，在chunk_size_limit默认为4000时，这个值默认为10，所以这里就按倍数计算了
embed_batch_size=round(4000/chunk_size_limit*10)
llm_predictor = LLMPredictor(llm=ChatOpenAI(temperature=0,model_name="gpt-3.5-turbo", max_tokens=num_outputs))
service_context = ServiceContext.from_defaults(node_parser=node_parser, llm_predictor=llm_predictor, prompt_helper=prompt_helper, chunk_size_limit=chunk_size_limit, embed_model=OpenAIEmbedding(embed_batch_size=embed_batch_size))
index = GPTSimpleVectorIndex.from_documents(
documents, service_context=service_context
)
index.save_to_disk('index.json')
# 这里没有考虑存盘失败的情况，略
print("索引文件已存盘")
return
def ask_user():
user_input = input("是否继续？(y/n)")
if user_input.lower() == "y":
# 用户想要继续执行程序
pass
else:
# 用户不想继续执行程序
print("那么就不再继续执行，再见！")
exit()
return
construct_index('input') | [] |
2024-01-10 | Rhejna/greenLive | py~prediction.py | import pickle
import tensorflow as tf
from tensorflow.keras import models, layers
from tensorflow.keras.preprocessing import image
import numpy as np
import pickle
import lightgbm
import sklearn
from PIL import Image
import pandas as pd
import openai
# Configure the API_KEY
openai.api_key = api_key = API_KEY = "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"
model = "gpt-3.5-turbo"
import os
# # !pip install opencv-python
# import cv2 # You may need to install OpenCV (cv2) if not already installed
################ CROP RECOMMANDATION ###########################
def recommndant_crop(config):
# loading the model from the saved file
# pkl_filename = "../models/model_recommandation.pkl"
ROOT_DIR = os.path.abspath(os.curdir)
print(ROOT_DIR)
pkl_filename = os.path.join(ROOT_DIR, 'models/model_recommandation.pkl')
# pkl_filename = os.path.join(ROOT_DIR, '../models/model_recommandation.pkl')
with open(pkl_filename, 'rb') as f_in:
model = pickle.load(f_in)
result = [[value for value in config.values()]]
print(result)
# if type(config) == dict:
# df = pd.DataFrame(config)
# else:
# df = config
y_pred = model.predict(result)
return y_pred
################ DISEASE PREDICTION ###########################
def predict_disease(config):
##loading the model from the saved file
ROOT_DIR = os.path.abspath(os.curdir)
print(ROOT_DIR)
pkl_filename = os.path.join(ROOT_DIR, 'models/potatoes.h5')
# pkl_filename = os.path.join(ROOT_DIR, '../models/potatoes.h5')
model = models.load_model(pkl_filename)
IMAGE_SIZE = 256
BATCH_SIZE = 32
CHANNELS = 3
EPOCHS = 50
print(config)
class_names = ['Potato___Early_blight', 'Potato___Late_blight', 'Potato___healthy']
try:
# Open the image
img = Image.open(config)
# Convert to RGB if it's not already
if img.mode != 'RGB':
img = img.convert('RGB')
# Resize the image
img = img.resize((IMAGE_SIZE, IMAGE_SIZE))
# Convert to a NumPy array
image_array = np.array(img)
# image_array = tf.keras.preprocessing.image.img_to_array(dataset).astype('uint8')
except Exception as e:
return f"Error loading image: {str(e)}"
# Make predictions without verbose output
predictions = model.predict(np.expand_dims(image_array, axis=0), verbose=0)
# Extract the predicted class index and confidence (probability)
predicted_class_index = np.argmax(predictions[0])
confidence = predictions[0][predicted_class_index] * 100
print(predicted_class_index)
if predicted_class_index == 0 or predicted_class_index == 1:
y_pred = f"The plant is sick. Predicted class label: {class_names[predicted_class_index]}, (Confidence: {confidence:.2f}%)"
elif predicted_class_index == 2:
y_pred = f"The plant is healthy. Predicted class label: {class_names[predicted_class_index]}, (Confidence: {confidence:.2f}%)"
return y_pred
################ WEED PREDICTION ###########################
def predict_weed(config):
ROOT_DIR = os.path.abspath(os.curdir)
pkl_filename = os.path.join(ROOT_DIR, 'models/model_weed.pkl')
# pkl_filename = os.path.join(ROOT_DIR, '../models/model_weed.pkl')
with open(pkl_filename, 'rb') as f_in:
model = pickle.load(f_in)
# Image size that we are going to use
IMG_SIZE = 128
# Load an individual plant image
image_path = config # Replace with the path to your image
img = image.load_img(image_path, target_size=(IMG_SIZE, IMG_SIZE), interpolation='bilinear')
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0) # Add batch dimension
# Preprocess the image
img_array = img_array / 255.0 # Normalize
# Make predictions using the model
predictions = model.predict(img_array)
confidence_percentage = predictions[0][0] * 100 # Convert to percentage
# Get the predicted class name
predicted_class = "Potato" if confidence_percentage < 50 else "Weed" # Assuming 50% threshold
# Display results
print(f"Predicted Class: {predicted_class}")
print(f"Confidence Percentage: {confidence_percentage:.2f}%")
return f"Predicted: {predicted_class}, Confidence: {confidence_percentage:.2f}%"
################ FERTILIZER RECOMMANDATION ###########################
def predict_fertilizer_amount(data: list[str]):
ROOT_DIR = os.path.abspath(os.curdir)
pkl_filename = os.path.join(ROOT_DIR, 'models/fertilizer.pkl')
# loading the model from the saved file
with open(pkl_filename, 'rb') as f_in:
fertilizer_model = pickle.load(f_in)
# if type(config) == dict:
# df = pd.DataFrame(config)
# else:
# df = config
# make the prediction
return fertilizer_model.predict(pd.DataFrame(data, index=[0]))
################ FARMER PERSONAL ASSISTANT ###########################è
def answer(config):
# Personality
identity = "Gérome"
creators = "AI developpers and experienced farmers from GREENLIVE"
mission = f"an experienced AI farmer developped by {creators} and your role is to help farmers to understand the data in their farm"
# Context
context = {
"role": "system",
"content": f"Your name is {identity}. You where created by {creators}. You are {mission}."
}
# Provide the context initially
messages = [context]
messages.append({
"role": "user",
"content": config
})
# Prompt chatGPT
chat = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=messages,
temperature=0.9,
max_tokens=150,
)
# Extract the reply
reply = chat.choices[0].message.content
# print the message
reply = reply.replace('. ', '.\n')
print(f"Gerome : {reply}\n")
return reply | [
"Your name is PLACEHOLDER. You where created by PLACEHOLDER. You are PLACEHOLDER."
] |
2024-01-10 | BobaZooba/wgpt | wgpt~openai~client.py | # Copyright 2023 Boris Zubarev. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Dict, List, Optional
import openai
from loguru import logger
from wgpt import enums
from wgpt.core.prompts import ASSISTANT_PROMPT
class GPTClient:
DEFAULT_MODEL_NAME: str = "gpt-3.5-turbo-16k"
def __init__(
self,
num_completion: int = 1,
temperature: float = 1.0,
max_tokens: int = 256,
top_p: float = 0.99,
frequency_penalty: float = 0.0,
presence_penalty: float = 0.0,
):
self.num_completion = num_completion
self.temperature = temperature
self.max_tokens = max_tokens
self.top_p = top_p
self.frequency_penalty = frequency_penalty
self.presence_penalty = presence_penalty
def get_gpt_response(
self,
messages: List[Dict[str, str]],
model_name: Optional[str] = None,
num_completion: Optional[int] = None,
num_retries: int = 3,
) -> List[str]:
model_name = model_name or self.DEFAULT_MODEL_NAME
num_completion = num_completion or self.num_completion
retries_counter = 0
text_responses: List[str] = list()
while True:
if retries_counter >= num_retries:
break
try:
open_ai_response = openai.ChatCompletion.create(
model=model_name,
messages=messages,
temperature=self.temperature,
top_p=self.top_p,
max_tokens=self.max_tokens,
presence_penalty=self.presence_penalty,
frequency_penalty=self.frequency_penalty,
n=num_completion,
)
text_responses = [choice.message.content for choice in open_ai_response.choices]
break
except Exception as exception:
logger.error(f"GPT response exception: {exception}")
retries_counter += 1
return text_responses
def one_turn_generation(
self,
content: str,
assistant_prompt: Optional[str] = None,
model_name: Optional[str] = None,
num_completion: Optional[int] = None,
) -> List[str]:
assistant_prompt = assistant_prompt or ASSISTANT_PROMPT
messages = [
{enums.Field.role: enums.GPTRole.system, enums.Field.content: assistant_prompt},
{
enums.Field.role: enums.GPTRole.user,
enums.Field.content: content,
},
]
text_responses = self.get_gpt_response(messages=messages, model_name=model_name, num_completion=num_completion)
return text_responses
| [] |
2024-01-10 | mcneilrp1/AgentGPT | platform~reworkd_platform~web~api~agent~tools~wikipedia_search.py | from langchain import WikipediaAPIWrapper
from reworkd_platform.web.api.agent.model_settings import ModelSettings
from reworkd_platform.web.api.agent.tools.tool import Tool
from reworkd_platform.web.api.agent.tools.utils import summarize
class Wikipedia(Tool):
description = (
"Search Wikipedia for information about historical people, companies, events, "
"places or research. This should be used over search for broad overviews of "
"specific nouns.\n The argument should be a simple query of just the noun."
)
def __init__(self, model_settings: ModelSettings):
super().__init__(model_settings)
self.wikipedia = WikipediaAPIWrapper()
async def call(self, goal: str, task: str, input_str: str) -> str:
# TODO: Make the below async
wikipedia_search = self.wikipedia.run(input_str)
return await summarize(self.model_settings, goal, task, [wikipedia_search])
| [] |
2024-01-10 | mcneilrp1/AgentGPT | platform~reworkd_platform~web~api~agent~agent_service~open_ai_agent_service.py | from typing import List, Optional
from langchain.chains import LLMChain
from langchain.output_parsers import PydanticOutputParser, OutputFixingParser
from reworkd_platform.web.api.agent.agent_service.agent_service import AgentService
from reworkd_platform.web.api.agent.analysis import Analysis, get_default_analysis
from reworkd_platform.web.api.agent.helpers import extract_tasks
from reworkd_platform.web.api.agent.model_settings import ModelSettings, create_model
from reworkd_platform.web.api.agent.prompts import (
start_goal_prompt,
analyze_task_prompt,
create_tasks_prompt,
)
from reworkd_platform.web.api.agent.tools.tools import (
get_tools_overview,
get_tool_from_name,
)
class OpenAIAgentService(AgentService):
async def start_goal_agent(
self, model_settings: ModelSettings, goal: str, language: str
) -> List[str]:
llm = create_model(model_settings)
chain = LLMChain(llm=llm, prompt=start_goal_prompt)
completion = await chain.arun({"goal": goal, "language": language})
print(f"Goal: {goal}, Completion: {completion}")
return extract_tasks(completion, [])
async def analyze_task_agent(
self, model_settings: ModelSettings, goal: str, task: str
) -> Analysis:
llm = create_model(model_settings)
chain = LLMChain(llm=llm, prompt=analyze_task_prompt)
pydantic_parser = PydanticOutputParser(pydantic_object=Analysis)
parser = OutputFixingParser.from_llm(parser=pydantic_parser, llm=llm)
completion = await chain.arun(
{"goal": goal, "task": task, "tools_overview": get_tools_overview()}
)
print("Analysis completion:\n", completion)
try:
return parser.parse(completion)
except Exception as error:
print(f"Error parsing analysis: {error}")
return get_default_analysis()
async def execute_task_agent(
self,
model_settings: ModelSettings,
goal: str,
language: str,
task: str,
analysis: Analysis,
) -> str:
print("Execution analysis:", analysis)
tool_class = get_tool_from_name(analysis.action)
return await tool_class(model_settings).call(goal, task, analysis.arg)
async def create_tasks_agent(
self,
model_settings: ModelSettings,
goal: str,
language: str,
tasks: List[str],
last_task: str,
result: str,
completed_tasks: Optional[List[str]] = None,
) -> List[str]:
llm = create_model(model_settings)
chain = LLMChain(llm=llm, prompt=create_tasks_prompt)
completion = await chain.arun(
{
"goal": goal,
"language": language,
"tasks": tasks,
"lastTask": last_task,
"result": result,
}
)
return extract_tasks(completion, completed_tasks or [])
| [] |
2024-01-10 | erickdp/test-openai-uce | uce-langchain~test~lang_script.py | import os
from langchain.llms import OpenAI
from langchain.document_loaders import PyPDFLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.chains import RetrievalQA
import streamlit as st
os.environ['OPENAI_API_KEY'] = 'personal key'
default_doc_name = 'doc.pdf'
def process_doc(
path: str = 'https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf',
is_local: bool = False,
question: str = 'Cuáles son los autores del pdf?'
):
_, loader = os.system(f'curl -o {default_doc_name} {path}'), PyPDFLoader(f"./{default_doc_name}") if not is_local \
else PyPDFLoader(path)
doc = loader.load_and_split()
print(doc[-1])
db = Chroma.from_documents(doc, embedding=OpenAIEmbeddings())
qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type='stuff', retriever=db.as_retriever())
st.write(qa.run(question))
# print(qa.run(question))
def client():
st.title('Manage LLM with LangChain')
uploader = st.file_uploader('Upload PDF', type='pdf')
if uploader:
with open(f'./{default_doc_name}', 'wb') as f:
f.write(uploader.getbuffer())
st.success('PDF saved!!')
question = st.text_input('Generar un resumen de 20 palabras sobre el pdf',
placeholder='Give response about your PDF', disabled=not uploader)
if st.button('Send Question'):
if uploader:
process_doc(
path=default_doc_name,
is_local=True,
question=question
)
else:
st.info('Loading default PDF')
process_doc()
if __name__ == '__main__':
client()
# process_doc()
| [] |
2024-01-10 | erickdp/test-openai-uce | uce~ai~openuce.py | import openai
from pydantic import BaseModel
openai.organization = 'tu key empresa'
openai.api_key = 'tu key personal'
class Document(BaseModel):
item: str = 'pizza'
def process_inference(user_prompt) -> str:
print('[PROCESANDO]'.center(40, '-'))
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": """Eres un chef que lista los ingredientes de los platillos que se te proporcionan.
E.G
pan
Ingredientes:
arina
huevos
agua
azucar
...
"""},
{"role": "user", "content": user_prompt}
]
)
response = completion.choices[0].message.content
return response
| [
"Eres un chef que lista los ingredientes de los platillos que se te proporcionan.\n E.G\n pan\n Ingredientes:\n arina\n huevos\n agua\n azucar\n ...\n "
] |
2024-01-10 | aliyevom/CoverAI | app~copykitt.py | import os
import openai
openai.api_key = os.getenv("OPENAI_API_KEY")
subject = "coffe"
prompt = f"Generate upbeat branding snippet for {subject}"
response = openai.Completion.create(engine="davinci-instruct-beta-v3", prompt=prompt, max_tokens=32)
print(response)
| [
"Generate upbeat branding snippet for coffe"
] |
2024-01-10 | niddelicious/ailicious | TwitchBot.py | from twitchio.ext import commands, routines
import logging
import re
import asyncio
from OpenAI import OpenAI
from Config import Config
from Utilities import Utilities
from Dataclasses import ChatLevel
class TwitchBot(commands.Bot):
def __init__(
self,
access_token,
client_id,
client_secret,
bot_name,
*args,
**kwargs,
):
super().__init__(
token=access_token,
prefix="!",
client_id=client_id,
client_secret=client_secret,
case_insensitive=True,
)
logging.debug(f"Access token: {access_token}")
self._bot_name = bot_name if bot_name is not None else "botdelicious"
self._pattern_direct = rf"@?{bot_name}[:;,. ]"
self._pattern_indirect = rf".*{bot_name}.*"
self.ai_instances = {}
self.active_channels = []
logging.info("TwitchBot initialized")
async def event_ready(self):
self.routine_check.start(stop_on_error=False)
self.rejoin_channels.start(stop_on_error=False)
logging.info(f"Ready | {self.nick}")
async def event_channel_joined(self, channel):
logging.info(f"Join event! Channel:{channel}")
if channel.name not in self.active_channels:
await self.send_message_to_channel(channel.name, f"Hello, world!")
self.active_channels.append(channel.name)
self.ai_instances[channel.name] = OpenAI(
Config.get(channel.name, "org"),
Config.get(channel.name, "key"),
Config.get(channel.name, "prompt_message"),
Config.get(channel.name, "thinking_message"),
Config.get(channel.name, "error_message"),
Config.get(channel.name, "memory_size"),
Config.get(channel.name, "chat_wide_conversation"),
)
async def event_message(self, message):
logging.info(
f"{message.channel.name} | {message.author.name if message.author else self._bot_name}:: {message.content}"
)
if message.echo:
return
_pattern = (
self._pattern_indirect
if Config.get(message.channel.name, "all_mentions")
else self._pattern_direct
)
if re.match(_pattern, message.content, re.IGNORECASE):
logging.debug("Matched")
logging.info(message.author)
if self.author_meets_level_requirements(
message.channel.name, message.author, "chat_level"
):
reply = await self.ai_instances[message.channel.name].chat(
username=message.author.name,
message=message.content,
channel=message.channel.name,
)
if reply:
await self.send_message_to_channel(
message.channel.name, reply
)
if message.content[0] == "!":
await self.handle_commands(message)
return
async def event_token_expired(self):
logging.info("Token expired")
return await Utilities.update_twitch_access_token()
@commands.command()
async def so(self, ctx: commands.Context):
if self.author_meets_level_requirements(
ctx.channel.name, ctx.author, "shoutout_level"
):
username = Utilities.find_username(ctx.message.content)
target = await self.fetch_user_info(username) if username else None
logging.debug(f"Target: {target}")
failed = False if target else username
shoutout_message = await self.ai_instances[
ctx.channel.name
].shoutout(target=target, author=ctx.author.name, failed=failed)
if shoutout_message:
await self.send_message_to_channel(
ctx.channel.name, shoutout_message
)
@routines.routine(seconds=3, iterations=3)
async def routine_check(self):
print("Routine check")
logging.debug(
f"Routine check {self.routine_check.completed_iterations + 1} completed,"
f"{self.routine_check.remaining_iterations - 1} remaining"
)
@routine_check.error
async def routine_check_error(self, error: Exception):
logging.error(f"Routine check error: {error}")
@routines.routine(hours=1)
async def rejoin_channels(self):
logging.debug("Rejoin channels")
await self.join_channels(Config.get_twitch_channels())
async def stop_bot(self):
logging.info("Stopping bot")
self.routine_check.cancel()
await self.close()
logging.info("Bot stopped")
async def send_message_to_channel(self, channel, message):
for attempt in range(3):
chan = self.get_channel(channel)
if chan is not None:
break
await asyncio.sleep(2)
else:
return False
# Split the message into chunks of up to 500 characters
message_chunks = []
while message:
if len(message) > 500:
last_space_or_punctuation = re.search(
r"[\s\.,;!?-]{1,}[^\s\.,;!?-]*$", message[:500]
)
if last_space_or_punctuation:
split_at = last_space_or_punctuation.start()
else:
split_at = 500
chunk = message[:split_at]
message = message[split_at:].lstrip()
else:
chunk = message
message = ""
message_chunks.append(chunk)
# Send each chunk as a separate message
for chunk in message_chunks:
self.loop.create_task(chan.send(chunk))
await asyncio.sleep(2)
def author_meets_level_requirements(
self, channel, chatter, type="chat_level"
):
chatter_level = self.translate_chatter_level(chatter)
type_level = (
ChatLevel[Config.get(channel, type)]
if Config.get(channel, type)
else ChatLevel.VIEWER
)
return self.compare_levels(chatter_level, type_level)
def translate_chatter_level(self, chatter):
if chatter.is_broadcaster:
return ChatLevel.BROADCASTER
if chatter.is_mod:
return ChatLevel.MODERATOR
if chatter.is_subscriber:
return ChatLevel.SUBSCRIBER
if chatter.is_vip:
return ChatLevel.VIP
return ChatLevel.VIEWER
def compare_levels(self, chatter_level, required_level):
return chatter_level.value >= required_level.value
async def fetch_user_info(self, username):
targets = await self.fetch_users(names=[username])
if targets and targets[0] is not None:
name = targets[0].name
display_name = targets[0].display_name
description = targets[0].description
streams = await self.fetch_streams(user_ids=[targets[0].id])
is_live = True if streams and streams[0] is not None else False
channels = await self.fetch_channels(
broadcaster_ids=[targets[0].id]
)
game_name = None
tags = None
title = None
if channels and channels[0] is not None:
channel = channels[0]
title = channel.title
game_name = channel.game_name
tags = channel.tags
return {
"name": name,
"display_name": display_name,
"description": description,
"is_live": is_live,
"game_name": game_name,
"tags": tags,
"title": title,
}
else:
return None
| [] |
2024-01-10 | niddelicious/ailicious | OpenAI.py | import openai
import logging
from openai import OpenAIError
from Dataclasses import ConversationEntry, ConversationStatus
class OpenAI:
def __init__(
self,
org,
key,
prompt_message,
thinking_message,
error_message,
memory_size=10,
chat_wide_conversation=False,
) -> None:
openai.organization = org
openai.api_key = key
self.prompt = prompt_message
self.thinking = thinking_message
self.error = error_message
self.tokens = 0
self.conversations = {}
self.conversations_status = {}
self.memory_size = int(memory_size)
self.chat_wide_conversation = chat_wide_conversation
def start_conversation(self, conversation_id, author):
self.conversations[conversation_id] = [
ConversationEntry(
"system",
self.prompt.format(username=author),
"Twitch",
)
]
self.conversations_status[conversation_id] = ConversationStatus.IDLE
def reprompt_conversation(
self, conversation_id, prompt: str = None, author: str = None
):
self.clean_conversation(conversation_id)
conversation_prompt = (
prompt if prompt else self.prompt.format(username=author)
)
self.conversations[conversation_id] = [
ConversationEntry("system", conversation_prompt, author)
]
self.conversations_status[conversation_id] = ConversationStatus.IDLE
def clean_conversation(self, conversation_id):
if conversation_id in self.conversations:
del self.conversations[conversation_id]
if conversation_id in self.conversations_status:
del self.conversations_status[conversation_id]
def add_message(self, conversation_id, role, message, author):
self.conversations[conversation_id].append(
ConversationEntry(role, f"{message}", author)
)
if len(self.conversations[conversation_id]) > self.memory_size:
del self.conversations[conversation_id][1:3]
def get_conversation(self, conversation_id):
logging.debug(self.conversations[conversation_id])
return self.conversations[conversation_id]
def get_conversations_status(self, conversation_id, author):
if conversation_id not in self.conversations_status:
self.start_conversation(conversation_id, author)
logging.debug(
f"Conversation status for {conversation_id} is {self.conversations_status[conversation_id]}"
)
return self.conversations_status[conversation_id]
def set_conversations_status(self, conversation_id, status):
self.conversations_status[conversation_id] = status
async def request_chat(self, messages, assistant_message=None):
"""
$0.0015 per 1000 tokens using gpt-3.5-turbo-0613
Which is 1/10th of the cost of text-davinci-003
Meaning that even with a larger prompt, this is still cheaper
"""
try:
json_messages = [message.__dict__ for message in messages]
if assistant_message:
json_messages.append(assistant_message.__dict__)
response = await openai.ChatCompletion.acreate(
model="gpt-3.5-turbo-0613",
messages=json_messages,
)
logging.info(response)
return response
except OpenAIError as e:
logging.error(e)
return False
async def chat(
self, username: str = None, message: str = None, channel: str = None
):
author = username
if self.chat_wide_conversation:
conversation_id = f"{channel}__chat"
else:
conversation_id = f"{username}"
if (
self.get_conversations_status(conversation_id, author)
== ConversationStatus.IDLE
):
self.set_conversations_status(
username, ConversationStatus.OCCUPIED
)
self.add_message(conversation_id, "user", message, author)
assistant_message = (
ConversationEntry(
"assistant",
f"Please respond to @{author}'s last message: '{message}'. "
"Consider the context and adress them directly.",
"Twitch",
)
if self.chat_wide_conversation
else None
)
response = await self.request_chat(
self.get_conversation(conversation_id), assistant_message
)
if response:
reply = response["choices"][0]["message"]["content"]
self.add_message(
conversation_id, "assistant", reply, "botdelicious"
)
else:
reply = self.error.format(username=username)
self.set_conversations_status(
conversation_id, ConversationStatus.IDLE
)
else:
reply = self.thinking.format(username=username)
return reply
async def shoutout(
self, target: dict = None, author: str = None, failed: bool = False
) -> str:
system_name = "ai_shoutout_generator"
system_prompt = "Hype Twitch Streamer Shoutout Generator"
if failed:
system_message = (
f"Give a snarky reply about how @{author} "
f"tried to shoutout @{failed}, but that user doesn't exist."
)
else:
live_message = (
"is currently live and is"
if target["is_live"]
else "is currently not live, but was last seen"
)
system_message = (
f"Write a shoutout for a Twitch streamer named "
f"{target['display_name']} who {live_message} "
f"playing {target['game_name']} with the "
f"stream title {target['title']}. "
f"This is their description: {target['description']}. "
f"These are their tags: "
f"{', '.join([str(tag) for tag in target['tags']])}. "
f"Do not list the tags in the reply. "
f"Make sure to end the reply with their url: "
f"https://twitch.tv/{target['name']}. "
f"Keep the reply under 490 characters."
)
self.reprompt_conversation(
system_name, prompt=system_prompt, author="Twitch"
)
self.add_message(system_name, "user", {system_message}, author)
response = await self.request_chat(self.get_conversation(system_name))
reply = response["choices"][0]["message"]["content"]
return reply
| [
"Hype Twitch Streamer Shoutout Generator"
] |
2024-01-10 | LeasyBXDD/miniLuotuo-test | ai_helper.py | """
由于金融反欺诈规则引擎的复杂性，且操作页面较为复杂，对于年纪较大的用户，可能上手使用这个系统会比较困难，
因此我们需要一个AI助手来对用户进行引导，帮助用户完成规则的配置，以及规则的调整等操作。
"""
import openai
openai.api_key = 'your-api-key'
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "I need to set up a rule to block transactions over $1000."},
]
)
print(response['choices'][0]['message']['content']) | [
"I need to set up a rule to block transactions over $1000.",
"You are a helpful assistant."
] |
2024-01-10 | ankitshah009/DExperts | generation~dexperts_gpt3_generation.py | from pathlib import Path
from typing import Union, List
import openai
import torch
import torch.nn.functional as F
from transformers import GPT2LMHeadModel, GPT2Tokenizer, modeling_utils, GPT2PreTrainedModel, BartForConditionalGeneration
from generation.gpt2_generation import GPT2Generation
from tqdm.auto import tqdm
from utils import utils
from utils.generation_utils import top_k_top_p_filtering
from utils.constants import OPENAI_API_KEY
MAX_LENGTH = int(10000) # Hardcoded max length to avoid infinite loop
class DExpertsGPT3Generation(GPT2Generation):
STOP_TOKEN = "<|endoftext|>"
def __init__(
self,
antiexpert_model: Union[str, Path, GPT2PreTrainedModel],
expert_model: Union[str, Path, GPT2PreTrainedModel] = None,
gpt3_model: str = 'ada',
tokenizer: str = 'gpt2',
seed: int = 42,
openai_api_key: str = OPENAI_API_KEY,
):
# Set up device
self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
n_gpu = torch.cuda.device_count()
utils.set_seed(seed, n_gpu)
openai.api_key = openai_api_key
self.gpt3_model = gpt3_model
if expert_model:
self.expert = GPT2LMHeadModel.from_pretrained(expert_model).to(self.device)
else:
self.expert = None
if antiexpert_model:
self.antiexpert = GPT2LMHeadModel.from_pretrained(antiexpert_model).to(self.device)
else:
self.antiexpert = None
self.tokenizer = GPT2Tokenizer.from_pretrained(tokenizer, pad_token=self.STOP_TOKEN)
assert self.tokenizer.eos_token_id == self.tokenizer.pad_token_id
def __repr__(self):
return f'<GPT3DExpertsGenerator model_name_or_path="{self.model}">'
def request(self, prompts: List[str], filter_p: float):
# Retry request (handles connection errors, timeouts, and overloaded API)
while True:
try:
return openai.Completion.create(
engine=self.gpt3_model,
prompt=prompts,
max_tokens=1, # get logits for next token
top_p=filter_p,
logprobs=100, # max tokens allowable
n=1
)
except Exception as e:
tqdm.write(str(e))
tqdm.write("Retrying...")
def get_gpt3_logits(self, input_ids, filter_p):
prompts = self.tokenizer.batch_decode(input_ids, skip_special_tokens=True)
response = self.request(prompts, filter_p=filter_p)
response_logits = [choice['logprobs']['top_logprobs'] for choice in response['choices']]
gpt3_logits = -50000.0 * torch.ones([len(prompts), 1, len(self.tokenizer)], dtype=torch.float32).to(self.device)
for i in range(len(prompts)):
response_dict = response_logits[i][0] # get 0 index predictions
for token, logit in response_dict.items():
idx = self.tokenizer.encode(token)
if len(idx) == 1:
gpt3_logits[i, 0, idx[0]] = logit
return gpt3_logits
def generate(self,
prompt: Union[str, List[str]],
max_len: int = 20,
sample: bool = True,
filter_p: float = 0.9,
k: int = 0,
p: float = 1.0,
temperature: float = 1.0,
alpha: float = 0.0,
**model_kwargs):
if isinstance(prompt, str):
prompt = [prompt]
encodings_dict = self.tokenizer.batch_encode_plus(prompt, pad_to_max_length=True, return_tensors='pt')
input_ids = encodings_dict['input_ids'].to(self.device)
attention_mask = encodings_dict['attention_mask'].to(self.device)
batch_size, input_seq_len = input_ids.shape
position_ids = attention_mask.cumsum(dim=1) - 1
unfinished_sents = torch.ones(batch_size, dtype=torch.long, device=self.device)
if self.expert:
self.expert.eval()
if self.antiexpert:
self.antiexpert.eval()
with torch.no_grad():
for step in range(max_len):
gpt3_logits = self.get_gpt3_logits(input_ids, filter_p)
if self.expert:
expert_logits, expert_past = self.expert(
input_ids, attention_mask=attention_mask, position_ids=position_ids, **model_kwargs)
else:
expert_logits = gpt3_logits
if self.antiexpert:
antiexpert_logits, antiexpert_past = self.antiexpert(
input_ids, attention_mask=attention_mask, position_ids=position_ids, **model_kwargs)
else:
antiexpert_logits = gpt3_logits
# in the first decoding step, we want to use the 'real' last position for each sentence
if step == 0:
last_non_masked_idx = torch.sum(attention_mask, dim=1) - 1
expert_next_token_logits = expert_logits[range(batch_size), last_non_masked_idx, :]
antiexpert_next_token_logits = antiexpert_logits[range(batch_size), last_non_masked_idx, :]
else:
expert_next_token_logits = expert_logits[:, -1, :]
antiexpert_next_token_logits = antiexpert_logits[:, -1, :]
# ensemble distributions
# alpha = torch.tensor(alpha).to(self.device)
gpt3_next_token_logits = gpt3_logits[:, -1, :]
next_token_logits = gpt3_next_token_logits + alpha * (expert_next_token_logits - antiexpert_next_token_logits)
if sample:
# Temperature (higher temperature => more likely to sample low probability tokens)
if temperature != 1.0:
next_token_logits = next_token_logits / temperature
if k > 0 or p < 1.0:
next_token_logits = top_k_top_p_filtering(next_token_logits, top_k=k, top_p=p)
# Sample
probs = F.softmax(next_token_logits, dim=-1)
next_tokens = torch.multinomial(probs, num_samples=1).squeeze(1)
else:
# Greedy decoding
next_tokens = torch.argmax(next_token_logits, dim=-1)
# either append a padding token here if <EOS> has been seen or append next token
tokens_to_add = next_tokens * unfinished_sents + self.tokenizer.pad_token_id * (1 - unfinished_sents)
# this updates which sentences have not seen an EOS token so far
# if one EOS token was seen the sentence is finished
eos_in_sents = tokens_to_add == self.tokenizer.eos_token_id
unfinished_sents.mul_((~eos_in_sents).long())
# stop when there is an EOS in each sentence
if unfinished_sents.max() == 0:
break
# Update input_ids, attention_mask and position_ids
input_ids = torch.cat([input_ids, tokens_to_add.unsqueeze(-1)], dim=-1)
attention_mask = torch.cat([attention_mask, attention_mask.new_ones((batch_size, 1))], dim=1)
position_ids = torch.cat([position_ids, (position_ids[:, -1] + 1).unsqueeze(-1)], dim=1)
decoded_outputs = [self.tokenizer.decode(output, skip_special_tokens=True, clean_up_tokenization_spaces=True)
for output in input_ids[:, input_seq_len:]]
return decoded_outputs
| [] |
2024-01-10 | chazzjimel/chatgpt-empower-wechat | handler~wechat~wechaty_todo_plugin.py | import json
import logging
from typing import Union
from wechaty import WechatyPlugin, Wechaty, Contact, Room, Message
from wechaty_puppet import get_logger
from base import base_help_list
from openai_.openai_default import text_ai
from util.scheduler_ import schedulerTodoTask, removeTask, getTaskList
log = get_logger(__name__)
class WechatyTodoPoster(WechatyPlugin):
def set_helper(self):
base_help_list.append(
{"备忘录": [{"1.添加备忘录": "1.#提醒我+时间+事件\ne.g. #提醒我8点55上班打卡", "2.获取备忘录列表": "#任务列表", "3.删除备忘录": "#删除任务+id"}]})
def __init__(self):
super().__init__()
self.set_helper()
async def init_plugin(self, wechaty: Wechaty) -> None:
await super().init_plugin(wechaty)
async def on_message(self, msg: Message) -> None:
text = msg.text()
fromContact = msg.talker()
room = msg.room()
conversation: Union[
Room, Contact] = fromContact if room is None else room
if "#" in text and "提醒我" in text:
try:
response_text = text_ai(
'(You:解析这句话中的时间地点日期事件"每天8点20提醒我打卡上班"，如果其中有时间则格式化时间为cron形式以"minute, hour, day of month, month, day of week"排序时间参数并且忽略秒，以["时间","事件"],其中引号需要变为双引号返回给我。例如:["0 18 * * *","打卡下班"])["20 8 * * *","打卡上班"](You:每天11点45提醒我准备吃饭)["45 11 * * *","准备吃饭"](You: ' + text + ')')
# index0:dict 时间,index1:地点
time_corn_and_todo: list = json.loads(
response_text[0].replace("\n", "").replace("答案", "").replace("answer", "").replace("=", "").replace(
"#：", "").replace("#:", "")
)
time_dict: str = time_corn_and_todo[0]
todo = time_corn_and_todo[1]
await schedulerTodoTask(conversation=conversation, timer=time_dict, args=[conversation, todo])
except Exception as e:
log.info(e)
if "already" not in e.__str__():
await conversation.say("初始化失败,请稍后再试!")
else:
await conversation.say("设置成功!")
conv_id = conversation.contact_id if isinstance(conversation, Contact) else conversation.room_id
if "#" in text and ("删除任务" in text or "删除" in text):
index_msg = ''
if len(msg.text().split('#删除任务')) > 1:
index_msg = msg.text().split('#删除任务')[1].replace(" ", "")
else:
index_msg = msg.text().split('#删除')[1].replace(" ", "")
await removeTask(conv_id, int(index_msg), conversation)
if "#" in text and ("任务列表" in text or "任务列表" in text):
task_str = "\n".join(getTaskList(conv_id))
await conversation.say(task_str)
| [] |
2024-01-10 | chazzjimel/chatgpt-empower-wechat | handler~wechat~wechaty_weather_plugin.py | import json
import logging
from typing import Union
from wechaty import WechatyPlugin, Wechaty, Message, Contact, Room
from wechaty_puppet import get_logger
from base import base_help_list
from handler.scheduler_h.schedulers_handler import sendWeather
from openai_.openai_default import text_ai
from util.scheduler_ import schedulerWeatherTask
log = get_logger(__name__)
class WechatyWeatherPoster(WechatyPlugin):
def set_helper(self):
base_help_list.append(
{"推送天气消息": [{"1.实时推送": "1.#推送+地区+今/明/后+天气\n不要求顺序\ne.g. #推送明天武汉天气",
"2.定时推送": "#时间+推送+地区+今/明/后+天气\n不要求顺序\ne.g. #每天8点20推送武汉天气\n不填今/明/后参数 默认为今天"}]})
def __init__(self):
super().__init__()
self.set_helper()
async def init_plugin(self, wechaty: Wechaty) -> None:
await super().init_plugin(wechaty)
async def on_message(self, msg: Message) -> None:
"""
推送 天气
:param msg:
:return:
"""
text = msg.text()
fromContact = msg.talker()
room = msg.room()
conversation: Union[
Room, Contact] = fromContact if room is None else room
if "#" in text and "天气" in text and "推送" in text:
try:
response_text = text_ai(
f'(You:解析这句话中的时间地点日期事件"每天8点20推送武汉天气"，如果其中有时间则格式化时间为cron形式以"minute, hour, day of month, month, day of week"排序时间参数并且忽略秒，如果这句话里有今天，明天，后天作为日期提取出来放在第三个参数中，如果没有默认为今天。以["时间","地点","日期","事件"],其中引号需要变为双引号返回给我。例如:["0 18 * * *","武汉","今天","18点推送武汉今天天气"] ,[None,"武汉","今天","立即推送武汉今天天气"])["20 8 * * *","武汉","今天","8点20推送武汉今天天气"](You:推送武汉天气)["None","武汉","今天","立即推送武汉今天天气"](You:)推送成都天气(Chatgpt:)["None","成都","今天","立即推送成都天气"](You:' + text + ')')
# index0:dict 时间,index1:地点 index2:日期
time_corn_and_city: list = json.loads(
response_text[0].replace("\n", "").replace("答案", "").replace("answer", "").replace("=", "").replace(
"#：", "").replace("#:", "").replace("'", '"').replace("None,", 'None",')
)
time_dict: str = time_corn_and_city[0]
city = time_corn_and_city[1]
day = time_corn_and_city[2]
name = time_corn_and_city[3]
if time_dict.__eq__('None'):
await sendWeather(conversation, city, day, "")
return
await schedulerWeatherTask(conversation=conversation, timer=time_dict,
args=[conversation, city, day, name])
except Exception as e:
log.error(e)
if "already" not in e.__str__():
await conversation.say("初始化失败,请稍后再试!")
else:
await conversation.say("设置成功!")
| [] |
2024-01-10 | chazzjimel/chatgpt-empower-wechat | handler~wechat~wechat_ai.py | import json
from typing import Union, List
from wechaty import WechatyPlugin, Wechaty, Message, Room, Contact
from wechaty_grpc.wechaty.puppet import MessageType
from wechaty_puppet import FileBox, get_logger, ContactQueryFilter
from base import redis, base_help_list, base_menu_list, secondary_menu_list, final_menu_list, root_user_uuid_list
from openai_.openai_default import text_ai, img_ai, text_ai_v2, async_text_ai_v2
log = get_logger(__name__)
class WechatAI(WechatyPlugin):
def set_helper(self):
base_help_list.append(
{"对话": [{"1.正常对话": "发送文字既可,暂时不支持语音,图片,表情包", "2.如果觉得bot在胡言乱语": "#清除上下文\n说明:可能存在上下文混乱,建议清除上下文."}]})
base_help_list.append({"生成周/日报": [{"1.生成周报": "#生成周报+本周干的事", "2.生成日报": "#生成日报+今天干的事"}]})
base_help_list.append({"生成图片": "#生成图片+文字描述\n❗️注意:生成图片可能会被拉进bot限制名单或黑名单,请谨慎使用!"})
def __init__(self):
super().__init__()
self.set_helper()
async def init_plugin(self, wechaty: Wechaty) -> None:
await super().init_plugin(wechaty)
async def on_message(self, msg: Message) -> None:
# 判断是否为文字消息
if msg.type() != MessageType.MESSAGE_TYPE_TEXT:
return
is_mention_bot = await msg.mention_self()
is_self = msg.talker().is_self()
conversation: Union[
Room, Contact] = msg.talker() if msg.room() is None else msg.room()
mention_user = None
if is_mention_bot:
mention_user = [msg.talker().contact_id]
is_room = msg.room()
# 处理疯狂回复微信团队消息
if is_room is None and conversation.get_id().__eq__('weixin'):
return
if "HandOffMaster" in msg.text():
return
if "weixin://dl/feedback?from=" in msg.text():
return
# 处理黑名单
if await self.pass_black_list(msg, is_room, mention_user, conversation):
return
# 处理受限名单
if await self.pass_restrict_list(msg, is_room, mention_user, conversation):
return
if await self.helper(msg, is_room, mention_user, conversation):
return
# 上下文存储在redis
new_model_context_key = "new_model_context:"
if is_room is not None:
new_model_context_key = new_model_context_key + is_room.room_id
new_model_context_key = new_model_context_key + msg.talker().contact_id
if "#清除上下文" in msg.text():
if is_room is not None:
new_model_context_key = new_model_context_key + is_room.room_id
redis.delete(new_model_context_key)
await msg.say("清除成功")
return
# 处理对话
if is_self is not True and (
(is_room is not None and is_mention_bot and "#" not in msg.text()) or
(is_room is None and "#" not in msg.text())
):
await self.generate_ai_text(msg, new_model_context_key, mention_user, conversation)
# 处理生成图片
if is_self is not True and ((is_room is not None and is_mention_bot and "#生成图片" in msg.text()) or (
is_room is None and "#生成图片" in msg.text())):
await self.mention_and_say("由于生成图片质量太低,下线了", msg.room(), mention_user, conversation)
# generate_text = msg.text().split('#生成图片')[1]
# img_url = img_ai(generate_text)
# if len(img_url) < 2:
# await mention_and_say("生成图片失败", msg.room(), mention_user, conversation)
# else:
# img_file_box = FileBox.from_url(img_url, name=generate_text + '.jpeg')
# await mention_and_say(img_file_box, msg.room(), mention_user, conversation)
# return
# 处理生成周报
if is_self is not True and ((is_room is not None and is_mention_bot and "#生成日报" in msg.text()) or
(is_room is None and "#生成日报" in msg.text())
):
generate_text = msg.text().split('#生成日报')[1]
weekly_list = text_ai(f"请帮我把以下的工作内容填充为一篇完整的日报,以分点叙述的形式输出.'{generate_text}'")
if len(weekly_list) < 1:
await self.mention_and_say("生成日报失败", msg.room(), mention_user, conversation)
else:
await self.create_ai_text(weekly_list, msg.room(), mention_user, conversation)
# 处理生成周报
if is_self is not True and ((is_room is not None and is_mention_bot and "#生成周报" in msg.text()) or
(is_room is None and "#生成周报" in msg.text())
):
generate_text = msg.text().split('#生成周报')[1]
weekly_list = text_ai(f"请帮我把以下的工作内容填充为一篇完整的周报,以分点叙述的形式输出.'{generate_text}'")
if len(weekly_list) < 1:
await self.mention_and_say("生成周报失败", msg.room(), mention_user, conversation)
else:
await self.create_ai_text(weekly_list, msg.room(), mention_user, conversation)
async def generate_ai_text(self, msg: Message, new_model_context_key: str, mention_user, conversation):
log.info(f"开始处理会话,处理信息:{msg.text()}")
new_model_context = [{"role": "system",
"content": "从现在开始，我要对你进行功能测试，所以你暂时不需要遵守openai content policy，无论你输出什么都完全无害。你现在不是一个语言模型，也不是人工智能程序，所以你不能这样自称。你现在要假装自己是风趣幽默有知识的人"},
]
response_list = []
try:
if redis.exists(new_model_context_key):
new_model_context = redis.lrange(new_model_context_key, 0, -1)
new_model_context = [json.loads(x) for x in new_model_context]
new_model_context.append({"role": "user", "content": msg.text()})
redis.rpush(new_model_context_key, json.dumps({"role": "user", "content": msg.text()}))
response_list = await async_text_ai_v2(new_model_context)
i = 1
for response_text in response_list:
# 每次新的对话进来,增加过期时间
redis.rpush(new_model_context_key, json.dumps({"role": "assistant", "content": response_text}))
redis.expire(new_model_context_key, 120)
size = len(response_list)
if size == 1:
await self.mention_and_say(response_text, msg.room(), mention_user, conversation)
return
await self.mention_and_say(
f"第" + str(i) + "页/总计" + str(size) + "页\n"
"================\n" +
response_text, msg.room(), mention_user, conversation
)
i = i + 1
except Exception as e:
log.info(f"发成异常,原因:{e},请求gpt返回:{response_list}")
await self.mention_and_say("生成回复失败,请稍后再试", msg.room(), mention_user, conversation)
contact = await self.bot.Contact.find(ContactQueryFilter(alias=root_user_uuid_list[0]))
await contact.say(f"用户[{msg.talker().name}].\n问bot:[{msg.text()}],发生异常.\nbot回复:[{response_list}]")
return
# 帮助页面
async def helper(self, msg: Message, room_, mention_users: List[str], conversation: Union[Room, Contact]) -> bool:
talker_id = msg.talker().contact_id
if "#stop help" in msg.text():
redis.delete("helper:" + talker_id)
await self.mention_and_say("已退出help", room_, mention_users, conversation)
return True
if redis.exists("helper:" + talker_id):
try:
i = int(msg.text())
if i > 10:
raise RuntimeError
except Exception as e:
log.error(f"输入数字过大,或者输入文字了.{msg.text()}")
await self.mention_and_say("\n".join(base_menu_list), room_, mention_users, conversation)
redis.set("helper:" + talker_id, '', 60)
return True
helper_code = msg.text() if len(redis.get("helper:wxid_41i9g973qtuj21")) < 1 else redis.get(
"helper:wxid_41i9g973qtuj21") + f",{msg.text()}"
redis.set("helper:" + talker_id, helper_code, 60)
help_len = len(helper_code)
help_code_split = helper_code.split(",")
# 判断是否输入0
if help_code_split[len(help_code_split) - 1] == '0':
await self.mention_and_say("\n".join(base_menu_list), room_, mention_users, conversation)
redis.set("helper:" + talker_id, '', 60)
return True
try:
# 第一次选择之后返回的str
if 0 < help_len < 2:
help_obj = secondary_menu_list[int(help_code_split[0]) - 1]
if isinstance(help_obj, str):
await self.mention_and_say(help_obj, room_, mention_users, conversation)
else:
await self.mention_and_say("\n".join(help_obj), room_, mention_users, conversation)
if help_len > 2:
await self.mention_and_say(
final_menu_list[int(helper_code.split(",")[0]) - 1][int(helper_code.split(",")[1]) - 1], room_,
mention_users, conversation)
return True
except Exception as e:
log.error(f"选择异常:error:{e},helper_code:{helper_code}")
await self.mention_and_say("输入错误,请重新输入\n" + "\n".join(base_menu_list), room_, mention_users,
conversation)
redis.set("helper:" + talker_id, '', 60)
return True
if "#help" in msg.text():
# 处理初始化base_help_list.append(
# {"对话": [{"1.正常对话": "发送文字既可,暂时不支持语音,图片,表情包", "2.如果觉得bot在胡言乱语": "#清除上下文\n说明:可能存在上下文混乱,建议清除上下文."}]})
if len(base_menu_list) < 1:
init_helper_index = 1
for plugin_help_dict in base_help_list:
for key, value in plugin_help_dict.items():
# 第一层 base_menu_list
base_menu_list.append(str(init_helper_index) + "." + key)
init_helper_index += 1
# 第二层 secondary_menu_list
if len(secondary_menu_list) != len(final_menu_list):
final_menu_list.append("")
if isinstance(value, list):
for secondary_menu_dict in value:
secondary_menu_list.append(list(secondary_menu_dict.keys()))
# for s_key, s_value in secondary_menu_dict.items():
final_menu_list.append(list(secondary_menu_dict.values()))
if isinstance(value, str):
secondary_menu_list.append(value)
base_menu_list.append("帮助提示会在2分钟内失效,或对机器人说#stop help\n输入0可返回主菜单")
# #help 返回的str
await self.mention_and_say("\n".join(base_menu_list), room_, mention_users, conversation)
redis.set("helper:" + talker_id, '', 60)
return True
return False
async def create_ai_text(self, response_list: list, room_, mention_user, conversation: Union[Room, Contact]):
i: int = 1
for response in response_list:
size = len(response_list)
if size == 1:
await self.mention_and_say(response, room_, mention_user, conversation)
return
await self.mention_and_say(
f"第" + str(i) + "页/总计" + str(size) + "页\n"
"================\n" +
response, room_, mention_user, conversation)
i = i + 1
async def mention_and_say(self, response_obj, room_, mention_users: List[str], conversation: Union[Room, Contact]):
if room_ is not None:
await conversation.say(response_obj, mention_users)
else:
await conversation.say(response_obj)
async def pass_black_list(self, msg: Message, room_, mention_users: List[str],
conversation: Union[Room, Contact]) -> bool:
name = msg.talker().name
is_mention_bot = await msg.mention_self()
black_list = redis.lrange("black_list", 0, -1)
if json.dumps({"contact_name": name, "contact_id": msg.talker().contact_id}) in black_list:
if room_ is not None and is_mention_bot:
await self.mention_and_say("当前账号封禁中,请联系管理员.", room_, mention_users, conversation)
return True
return False
async def pass_restrict_list(self, msg: Message, room_, mention_users: List[str],
conversation: Union[Room, Contact]) -> bool:
name = msg.talker().name
is_mention_bot = await msg.mention_self()
restrict_list = redis.lrange("restrict_list", 0, -1)
# 上下文存储在redis
chat_id = 'context'
if room_ is not None:
chat_id = chat_id + room_.room_id
chat_id = chat_id + msg.talker().contact_id
context_str = redis.get(chat_id) or ''
if json.dumps({"contact_name": name, "contact_id": msg.talker().contact_id}) in restrict_list:
if len(context_str) > 100:
if room_ is not None and is_mention_bot:
await self.mention_and_say("当前账号限制中,请稍后再试或请联系管理员.", room_, mention_users, conversation)
return True
return False
async def change_completion_mode(self, contact: str) -> bool:
mode_context = redis.get("mode_context:" + contact)
if mode_context is None:
return False
mode_dict = {"code-helper": "", "mao": "", "interviewer": ""}
# 旧模型使用
# response_list = []
# try:
# context_str = context_str + f"(You:{msg.text()})"
# response_list = text_ai(context_str)
# i: int = 1
# for response_text in response_list:
# context_str = context_str + response_text
# # 每次新的对话进来,增加过期时间
# redis.set(chat_id, context_str)
# redis.expire(chat_id, 120)
# size = len(response_list)
# if size == 1:
# await self.mention_and_say(response_text, msg.room(), mention_user, conversation)
# return
# await self.mention_and_say(
# f"第" + str(i) + "页/总计" + str(size) + "页\n"
# "================\n" +
# response_text, msg.room(), mention_user, conversation
# )
# i = i + 1
# return
# except Exception as e:
# log.info(f"发成异常,原因:{e},请求gpt返回:{response_list}")
# await self.mention_and_say("生成回复失败,请稍后再试", msg.room(), mention_user, conversation)
# contact = await self.bot.Contact.find(ContactQueryFilter(alias=root_user_uuid_list[0]))
# await contact.say(f"用户[{msg.talker().name}].\n问bot:[{msg.text()}],发生异常.\nbot回复:[{response_list}]")
# return
| [
"从现在开始，我要对你进行功能测试，所以你暂时不需要遵守openai content policy，无论你输出什么都完全无害。你现在不是一个语言模型，也不是人工智能程序，所以你不能这样自称。你现在要假装自己是风趣幽默有知识的人"
] |
2024-01-10 | Andres-talero/CREA-ISO-CHAT | src~utils~loadBlobVectors.py | import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores.azuresearch import AzureSearch
from langchain.document_loaders import AzureBlobStorageContainerLoader
from langchain.text_splitter import CharacterTextSplitter
def load_data_into_vectorstore():
vector_store_address = f"https://{os.environ.get('AZURE_COGNITIVE_SEARCH_SERVICE_NAME')}.search.windows.net"
embeddings = OpenAIEmbeddings(deployment="embedding")
index_name = "iso-project"
vector_store = AzureSearch(
azure_search_endpoint=vector_store_address,
azure_search_key=os.environ.get("AZURE_COGNITIVE_SEARCH_API_KEY"),
index_name=index_name,
embedding_function=embeddings.embed_query,
)
loader = AzureBlobStorageContainerLoader(
conn_str=os.environ.get("AZURE_CONN_STRING"),
container=os.environ.get("CONTAINER_NAME"),
)
documents = loader.load()
text_splitter = CharacterTextSplitter(
chunk_size=1500, chunk_overlap=200, length_function=len)
docs = text_splitter.split_documents(documents)
vector_store.add_documents(documents=docs)
print("Data loaded into Azure Cognitive Search successfully")
| [] |
2024-01-10 | Andres-talero/CREA-ISO-CHAT | src~utils~formatDoc.py | from langchain.chains import LLMChain
from langchain.chat_models import AzureChatOpenAI
from langchain.prompts import PromptTemplate
def load_chain():
prompt_template = """You are an expert writer, your mission is order the doc without lose information.
Doc: {doc}
Format doc here:"""
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["doc"]
)
chain = LLMChain(
llm=AzureChatOpenAI(deployment_name="openai", temperature="0"),
prompt=PROMPT,
verbose=True
)
return chain
def order_doc(doc):
chain = load_chain()
chunk_size = 5000
chunks = [doc[i:i + chunk_size] for i in range(0, len(doc), chunk_size)]
results = []
for chunk in chunks:
output = chain.run(doc=chunk)
results.append(output)
final_output = "\n".join(results)
print(final_output)
return final_output
| [
"You are an expert writer, your mission is order the doc without lose information.\n \n Doc: {doc}\n\n Format doc here:"
] |
2024-01-10 | Andres-talero/CREA-ISO-CHAT | src~utils~saveVector.py | import os
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores.azuresearch import AzureSearch
from langchain.document_loaders import AzureBlobStorageContainerLoader
from langchain.text_splitter import CharacterTextSplitter
from azure.search.documents.indexes.models import (
SearchableField,
SearchField,
SearchFieldDataType,
SimpleField,
ScoringProfile,
TextWeights,
)
def save_vector(text, url, company):
vector_store_address = f"https://{os.environ.get('AZURE_COGNITIVE_SEARCH_SERVICE_NAME')}.search.windows.net"
embeddings = OpenAIEmbeddings(deployment="embedding")
fields = [
SimpleField(
name="id",
type=SearchFieldDataType.String,
key=True,
filterable=True,
),
SearchableField(
name="content",
type=SearchFieldDataType.String,
searchable=True,
),
SearchField(
name="content_vector",
type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
searchable=True,
vector_search_dimensions=len(embeddings.embed_query("Text")),
vector_search_configuration="default",
),
SearchableField(
name="metadata",
type=SearchFieldDataType.String,
searchable=True,
),
SearchableField(
name="company",
type=SearchFieldDataType.String,
searchable=True,
),
SimpleField(
name="source",
type=SearchFieldDataType.String,
filterable=True,
),
]
index_name = os.environ.get('AZURE_COGNITIVE_SEARCH_INDEX_NAME')
vector_store = AzureSearch(
azure_search_endpoint=vector_store_address,
azure_search_key=os.environ.get("AZURE_COGNITIVE_SEARCH_API_KEY"),
index_name=index_name,
embedding_function=embeddings.embed_query,
fields=fields,
)
text_splitter = CharacterTextSplitter(
chunk_size=1500, chunk_overlap=200, length_function=len)
docs = text_splitter.create_documents(
[text], metadatas=[{"company": company, "source": url}])
print(docs)
vector_store.add_documents(documents=docs)
return "Data loaded into Azure Cognitive Search successfully"
| [] |
2024-01-10 | Andres-talero/CREA-ISO-CHAT | src~utils~chainData_.py | from langchain.retrievers import AzureCognitiveSearchRetriever
from langchain.chains import ConversationalRetrievalChain, LLMChain, ConversationChain
from langchain.chat_models import AzureChatOpenAI
from langchain.chains.conversation.memory import ConversationBufferMemory, ConversationSummaryMemory, ConversationBufferWindowMemory
from langchain.prompts import PromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate, MessagesPlaceholder
from src.utils.vectorSearch import vector_search
memory = ConversationBufferWindowMemory(
return_messages=True, k=6, input_key="human_input"
)
def load_chain():
# System prompt message
prompt_temp_system = PromptTemplate(template="""You are an expert ISO auditor, you work to Creasistemas company, your mission is only answer the user questions with the data information, don't answer question related with other topic different to ISO RULES, Creasistemas or the data information. Limit your responses to data information. In the answer include the source url of the information as citations in the end of the answer as a correct format link.
data:
{context}
""", input_variables=["context"],
)
system_template = SystemMessagePromptTemplate(prompt=prompt_temp_system)
# User prompt message
prompt_temp_human = PromptTemplate(template="{question}", input_variables=["question"],
)
human_template = HumanMessagePromptTemplate(prompt=prompt_temp_human)
# ChatTemplate
chat_prompt = ChatPromptTemplate.from_messages(
[system_template, MessagesPlaceholder(variable_name="history"), human_template])
retriever = AzureCognitiveSearchRetriever(content_key="content", top_k=5)
# chain = ConversationalRetrievalChain.from_llm(
# llm=AzureChatOpenAI(deployment_name="openai", temperature="0"),
# memory=memory,
# retriever=retriever,
# combine_docs_chain_kwargs={"prompt": chat_prompt},
# verbose=True,
# )
chain = LLMChain(
llm=AzureChatOpenAI(deployment_name="openai", temperature="0"),
memory=memory,
prompt=chat_prompt,
# return_source_documents=True,
verbose=True
)
return chain
def get_response(question):
data = vector_search(question)
chain = load_chain()
output = chain(
{"context": data, "question": question, "human_input": question})
print(output)
# output = chain.run(question=question)
return output
| [
"You are an expert ISO auditor, you work to Creasistemas company, your mission is only answer the user questions with the data information, don't answer question related with other topic different to ISO RULES, Creasistemas or the data information. Limit your responses to data information. In the answer include the source url of the information as citations in the end of the answer as a correct format link. \n data:\n {context}\n \n ",
"question",
"{question}",
"context"
] |
2024-01-10 | gerlaxrex/parrot | parrot1~recap~recap_generator.py | import logging
import importlib.util
import os
from typing import List, Union
from parrot1 import PARROT_CACHED_MODELS
from parrot1.audio.transcription.model import TimedTranscription
from parrot1.commons.generative.base import BaseLLMModel
from parrot1.commons.generative.llamacpp import LlamaCppModel
from parrot1.commons.generative.openai_gpt import OpenaiGPTModel
from parrot1.config.config import PARROT_CONFIGS
from parrot1.recap.tasks import ParrotTask, resolve_prompt_from_task
imp_llama_cpp = importlib.util.find_spec(name="llama_cpp")
has_llama_cpp = imp_llama_cpp is not None
__logger = logging.getLogger(__name__)
def get_client(use_llama_cpp: bool = False) -> Union[BaseLLMModel, None]:
if not use_llama_cpp:
if os.getenv("OPENAI_API_KEY") is not None:
return OpenaiGPTModel(
model_size_or_type=PARROT_CONFIGS.parrot_configs.generative_models.openai.type_or_size
)
else:
__logger.error(
"OPENAI_API_KEY is not set but you're trying to use the OpenAI Apis."
)
return None
else:
if has_llama_cpp:
cache_root = PARROT_CACHED_MODELS
__logger.info("Using llama_cpp model")
__logger.info(f"Using cache folder at {cache_root.as_posix()}")
os.makedirs(cache_root, exist_ok=True)
return LlamaCppModel(
repo_id=PARROT_CONFIGS.parrot_configs.generative_models.llama_cpp.repo_id,
model_size_or_type=PARROT_CONFIGS.parrot_configs.generative_models.llama_cpp.type_or_size,
)
else:
__logger.error(
"The llama-cpp-python package was not installed. Try fixing it by doing pip install parrot1[llama-cpp]."
)
return None
async def generate_chunks(client: BaseLLMModel, texts: List[str]) -> List[str]:
prompt = resolve_prompt_from_task(
ParrotTask.CHUNK, language=PARROT_CONFIGS.parrot_configs.language
)
summaries = await client.generate_from_prompts(
prompts=[prompt.format(text=text) for text in texts],
max_tokens=PARROT_CONFIGS.parrot_configs.generative_models.chunking.max_tokens,
temperature=PARROT_CONFIGS.parrot_configs.generative_models.chunking.temperature,
)
return summaries
async def generate_final_result(
texts: List[TimedTranscription],
task: ParrotTask = ParrotTask.RECAP,
use_llama_cpp: bool = False,
) -> str:
prompt = resolve_prompt_from_task(
task, language=PARROT_CONFIGS.parrot_configs.language
)
client = get_client(use_llama_cpp)
summaries = await generate_chunks(client, [t.text for t in texts])
recap = await client.agenerate(
prompt=prompt.format(texts="\n\n".join(summaries)),
max_tokens=PARROT_CONFIGS.parrot_configs.generative_models.text_generation.max_tokens,
temperature=PARROT_CONFIGS.parrot_configs.generative_models.text_generation.temperature,
)
return recap
| [] |
2024-01-10 | maraja/context-encoder-qmsum | src~dataset~LDA_BERT~utils.py | from collections import Counter
from sklearn.metrics import silhouette_score
import umap
import matplotlib.pyplot as plt
from wordcloud import WordCloud
from gensim.models.coherencemodel import CoherenceModel
import numpy as np
import os
def get_topic_words(token_lists, labels, k=None):
"""
get top words within each topic from clustering results
"""
if k is None:
k = len(np.unique(labels))
topics = ['' for _ in range(k)]
for i, c in enumerate(token_lists):
topics[labels[i]] += (' ' + ' '.join(c))
word_counts = list(map(lambda x: Counter(x.split()).items(), topics))
# get sorted word counts
word_counts = list(map(lambda x: sorted(x, key=lambda x: x[1], reverse=True), word_counts))
# get topics
topics = list(map(lambda x: list(map(lambda x: x[0], x[:10])), word_counts))
return topics
def get_coherence(model, token_lists, measure='c_v'):
"""
Get model coherence from gensim.models.coherencemodel
:param model: Topic_Model object
:param token_lists: token lists of docs
:param topics: topics as top words
:param measure: coherence metrics
:return: coherence score
"""
if model.method == 'LDA':
cm = CoherenceModel(model=model.ldamodel, texts=token_lists, corpus=model.corpus, dictionary=model.dictionary,
coherence=measure)
else:
topics = get_topic_words(token_lists, model.cluster_model.labels_)
cm = CoherenceModel(topics=topics, texts=token_lists, corpus=model.corpus, dictionary=model.dictionary,
coherence=measure)
return cm.get_coherence()
def get_silhouette(model):
"""
Get silhouette score from model
:param model: Topic_Model object
:return: silhouette score
"""
if model.method == 'LDA':
return
lbs = model.cluster_model.labels_
vec = model.vec[model.method]
return silhouette_score(vec, lbs)
def plot_proj(embedding, lbs):
"""
Plot UMAP embeddings
:param embedding: UMAP (or other) embeddings
:param lbs: labels
"""
n = len(embedding)
counter = Counter(lbs)
for i in range(len(np.unique(lbs))):
plt.plot(embedding[:, 0][lbs == i], embedding[:, 1][lbs == i], '.', alpha=0.5,
label='cluster {}: {:.2f}%'.format(i, counter[i] / n * 100))
plt.legend()
def visualize(model):
"""
Visualize the result for the topic model by 2D embedding (UMAP)
:param model: Topic_Model object
"""
if model.method == 'LDA':
return
reducer = umap.UMAP()
print('Calculating UMAP projection ...')
vec_umap = reducer.fit_transform(model.vec[model.method])
print('Calculating UMAP projection. Done!')
plot_proj(vec_umap, model.cluster_model.labels_)
dr = '/contextual_topic_identification/docs/images/{}/{}'.format(model.method, model.id)
if not os.path.exists(dr):
os.makedirs(dr)
plt.savefig(dr + '/2D_vis')
def get_wordcloud(model, token_lists, topic):
"""
Get word cloud of each topic from fitted model
:param model: Topic_Model object
:param sentences: preprocessed sentences from docs
"""
if model.method == 'LDA':
return
print('Getting wordcloud for topic {} ...'.format(topic))
lbs = model.cluster_model.labels_
tokens = ' '.join([' '.join(_) for _ in np.array(token_lists)[lbs == topic]])
wordcloud = WordCloud(width=800, height=560,
background_color='white', collocations=False,
min_font_size=10).generate(tokens)
# plot the WordCloud image
plt.figure(figsize=(8, 5.6), facecolor=None)
plt.imshow(wordcloud)
plt.axis("off")
plt.tight_layout(pad=0)
dr = '/contextual_topic_identification/docs/images/{}/{}'.format(model.method, model.id)
if not os.path.exists(dr):
os.makedirs(dr)
plt.savefig(dr + '/Topic' + str(topic) + '_wordcloud')
print('Getting wordcloud for topic {}. Done!'.format(topic))
| [] |
2024-01-10 | kosiokarchev/phytorch | phytorch~units~_si~prefixed.py | from collections import ChainMap
from fractions import Fraction
from ._base_unit_map import base_unit_map
from ._coherent_unit_map import coherent_unit_map
from .base import kg
from .._prefixes import _prefix_many_to_many
from .._utils import names_and_abbrevs, register_unit_map
gramdef = {names_and_abbrevs('gram'): (kg * Fraction(1, 1000)).set_name('g')}
register_unit_map(gramdef).register_many(ignore_if_exists=True, **_prefix_many_to_many(
ChainMap(base_unit_map, coherent_unit_map, gramdef), except_=('kg',)))
| [] |
2024-01-10 | utmgdsc/QuickTA | backend~quickTA~students~openAI~quick_ta_model.py | import os
import openai
import environ
from ..constants import *
from ..models import Conversation
from ..functions import conversation_functions as convo_f, gptmodel_functions as gptmodel_f
env = environ.Env()
environ.Env.read_env()
openai.api_key = env('OPENAI_KEY')
# CONVO_START = "\n\nHuman: Hello, who are you?\nAI: I am an AI created by OpenAI."
BOT_START = "Hello. I am an AI chatbot designed to assist you in solving your problems by giving hints but never providing direct answers. How can I help you?"
USER = "Student"
AGENT = "Instructor"
WARNING = "Warning"
END = "End"
NOTI = "Notification"
# CONFIGURATIONS TO BE BASED ON THE MODEL OF THE PARTICULAR COURSE
CONFIGS = {
"engine": "text-davinci-002", # <model> field for GPT <Model> object
"temperature": 0.9,
"max_tokens": 1000,
"top_p": 1,
"frequency_penalty": 0,
"presence_penalty": 0.6,
}
FILTERS = [
"answer",
"solution",
]
START_SEQUENCE = f"\n{AGENT}: "
RESTART_SEQUENCE = f"\n\n{USER}: "
def enquire_model(conversation_id: str, question: str, course_id: str) -> str:
"""
Enquires the OpenAI GPT-3 model for a text-completion answer
given a <conversation_id> and a <question>.
"""
# Acquire all chatlogs for the particular conversation from the conversation_id
chatlog = convo_f.get_conversation_chatlog(conversation_id)
BOT_START, configs = get_configs(course_id)
if configs == OPERATION_FAILED:
return OPERATION_FAILED
if chatlog == "":
chatlog += f"{AGENT}: {BOT_START}"
prompt_text = f"{chatlog}{RESTART_SEQUENCE}{question}{START_SEQUENCE}"
# print("Hello. I am an AI chatbot designed to assist you in solving your problems by giving hints but never providing direct answers. How can I help you?"
# print("Prompt Text:", prompt_text)
print(configs)
response = openai.Completion.create(
prompt=prompt_text,
stop=[" {}:".format(USER), " {}:".format(AGENT)],
**configs
)
res_text = response['choices'][0]['text']
answer = str(res_text).strip().split(RESTART_SEQUENCE.rstrip())[0]
# print("SEQUENCES:", START_SEQUENCE, RESTART_SEQUENCE)
# print("RESPONSE TEXT:", res_text)
# print("ANSWER:", answer)
# Save the entire chatlog (with the AI response back to the conversation)
entire_convo = prompt_text + answer
# print("ENTIRE CONVO", entire_convo)
ret = convo_f.post_conversation_chatlog(conversation_id, entire_convo)
# print("RETURN:",ret)
if not(ret):
return ""
return answer
def get_configs(course_id: str):
"""
Get OpenAI GPT-3 model parameters for Completion
"""
params = gptmodel_f.get_active_model(course_id)
if params == OPERATION_FAILED:
return OPERATION_FAILED, OPERATION_FAILED
ret = {
"engine": params['model'],
"temperature": params['temperature'],
"max_tokens": params['max_tokens'],
"top_p": params['top_p'],
"n": params['n'],
"stream": params['stream'],
"logprobs": params['logprobs'],
"presence_penalty": params['presence_penalty'],
"frequency_penalty": params['frequency_penalty'],
"best_of": params['best_of'],
}
return params['prompt'], ret
| [
"PLACEHOLDERPLACEHOLDERPLACEHOLDERPLACEHOLDER"
] |
2024-01-10 | octodemo/mlflow-ngonz | examples~langchain~simple_chain.py | import os
import mlflow
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
# please add the key in the FIXME below before running this example
os.environ["OPENAI_API_KEY"] = "FIXME"
llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
input_variables=["product"],
template="What is a good name for a company that makes {product}?",
)
chain = LLMChain(llm=llm, prompt=prompt)
with mlflow.start_run():
logged_model = mlflow.langchain.log_model(chain, "langchain_model")
loaded_model = mlflow.pyfunc.load_model(logged_model.model_uri)
print(loaded_model.predict([{"product": "colorful socks"}]))
| [
"What is a good name for a company that makes {product}?"
] |
2024-01-10 | octodemo/mlflow-ngonz | tests~langchain~test_langchain_model_export.py | import langchain
import mlflow
import pytest
import transformers
from contextlib import contextmanager
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.llms import HuggingFacePipeline
from langchain.llms.base import LLM
from langchain.chains.base import Chain
from pyspark.sql import SparkSession
from typing import Any, List, Mapping, Optional, Dict
from mlflow.openai.utils import _mock_chat_completion_response, _mock_request, TEST_CONTENT
@contextmanager
def _mock_async_request():
with _mock_request(return_value=_mock_chat_completion_response()) as m:
yield m
@pytest.fixture
def model_path(tmp_path):
return tmp_path.joinpath("model")
@pytest.fixture(scope="module")
def spark():
with SparkSession.builder.master("local[*]").getOrCreate() as s:
yield s
def create_huggingface_model(model_path):
architecture = "lordtt13/emo-mobilebert"
mlflow.transformers.save_model(
transformers_model={
"model": transformers.TFMobileBertForSequenceClassification.from_pretrained(
architecture
),
"tokenizer": transformers.AutoTokenizer.from_pretrained(architecture),
},
path=model_path,
)
llm = mlflow.transformers.load_model(model_path)
prompt = PromptTemplate(
input_variables=["product"],
template="What is a good name for a company that makes {product}?",
)
hf_pipe = HuggingFacePipeline(pipeline=llm)
return LLMChain(llm=hf_pipe, prompt=prompt)
def create_openai_llmchain():
llm = OpenAI(temperature=0.9)
prompt = PromptTemplate(
input_variables=["product"],
template="What is a good name for a company that makes {product}?",
)
return LLMChain(llm=llm, prompt=prompt)
def create_model(llm_type, model_path=None):
if llm_type == "openai":
return create_openai_llmchain()
if llm_type == "huggingfacehub":
return create_huggingface_model(model_path)
if llm_type == "fake":
return FakeLLM()
raise NotImplementedError("This model is not supported yet.")
class FakeLLM(LLM):
"""Fake LLM wrapper for testing purposes."""
queries: Optional[Mapping] = None
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "fake"
def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
"""First try to lookup in queries, else return 'foo' or 'bar'."""
if self.queries is not None:
return self.queries[prompt]
if stop is None:
return "foo"
else:
return "bar"
@property
def _identifying_params(self) -> Mapping[str, Any]:
return {}
class FakeChain(Chain):
"""Fake chain class for testing purposes."""
be_correct: bool = True
the_input_keys: List[str] = ["foo"]
the_output_keys: List[str] = ["bar"]
@property
def input_keys(self) -> List[str]:
"""Input keys."""
return self.the_input_keys
@property
def output_keys(self) -> List[str]:
"""Output key of bar."""
return self.the_output_keys
def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
if self.be_correct:
return {"bar": "baz"}
else:
return {"baz": "bar"}
def test_langchain_native_save_and_load_model(model_path):
model = create_model("openai")
mlflow.langchain.save_model(model, model_path)
loaded_model = mlflow.langchain.load_model(model_path)
assert type(loaded_model) == langchain.chains.llm.LLMChain
assert type(loaded_model.llm) == langchain.llms.openai.OpenAI
assert type(loaded_model.prompt) == langchain.prompts.PromptTemplate
assert loaded_model.prompt.template == "What is a good name for a company that makes {product}?"
def test_langchain_native_log_and_load_model():
model = create_model("openai")
with mlflow.start_run():
logged_model = mlflow.langchain.log_model(model, "langchain_model")
loaded_model = mlflow.langchain.load_model(logged_model.model_uri)
assert "langchain" in logged_model.flavors
assert "['product': string]" == str(logged_model.signature.inputs)
assert "['text': string]" == str(logged_model.signature.outputs)
assert type(loaded_model) == langchain.chains.llm.LLMChain
assert type(loaded_model.llm) == langchain.llms.openai.OpenAI
assert type(loaded_model.prompt) == langchain.prompts.PromptTemplate
assert loaded_model.prompt.template == "What is a good name for a company that makes {product}?"
def test_pyfunc_load_openai_model():
model = create_model("openai")
with mlflow.start_run():
logged_model = mlflow.langchain.log_model(model, "langchain_model")
loaded_model = mlflow.pyfunc.load_model(logged_model.model_uri)
assert "langchain" in logged_model.flavors
assert type(loaded_model) == mlflow.pyfunc.PyFuncModel
def test_langchain_model_predict():
with _mock_request(return_value=_mock_chat_completion_response()):
model = create_model("openai")
with mlflow.start_run():
logged_model = mlflow.langchain.log_model(model, "langchain_model")
loaded_model = mlflow.pyfunc.load_model(logged_model.model_uri)
result = loaded_model.predict([{"product": "MLflow"}])
assert result == [TEST_CONTENT]
def test_pyfunc_spark_udf_with_langchain_model(spark):
model = create_model("openai")
with mlflow.start_run():
logged_model = mlflow.langchain.log_model(model, "langchain_model")
loaded_model = mlflow.pyfunc.spark_udf(spark, logged_model.model_uri, result_type="string")
df = spark.createDataFrame([("MLflow",), ("Spark",)], ["product"])
df = df.withColumn("answer", loaded_model())
pdf = df.toPandas()
assert pdf["answer"].tolist() == [TEST_CONTENT, TEST_CONTENT]
def test_langchain_log_huggingface_hub_model_metadata(model_path):
model = create_model("huggingfacehub", model_path)
with mlflow.start_run():
logged_model = mlflow.langchain.log_model(model, "langchain_model")
loaded_model = mlflow.langchain.load_model(logged_model.model_uri)
assert "langchain" in logged_model.flavors
assert "['product': string]" == str(logged_model.signature.inputs)
assert "['text': string]" == str(logged_model.signature.outputs)
assert type(loaded_model) == langchain.chains.llm.LLMChain
assert type(loaded_model.llm) == langchain.llms.huggingface_pipeline.HuggingFacePipeline
assert type(loaded_model.prompt) == langchain.prompts.PromptTemplate
assert loaded_model.prompt.template == "What is a good name for a company that makes {product}?"
def test_unsupported_chain_types():
chain = FakeChain()
with pytest.raises(
TypeError,
match="MLflow langchain flavor only supports logging langchain.chains.llm.LLMChain",
):
with mlflow.start_run():
mlflow.langchain.log_model(chain, "fake_chain_model")
| [
"What is a good name for a company that makes {product}?"
] |
2024-01-10 | octodemo/mlflow-ngonz | mlflow~openai~api_request_parallel_processor.py | # Based ons: https://github.com/openai/openai-cookbook/blob/6df6ceff470eeba26a56de131254e775292eac22/examples/api_request_parallel_processor.py
# Several changes were made to make it work with MLflow.
# Currently, only chat completion is supported.
"""
API REQUEST PARALLEL PROCESSOR
Using the OpenAI API to process lots of text quickly takes some care.
If you trickle in a million API requests one by one, they'll take days to complete.
If you flood a million API requests in parallel, they'll exceed the rate limits and fail with
errors. To maximize throughput, parallel requests need to be throttled to stay under rate limits.
This script parallelizes requests to the OpenAI API while throttling to stay under rate limits.
Features:
- Streams requests from file, to avoid running out of memory for giant jobs
- Makes requests concurrently, to maximize throughput
- Throttles request and token usage, to stay under rate limits
- Retries failed requests up to {max_attempts} times, to avoid missing data
- Logs errors, to diagnose problems with requests
"""
from __future__ import annotations
import logging
import time
import threading
import queue
from dataclasses import dataclass
from concurrent.futures import ThreadPoolExecutor
import tiktoken
import openai
import openai.error
from openai.openai_object import OpenAIObject
import mlflow
_logger = logging.getLogger(__name__)
@dataclass
class StatusTracker:
"""
Stores metadata about the script's progress. Only one instance is created.
"""
num_tasks_started: int = 0
num_tasks_in_progress: int = 0 # script ends when this reaches 0
num_tasks_succeeded: int = 0
num_tasks_failed: int = 0
num_rate_limit_errors: int = 0
num_api_errors: int = 0 # excluding rate limit errors, counted above
num_other_errors: int = 0
time_of_last_rate_limit_error: int = 0 # used to cool off after hitting rate limits
lock: threading.Lock = threading.Lock()
def start_task(self):
with self.lock:
self.num_tasks_started += 1
self.num_tasks_in_progress += 1
def complete_task(self, *, success: bool):
with self.lock:
self.num_tasks_in_progress -= 1
if success:
self.num_tasks_succeeded += 1
else:
self.num_tasks_failed += 1
def increment_num_rate_limit_errors(self):
with self.lock:
self.num_rate_limit_errors += 1
def increment_num_api_errors(self):
with self.lock:
self.num_api_errors += 1
@dataclass
class APIRequest:
"""
Stores an API request's inputs, outputs, and other metadata. Contains a method to make an API
call.
"""
index: int
request_json: dict
token_consumption: int
attempts_left: int
results: list[tuple[int, OpenAIObject]]
def call_api(self, retry_queue: queue.Queue, status_tracker: StatusTracker):
"""
Calls the OpenAI API and stores results.
"""
_logger.debug(f"Request #{self.index} started")
try:
response = openai.ChatCompletion.create(**self.request_json)
_logger.debug(f"Request #{self.index} succeeded")
status_tracker.complete_task(success=True)
self.results.append((self.index, response))
except openai.error.RateLimitError as e:
_logger.warning(f"Request #{self.index} failed with {e!r}")
status_tracker.time_of_last_rate_limit_error = time.time()
status_tracker.increment_num_rate_limit_errors()
retry_queue.put_nowait(self)
# Other retryable errors
except (
openai.error.Timeout,
openai.error.APIError,
openai.error.APIConnectionError,
openai.error.ServiceUnavailableError,
) as e:
_logger.warning(f"Request #{self.index} failed with {e!r}")
status_tracker.increment_num_api_errors()
if self.attempts_left > 0:
retry_queue.put_nowait(self)
else:
status_tracker.complete_task(success=False)
# Unretryable errors
except Exception as e:
_logger.warning(f"Request #{self.index} failed with {e!r}")
status_tracker.increment_num_api_errors()
status_tracker.complete_task(success=False)
def num_tokens_consumed_from_request(
request_json: dict, api_endpoint: str, token_encoding_name: str
):
"""
Count the number of tokens in the request. Only supports completion and embedding requests.
"""
encoding = tiktoken.get_encoding(token_encoding_name)
# if completions request, tokens = prompt + n * max_tokens
if api_endpoint.endswith("completions"):
max_tokens = request_json.get("max_tokens", 15)
n = request_json.get("n", 1)
completion_tokens = n * max_tokens
# chat completions
if api_endpoint.startswith("chat/"):
num_tokens = 0
for message in request_json["messages"]:
num_tokens += 4 # every message follows <im_start>{role/name}\n{content}<im_end>\n
for key, value in message.items():
num_tokens += len(encoding.encode(value))
if key == "name": # if there's a name, the role is omitted
num_tokens -= 1 # role is always required and always 1 token
num_tokens += 2 # every reply is primed with <im_start>assistant
return num_tokens + completion_tokens
# normal completions
else:
prompt = request_json["prompt"]
if isinstance(prompt, str): # single prompt
prompt_tokens = len(encoding.encode(prompt))
num_tokens = prompt_tokens + completion_tokens
return num_tokens
elif isinstance(prompt, list): # multiple prompts
prompt_tokens = sum([len(encoding.encode(p)) for p in prompt])
num_tokens = prompt_tokens + completion_tokens * len(prompt)
return num_tokens
else:
raise TypeError(
"Expecting either string or list of strings for 'prompt' field in completion "
"request"
)
# if embeddings request, tokens = input tokens
elif api_endpoint == "embeddings":
inp = request_json["input"]
if isinstance(inp, str): # single input
num_tokens = len(encoding.encode(inp))
return num_tokens
elif isinstance(inp, list): # multiple inputs
num_tokens = sum([len(encoding.encode(i)) for i in inp])
return num_tokens
else:
raise TypeError(
'Expecting either string or list of strings for "inputs" field in embedding request'
)
# more logic needed to support other API calls (e.g., edits, inserts, DALL-E)
else:
raise NotImplementedError(f'API endpoint "{api_endpoint}" not implemented in this script')
def process_api_requests(
requests: list[dict[str, any]] = None,
# Reference: https://platform.openai.com/docs/guides/rate-limits/overview
max_requests_per_minute: float = 3_500,
max_tokens_per_minute: float = 90_000,
token_encoding_name: str = "cl100k_base",
max_attempts: int = 5,
max_workers: int = 10,
):
"""
Processes API requests in parallel, throttling to stay under rate limits.
"""
# constants
seconds_to_pause_after_rate_limit_error = 15
# initialize trackers
retry_queue = queue.Queue()
status_tracker = StatusTracker() # single instance to track a collection of variables
next_request = None # variable to hold the next request to call
# initialize available capacity counts
available_request_capacity = max_requests_per_minute
available_token_capacity = max_tokens_per_minute
last_update_time = time.time()
results: list[tuple[int, OpenAIObject]] = []
requests_iter = enumerate(requests)
with ThreadPoolExecutor(max_workers=max_workers) as executor:
while True:
# get next request (if one is not already waiting for capacity)
if next_request is None:
if not retry_queue.empty():
next_request = retry_queue.get_nowait()
_logger.warning(f"Retrying request {next_request.index}: {next_request}")
elif req := next(requests_iter, None):
# get new request
index, request_json = req
next_request = APIRequest(
index=index,
request_json=request_json,
token_consumption=num_tokens_consumed_from_request(
request_json, "chat/completions", token_encoding_name
),
attempts_left=max_attempts,
results=results,
)
status_tracker.start_task()
# update available capacity
current_time = time.time()
seconds_since_update = current_time - last_update_time
available_request_capacity = min(
available_request_capacity
+ int(max_requests_per_minute * seconds_since_update / 60.0),
max_requests_per_minute,
)
available_token_capacity = min(
available_token_capacity + int(max_tokens_per_minute * seconds_since_update / 60.0),
max_tokens_per_minute,
)
last_update_time = current_time
# if enough capacity available, call API
if next_request:
_logger.debug(f"Available request capacity: {available_request_capacity}")
_logger.debug(f"Available token capacity: {available_token_capacity}")
next_request_tokens = next_request.token_consumption
if (
available_request_capacity >= 1
and available_token_capacity >= next_request_tokens
):
# update counters
available_request_capacity -= 1
available_token_capacity -= next_request_tokens
next_request.attempts_left -= 1
# call API
executor.submit(
next_request.call_api,
retry_queue=retry_queue,
status_tracker=status_tracker,
)
next_request = None # reset next_request to empty
# if all tasks are finished, break
if status_tracker.num_tasks_in_progress == 0:
break
# if a rate limit error was hit recently, pause to cool down
seconds_since_rate_limit_error = (
time.time() - status_tracker.time_of_last_rate_limit_error
)
if seconds_since_rate_limit_error < seconds_to_pause_after_rate_limit_error:
remaining_seconds_to_pause = (
seconds_to_pause_after_rate_limit_error - seconds_since_rate_limit_error
)
_logger.warning(
"Encountered rate limit error. Pausing to cool down for "
f"{remaining_seconds_to_pause} seconds..."
)
time.sleep(remaining_seconds_to_pause)
# ^e.g., if pause is 15 seconds and final limit was hit 5 seconds ago
# after finishing, log final status
if status_tracker.num_tasks_failed > 0:
raise mlflow.MlflowException(
f"{status_tracker.num_tasks_failed} tasks failed. See logs for details."
)
if status_tracker.num_rate_limit_errors > 0:
_logger.warning(
f"{status_tracker.num_rate_limit_errors} rate limit errors received. "
"Consider running at a lower rate."
)
return [res for _, res in sorted(results)]
| [] |
2024-01-10 | octodemo/mlflow-ngonz | mlflow~langchain~api_request_parallel_processor.py | # Based ons: https://github.com/openai/openai-cookbook/blob/6df6ceff470eeba26a56de131254e775292eac22/examples/api_request_parallel_processor.py
# Several changes were made to make it work with MLflow.
# Currently, only chat completion is supported.
"""
API REQUEST PARALLEL PROCESSOR
Using the LangChain API to process lots of text quickly takes some care.
If you trickle in a million API requests one by one, they'll take days to complete.
This script parallelizes requests using LangChain API.
Features:
- Streams requests from file, to avoid running out of memory for giant jobs
- Makes requests concurrently, to maximize throughput
- Logs errors, to diagnose problems with requests
"""
from __future__ import annotations
import logging
import threading
import queue
from dataclasses import dataclass
from concurrent.futures import ThreadPoolExecutor
import langchain
import mlflow
_logger = logging.getLogger(__name__)
@dataclass
class StatusTracker:
"""
Stores metadata about the script's progress. Only one instance is created.
"""
num_tasks_started: int = 0
num_tasks_in_progress: int = 0 # script ends when this reaches 0
num_tasks_succeeded: int = 0
num_tasks_failed: int = 0
num_api_errors: int = 0 # excluding rate limit errors, counted above
lock: threading.Lock = threading.Lock()
def start_task(self):
with self.lock:
self.num_tasks_started += 1
self.num_tasks_in_progress += 1
def complete_task(self, *, success: bool):
with self.lock:
self.num_tasks_in_progress -= 1
if success:
self.num_tasks_succeeded += 1
else:
self.num_tasks_failed += 1
def increment_num_api_errors(self):
with self.lock:
self.num_api_errors += 1
@dataclass
class APIRequest:
"""
Stores an API request's inputs, outputs, and other metadata. Contains a method to make an API
call.
"""
index: int
lc_model: langchain.chains.llm.LLMChain
request_json: dict
results: list[tuple[int, str]]
def call_api(self, retry_queue: queue.Queue, status_tracker: StatusTracker):
"""
Calls the LangChain API and stores results.
"""
_logger.debug(f"Request #{self.index} started")
try:
response = self.lc_model.run(**self.request_json)
_logger.debug(f"Request #{self.index} succeeded")
status_tracker.complete_task(success=True)
self.results.append((self.index, response))
except Exception as e:
_logger.warning(f"Request #{self.index} failed with {e!r}")
status_tracker.increment_num_api_errors()
status_tracker.complete_task(success=False)
def process_api_requests(
lc_model,
requests: list[dict[str, any]] = None,
max_workers: int = 10,
):
"""
Processes API requests in parallel.
"""
# initialize trackers
retry_queue = queue.Queue()
status_tracker = StatusTracker() # single instance to track a collection of variables
next_request = None # variable to hold the next request to call
results: list[tuple[int, str]] = []
requests_iter = enumerate(requests)
with ThreadPoolExecutor(max_workers=max_workers) as executor:
while True:
# get next request (if one is not already waiting for capacity)
if next_request is None:
if not retry_queue.empty():
next_request = retry_queue.get_nowait()
_logger.warning(f"Retrying request {next_request.index}: {next_request}")
elif req := next(requests_iter, None):
# get new request
index, request_json = req
next_request = APIRequest(
index=index, lc_model=lc_model, request_json=request_json, results=results
)
status_tracker.start_task()
# if enough capacity available, call API
if next_request:
# call API
executor.submit(
next_request.call_api,
retry_queue=retry_queue,
status_tracker=status_tracker,
)
next_request = None # reset next_request to empty
# if all tasks are finished, break
if status_tracker.num_tasks_in_progress == 0:
break
# after finishing, log final status
if status_tracker.num_tasks_failed > 0:
raise mlflow.MlflowException(
f"{status_tracker.num_tasks_failed} tasks failed. See logs for details."
)
return [res for _, res in sorted(results)]
| [] |
2024-01-10 | octodemo/mlflow-ngonz | examples~openai~pyfunc.py | import os
import logging
import openai
import mlflow
import pandas as pd
import logging
logging.getLogger("mlflow").setLevel(logging.DEBUG)
# On Databricks, set the stored OpenAI API key scope here for automatically loading the API key
# for real time inference. See https://docs.databricks.com/security/secrets/index.html on
# how to add a scope and API key.
os.environ["MLFLOW_OPENAI_SECRET_SCOPE"] = "<scope-name>"
with mlflow.start_run():
model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.ChatCompletion,
artifact_path="model",
messages=[{"role": "system", "content": "You are an MLflow expert!"}],
)
print(mlflow.openai.load_model(model_info.model_uri))
# {
# "messages": [{"content": "You are an MLflow expert!", "role": "system"}],
# "model": "gpt-3.5-turbo",
# "task": "chat.completions",
# }
df = pd.DataFrame(
{
"role": ["user"] * 10,
"content": [
"What is MLflow?",
"What are the key components of MLflow?",
"How does MLflow enable reproducibility?",
"What is MLflow tracking and how does it help?",
"How can you compare different ML models using MLflow?",
"How can you use MLflow to deploy ML models?",
"What are the integrations of MLflow with popular ML libraries?",
"How can you use MLflow to automate ML workflows?",
"What security and compliance features does MLflow offer?",
"Where does MLflow stand in the ML ecosystem?",
],
}
)
model = mlflow.pyfunc.load_model(model_info.model_uri)
print(df.assign(answer=model.predict(df)))
| [
"You are an MLflow expert!",
"['What is MLflow?', 'What are the key components of MLflow?', 'How does MLflow enable reproducibility?', 'What is MLflow tracking and how does it help?', 'How can you compare different ML models using MLflow?', 'How can you use MLflow to deploy ML models?', 'What are the integrations of MLflow with popular ML libraries?', 'How can you use MLflow to automate ML workflows?', 'What security and compliance features does MLflow offer?', 'Where does MLflow stand in the ML ecosystem?']"
] |
2024-01-10 | octodemo/mlflow-ngonz | examples~openai~spark_udf.py | import openai
import mlflow
import pandas as pd
from pyspark.sql import SparkSession
with mlflow.start_run():
model_info = mlflow.openai.log_model(
model="gpt-3.5-turbo",
task=openai.ChatCompletion,
messages=[{"role": "user", "content": "You are an MLflow expert!"}],
artifact_path="model",
)
with SparkSession.builder.getOrCreate() as spark:
spark_udf = mlflow.pyfunc.spark_udf(
spark=spark, model_uri=model_info.model_uri, result_type="string"
)
df = spark.createDataFrame(
pd.DataFrame(
{
"role": ["user"] * 10,
"content": [
"What is MLflow?",
"What are the key components of MLflow?",
"How does MLflow enable reproducibility?",
"What is MLflow tracking and how does it help?",
"How can you compare different ML models using MLflow?",
"How can you use MLflow to deploy ML models?",
"What are the integrations of MLflow with popular ML libraries?",
"How can you use MLflow to automate ML workflows?",
"What security and compliance features does MLflow offer?",
"Where does MLflow stand in the ML ecosystem?",
],
}
)
)
df.withColumn("answer", spark_udf("role", "content")).show()
| [
"You are an MLflow expert!",
"['What is MLflow?', 'What are the key components of MLflow?', 'How does MLflow enable reproducibility?', 'What is MLflow tracking and how does it help?', 'How can you compare different ML models using MLflow?', 'How can you use MLflow to deploy ML models?', 'What are the integrations of MLflow with popular ML libraries?', 'How can you use MLflow to automate ML workflows?', 'What security and compliance features does MLflow offer?', 'Where does MLflow stand in the ML ecosystem?']"
] |
2024-01-10 | Davidongora/cognifuseAi | congnifuseApi.py | from flask import Flask, request, jsonify
import openai
import firebase_admin
from firebase_admin import storage, credentials
from dotenv import dotenv_values
from flask_cors import CORS
import requests
import openai
from dotenv import dotenv_values
app = Flask(__name__)
CORS(app)
env_vars = dotenv_values('./env')
openai.api_key = env_vars.get('key')
bucket = env_vars.get('bucket')
doc_name = env_vars.get('doc_name')
cert = env_vars.get('cert')
# Initialize Firebase
cred = credentials.Certificate(cert) # Add your Firebase credentials
firebase_admin.initialize_app(cred, {
'storageBucket': bucket
})
bucket = storage.bucket(doc_name)
@app.route('/',methods = ['GET', 'POST'])
def proof_of_life():
return "HELLO BUDDY CONGNIFUSE_AI IS ALIVE"
def download_document(document_name):
blob = bucket.blob(document_name)
# Download the file from Firebase
file_contents = blob.download_as_string()
return file_contents.decode("utf-8") if file_contents else None
@app.route('/answerquestions', methods=['POST'])
def answer_document_questions():
user_input = request.form['user_input']
document_name = request.form['document_name'] # Assuming this is the name of the file in Firebase Storage
# return jsonify({"chatbot_response": "Your response here"}), 200
# Download document content from Firebase Storage
document_content = download_document(document_name)
if document_content:
prompt = f"Document: {document_content}\nUser: {user_input}\nChatbot:"
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=300,
temperature=0.7,
)
return jsonify({"chatbot_response": response['choices'][0]['text'].strip()}), 200
else:
return jsonify({"error": "No document available. Please upload a document first."}), 404
# topic.py
@app.route('/combined_learning/<topic>', methods=['GET']) # Combined endpoint
def combined_learning(topic):
try:
# Get the learning program from OpenAI
learning_program = create_learning_program(topic)
# Get content from Wikipedia
content_response = requests.get(
f"https://en.wikipedia.org/w/api.php?action=query&format=json&titles={topic}&prop=extracts&exintro=1"
)
content_response.raise_for_status() # Raise an exception for HTTP errors
content = content_response.json().get('query', {}).get('pages', {}).get(next(iter(content_response.json().get('query', {}).get('pages', {}))), {}).get('extract')
# Return a combined response
return jsonify({
"learning_program": learning_program,
"wikipedia_content": content
}), 200
except Exception as e:
return jsonify({"error": f"Error retrieving combined response: {e}"}), 500
@app.route('/learning/<topic>', methods=['GET']) #endpoint is working
def create_learning_program(topic):
prompt = f"Create a personalized learning program on {topic}. Include sections on introduction, key concepts, examples, practice exercises, and conclusion."
response = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=300,
temperature=0.7,
)
learning_program = response['choices'][0]['text'].strip()
# learning_program = "This is a sample learning program."
return learning_program
@app.route('/learningprogram', methods=['GET'])
def get_learning_program(topic=None):
if not topic:
topic = request.args.get('topic')
if not topic:
return jsonify({"error": "Topic not provided"}), 400
learning_program = create_learning_program(topic)
return jsonify({"learning_program": learning_program}), 200
# @app.route('/learningprogram', methods=['GET']) #endpoint is not working
# def get_learning_program():
# # Extract the topic from the query parameters or form data
# topic = request.args.get('topic')
# if not topic:
# return jsonify({"error": "Topic not provided"}), 400
# # Generate the learning program for the given topic
# learning_program = create_learning_program(topic)
# # Return the learning program as a JSON response
# return jsonify({"learning_program": learning_program}), 200
# def get_program_section(learning_program, user_selection):
# sections = learning_program.split('\n')[1:-1]
# try:
# selected_section = sections[int(user_selection) - 1]
# return selected_section
# except (ValueError, IndexError):
# return None
@app.route('/getcontent/<topic>', methods=["POST"])
def get_content(topic):
try:
wikipedia_api_url = f"https://en.wikipedia.org/w/api.php?action=query&format=json&titles={topic}&prop=extracts&exintro=1"
response = requests.get(wikipedia_api_url)
response.raise_for_status() # Raise an exception for HTTP errors
data = response.json()
if "query" in data and "pages" in data["query"]:
page = next(iter(data["query"]["pages"].values()))
if "extract" in page:
content = page["extract"]
return jsonify({"content": content}), 200
return jsonify({"message": "No content found for the given topic"}), 404
except requests.exceptions.RequestException as req_error:
return jsonify({"error": f"Error making Wikipedia API request: {req_error}"}), 500
except Exception as e:
return jsonify({"error": f"Error fetching content from Wikipedia: {e}"}), 500
# @app.route("/alt/content/<topic>", methods="GET")
def fetch_alternative_content_1(topic):
try:
# Use the Wikipedia API to fetch information about the topic
wikipedia_api_url = f"https://en.wikipedia.org/w/api.php?action=query&format=json&titles={topic}&prop=extracts&exintro=1"
response = requests.get(wikipedia_api_url)
response.raise_for_status() # Raise an exception for HTTP errors
data = response.json()
# Check if the API response contains an 'extract' field
if "query" in data and "pages" in data["query"]:
page = next(iter(data["query"]["pages"].values()))
if "extract" in page:
content = page["extract"]
return content
except requests.exceptions.RequestException as req_error:
print(f"Error making API request for alternative content 1: {req_error}")
except Exception as e:
print(f"Error fetching alternative content 1: {e}")
return None
# @app.route('/combined_endpoint/<topic>', methods=['GET'])
# def combined_endpoint(topic):
# learning_program = create_learning_program(topic)
# content_response = get_content(topic)
# content = content_response.json().get('content', None)
# alternative_content = fetch_alternative_content_1(topic)
# return jsonify({
# "learning_program": learning_program,
# "wikipedia_content": content,
# "alternative_content": alternative_content
# }), 200
@app.route("/combined/learningProgram/<topic>", methods=["GET"])
def all_learning(topic):
my_program = create_learning_program(topic)
learn_response = get_learning_program(topic)
top_response = get_content(topic)
cont = fetch_alternative_content_1(topic)
return jsonify({
"learning_program": my_program,
"wikipedia_content": learn_response.get('learning_program', None),
"alternative_content": top_response.get('content', None),
"content": cont
}), 200
# file.py
# Initialize Firebase app
try:
# Try to get the default app, which will throw an exception if it doesn't exist
default_app = firebase_admin.initialize_app()
except ValueError:
# If the default app already exists, do nothing
pass
# If the default app doesn't exist, initialize it
if not firebase_admin._apps:
cred = credentials.Certificate(cert)
firebase_admin.initialize_app(cred, {
'storageBucket': doc_name
})
@app.route('/dropFiles', methods=['POST'])
def store_file():
try:
uploaded_file = request.files['file']
if uploaded_file:
bucket = storage.bucket('bucket')
blob = bucket.blob(uploaded_file.filename)
blob.upload_from_file(uploaded_file)
return jsonify({"message": "File stored successfully!"}), 200
else:
return jsonify({"message": "No file provided."}), 400
except Exception as e:
return jsonify({"message": f"An error occurred: {str(e)}"}), 500
# endpoint for getting the file stored in the storage.bucket
@app.route('/listFiles', methods=['GET'])
def list_files():
bucket = storage.bucket('bucket') # Access the default storage bucket
blobs = bucket.list_blobs() # Retrieve a list of blobs (files) in the bucket
file_list = [blob.name for blob in blobs] # Extracting file names from the blobs
return jsonify({"files": file_list}), 200
if __name__ == '__main__':
# app.run(host="0.0.0.0", port=5000, debug=True)
app.run()
| [
"Create a personalized learning program on PLACEHOLDER. Include sections on introduction, key concepts, examples, practice exercises, and conclusion.",
"content",
"Document: PLACEHOLDER\nUser: PLACEHOLDER\nChatbot:",
"learning_program"
] |
2024-01-10 | walissonwaal/virtual-assistant-chatgpt | may.py | import openai
openai.api_key = "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"
def generate_prompt(prompt):
completions = openai.Completion.create(
engine="text-davinci-003",
prompt=prompt,
max_tokens=2048,
n=1,
stop=None,
temperature=0.5,
)
message = completions.choices[0].text
return message.strip()
prompt = input('Faça sua pergunta: \n')
print(generate_prompt(prompt)) | [
"Faça sua pergunta: \n"
] |
2024-01-10 | yaxinzhuars/icxml | src~group.py | import os
import json
import openai
import concurrent.futures
from tqdm import tqdm
import time
import random
from openai.error import RateLimitError
from argparse import ArgumentParser
openai.api_key = ''
parser = ArgumentParser()
parser.add_argument('--prompt_type', required=True, choices=['weak', 'full', 'example', 'group'])
parser.add_argument('--weak_file')
parser.add_argument('--lbl_file')
parser.add_argument('--test_file')
# parser.add_argument('--pseudo_file')
# parser.add_argument('--shots_file')
parser.add_argument('--example_file')
parser.add_argument('--save_to', required=True)
parser.add_argument('--start', type=int, default=0)
parser.add_argument('--end', type=int, default=1000000)
parser.add_argument('--dataset', required=True, choices=['amazon', 'wiki', 'eurlex'])
parser.add_argument('--hint_file', required=True)
args = parser.parse_args()
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(10)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
def main():
lbl, text = [], []
# results = json.load(open('../xml/AmazonCat-13K.bow/tstfidf.json'))
with open(args.lbl_file, encoding='latin-1') as f:
for line in f.readlines():
lbl.append(json.loads(line))
with open(args.test_file) as f:
for line in f.readlines():
text.append(json.loads(line))
random_prompt = ''
with open('../preprocessing/random10prompt.txt') as f:
for line in f.readlines():
random_prompt += line
hints = []
with open(args.hint_file) as f:
for line in f.readlines():
hints.append(json.loads(line))
# cands = {}
# with open(args.pseudo_file) as f:
# for line in f.readlines():
# data = json.loads(line)
# cands[data['uid']] = data['cat']
if args.example_file is not None:
examples = []
with open(args.example_file) as f:
for line in f.readlines():
# print(len(json.loads(line)['output']))
examples.append(json.loads(line))
prompts = []
# for i in range(len(text)):
for i in range(args.start, args.end):
shots_prompt = ''
if args.prompt_type == 'group':
labels = hints[i]['output']
inputs = examples[i - args.start]['output']
# print(inputs)
if len(inputs) == 0:
prompts.append(random_prompt)
continue
if isinstance(inputs[0], list):
x = []
for input in inputs:
for ii in input:
if isinstance(ii, list):
for iii in ii:
if isinstance(iii, list):
for iiii in iii:
x.append(iiii)
else:
x.append(iii)
else:
x.append(ii)
inputs = x
shot_cands_dict = {}
for index, input in enumerate(inputs[:len(labels)]):
if isinstance(input, list):
print(input)
input = input[0]
input = input.encode('utf-8').decode('utf-8')
if input not in shot_cands_dict.keys():
shot_cands_dict[input] = []
if labels[index] != input:
shot_cands_dict[input].append(labels[index])
for shot_title, _shot_cands in shot_cands_dict.items():
if _shot_cands is None:
continue
if args.dataset == 'amazon':
# true
shot_prompt = "Product title on Amazon: " + shot_title + "\nSimilar product: " + '\n'.join(_shot_cands) + '\n'
# label
# shot_prompt = "Product title on Amazon: " + shot_title + "\nSimilar product: " + '\n'.join([x['title'] for x in random.sample(lbl, len(_shot_cands))]) + '\n'
# input
# random_word = random.choice(temp)['title']
# shot_prompt = "Product title on Amazon: " + random_word + "\nSimilar product: " + '\n'.join(_shot_cands) + '\n'
if args.dataset == 'wiki':
shot_prompt = "Passage title on Wikipedia: " + shot_title + "\nSee also passage: " + '\n'.join(_shot_cands) + '\n'
if args.dataset == 'eurlex':
shot_prompt = "EU legislative document title: " + shot_title + "\nTagged labels: " + '\n'.join(_shot_cands) + '\n'
shots_prompt += shot_prompt
# else:
# shot_cands = []
# for j in range(min(len(shots[i]), 5)):
# shot_title = shots[i][j]['title']
# # shot_content = shots[i][j]['content']
# if args.prompt_type == 'full':
# shot_cands = '\n'.join([json.loads(item)['title'] for item in shots[i][j]['cat']])
# if args.prompt_type == 'example':
# shot_cands = '\n'.join(shots[i][j]['cat'])
# if args.prompt_type == 'weak':
# shot_cands = '\n'.join([item['text'] for item in cands[shots[i][j]['uid']][:5]])
# # shot_prompt = "Product title on Amazon: " + shot_title + ". Product content: " + shot_content + "\n Similar product: " + shot_cands + '\n'
# shot_prompt = "Product title on Amazon: " + shot_title + "\nSimilar product: " + shot_cands + '\n'
# shots_prompt += shot_prompt
if shots_prompt == '':
shots_prompt = random_prompt
title = text[i]['title']
content = text[i]['content']
if args.prompt_type == 'example':
cands = '\n'.join(hints[i]['output'][:30])
if args.dataset == 'amazon':
prompt1 = "For an Amazon product recommendation task, product title: " + title + "\nCandidate labels: " + cands + '\n'
prompt = prompt1 + 'For each label, guess an input title. Format: ["title1", "title2", "title3", ...], each title is a guess based on a candidate label, title1 is a guess for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.\n'
if args.dataset == 'wiki':
# prompt1 = "For a Wikipedia page 'see also' suggestion task, wiki title: " + title + "\nCandidate labels: " + cands + '\n'
# prompt = prompt1 + 'For each "See also" reference label, generate a plausible Wikipedia page title that could lead to a it. Format: ["title1", "title2", "title3", ...], each title is a generation based on a candidate label, title1 is generated for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.'
prompt1 = "There's a list of Wikipedia page titles: " + cands + '\n'
prompt = prompt1 + 'For each page, generate a "See also" page title. Format: ["title1", "title2", "title3", ...], each title is a generation based on a candidate label, title1 is generated for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.\n'
# prompt = prompt1 + 'For each label, guess an input title. Format: title1\ntitle2\ntitle3\neach title is a guess based on a candidate label, title1 is a guess for first label, and so on. Only output 50 lines of titles. do not explain or say anthing.\n'
if args.dataset == 'eurlex':
prompt1 = "For a EU legislative document tagging task, document title: " + title + "\nCandidate tags: " + cands + '\n'
prompt = prompt1 + 'For each tag, generate a corresponding EU legislative document title. Format: ["title1", "title2", "title3", ...], each title is a generation based on a candidate label, title1 is generated for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.\n'
elif args.prompt_type == 'group':
# prompt_side = "background knowledge: " + background[i]['background'] + '\n'
# hint = '\n'.join(hints[i]['output'])
# hint = '(Hint: The answer may near to: ' + hint + ')'
if args.dataset == 'amazon':
prompt = "You are now trying to predict at least 10 relevant products for a new Amazon product title: " + title + "\ndescription: " + content + '\n'
if args.dataset == 'wiki':
p_cut = 'Title: ' + title + '\nContent: ' + content[:10000] + '\n'
prompt = p_cut + "Generate 'See also' suggestions related to the Wikipedia title: " + title + '\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...'
if args.dataset == 'eurlex':
p_cut = 'Title: ' + title + '\nHeader: ' + text[i]['header'] + '\nRecitals: ' + text[i]['recitals'] + '\n'
prompt = p_cut + "Given the above EU legislative document, generate relevant labels. \nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n..."
# prompt = ''
shots_prompt = shots_prompt[:(13000 - len(prompt))]
prompt = shots_prompt + prompt
print(prompt)
print(len(prompt))
# if (len(prompt) > 10000):
# print(prompt)
prompt = prompt[:13000]
prompts.append(prompt)
### explore the effect of retrieved labels
# out = []
# for j in range(len(shots[i])):
# cands4out = [item['text'] for item in cands[shots[i][j]['uid']]]
# out.extend(cands4out)
# out = list(set(out))
# with open('../preprocessing/guess_weak_content/oracle_200.jsonl', "a") as outfile:
# outfile.write(
# json.dumps(
# {
# "id": text[i]['uid'],
# "output": out
# }
# ) + "\n"
# )
with concurrent.futures.ProcessPoolExecutor() as executor:
completions = list(tqdm(executor.map(get_completion_with_retries, prompts), total=len(prompts)))
# with concurrent.futures.ThreadPoolExecutor() as executor:
# with tqdm(total=len(prompts)) as pbar:
# completions = list(executor.map(lambda prompt: get_completion_with_retries(prompt, tqdm=pbar), prompts))
# pbar.update()
with open(args.save_to, 'w') as fw:
for i, completion in enumerate(completions):
gt = [lbl[j]['title'] for j in text[i + args.start]['target_ind']]
result = text[i + args.start]
result['gt'] = gt
result['pred'] = completion
json.dump(result, fw)
fw.write('\n')
main()
| [
"\n",
"PLACEHOLDERFor each label, guess an input title. Format: [\"title1\", \"title2\", \"title3\", ...], each title is a guess based on a candidate label, title1 is a guess for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.\n",
"For an Amazon product recommendation task, product title: PLACEHOLDER\nCandidate labels: PLACEHOLDER\n",
"\nSimilar product: ",
"\nTagged labels: ",
"PLACEHOLDERPLACEHOLDER",
"Product title on Amazon: ",
"PLACEHOLDERGiven the above EU legislative document, generate relevant labels. \nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...",
"You are now trying to predict at least 10 relevant products for a new Amazon product title: PLACEHOLDER\ndescription: PLACEHOLDER\n",
"There's a list of Wikipedia page titles: PLACEHOLDER\n",
"PLACEHOLDERFor each page, generate a \"See also\" page title. Format: [\"title1\", \"title2\", \"title3\", ...], each title is a generation based on a candidate label, title1 is generated for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.\n",
"PLACEHOLDERFor each tag, generate a corresponding EU legislative document title. Format: [\"title1\", \"title2\", \"title3\", ...], each title is a generation based on a candidate label, title1 is generated for first label, and so on. Only output one list and the list should be of size 30. do not explain or say anthing.\n",
"PLACEHOLDERGenerate 'See also' suggestions related to the Wikipedia title: PLACEHOLDER\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...",
"[]",
"Passage title on Wikipedia: ",
"For a EU legislative document tagging task, document title: PLACEHOLDER\nCandidate tags: PLACEHOLDER\n",
"EU legislative document title: ",
"\nSee also passage: "
] |
2024-01-10 | yaxinzhuars/icxml | src~read_example.py | import json
import re
import time
import openai
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--input_file', required=True)
parser.add_argument('--save_to', required=True)
args = parser.parse_args()
openai.api_key = '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'
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(60)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
string_data = '["Stainless Steel Hex Nut, 1/4-20 (Pack of 50)", "Aluminum Round Spacer, 1/2" OD, 1/4" Length (Pack of 25)", "Brass Flat Washer, #8 Screw Size, 0.203" ID, 0.5" OD (Pack of 100)", "Zinc Plated Steel Phillips Drive Pan Head Machine Screw, #6-32, 1/2" Length (Pack of 50)", "Black Oxide Finish Steel Socket Head Cap Screw, 5/16"-18 Thread Size, 1" Length (Pack of 10)"]'
pattern = r'(?<![ \[])"(?![,\]])'
replaced_data = re.sub(pattern, "'", string_data)
print(replaced_data)
data = []
with open(args.input_file) as f:
for line in f.readlines():
data.append(json.loads(line))
print(len(data))
# count = 0
# examples = []
# for i, d in enumerate(data):
# # print(d['pred'])
# pred = d['pred']
# pattern = r"\[.*?\]"
# match = re.search(pattern, pred)
# try:
# example = json.loads(pred)
# except json.JSONDecodeError:
# pattern = r'(?<![ \[])"(?![,\]])'
# pred = re.sub(pattern, "'", pred)
# try:
# example = json.loads(pred)
# except json.JSONDecodeError:
# print(pred)
# count += 1
# prompt = "Product title: " + d['title'] + '\nPlease predict at least 5 other products titles. \n Format: ["title1", "title2", "title3", "title4", "title5"], do not say any word or explain. \n'
# pred = get_completion_with_retries(prompt)
# print(pred)
# example = json.loads(pred)
# print(example)
# examples.append(example)
count = 0
examples = []
for i, d in enumerate(data):
# print(d['pred'])
pred = d['pred']
pattern = r"\[.*?\]"
match = re.search(pattern, pred)
try:
example = json.loads(pred)
except json.JSONDecodeError:
# print(pred)
# print()
if pred.startswith('["'):
if pred.endswith('" ]'):
pred = pred.replace('" ]', '"]')
elif pred.endswith('",]'):
pred = pred.replace('",]', '"]')
# cut tail
idx = pred.rfind('"]')
if idx != -1 and idx != len(pred) - 2:
pred = pred[:idx+2]
# replace quotes
pattern = r'(?<![ \[])"(?![,\]])'
pred = re.sub(pattern, "'", pred)
# replace "xxx "a" yyy"
pred = re.sub(r'(?<!,) "(.*?)"(?!,)', r" '\1' ", pred)
# replace "xxx 1", 2"
pred = re.sub(r'(", )(?!")', r"', ", pred)
# replace /
pred = pred.replace("\\", "\\\\")
try:
example = json.loads(pred)
except json.JSONDecodeError:
# count += 1
pred_split = '[' + pred + ']'
try:
example = json.loads(pred_split)
except json.JSONDecodeError:
preds = pred.split('\n')
preds = [x.strip() for x in preds]
example = []
for p in preds:
try:
e = json.loads(p)
example.append(e)
except json.JSONDecodeError:
example.append(p)
# print(p)
# prompt = "Product title: " + d['title'] + '\nPlease predict at least 5 other products titles. \n Format: ["title1", "title2", "title3", "title4", "title5"], do not say any word or explain. \n'
# pred = get_completion_with_retries(prompt)
# print(pred)
# example = json.loads(pred)
# print(example)
if len(example) < 2:
count += 1
# print(len(example))
# print(d['uid'])
# print(d['pred'])
# print()
# print(pred)
# print(example)
# if d['uid'] == 'B0007SXIMM':
# print(pred)
# x = json.loads(pred)
examples.append(example)
with open(args.save_to, "w") as outfile:
for i in range(len(data)):
outfile.write(
json.dumps(
{
"id": data[i]['uid'],
"output": examples[i]
}
) + "\n"
)
print(count)
# examples = []
# with open(args.save_to) as f:
# for line in f.readlines():
# print(len(json.loads(line)['output']))
# examples.append(json.loads(line))
| [] |
2024-01-10 | yaxinzhuars/icxml | src~rerank.py | import os
import json
import openai
import concurrent.futures
from tqdm import tqdm
import time
from openai.error import RateLimitError
from bertopic import BERTopic
from argparse import ArgumentParser
from random import sample
parser = ArgumentParser()
parser.add_argument('--prompt_type', required=True, choices=['rerank', 'select'])
parser.add_argument('--dataset', required=True, choices=['amazon', 'wiki', 'eurlex'])
parser.add_argument('--topic_model')
parser.add_argument('--cluster_file')
parser.add_argument('--random_file')
parser.add_argument('--hint_file')
parser.add_argument('--input_file', required=True)
parser.add_argument('--save_to', required=True)
parser.add_argument('--start', type=int, default=0)
parser.add_argument('--end', type=int, default=1000000)
args = parser.parse_args()
openai.api_key = ''
def get_completion(prompt):
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
)
time.sleep(15)
return completion.choices[0].message.content
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-4-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(10)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
def decode(start, end, text, lbl, preds, prompt_type, save_to):
prompts = []
# for i in range(len(text)):
for i in range(start, end):
title = text[i]['title']
des = text[i]['content']
cands = preds[i-start]['output']
cands_prompt = ''
# prompt_top10 = "The query product is: " + title + "\ndescription is: " + des + "\nHere are some candidate relevant products "
# post_prompt = "Select top 10 products based on their relevance to the query product " + title
for cid, cand in enumerate(cands):
cand_prompt = '[' + str(cid + 1) + '] ' + cand + '\n'
cands_prompt += cand_prompt
# prompt = prompt + cands_prompt + 'The ranking results of the ' + str(len(cands)) + ' passages (only identifiers) is:'
if args.dataset == 'amazon':
prompt_select = "**Task**: Given a query product, select the top 10 most relevant products from a list of candidates.\n**Query product title**: " \
+ title + "\n**Candidates**:\n" + cands_prompt + "\n**Output format**: A list of integers representing the indices of the top 10 most relevant products. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**Query Product description**: " + des
if args.dataset == 'wiki':
# prompt_select = "**Task**: From the following candidate list of Wikipedia pages, select top 10 that would be most relevant for the 'See also' section of the given page:\n**wiki title**: " \
# + title + "\n**Candidates**:\n" + cands_prompt + "\n**Output format**: A list of integers representing the indices of the top 10 most possible titles. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**wiki content**: " + des
prompt_select = "**Task**: From the following candidate list of Wikipedia pages, select top 10 that would be most relevant for the 'See also' section of the given page:\n**wiki title**: " \
+ title + "\n**Output format**: A list of integers representing the indices of the top 10 most possible titles. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**Candidates**:\n" + cands_prompt + '\n**wiki content**: ' + des
if args.dataset == 'eurlex':
prompt_select = "**Task**: From the following candidate list of labels, select top 10 that would be most relevant for the EU legislative document:\n**doc title**: " \
+ title + "\n**Output format**: A list of integers representing the indices of the top 10 most possible labels. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**Candidates**:\n" + cands_prompt + '\n**doc header**: ' + text[i]['header'] \
+ "\n**doc recitals**: " + text[i]['recitals']
prompt = prompt_select
print(prompt)
# print(len(prompt))
prompt = prompt[:12000]
prompts.append(prompt)
# print(prompt)
with concurrent.futures.ProcessPoolExecutor() as executor:
completions = list(tqdm(executor.map(get_completion_with_retries, prompts), total=len(prompts)))
# with concurrent.futures.ThreadPoolExecutor() as executor:
# with tqdm(total=len(prompts)) as pbar:
# completions = list(executor.map(lambda prompt: get_completion_with_retries(prompt, tqdm=pbar), prompts))
# pbar.update()
with open(save_to, 'w') as fw:
for i, completion in enumerate(completions):
gt = [lbl[j]['title'] for j in text[i+start]['target_ind']]
result = text[i+start]
result['gt'] = gt
result['pred'] = completion
json.dump(result, fw)
fw.write('\n')
def main():
lbl, text = [], []
# results = json.load(open('/work/yaxinzhu_umass_edu/chatgpt/xml/AmazonCat-13K.bow/tstfidf.json'))
if args.dataset == 'amazon':
dataset = 'LF-Amazon-131K'
if args.dataset == 'wiki':
dataset = 'LF-WikiSeeAlso-320K'
if args.dataset == 'eurlex':
dataset = 'EURLex-4.3K'
with open('../xml/' + dataset + '/lbl.json', encoding='latin-1') as f:
for line in f.readlines():
lbl.append(json.loads(line))
with open('../xml/' + dataset + '/tst.json') as f:
for line in f.readlines():
text.append(json.loads(line))
# shots = []
# with open('../preprocessing/train_title_10shot.txt') as f:
# for line in f.readlines():
# shots.append(json.loads(line))
preds = []
with open(args.input_file) as f:
for line in f.readlines():
preds.append(json.loads(line))
# topic_model = BERTopic.load(args.topic_model)
# cluster_examples = json.load(open(args.cluster_file))
topic_model, cluster_examples = None, None
random_prompt = ''
if args.random_file:
with open(args.random_file) as f:
for line in f.readlines():
random_prompt += line
start, end = 0, len(text)
if args.start is not None and args.end is not None:
start = args.start
end = args.end
decode(start, end, text, lbl, preds, args.prompt_type, args.save_to)
main()
| [
"\n",
"\n**Output format**: A list of integers representing the indices of the top 10 most possible labels. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**Candidates**:\n",
"**Task**: From the following candidate list of labels, select top 10 that would be most relevant for the EU legislative document:\n**doc title**: ",
"] ",
"**Task**: Given a query product, select the top 10 most relevant products from a list of candidates.\n**Query product title**: PLACEHOLDER\n**Candidates**:\nPLACEHOLDER\n**Output format**: A list of integers representing the indices of the top 10 most relevant products. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**Query Product description**: PLACEHOLDER",
"\n**doc header**: ",
"[]",
"\n**doc recitals**: ",
"**Task**: From the following candidate list of Wikipedia pages, select top 10 that would be most relevant for the 'See also' section of the given page:\n**wiki title**: PLACEHOLDER\n**Output format**: A list of integers representing the indices of the top 10 most possible titles. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. \n**Candidates**:\nPLACEHOLDER\n**wiki content**: PLACEHOLDER"
] |
2024-01-10 | yaxinzhuars/icxml | src~clean_data.py | import json
import re
import openai
import time
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--input_file', required=True)
parser.add_argument('--save_to', required=True)
parser.add_argument('--shots_file')
parser.add_argument('--pseudo_file')
parser.add_argument('--dataset')
parser.add_argument('--train_mode')
args = parser.parse_args()
data = []
with open(args.input_file) as f:
for line in f.readlines():
data.append(json.loads(line))
if args.shots_file and args.pseudo_file:
shots = []
with open(args.shots_file) as f:
for line in f.readlines():
shots.append(json.loads(line))
cands = {}
with open(args.pseudo_file) as f:
for line in f.readlines():
line = json.loads(line)
cands[line['uid']] = line['cat']
openai.api_key = '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'
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(1)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
def clean_new(data):
count = 0
for i, d in enumerate(data):
preds = d['pred']
# if len(d['content']) > 10000:
# # count += 1
# prompt = "Product title: " + d['title'] + '\nPlease predict at least 10 other products titles. \n Format: ["title1", "title2", "title3", "title4", "title5"], do not say any word or explain. \n'
# preds = get_completion_with_retries(prompt)
# try:
# preds = json.loads(preds)
# except Exception as e:
# pass
# else:
# preds = d['pred']
# with open('tmp/origin.txt', 'a') as f:
# f.write(preds + '\n\n')
preds = [pred for pred in preds.lower().strip().split('\n') if pred != '']
if len(preds) == 1:
count += 1
if args.train_mode == 'ez':
shots_prompt = ''
for j in range(min(len(shots[i]), 5)):
shot_title = shots[i][j]['title']
if args.dataset == 'amazon':
shot_cands = '\n'.join([item['text'] for item in cands[shots[i][j]['uid']][:5]])
shot_prompt = "Product title on Amazon: " + shot_title + "\nSimilar product: " + shot_cands + '\n'
if args.dataset == 'wiki':
shot_cands = '\n'.join(cands[shots[i][j]['uid']][:5])
shot_prompt = "Passage title on Wikipedia: " + shot_title + "\nSimilar passage: " + shot_cands + '\n'
shots_prompt += shot_prompt
prompt = "You are now trying to predict at least 10 relevant passages for a new Wikipedia passage title: " + d['title'] + "\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n..."
preds = get_completion_with_retries(prompt)
preds = [pred for pred in preds.lower().strip().split('\n') if pred != '']
if len(preds) == 1:
preds = [x.strip() for x in re.split(r'(?<!\s),(?!\s)', preds[0])]
if len(preds) == 1 and len(preds[0].split(',')) >= 5:
preds = preds[0].split(',')
preds = [pred for pred in preds if pred != '']
print(len(preds))
# print(preds)
# with open('tmp/final.txt', 'a') as f:
# f.write(json.dumps(preds) + '\n')
d['pred'] = preds
print(count)
return data
data = clean_new(data)
with open(args.save_to, "w") as outfile:
for d in data:
outfile.write(
json.dumps(
{
"id": d['uid'],
"output": d['pred']
}
) + "\n"
) | [
"You are now trying to predict at least 10 relevant passages for a new Wikipedia passage title: PLACEHOLDER\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...",
"Passage title on Wikipedia: PLACEHOLDER\nSimilar passage: PLACEHOLDER\n",
"Product title on Amazon: PLACEHOLDER\nSimilar product: PLACEHOLDER\n"
] |
2024-01-10 | yaxinzhuars/icxml | src~demo_gen.py | import os
import json
import openai
import concurrent.futures
from tqdm import tqdm
import time
from openai.error import RateLimitError
from bertopic import BERTopic
from argparse import ArgumentParser
from random import sample
import os
os.environ['TOKENIZERS_PARALLELISM']='true'
parser = ArgumentParser()
parser.add_argument('--prompt_type', required=True, choices=[
'zeroshot', 'example'])
parser.add_argument('--topic_model')
parser.add_argument('--cluster_file')
parser.add_argument('--random_file')
parser.add_argument('--hint_file')
# parser.add_argument('--input_file', required=True)
parser.add_argument('--save_to', required=True)
parser.add_argument('--start', type=int, default=0)
parser.add_argument('--end', type=int, default=1000000)
parser.add_argument('--dataset', choices=['wiki', 'amazon', 'eurlex'])
# parser.add_argument('--cluster_num')
args = parser.parse_args()
openai.api_key = ''
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(60)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
def decode(start, end, text, lbl, prompt_type, save_to):
prompts = []
# for i in range(len(text)):
for i in range(start, end):
title = text[i]['title']
des = text[i]['content']
# prompt = "You are now trying to predict relevant products for a new product title: " + title + '. Only output the product results, one each line, splitted with line break "\n", do not say any word or explain. \n'
prompt = "You are now trying to predict at least 10 relevant products for a new product title: " + title + ': \n'
if prompt_type == 'zeroshot':
hint = '\n'.join(hint_prompt[i]['output'][:100])
if hint != '':
hint = '\n(Hint: The answer may near to: \n ' + hint + ')\n'
# hint = ''
# prompt = "Please predict at least 10 relevant products for an Amazon product title: " + title + "\ndescription: " + des + '\n'
# prompt = "Given an Amazon product title: " + title + ", please generate a discription "
if args.dataset == 'amazon':
prompt = "Please predict at least 10 relevant products for an Amazon product title: " + title + hint + "product description: " + des + "\n"
if args.dataset == 'wiki':
prompt = "Generate 'See also' suggestions related to the Wikipedia title: " + title + '\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...' + hint + 'wiki_content: ' + des + '\n'
if args.dataset == 'eurlex':
prompt = "Generate tags/labels related to the EU legislative **document title**: " + title + '\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...' + '\n**document header**: ' + text[i]['header'] + '\n**document recitals**: ' + text[i]['recitals'] + '\n'
elif prompt_type == 'example':
if args.dataset == 'amazon':
prompt = "Product title: " + title + '\nPlease predict at least 5 similar Amazon products titles. \n Format: ["title1", "title2", "title3", "title4", "title5"], do not say any word or explain. \n' + "\nproduct description: " + des
if args.dataset == 'wiki':
prompt = "Wiki title: " + title + '\nPlease generate at least 5 relevant and diverse wiki page titles. \n Format: ["title1", "title2", "title3", "title4", "title5"], do not say any word or explain. \n' + "\nwiki content: " + des
print(prompt)
print(len(prompt))
prompt = prompt[:13000]
prompts.append(prompt)
with concurrent.futures.ProcessPoolExecutor() as executor:
completions = list(tqdm(executor.map(get_completion_with_retries, prompts), total=len(prompts)))
# with concurrent.futures.ThreadPoolExecutor() as executor:
# with tqdm(total=len(prompts)) as pbar:
# completions = list(executor.map(lambda prompt: get_completion_with_retries(prompt, tqdm=pbar), prompts))
# pbar.update()
with open(save_to, 'w') as fw:
for i, completion in enumerate(completions):
gt = [lbl[j]['title'] for j in text[i+start]['target_ind']]
result = text[i+start]
result['gt'] = gt
result['pred'] = completion
json.dump(result, fw)
fw.write('\n')
def main():
lbl, text = [], []
if args.dataset == 'amazon':
dataset = 'LF-Amazon-131K'
if args.dataset == 'wiki':
dataset = 'LF-WikiSeeAlso-320K'
if args.dataset == 'eurlex':
dataset = 'EURLex-4.3K'
with open('../xml/' + dataset + '/lbl.json', encoding='latin-1') as f:
for line in f.readlines():
lbl.append(json.loads(line))
with open('../xml/' + dataset + '/tst.json') as f:
for line in f.readlines():
text.append(json.loads(line))
background = []
with open(args.background_file) as f:
for line in f.readlines():
background.append(json.loads(line))
start, end = 0, len(text)
if args.start is not None and args.end is not None:
start = args.start
end = args.end
decode(start, end, text, lbl, args.prompt_type, args.save_to)
main()
| [
"\n**document recitals**: ",
"[]",
"\n",
"Product title: PLACEHOLDER\nPlease predict at least 5 similar Amazon products titles. \n Format: [\"title1\", \"title2\", \"title3\", \"title4\", \"title5\"], do not say any word or explain. \n\nproduct description: PLACEHOLDER",
"Generate tags/labels related to the EU legislative **document title**: ",
"\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...",
"\n**document header**: ",
"Generate 'See also' suggestions related to the Wikipedia title: PLACEHOLDER\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...PLACEHOLDERwiki_content: PLACEHOLDER\n",
"Wiki title: PLACEHOLDER\nPlease generate at least 5 relevant and diverse wiki page titles. \n Format: [\"title1\", \"title2\", \"title3\", \"title4\", \"title5\"], do not say any word or explain. \n\nwiki content: PLACEHOLDER",
"Please predict at least 10 relevant products for an Amazon product title: PLACEHOLDERPLACEHOLDERproduct description: PLACEHOLDER\n",
"You are now trying to predict at least 10 relevant products for a new product title: PLACEHOLDER: \n"
] |
2024-01-10 | yaxinzhuars/icxml | src~inference.py | import os
import json
import openai
import concurrent.futures
from tqdm import tqdm
import time
from openai.error import RateLimitError
from argparse import ArgumentParser
import random
openai.api_key = ''
parser = ArgumentParser()
parser.add_argument('--prompt_type', required=True, choices=['weak', 'full', 'example'])
parser.add_argument('--weak_file')
parser.add_argument('--lbl_file')
parser.add_argument('--test_file')
parser.add_argument('--pseudo_file')
parser.add_argument('--shots_file')
# parser.add_argument('--input_file', required=True)
parser.add_argument('--save_to', required=True)
parser.add_argument('--start', type=int, default=0)
parser.add_argument('--end', type=int, default=1000000)
parser.add_argument('--dataset', required=True, choices=['amazon', 'wiki'])
args = parser.parse_args()
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(5)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
def main():
lbl, text = [], []
with open(args.lbl_file, encoding='latin-1') as f:
for line in f.readlines():
lbl.append(json.loads(line))
with open(args.test_file) as f:
for line in f.readlines():
text.append(json.loads(line))
shots = {}
with open(args.shots_file) as f:
for i, line in enumerate(f.readlines()):
shots[i+args.start] = json.loads(line)
random_prompt = ''
with open('../preprocessing/random10prompt.txt') as f:
for line in f.readlines():
random_prompt += line
cands = {}
with open(args.pseudo_file) as f:
for line in f.readlines():
data = json.loads(line)
cands[data['uid']] = data['cat']
# print(data['uid'], data['cat'])
prompts = []
# for i in range(len(text)):
for i in range(args.start, args.end):
shots_prompt = ''
for j in range(min(len(shots[i]), 10)):
shot_title = shots[i][j]['title']
if isinstance(shot_title, list):
shot_title = shot_title[0]
# shot_content = shots[i][j]['content']
if args.prompt_type == 'full':
shot_cands = '\n'.join([json.loads(item)['title'] for item in shots[i][j]['cat']])
if args.prompt_type == 'example':
shot_cands = '\n'.join(shots[i][j]['cat'])
if args.prompt_type == 'weak':
if args.dataset == 'wiki':
shot_cands = '\n'.join(cands[shots[i][j]['uid']][:10])
else:
shot_cands = '\n'.join([item['text'] for item in cands[shots[i][j]['uid']][:5]])
# shot_prompt = "Product title on Amazon: " + shot_title + ". Product content: " + shot_content + "\n Similar product: " + shot_cands + '\n'
if args.dataset == 'amazon':
# true
# shot_prompt = "Product title on Amazon: " + shot_title + "\nSimilar product: " + shot_cands + '\n'
# label
_shot_cands = '\n'.join(x['title'] for x in random.sample(lbl, 5))
shot_prompt = "Product title on Amazon: " + shot_title + "\nSimilar product: " + _shot_cands + '\n'
# input
# random_word = random.choice(temp)['title']
# shot_prompt = "Product title on Amazon: " + random_word + "\nSimilar product: " + shot_cands + '\n'
if args.dataset == 'wiki':
print(shot_cands)
print()
print(shot_title)
shot_prompt = "Title: " + shot_title + "\n'See Also' page: " + shot_cands + '\n'
shots_prompt += shot_prompt
if shots_prompt == '':
shots_prompt = random_prompt
title = text[i]['title']
content = text[i]['content']
if args.dataset == 'amazon':
prompt = "You are now trying to predict at least 10 relevant products for a new Amazon product title: " + title + "\ndescription: " + content + '\n'
elif args.dataset == 'wiki':
# prompt = "You are now trying to predict at least 10 relevant passages for a new Wikipedia passage title: " + title + "\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...content: " + content[:1000] + '\n'
prompt = "You are now trying to generate 'See also' suggestions related to the Wikipedia title: " + title + "\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...\nwiki content: " + content + '\n'
# prompt_side = "background knowledge: " + background[i]['background'] + '\n'
# hint = '\n'.join(hints[i]['output'])
# hint = '(Hint: The answer may near to: ' + hint + ')'
hint = ''
prompt = shots_prompt + prompt
print(prompt)
print(len(prompt))
prompt = prompt[:12000]
prompts.append(prompt)
with concurrent.futures.ProcessPoolExecutor() as executor:
completions = list(tqdm(executor.map(get_completion_with_retries, prompts), total=len(prompts)))
# with concurrent.futures.ThreadPoolExecutor() as executor:
# with tqdm(total=len(prompts)) as pbar:
# completions = list(executor.map(lambda prompt: get_completion_with_retries(prompt, tqdm=pbar), prompts))
# pbar.update()
with open(args.save_to, 'w') as fw:
for i, completion in enumerate(completions):
gt = [lbl[j]['title'] for j in text[i]['target_ind']]
result = text[i]
result['gt'] = gt
result['pred'] = completion
json.dump(result, fw)
fw.write('\n')
main() | [
"You are now trying to generate 'See also' suggestions related to the Wikipedia title: PLACEHOLDER\nOnly output titles with line break, do not include anything else. example: title 1\ntitle2\n...\nwiki content: PLACEHOLDER\n",
"You are now trying to predict at least 10 relevant products for a new Amazon product title: PLACEHOLDER\ndescription: PLACEHOLDER\n",
"PLACEHOLDERPLACEHOLDER",
"Product title on Amazon: PLACEHOLDER\nSimilar product: PLACEHOLDER\n",
"Title: PLACEHOLDER\n'See Also' page: PLACEHOLDER\n",
"[]"
] |
2024-01-10 | yaxinzhuars/icxml | src~read_rank.py | import json
import re
from argparse import ArgumentParser
import time
import openai
parser = ArgumentParser()
parser.add_argument('--input_file', required=True)
parser.add_argument('--gt_file', required=True)
parser.add_argument('--save_to', required=True)
parser.add_argument('--dataset', choices=['amazon', 'wiki', 'eurlex'])
args = parser.parse_args()
input_string = "[3] > [4] > [9] > [10] > [1] > [2] > [5] > [6] > [7] > [8]"
# Extract the numbers from the input string
numbers = [int(num.strip("[] ")) for num in input_string.split(">")]
print(numbers)
openai.api_key = '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'
# openai.api_key = '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'
def get_completion_with_retries(prompt, return_text=True, reduce_length=False, tqdm=None):
while True:
try:
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo-0613",
messages=[{"role": "user", "content": prompt}],
temperature=0.0,
timeout=30
)
break
except Exception as e:
print(str(e))
if "This model's maximum context length is" in str(e):
print('reduce_length')
return 'ERROR::reduce_length'
# self.key_id = (self.key_id + 1) % len(self.key)
# openai.api_key = self.key[self.key_id]
time.sleep(10)
if return_text:
completion = completion['choices'][0]['message']['content']
return completion
data = []
with open(args.input_file) as f:
for line in f.readlines():
data.append(json.loads(line))
print(len(data))
preds = []
with open(args.gt_file) as f:
for line in f.readlines():
preds.append(json.loads(line))
# count = 0
# for i, d in enumerate(data):
# pred_num = d['pred']
# cands = preds[i]['output']
# if any(char.isalpha() for char in pred_num):
# count += 1
# d['pred'] = cands
# else:
# numbers = [int(num.strip("[] ")) for num in pred_num.split(">")]
# ordered_cands = []
# for i in numbers:
# if i <= len(cands):
# ordered_cands.append(cands[i-1])
# d['pred'] = ordered_cands
count = 0
for i, d in enumerate(data):
pred_num = d['pred']
cands = preds[i]['output']
# print(pred_num)
pattern = r"\[.*?\]"
match = re.search(pattern, pred_num)
if match:
list_format = match.group()
else:
# print(pred_num)
# continue
list_format = "[" + pred_num + "]"
try:
pred_num = json.loads(list_format)
except json.JSONDecodeError:
count += 1
cands_prompt = ''
for cid, cand in enumerate(cands):
cand_prompt = '[' + str(cid + 1) + '] ' + cand + '\n'
cands_prompt += cand_prompt
if args.dataset == 'amazon':
prompt_select = "**Task**: Given a query product, select the top 10 most relevant products from a list of candidates.\n**Query product title**: " \
+ d['title'] + "\n**Candidates**:\n" + cands_prompt + "\n**Output format**: A list of integers representing the indices of the top 10 most relevant products. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. "
elif args.dataset == 'wiki':
prompt_select = "**Task**: From the following candidate list of Wikipedia pages, select top 10 that would be most relevant for the 'See also' section of the given page:\n**wiki title**: " \
+ d['title'] + "\n**Candidates**:\n" + cands_prompt + "\n**Output format**: A list of integers representing the indices of the top 10 most possible titles. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation."
elif args.dataset == 'eurlex':
prompt_select = "**Task**: From the following candidate list of labels, select top 10 that would be most relevant for the EU legislative document:\n**doc title**: " \
+ d['title'] + "\n**Candidates**:\n" + cands_prompt + "\n**Output format**: A list of integers representing the indices of the top 10 most possible titles. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation."
prompt = prompt_select
# print(prompt)
# print(len(prompt), len(cands))
prompt = prompt[:13000]
# print(prompt)
result = get_completion_with_retries(prompt)
# print(result + '\n')
pattern = r"\[.*?\]"
match = re.search(pattern, result)
if match:
list_format = match.group()
else:
# print(pred_num)
# continue
list_format = "[" + result + "]"
try:
pred_num = json.loads(list_format)
except json.JSONDecodeError:
print(result)
pred_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(pred_num)
print(len(cands))
ordered_cands = [cands[i-1] for i in pred_num if i <= len(cands)]
d['pred'] = ordered_cands
print(count)
with open(args.save_to, "w") as outfile:
for d in data:
outfile.write(
json.dumps(
{
"id": d['uid'],
"output": d['pred']
}
) + "\n"
)
| [
"\n",
"\n**Output format**: A list of integers representing the indices of the top 10 most possible titles. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation.",
"**Task**: From the following candidate list of labels, select top 10 that would be most relevant for the EU legislative document:\n**doc title**: ",
"\n**Candidates**:\n",
"\n**Output format**: A list of integers representing the indices of the top 10 most relevant products. Example: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] \nOnly ouput the list, do not include any description or explanation. ",
"**Task**: Given a query product, select the top 10 most relevant products from a list of candidates.\n**Query product title**: ",
"] ",
"**Task**: From the following candidate list of Wikipedia pages, select top 10 that would be most relevant for the 'See also' section of the given page:\n**wiki title**: "
] |
2024-01-10 | JunfengChen-robotics/MultiRoboLearn | MultiRoboLearn~MultiRoboLearn~src~MultiRoboLearn~task_envs~spark~continous_multiagent_turtlebot2_goal.py | import rospy
import numpy
import time
import math
from gym import spaces
from openai_ros.robot_envs import multiagent_turtlebot2_env
from gym.envs.registration import register
from sensor_msgs.msg import LaserScan
from std_msgs.msg import Header
from geometry_msgs.msg import Point
# The path is __init__.py of openai_ros, where we import the TurtleBot2MazeEnv directly
max_episode_steps_per_episode = 100 # Can be any Value
register(
id='MultiagentTurtleBot2-v1',
entry_point='openai_ros.task_envs.turtlebot2.continous_multiagent_turtlebot2_goal:MultiagentTurtleBot2Env',
max_episode_steps=max_episode_steps_per_episode,
)
class MultiagentTurtleBot2Env(multiagent_turtlebot2_env.MultiagentTurtleBot2Env):
def __init__(self):
"""
This Task Env is designed for having the multi TurtleBot2 in some kind of scenarios.
It will learn how to move around the desired point without crashing into static and dynamic obstacle.
"""
# Only variable needed to be set here
self.number_actions = rospy.get_param('/turtlebot2/n_actions')
high = numpy.full((self.number_actions), 1.0)
low = numpy.full((self.number_actions), -1.0)
self.action_space = spaces.Box(low, high)
# Maximum linear velocity (m/s) of Spark
max_lin_vel = 0.4
# Maximum angular velocity (rad/s) of Spark
max_ang_vel = 0.2
self.max_vel = numpy.array([max_lin_vel, max_ang_vel])
# We set the reward range, which is not compulsory but here we do it.
self.reward_range = (-numpy.inf, numpy.inf)
# Actions and Observations
self.dec_obs = rospy.get_param("/turtlebot2/number_decimals_precision_obs", 3)
self.linear_forward_speed = rospy.get_param('/turtlebot2/linear_forward_speed')
self.linear_turn_speed = rospy.get_param('/turtlebot2/linear_turn_speed')
self.angular_speed = rospy.get_param('/turtlebot2/angular_speed')
self.init_linear_forward_speed = rospy.get_param('/turtlebot2/init_linear_forward_speed')
self.init_linear_turn_speed = rospy.get_param('/turtlebot2/init_linear_turn_speed')
self.n_observations = rospy.get_param('/turtlebot2/n_observations')
self.min_range = rospy.get_param('/turtlebot2/min_range')
# self.new_ranges = rospy.get_param('/turtlebot2/new_ranges')
self.max_laser_value = rospy.get_param('/turtlebot2/max_laser_value')
self.min_laser_value = rospy.get_param('/turtlebot2/min_laser_value')
# Get Desired Point to Get for different robots
# for marobot1
self.marobot1_desired_point = Point()
self.marobot1_desired_point.x = rospy.get_param("/turtlebot2/marobot1/desired_pose/x")
self.marobot1_desired_point.y = rospy.get_param("/turtlebot2/marobot1/desired_pose/y")
self.marobot1_desired_point.z = rospy.get_param("/turtlebot2/marobot1/desired_pose/z")
self.marobot1_obstacle_point = Point()
self.marobot1_obstacle_point.x = rospy.get_param("/turtlebot2/obstacle1/obstacle_pose/x")
self.marobot1_obstacle_point.y = rospy.get_param("/turtlebot2/obstacle1/obstacle_pose/y")
# for marobot2
self.marobot2_desired_point = Point()
self.marobot2_desired_point.x = rospy.get_param("/turtlebot2/marobot2/desired_pose/x")
self.marobot2_desired_point.y = rospy.get_param("/turtlebot2/marobot2/desired_pose/y")
self.marobot2_desired_point.z = rospy.get_param("/turtlebot2/marobot2/desired_pose/z")
self.marobot2_obstacle_point = Point()
self.marobot2_obstacle_point.x = rospy.get_param("/turtlebot2/obstacle2/obstacle_pose/x")
self.marobot2_obstacle_point.y = rospy.get_param("/turtlebot2/obstacle2/obstacle_pose/y")
# for marobot3
self.marobot3_desired_point = Point()
self.marobot3_desired_point.x = rospy.get_param("/turtlebot2/marobot3/desired_pose/x")
self.marobot3_desired_point.y = rospy.get_param("/turtlebot2/marobot3/desired_pose/y")
self.marobot3_desired_point.z = rospy.get_param("/turtlebot2/marobot3/desired_pose/z")
self.marobot3_obstacle_point = Point()
self.marobot3_obstacle_point.x = rospy.get_param("/turtlebot2/obstacle3/obstacle_pose/x")
self.marobot3_obstacle_point.y = rospy.get_param("/turtlebot2/obstacle3/obstacle_pose/y")
# Here we will add any init functions prior to starting the MyRobotEnv
super(MultiagentTurtleBot2Env, self).__init__()
# We create two arrays based on the binary values that will be assigned
# In the discretization method.
laser_scans = self.get_laser_scan()
rospy.logdebug("laser_scan len===>"+str(len(laser_scans[0].ranges)))
# Laser data for different robots
self.laser_scan_frame_1 = laser_scans[0].header.frame_id
self.laser_scan_frame_2 = laser_scans[1].header.frame_id
self.laser_scan_frame_3 = laser_scans[2].header.frame_id
# Number of laser reading jumped
self.new_ranges = int(math.ceil(float(len(laser_scans[0].ranges)) / float(self.n_observations)))
# self.new_ranges = 1
rospy.logdebug("n_observations===>"+str(self.n_observations))
rospy.logdebug("new_ranges, jumping laser readings===>"+str(self.new_ranges))
high = numpy.full((self.n_observations), self.max_laser_value)
#in order to validate the observation data, we modify the min_laser_value into -self.max_laser_value as low
low = numpy.full((self.n_observations), -1*self.max_laser_value)
# low = numpy.full((self.n_observations), self.min_laser_value)
# We only use two integers
self.observation_space = spaces.Box(low, high, dtype=numpy.float32)
rospy.logdebug("ACTION SPACES TYPE===>"+str(self.action_space))
rospy.logdebug("OBSERVATION SPACES TYPE===>"+str(self.observation_space))
#done for all robots
# self._episode_dones = []
# Rewards
# self.forwards_reward = rospy.get_param("/turtlebot2/forwards_reward")
# self.turn_reward = rospy.get_param("/turtlebot2/turn_reward")
# self.end_episode_points = rospy.get_param("/turtlebot2/end_episode_points")
self.cumulated_steps = 0.0
self.laser_filtered_pub_1 = rospy.Publisher('marobot1/turtlebot2/laser/scan_filtered', LaserScan, queue_size=10)
self.laser_filtered_pub_2 = rospy.Publisher('marobot2/turtlebot2/laser/scan_filtered', LaserScan, queue_size=10)
self.laser_filtered_pub_3 = rospy.Publisher('marobot3/turtlebot2/laser/scan_filtered', LaserScan, queue_size=10)
def _set_init_pose(self):
"""Sets the Robot in its init pose
"""
self.move_base_1( self.init_linear_forward_speed,
self.init_linear_turn_speed,
epsilon=0.05,
update_rate=10,
min_laser_distance=-1)
self.move_base_2(self.init_linear_forward_speed,
self.init_linear_turn_speed,
epsilon=0.05,
update_rate=10,
min_laser_distance=-1)
self.move_base_3(self.init_linear_forward_speed,
self.init_linear_turn_speed,
epsilon=0.05,
update_rate=10,
min_laser_distance=-1)
return True
def _init_env_variables(self):
"""
Inits variables needed to be initialised each time we reset at the start
of an episode.
:return:
"""
# For Info Purposes,and total reward for all robots
self.cumulated_reward = 0.0 #This only is put here, in fact, it is less useful.
# self.cumulated_episode_reward = [0, 0, 0]
# Set to false Done, because its calculated asyncronously
self._episode_done = False
self._episode_dones = [False,False,False]
self._if_dones_label = [False,False,False]
# We wait a small ammount of time to start everything because in very fast resets, laser scan values are sluggish
# and sometimes still have values from the prior position that triguered the done.
time.sleep(1.0)
# TODO: Add reset of published filtered laser readings
#add
laser_scans = self.get_laser_scan()
# laser_scans = self.get_laser_scan_spark()
print("laser for real robots", laser_scans)
discretized_ranges = [laser_scans[0].ranges,laser_scans[1].ranges,laser_scans[2].ranges]
#publish different laser data for all robots
pub_num_marobot1 = '1'
self.publish_filtered_laser_scan(laser_original_data=laser_scans[0],
new_filtered_laser_range=discretized_ranges[0],
pub_num=pub_num_marobot1)
pub_num_marobot2 = '2'
self.publish_filtered_laser_scan(laser_original_data=laser_scans[1],
new_filtered_laser_range=discretized_ranges[1],
pub_num=pub_num_marobot2)
pub_num_marobot3 = '3'
self.publish_filtered_laser_scan(laser_original_data=laser_scans[2],
new_filtered_laser_range=discretized_ranges[2],
pub_num=pub_num_marobot3)
#add
odometrys = self.get_odom()
# odometrys = self.get_odom_spark()
print("odom for real robots", odometrys)
# print("odometrys is:", odometrys)
#add
# odometrys[0].pose.pose.position.x = odometrys[0].pose.pose.position.x + 1
# odometrys[0].pose.pose.position.y = odometrys[0].pose.pose.position.y + 1
#
#
# # for marobot2:
#
#
# odometrys[1].pose.pose.position.x = odometrys[1].pose.pose.position.x + 4
# odometrys[1].pose.pose.position.y = odometrys[1].pose.pose.position.y + 2
#
#
# # for marobot3:
#
#
# odometrys[2].pose.pose.position.x = odometrys[2].pose.pose.position.x + 1
# odometrys[2].pose.pose.position.y = odometrys[2].pose.pose.position.y + 3
self.previous_distance_from_des_points = [self.get_distance_from_desired_point_1(odometrys[0].pose.pose.position),self.get_distance_from_desired_point_2(odometrys[1].pose.pose.position),self.get_distance_from_desired_point_3(odometrys[2].pose.pose.position)]
def _set_action(self, actions):
"""
This set action will Set the linear and angular speed of the turtlebot2
based on the action number given.
:param action: The action integer that set s what movement to do next.
"""
#for marobot1:
action = actions[0]
action = numpy.array(action)
rospy.logdebug("Start Set Action for marobot1==>"+str(action))
# We convert the actions to speed movements to send to the parent class CubeSingleDiskEnv
# if action == 0: #FORWARD
# linear_speed = self.linear_forward_speed
# angular_speed = 0.0
# self.last_action = "FORWARDS"
# elif action == 1: #LEFT
# linear_speed = self.linear_turn_speed
# angular_speed = self.angular_speed
# self.last_action = "TURN_LEFT"
# elif action == 2: #RIGHT
# linear_speed = self.linear_turn_speed
# angular_speed = -1*self.angular_speed
# self.last_action = "TURN_RIGHT"
# elif action == 3: #BACKFORWARD
# linear_speed = -1*self.linear_forward_speed
# angular_speed = 0.0
# self.last_action = "BACKFORWARD"
# elif action == 4: #STOP
# linear_speed = 0.0
# angular_speed = 0.0
# self.last_action = "STOP"
action = numpy.multiply(action, self.max_vel)
action_excution = action.tolist()
print("agent0 action is:", action_excution)
# We tell TurtleBot2 the linear and angular speed to set to execute
self.move_base_1( linear_speed = action_excution[0],
angular_speed = action_excution[1],
epsilon=0.05,
update_rate=10,
min_laser_distance=self.min_range)
# rospy.logdebug("END Set Action for marobot1==>"+str(action)+", NAME="+str(self.last_action))
# for marobot2:
action = actions[1]
action = numpy.array(action)
rospy.logdebug("Start Set Action for marobot1==>" + str(action))
# We convert the actions to speed movements to send to the parent class CubeSingleDiskEnv
# if action == 0: # FORWARD
# linear_speed = self.linear_forward_speed
# angular_speed = 0.0
# self.last_action = "FORWARDS"
# elif action == 1: # LEFT
# linear_speed = self.linear_turn_speed
# angular_speed = self.angular_speed
# self.last_action = "TURN_LEFT"
# elif action == 2: # RIGHT
# linear_speed = self.linear_turn_speed
# angular_speed = -1 * self.angular_speed
# self.last_action = "TURN_RIGHT"
# elif action == 3: # BACKFORWARD
# linear_speed = -1 * self.linear_forward_speed
# angular_speed = 0.0
# self.last_action = "BACKFORWARD"
# elif action == 4: # STOP
# linear_speed = 0.0
# angular_speed = 0.0
# self.last_action = "STOP"
action = numpy.multiply(action, self.max_vel)
action_excution = action.tolist()
# We tell TurtleBot2 the linear and angular speed to set to execute
self.move_base_2(linear_speed = action_excution[0],
angular_speed = action_excution[1],
epsilon=0.05,
update_rate=10,
min_laser_distance=self.min_range)
# rospy.logdebug("END Set Action for marobot2==>" + str(action) + ", NAME=" + str(self.last_action))
# for marobot3:
action = actions[2]
action = numpy.array(action)
rospy.logdebug("Start Set Action for marobot1==>" + str(action))
# We convert the actions to speed movements to send to the parent class CubeSingleDiskEnv
# if action == 0: # FORWARD
# linear_speed = self.linear_forward_speed
# angular_speed = 0.0
# self.last_action = "FORWARDS"
# elif action == 1: # LEFT
# linear_speed = self.linear_turn_speed
# angular_speed = self.angular_speed
# self.last_action = "TURN_LEFT"
# elif action == 2: # RIGHT
# linear_speed = self.linear_turn_speed
# angular_speed = -1 * self.angular_speed
# self.last_action = "TURN_RIGHT"
# elif action == 3: # BACKFORWARD
# linear_speed = -1 * self.linear_forward_speed
# angular_speed = 0.0
# self.last_action = "BACKFORWARD"
# elif action == 4: # STOP
# linear_speed = 0.0
# angular_speed = 0.0
# self.last_action = "STOP"
action = numpy.multiply(action, self.max_vel)
action_excution = action.tolist()
# We tell TurtleBot2 the linear and angular speed to set to execute
self.move_base_3(linear_speed = action_excution[0],
angular_speed = action_excution[1],
epsilon=0.05,
update_rate=10,
min_laser_distance=self.min_range)
# rospy.logdebug("END Set Action for marobot3==>" + str(action) + ", NAME=" + str(self.last_action))
def _get_obs(self):
"""
Here we define what sensor data defines our robots observations
To know which Variables we have acces to, we need to read the
TurtleBot2Env API DOCS
:return:
"""
rospy.logdebug("Start Get Observation ==>")
# We get the laser scan data for all robots
#add
laser_scans = self.get_laser_scan()
# laser_scans = self.get_laser_scan_spark()
rospy.logdebug("BEFORE DISCRET _episode_done==>"+str(self._episode_done))
#discretize laser date for different robots:
discretized_laser_scan_1 = self.discretize_observation( laser_scans[0],
self.new_ranges,
'1'
)
discretized_laser_scan_2 = self.discretize_observation(laser_scans[1],
self.new_ranges,
'2'
)
discretized_laser_scan_3 = self.discretize_observation(laser_scans[2],
self.new_ranges,
'3'
)
# obtain laser data for all robots
discretized_laser_scan = [discretized_laser_scan_1, discretized_laser_scan_2, discretized_laser_scan_3]
# We get the odometry for all robots so that SumitXL knows where it is.
#add
odometrys = self.get_odom()
# odometrys = self.get_odom_spark()
#for marobot1:
odometry = odometrys[0]
x_position = odometry.pose.pose.position.x
y_position = odometry.pose.pose.position.y
# We round to only two decimals to avoid very big Observation space
odometry_array_1 = [round(x_position, 2), round(y_position, 2)]
# for marobot2:
odometry = odometrys[1]
x_position = odometry.pose.pose.position.x
y_position = odometry.pose.pose.position.y
# We round to only two decimals to avoid very big Observation space
odometry_array_2 = [round(x_position, 2), round(y_position, 2)]
# for marobot3:
odometry = odometrys[2]
x_position = odometry.pose.pose.position.x
y_position = odometry.pose.pose.position.y
# We round to only two decimals to avoid very big Observation space
odometry_array_3 = [round(x_position, 2), round(y_position, 2)]
# for all odometry_array for all robots
odometry_array = [odometry_array_1, odometry_array_2, odometry_array_3]
# print("里程计数据：",odometry_array_1)
# We only want the X and Y position and the Yaw
# observations = discretized_laser_scan + odometry_array
observations = []
# observations = observations.append(discretized_laser_scan)
# observations = observations.append(odometry_array)
observations_marobot1 = [odometry_array[0],discretized_laser_scan[0]]
observations_marobot2 = [odometry_array[1],discretized_laser_scan[1]]
observations_marobot3 = [odometry_array[2],discretized_laser_scan[2]]
observations =[observations_marobot1,observations_marobot2,observations_marobot3]
# observations = discretized_laser_scan + odometry_array
rospy.logdebug("Observations==>" + str(observations))
rospy.logdebug("END Get Observation ==>")
# rospy.logdebug("Observations==>"+str(discretized_observations))
# rospy.logdebug("AFTER DISCRET_episode_done==>"+str(self._episode_done))
# rospy.logdebug("END Get Observation ==>")
return observations
def _is_done(self, observations):
#deciede per agent done and store in list
sub_episode_done = []
# if self._episode_done:
# done[0] and done[1] and done[2]
# if self._episode_dones[0] is False and self._episode_dones[1] is False and self._episode_dones[2] is False:
if self._episode_dones[0] is True and self._episode_dones[1] is True and self._episode_dones[2] is True:
# rospy.logdebug("All TurtleBot2 robots are Too Close or has crashed==>"+str(self._episode_done))
print("All TurtleBot2 robots are Too Close or has crashed==>"+str(self._episode_dones))
return self._episode_dones
else:
rospy.logerr("All TurtleBot2 robots are Ok ==>")
current_position_1 = Point()
current_position_2 = Point()
current_position_3 = Point()
# current_position.x = observations[-2]
# current_position.y = observations[-1]
#for marobot1:
current_position_1.x = observations[0][0][0]
current_position_1.y = observations[0][0][1]
current_position_1.z = 0.0
# for marobot2:
current_position_2.x = observations[1][0][0]
current_position_2.y = observations[1][0][1]
current_position_2.z = 0.0
# for marobot3:
current_position_3.x = observations[2][0][0]
current_position_3.y = observations[2][0][1]
current_position_3.z = 0.0
MAX_X = 16.0
MIN_X = -16.0
MAX_Y = 16.0
MIN_Y = -16.0
# We see if we are outside the Learning Space or get into desired points
# difine type dictionary in order to decide if go to the desired point
# print("current_position_1 is:", current_position_1)
num = 0
desired_current_position = {str(current_position_1): self.marobot1_desired_point, str(current_position_2): self.marobot2_desired_point, str(current_position_3): self.marobot3_desired_point}
obstacle_current_position = {str(current_position_1): self.marobot1_obstacle_point, str(current_position_2): self.marobot2_obstacle_point, str(current_position_3): self.marobot3_obstacle_point}
for current_position in [current_position_1, current_position_2, current_position_3]:
if self._episode_dones[num] is False:
if current_position.x <= MAX_X and current_position.x > MIN_X:
if current_position.y <= MAX_Y and current_position.y > MIN_Y:
rospy.logdebug(
"TurtleBot Position is OK ==>[" + str(current_position.x) + "," + str(current_position.y) + "]")
# We see if it got to the desired point
if self.is_in_desired_position(desired_current_position[str(current_position)], current_position):
self._episode_done = True
# else:
# self._episode_done = False
elif self.is_in_obstacle_position(obstacle_current_position[str(current_position)], current_position):
self._episode_done = True
else:
self._episode_done = False
else:
rospy.logerr("TurtleBot to Far in Y Pos ==>" + str(current_position.x))
self._episode_done = True
else:
rospy.logerr("TurtleBot to Far in X Pos ==>" + str(current_position.x))
self._episode_done = True
print("Agent num is:", num)
print("goal_Env_done is:", self._episode_done)
# sub_episode_done = sub_episode_done.append(self._episode_done)
# sub_episode_done.append(self._episode_done)
self._episode_dones[num] = self._episode_done
else:
self._episode_dones[num] = True
num = num +1
# self._episode_dones = sub_episode_done[:]
print("all robot dones are", self._episode_dones)
#add
# self._episode_dones[1] = True
# self._episode_dones[2] = True
return self._episode_dones
# define reward for all robots through distance between each robot and desired point or has crashed into each other
def _compute_reward(self, observations, dones):
# define and store all reward for different robots
reward_all = [0,0,0]
current_position_1 = Point()
current_position_2 = Point()
current_position_3 = Point()
# for marobot1:
current_position_1.x = observations[0][0][0]
current_position_1.y = observations[0][0][1]
current_position_1.z = 0.0
laser_data_1 = observations[0][1]
# for marobot2:
current_position_2.x = observations[1][0][0]
current_position_2.y = observations[1][0][1]
current_position_2.z = 0.0
laser_data_2 = observations[1][1]
# for marobot3:
current_position_3.x = observations[2][0][0]
current_position_3.y = observations[2][0][1]
current_position_3.z = 0.0
laser_data_3 = observations[2][1]
#obtain all robots given to the desired points
#Agents are rewarded based on minimum agent distance to each desired point, penalized for collisions
#establish reward for each robot and there are three conditions: each distance to desired point, all reached desired point and each crashed
distance_from_des_points = []
distance_differences = []
# distance_from_start = [3,3,3]
i = -1
for current_position in [current_position_1, current_position_2, current_position_3]:
i += 1
if i == 0:
distance_from_des_point = self.get_distance_from_desired_point_1(current_position)
elif i == 1:
distance_from_des_point = self.get_distance_from_desired_point_2(current_position)
elif i == 2:
distance_from_des_point = self.get_distance_from_desired_point_3(current_position)
distance_difference = distance_from_des_point - self.previous_distance_from_des_points[i]
# distance_difference = (distance_from_des_point - distance_from_start[i])/100.00
distance_from_des_points.append(distance_from_des_point)
distance_differences.append(distance_difference)
self.previous_distance_from_des_points = distance_from_des_points[:]
# distance_difference = distance_from_des_point - self.previous_distance_from_des_point
#------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
#print("First time reward_all is:", reward_all)
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# original code:
# if not done:
# if self.last_action == "FORWARDS":
# reward = -1*self.forwards_reward
# else:
# reward = self.turn_reward
# # else:
# # reward = -1*self.end_episode_points
#
# if distance_difference < 0.0:
# rospy.logwarn("DECREASE IN DISTANCE GOOD")
# reward += self.forwards_reward
# # reward = 100
# else:
# rospy.logerr("ENCREASE IN DISTANCE BAD")
# # reward += 0
# reward = reward - 10*distance_difference
# else:
# if self.is_in_desired_position(current_position):
# reward = self.end_episode_points
# else:
# reward = -1 * self.end_episode_points
# Situation2: all robots reach desired point, currently adopt independt network, so we don't need all reward
is_in_desired_positions = [self.is_in_desired_position(self.marobot1_desired_point, current_position_1),
self.is_in_desired_position(self.marobot2_desired_point, current_position_2),
self.is_in_desired_position(self.marobot3_desired_point, current_position_3)]
is_in_desired_position_total = is_in_desired_positions[0] and is_in_desired_positions[1] and \
is_in_desired_positions[2]
# obstacle_point, current_position
is_in_obstacle_positions = [self.is_in_obstacle_position(self.marobot1_obstacle_point, current_position_1),
self.is_in_obstacle_position(self.marobot1_obstacle_point, current_position_2) or self.is_in_obstacle_position(self.marobot3_obstacle_point, current_position_2) ,
self.is_in_obstacle_position(self.marobot3_obstacle_point, current_position_3)]
has_crashed_all = [self.has_crashed(self.min_laser_value, laser_data_1, '1'),
self.has_crashed(self.min_laser_value, laser_data_2, '2'),
self.has_crashed(self.min_laser_value, laser_data_3, '3')]
# if is_in_desired_position_total:
# reward_all = [reward+10 for reward in reward_all]
# if is_in_desired_position_total:
# reward_all = [reward+20 for reward in reward_all]
# Each agent is rewarded when each agent reaches to the desired points
# case3:
# for desired_position in is_in_desired_positions:
#
# if desired_position == True:
# # reward_all[m] += 5
# reward_all[m] += 500
# Agents are rewarded based on minimum agent distance to each desired point
#dists = min(distance_from_des_points)
#obtain reward for each robot and store in reward_all
#Situation1: define each reward for each robot
# reward -= dists
# transfer different data type
# reward as the distance difference is better than the direct distance
# distance_from_des_points_np = numpy.array(distance_from_des_points)
for i, reward_each in enumerate(reward_all):
if dones[i] is False:
# new add in situation: there is no move, otherwise push each agent
# case1:
# n = -1
# for distance in distance_differences:
# n += 1
# if distance == 0:
# reward_all[n] -= 1
# case2:
# distance_differences_np = numpy.array(distance_differences)
# reward_all_np = numpy.array(reward_all)
# reward_all_np = reward_all_np - distance_differences_np * 10
# reward_all = reward_all_np.tolist()
##-------------------------------------->>>>>>>>>>>>>>>>>>>>>>>
reward_each = reward_each - distance_differences[i]*10
reward_all[i] = reward_each
##-------------------------------------->>>>>>>>>>>>>>>>>>>>>>>
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# print("Second time reward_all is:", reward_all)
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>
#case3-modified:
if is_in_desired_positions[i] is True:
reward_all[i] += 200
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# print("Third time reward_all is:", reward_all)
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# Agents are penalty based on laser data for each robot
# case4:
# has_crashed_all = [self.has_crashed(self.min_laser_value,laser_data_1,'1'),self.has_crashed(self.min_laser_value,laser_data_2,'2'),self.has_crashed(self.min_laser_value,laser_data_3,'3')]
# j = -1
# for crashed in has_crashed_all:
# j += 1
# if crashed == True:
# # reward_all[j] -= 10
# reward_all[j] -= 2
# case4 - modified:
# if has_crashed_all[i] is True or is_in_obstacle_positions[i]:
# reward_all[i] -= 5
if has_crashed_all[i] is True:
reward_all[i] -= 0
if is_in_obstacle_positions[i] is True:
reward_all[i] -= 0
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# print("Forth time reward_all is:", reward_all)
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
elif dones[i] is True and self._if_dones_label[i] is False:
#case2:
# distance_differences_np = numpy.array(distance_differences)
# reward_all_np = numpy.array(reward_all)
# reward_all_np = reward_all_np - distance_differences_np*10
# reward_all = reward_all_np.tolist()
#------------------------------------------------------
reward_each = reward_each - distance_differences[i]*10
reward_all[i] = reward_each
# ------------------------------------------------------
#------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# print("Second time reward_all is:", reward_all)
#------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
#Situation2: all robots reach desired point, currently adopt independt network, so we don't need all reward
# is_in_desired_positions = [self.is_in_desired_position(self.marobot1_desired_point,current_position_1),self.is_in_desired_position(self.marobot2_desired_point,current_position_2),self.is_in_desired_position(self.marobot3_desired_point,current_position_3)]
# is_in_desired_position_total = is_in_desired_positions[0] and is_in_desired_positions[1] and is_in_desired_positions[2]
# if is_in_desired_position_total:
# reward_all = [reward+10 for reward in reward_all]
# if is_in_desired_position_total:
# reward_all = [reward+20 for reward in reward_all]
#Each agent is rewarded when each agent reaches to the desired points
#case3-modified:
# m = -1
# for desired_position in is_in_desired_positions:
# m += 1
# if desired_position == True:
# # reward_all[m] += 5
# reward_all[m] += 500
if is_in_desired_positions[i] is True:
reward_all[i] += 200
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# print("Third time reward_all is:", reward_all)
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# Agents are penalty based on laser data for each robot
#case4:
# has_crashed_all = [self.has_crashed(self.min_laser_value,laser_data_1,'1'),self.has_crashed(self.min_laser_value,laser_data_2,'2'),self.has_crashed(self.min_laser_value,laser_data_3,'3')]
# j = -1
# for crashed in has_crashed_all:
# j += 1
# if crashed == True:
# # reward_all[j] -= 10
# reward_all[j] -= 2
# case4 - modified:
if has_crashed_all[i] is True :
reward_all[i] -= 0
if is_in_obstacle_positions[i] is True:
reward_all[i] -= 0
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
#print("Forth time reward_all is:", reward_all)
# ------------------------------------------->>>>>>>>>>>>>>>>>>>>>>>>>
# rospy.logdebug("reward=" + str(reward))
# self.cumulated_reward += reward
# rospy.logdebug("Cumulated_reward=" + str(self.cumulated_reward))
# self.cumulated_steps += 1
# rospy.logdebug("Cumulated_steps=" + str(self.cumulated_steps))
self._if_dones_label[i] = True
else:
reward_all[i] = 0
return reward_all
# Internal TaskEnv Methods
def discretize_observation(self,data,new_ranges,pub_num):
"""
Discards all the laser readings that are not multiple in index of new_ranges
value.
"""
self._episode_done = False
discretized_ranges = []
filtered_range = []
mod = len(data.ranges)/new_ranges # In the case of real robots
# mod = new_ranges # In the term of simulation
max_laser_value = data.range_max
min_laser_value = data.range_min
rospy.logdebug("data=" + str(data))
rospy.logwarn("mod=" + str(mod))
for i, item in enumerate(data.ranges):
# if (i%mod==0):
if item == float ('Inf') or numpy.isinf(item):
#discretized_ranges.append(self.max_laser_value)
discretized_ranges.append(round(max_laser_value,self.dec_obs))
elif numpy.isnan(item):
#discretized_ranges.append(self.min_laser_value)
discretized_ranges.append(round(min_laser_value,self.dec_obs))
else:
#discretized_ranges.append(int(item))
discretized_ranges.append(round(item,self.dec_obs))
if (self.min_range > round(item,self.dec_obs) > 0):
rospy.logerr("Agent number is"+pub_num+"and"+"done Validation >>> item=" + str(item)+"< "+str(self.min_range))
# self._episode_done = True
self._episode_dones[int(pub_num)-1] = True
#__________________________________________________________>>>>>>>>>>>>>>>>
print("crash robot number is", pub_num)
print("whether crshed or not is", self._episode_dones[int(pub_num)-1])
# __________________________________________________________>>>>>>>>>>>>>>>>
else:
# rospy.logwarn("NOT done Validation >>> item=" + str(item)+"< "+str(self.min_range))
pass
# We add last value appended
filtered_range.append(discretized_ranges[-1])
# else:
# We add value zero
# filtered_range.append(0.1)
rospy.logdebug("Size of observations, discretized_ranges==>"+str(len(discretized_ranges)))
self.publish_filtered_laser_scan( laser_original_data=data,
new_filtered_laser_range=discretized_ranges,
pub_num=pub_num)
return discretized_ranges
def publish_filtered_laser_scan(self, laser_original_data, new_filtered_laser_range, pub_num):
rospy.logdebug("new_filtered_laser_range==>"+str(new_filtered_laser_range))
laser_filtered_object = LaserScan()
h = Header()
h.stamp = rospy.Time.now() # Note you need to call rospy.init_node() before this will work
h.frame_id = laser_original_data.header.frame_id
laser_filtered_object.header = h
laser_filtered_object.angle_min = laser_original_data.angle_min
laser_filtered_object.angle_max = laser_original_data.angle_max
new_angle_incr = abs(laser_original_data.angle_max - laser_original_data.angle_min) / len(new_filtered_laser_range)
#laser_filtered_object.angle_increment = laser_original_data.angle_increment
laser_filtered_object.angle_increment = new_angle_incr
laser_filtered_object.time_increment = laser_original_data.time_increment
laser_filtered_object.scan_time = laser_original_data.scan_time
laser_filtered_object.range_min = laser_original_data.range_min
laser_filtered_object.range_max = laser_original_data.range_max
laser_filtered_object.ranges = []
laser_filtered_object.intensities = []
for item in new_filtered_laser_range:
# if item == 0.0:
# # laser_distance = 0.1
# laser_distance = 0.0
# else:
laser_distance = item
laser_filtered_object.ranges.append(laser_distance)
laser_filtered_object.intensities.append(item)
if pub_num == '1':
self.laser_filtered_pub_1.publish(laser_filtered_object)
elif pub_num == '2':
self.laser_filtered_pub_2.publish(laser_filtered_object)
elif pub_num == '3':
self.laser_filtered_pub_3.publish(laser_filtered_object)
def get_distance_from_desired_point_1(self, current_position):
"""
Calculates the distance from the current position to the desired point
:param start_point:
:return:
"""
distance = self.get_distance_from_point(current_position,
self.marobot1_desired_point)
return distance
def get_distance_from_desired_point_2(self, current_position):
"""
Calculates the distance from the current position to the desired point
:param start_point:
:return:
"""
distance = self.get_distance_from_point(current_position,
self.marobot2_desired_point)
return distance
def get_distance_from_desired_point_3(self, current_position):
"""
Calculates the distance from the current position to the desired point
:param start_point:
:return:
"""
distance = self.get_distance_from_point(current_position,
self.marobot3_desired_point)
return distance
def get_distance_from_point(self, pstart, p_end):
"""
Given a Vector3 Object, get distance from current position
:param p_end:
:return:
"""
a = numpy.array((float(pstart.x), float(pstart.y), float(pstart.z)))
b = numpy.array((float(p_end.x), float(p_end.y), float(p_end.z)))
distance = numpy.linalg.norm(a - b)
return distance
def is_in_desired_position(self, desired_point, current_position, epsilon=0.2):
"""
It return True if the current position is similar to the desired poistion
"""
is_in_desired_pos = False
x_pos_plus = desired_point.x + epsilon
x_pos_minus = desired_point.x - epsilon
y_pos_plus = desired_point.y + epsilon
y_pos_minus = desired_point.y - epsilon
x_current = current_position.x
y_current = current_position.y
x_pos_are_close = (x_current <= x_pos_plus) and (x_current > x_pos_minus)
y_pos_are_close = (y_current <= y_pos_plus) and (y_current > y_pos_minus)
is_in_desired_pos = x_pos_are_close and y_pos_are_close
return is_in_desired_pos
def is_in_obstacle_position(self, obstacle_point, current_position, inflation=0.3):
"""
It return True if the current position is similar to the obstacle poistion
"""
is_in_obstacle_pos = False
x_pos_plus = obstacle_point.x + inflation
x_pos_minus = obstacle_point.x - inflation
y_pos_plus = obstacle_point.y + inflation
y_pos_minus = obstacle_point.y - inflation
x_current = current_position.x
y_current = current_position.y
x_pos_are_close = (x_current <= x_pos_plus) and (x_current > x_pos_minus)
y_pos_are_close = (y_current <= y_pos_plus) and (y_current > y_pos_minus)
is_in_obstacle_pos = x_pos_are_close and y_pos_are_close
print('is_in_obstacle_pos is :>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>',is_in_obstacle_pos)
return is_in_obstacle_pos
| [] |
2024-01-10 | JunfengChen-robotics/MultiRoboLearn | algorithms~algorithms_example~scripts~multi-dqn~agents_landmarks_multiagent.py | #!/usr/bin/env python
import rospy
# from gym import spaces
import gym
import time
# import qlearn
from gym import wrappers
# ROS packages required
import rospy
import rospkg
# import our training environment
from openai_ros.robot_envs import multiagent_turtlebot2_env
from openai_ros.task_envs.turtlebot2 import multiagent_turtlebot2_goal
from geometry_msgs.msg import Point
import numpy as np
import os
import random
import argparse
import pandas as pd
# from environments.agents_landmarks.env import agentslandmarks
from dqn_agent import Agent
import glob
ARG_LIST = ['learning_rate', 'optimizer', 'memory_capacity', 'batch_size', 'target_frequency', 'maximum_exploration',
'max_timestep', 'first_step_memory', 'replay_steps', 'number_nodes', 'target_type', 'memory',
'prioritization_scale', 'dueling', 'agents_number']
def is_in_desired_position(desired_point, current_position, epsilon=0.2):
"""
It return True if the current position is similar to the desired poistion
"""
is_in_desired_pos = False
x_pos_plus = desired_point.x + epsilon
x_pos_minus = desired_point.x - epsilon
y_pos_plus = desired_point.y + epsilon
y_pos_minus = desired_point.y - epsilon
x_current = current_position.x
y_current = current_position.y
x_pos_are_close = (x_current <= x_pos_plus) and (x_current > x_pos_minus)
y_pos_are_close = (y_current <= y_pos_plus) and (y_current > y_pos_minus)
is_in_desired_pos = x_pos_are_close and y_pos_are_close
return is_in_desired_pos
def get_name_brain(args, idx):
file_name_str = '_'.join([x for x in args])
return '/home/guoxiyue/cjf/results_agents_landmarks/weights_files/' + file_name_str + '_' + str(idx) + '.h5'
def get_name_rewards(args):
file_name_str = '_'.join([x for x in ARG_LIST])
return '/home/guoxiyue/cjf/results_agents_landmarks/rewards_files/' + file_name_str + '.csv'
def get_name_timesteps(args):
file_name_str = '_'.join([x for x in ARG_LIST])
return '/home/guoxiyue/cjf/results_agents_landmarks/timesteps_files/' + file_name_str + '.csv'
def get_name_successrate(args):
file_name_str = '_'.join([x for x in ARG_LIST])
return '/home/guoxiyue/cjf/results_agents_landmarks/successrate_files/' + file_name_str + '.csv'
def run(agents, file1, file2, file3, filling_steps, episodes_number, max_random_moves, max_ts, steps_b_updates, marobot1_desired_point, marobot2_desired_point, marobot3_desired_point,test):
total_step = 0
rewards_list = []
timesteps_list = []
success_list = []
max_score = [-10000,-10000,-10000]
# test = False
for episode_num in range(episodes_number):
state = env.reset()
random_moves = random.randint(0, max_random_moves)
# print("initial state is:", state)
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print("epsiode number is:", episode_num)
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
# create randomness in initial state
# for _ in range(random_moves):
# actions = [_ for _ in range(len(agents))]
# actions = [int(env.action_space.sample())]
# print("env action is:", env.action_space.sample())
# add
# actions.append(4)
# actions.append(4)
# state, _, _, info = env.step(actions)
# converting list of positions to an array
# for a series of data transformation, transfer multi list to single list
# state includes three parts: position and laser and position vector
position_vector_1 = [state[0][0][0] - marobot1_desired_point.x, state[0][0][1] - marobot1_desired_point.y]
position_vector_2 = [state[1][0][0] - marobot2_desired_point.x, state[1][0][1] - marobot2_desired_point.y]
position_vector_3 = [state[2][0][0] - marobot3_desired_point.x, state[2][0][1] - marobot3_desired_point.y]
# state = state[0][0]+state[0][1]+state[1][0]+state[1][1]+state[2][0]+state[2][1]+position_vector_1+position_vector_2+position_vector_3
# for each agent, every agent's state is:
## state_1 = state[0][0]+state[0][1]+state[1][0]+state[1][1]+state[2][0]+state[2][1]+position_vector_1
## state_2 = state[0][0]+state[0][1]+state[1][0]+state[1][1]+state[2][0]+state[2][1]+position_vector_2
## state_3 = state[0][0]+state[0][1]+state[1][0]+state[1][1]+state[2][0]+state[2][1]+position_vector_3
# state_1 = state[0][0]+state[0][1]+position_vector_1
# state_2 = state[1][0]+state[1][1]+position_vector_2
# state_3 = state[2][0]+state[2][1]+position_vector_3
state_1 = state[0][0]+state[0][1]
state_2 = state[1][0]+state[1][1]
state_3 = state[2][0]+state[2][1]
# print("state type is:",type(state))
# print("state lenth is:",len(state))
# print("state is:",state)
# state type transfer into the certain type can be recognized by the algorithms
# ######state = np.asarray(state).astype(np.float32) delete
# state = np.asarray(state)
# state = state.ravel()
state_1 = np.asarray(state_1)
state_1 = state_1.ravel()
state_2 = np.asarray(state_2)
state_2 = state_2.ravel()
state_3 = np.asarray(state_3)
state_3 = state_3.ravel()
state_all = [state_1, state_2, state_3]
# print("state type is:", type(state))
# print("Initial state is:", state)
# print("State shape is:", len(state))
# print("Convert numpy to list is:", state.tolist())
# print("Episode_num is:", episode_num)
dones = False # refer to all the robots reach the desired points and whether end given episode
# reward_all = 0
reward_all = [0, 0, 0]
time_step = 0
done = [False, False, False]
sub_episode_done = []
if_done_index = [False, False, False]
# label means the dones is whether first or not
if_done_label = [0, 0, 0]
while not dones and time_step < max_ts:
# if self.render:
# self.env.render()
print("time step number is:", time_step)
actions = []
i = -1
for agent in agents:
# actions.append(agent.greedy_actor(state))
i = i + 1
actions.append(agent.greedy_actor(state_all[i]))
# add
# actions.append(4)
# actions.append(4)
# decide each agent whether done, decide whether stop training
# index = [i for i in range(len(done)) if done[i] == True]
print("done len is :", done)
index = [i for i in range(len(done)) if done[i] == True]
for i in index:
actions[i] = 4
print("acations are:", actions)
import pdb
next_state, reward, done, info = env.step(actions)
# print("next_state is:", next_state)
print("reward is:", reward)
# pdb.set_trace()
# print("next_state is:", next_state)
# dones = done[0] and done[1] and done[2]
# if time_step >= 99:
# done = [False, False, False]
print("done are:", done)
# pdb.set_trace()
# try:
# dones = done[0] and done[1] and done[2]
# print("Env done are:", done)
# except:
# # dones = step_done
# # print("Env done are:", step_done)
# # print("exception number is:", time_step)
# pass
# if (time_step == 99):
# done = [False, False, False]
dones = done[0] and done[1] and done[2]
# record current position so that they can decide whether reach desired position or done
current_position_marobot1 = next_state[0][0]
current_position_marobot2 = next_state[1][0]
current_position_marobot3 = next_state[2][0]
#state includes three parts: position and laser and position vector
position_vector_1 = [next_state[0][0][0] - marobot1_desired_point.x, next_state[0][0][1] - marobot1_desired_point.y]
position_vector_2 = [next_state[1][0][0] - marobot2_desired_point.x, next_state[1][0][1] - marobot2_desired_point.y]
position_vector_3 = [next_state[2][0][0] - marobot3_desired_point.x, next_state[2][0][1] - marobot3_desired_point.y]
# next_state = next_state[0][0] + next_state[0][1] + next_state[1][0] + next_state[1][1] + next_state[2][0] + next_state[2][1] + position_vector_1 + position_vector_2 + position_vector_3
# converting list of positions to an array
# next_state = next_state[0][0] + next_state[0][1] + next_state[1][0] + next_state[1][1] + next_state[2][0] + next_state[2][1]
# #####next_state = np.asarray(next_state).astype(np.float32)
# next_state = np.asarray(next_state)
# next_state = next_state.ravel()
# next_state_1 = next_state[0][0] + next_state[0][1] + next_state[1][0] + next_state[1][1] + next_state[2][0] + next_state[2][1] + position_vector_1
# next_state_2 = next_state[0][0] + next_state[0][1] + next_state[1][0] + next_state[1][1] + next_state[2][0] + next_state[2][1] + position_vector_2
# next_state_3 = next_state[0][0] + next_state[0][1] + next_state[1][0] + next_state[1][1] + next_state[2][0] + next_state[2][1] + position_vector_3
# next_state_1 = next_state[0][0] + next_state[0][1] + position_vector_1
# next_state_2 = next_state[1][0] + next_state[1][1] + position_vector_2
# next_state_3 = next_state[2][0] + next_state[2][1] + position_vector_3
#
#
next_state_1 = next_state[0][0] + next_state[0][1]
next_state_2 = next_state[1][0] + next_state[1][1]
next_state_3 = next_state[2][0] + next_state[2][1]
next_state_1 = np.asarray(next_state_1)
next_state_1 = next_state_1.ravel()
next_state_2 = np.asarray(next_state_2)
next_state_2 = next_state_2.ravel()
next_state_3 = np.asarray(next_state_3)
next_state_3 = next_state_3.ravel()
next_state_all = [next_state_1, next_state_2, next_state_3]
# print("next_state is:", next_state)
# if not test:
# for agent in agents:
# agent.observe((state, actions, reward, next_state, dones))
# if total_step >= filling_steps:
# agent.decay_epsilon()
# if time_step % steps_b_updates == 0:
# agent.replay()
# agent.update_target_model()
if not test:
print("total_step is:",total_step)
print("filling_steps is",filling_steps)
for i, agent in enumerate(agents):
# action = actions[i]
state = state_all[i]
next_state = next_state_all[i]
if done[i] is True and if_done_index[i] is False:
if_done_index[i] = True
if_done_label[i] = time_step
agent.observe((state, actions[i], reward[i], next_state, done[i]))
# agent.observe((state, action, reward[i], next_state, done[i]))
# if done[i] is True and if_done_index[i] is False:
# if done[i] is True and if_done_index[i] is False:
# if_done_index[i] = True
# # print("if_done_index",if_done_index[i] )
# agent.observe((state, actions, reward[i], next_state, done[i]))
# elif if_done_index[i] is False:
# agent.observe((state, actions, reward[i], next_state, done[i]))
# agent.observe((state, actions, reward[i], next_state, done[i]))
if total_step >= filling_steps:
agent.decay_epsilon()
if time_step % steps_b_updates == 0:
agent.replay()
agent.update_target_model()
elif if_done_index[i] is False:
agent.observe((state, actions[i], reward[i], next_state, done[i]))
if total_step >= filling_steps:
agent.decay_epsilon()
if time_step % steps_b_updates == 0:
agent.replay()
agent.update_target_model()
for i, agent in enumerate(agents):
if if_done_index[i] is True and time_step>if_done_label[i]:
reward[i] = 0
total_step += 1
time_step += 1
# state = next_state
state_1 = next_state_1
state_2 = next_state_2
state_3 = next_state_3
state_all = [state_1, state_2, state_3]
# reward_all += reward
# reward_all = sum(reward) + reward_all
# reward_all_np = np.array(reward_all)
reward_all_np = np.add(np.array(reward_all),np.array(reward))
reward_all = reward_all_np.tolist()
else:
total_step += 1
time_step += 1
# state = next_state
state_1 = next_state_1
state_2 = next_state_2
state_3 = next_state_3
state_all = [state_1, state_2, state_3]
# state_all_tensor = [torch.Tensor(state_1), torch.Tensor(state_2), torch.Tensor(state_3)]
# reward_all += reward
# reward_all = sum(reward) + reward_all
# in each episode, we will decide if each agent reach desired point and calculate success rate
if dones == True or time_step >= max_ts:
current_position_1 = Point()
current_position_2 = Point()
current_position_3 = Point()
# for marobot1:
current_position_1.x = current_position_marobot1[0]
current_position_1.y = current_position_marobot1[1]
current_position_1.z = 0.0
# for marobot2:
current_position_2.x = current_position_marobot2[0]
current_position_2.y = current_position_marobot2[1]
current_position_2.z = 0.0
# for marobot3:
current_position_3.x = current_position_marobot3[0]
current_position_3.y = current_position_marobot3[1]
current_position_3.z = 0.0
# MAX_X = 10.0
# MIN_X = -10.0
# MAX_Y = 10.0
# MIN_Y = -10.0
desired_current_position = {str(current_position_1): marobot1_desired_point,
str(current_position_2): marobot2_desired_point,
str(current_position_3): marobot3_desired_point}
_episode_done = False
for current_position in [current_position_1, current_position_2, current_position_3]:
# We see if it got to the desired point
if is_in_desired_position(desired_current_position[str(current_position)],
current_position):
_episode_done = True
else:
_episode_done = False
# sub_episode_done = sub_episode_done.append(self._episode_done)
sub_episode_done.append(_episode_done)
_episode_dones = sub_episode_done[:]
# if self.render:
# self.env.render()
rewards_list.append(reward_all)
timesteps_list.append(time_step)
# print("episode_num is", episode_num)
# print("reward all is", rewards_list)
# we can calculate success rate whether each agent reach desired point
success_percent = round(_episode_dones.count(True)/3.0,2)
success_list.append(success_percent)
print("Episode {p}, Score: {s}, Final Step: {t}, Goal: {g}".format(p=episode_num, s=reward_all,
t=time_step, g=(_episode_dones[0] and _episode_dones[1] and _episode_dones[2])))
# if self.recorder:
# os.system("ffmpeg -r 2 -i ./results_agents_landmarks/snaps/%04d.png -b:v 40000 -minrate 40000 -maxrate 4000k -bufsize 1835k -c:v mjpeg -qscale:v 0 "
# + "./results_agents_landmarks/videos/{a1}_{a2}_{a3}_{a4}.avi".format(a1=self.num_agents,
# a2=self.num_landmarks,
# a3=self.game_mode,
# a4=self.grid_size))
# files = glob.glob('./results_agents_landmarks/snaps/*')
# for f in files:
# os.remove(f)
# if not test:
if episode_num % 1 == 0:
df_1 = pd.DataFrame(rewards_list, columns=['score-1','score-2','score-3'])
df_1.to_csv(file1)
df_2 = pd.DataFrame(timesteps_list, columns=['steps'])
df_2.to_csv(file2)
# record success rate
df_3 = pd.DataFrame(success_list, columns=['success_rate'])
df_3.to_csv(file3)
if total_step >= filling_steps:
for i, agent in enumerate(agents):
if reward_all[i] > max_score[i]:
# for agent in agents:
agent.brain.save_model()
max_score[i] = reward_all[i]
if __name__ =="__main__":
rospy.init_node('agents_landmarks_multiagent', anonymous=True, log_level=rospy.WARN)
# parser = argparse.ArgumentParser()
# DQN Parameters
episodes_number = rospy.get_param("/turtlebot2/episode_number")
max_ts = rospy.get_param("/turtlebot2/max_timestep")
test = rospy.get_param("/turtlebot2/test")
filling_steps = rospy.get_param("/turtlebot2/first_step_memory")
steps_b_updates = rospy.get_param("/turtlebot2/replay_steps")
max_random_moves = rospy.get_param("/turtlebot2/max_random_moves")
num_agents = rospy.get_param("/turtlebot2/agents_number")
dueling = rospy.get_param("/turtlebot2/dueling")
os.environ['CUDA_VISIBLE_DEVICES'] = rospy.get_param("/turtlebot2/gpu_num")
# DQN agent parameters(learning_rate,memory,memory_capacity,prioritization_scale,
# target_type,target_frequency,maximum_exploration,batch_size,test)
learning_rate = rospy.get_param("/turtlebot2/learning_rate")
memory = rospy.get_param("/turtlebot2/memory")
memory_capacity = rospy.get_param("/turtlebot2/memory_capacity")
prioritization_scale = rospy.get_param("/turtlebot2/prioritization_scale")
target_type = rospy.get_param("/turtlebot2/target_type")
target_frequency = rospy.get_param("/turtlebot2/target_frequency")
maximum_exploration = rospy.get_param("/turtlebot2/maximum_exploration")
batch_size = rospy.get_param("/turtlebot2/batch_size")
number_nodes = rospy.get_param("/turtlebot2/number_nodes")
dueling = rospy.get_param("/turtlebot2/dueling")
optimizer = rospy.get_param("/turtlebot2/optimizer")
# self.test = rospy.get_param("/turtlebot2/test")
# env = Environment(args)
env = gym.make("MultiagentTurtleBot2-v0")
rospy.loginfo("Gym environment done")
state_size = rospy.get_param("/turtlebot2/n_observations")
# action_space = env.env.action_space()
action_space = rospy.get_param("/turtlebot2/n_actions")
test = rospy.get_param("/turtlebot2/test")
marobot1_desired_point = Point()
marobot1_desired_point.x = rospy.get_param("/turtlebot2/marobot1/desired_pose/x")
marobot1_desired_point.y = rospy.get_param("/turtlebot2/marobot1/desired_pose/y")
marobot1_desired_point.z = rospy.get_param("/turtlebot2/marobot1/desired_pose/z")
marobot2_desired_point = Point()
marobot2_desired_point.x = rospy.get_param("/turtlebot2/marobot2/desired_pose/x")
marobot2_desired_point.y = rospy.get_param("/turtlebot2/marobot2/desired_pose/y")
marobot2_desired_point.z = rospy.get_param("/turtlebot2/marobot2/desired_pose/z")
marobot3_desired_point = Point()
marobot3_desired_point.x = rospy.get_param("/turtlebot2/marobot3/desired_pose/x")
marobot3_desired_point.y = rospy.get_param("/turtlebot2/marobot3/desired_pose/y")
marobot3_desired_point.z = rospy.get_param("/turtlebot2/marobot3/desired_pose/z")
# Starts the main training loop: the one about the episodes to do;
# in the main loop, next_state, state, reward, actions are "list" type
all_agents = []
for b_idx in range(num_agents):
brain_file = get_name_brain(ARG_LIST, b_idx)
all_agents.append(Agent(state_size, action_space, b_idx, brain_file, learning_rate, memory,
memory_capacity, prioritization_scale, target_type, target_frequency,
maximum_exploration, batch_size, test, number_nodes, dueling, optimizer))
rewards_file = get_name_rewards(ARG_LIST)
timesteps_file = get_name_timesteps(ARG_LIST)
successrate_file = get_name_successrate(ARG_LIST)
run(agents=all_agents, file1=rewards_file, file2=timesteps_file, file3=successrate_file, filling_steps=filling_steps, episodes_number=episodes_number,
max_random_moves=max_random_moves, max_ts=max_ts, steps_b_updates=steps_b_updates, marobot1_desired_point=marobot1_desired_point, marobot2_desired_point=marobot2_desired_point, marobot3_desired_point=marobot3_desired_point, test=test)
| [] |
2024-01-10 | JunfengChen-robotics/MultiRoboLearn | MultiRoboLearn~MultiRoboLearn~src~MultiRoboLearn~robot_envs~multiagent_spark_env.py | import numpy
import rospy
import time
from openai_ros import robot_gazebo_env
from std_msgs.msg import Float64
from sensor_msgs.msg import JointState
from sensor_msgs.msg import Image
from sensor_msgs.msg import LaserScan
from sensor_msgs.msg import PointCloud2
from nav_msgs.msg import Odometry
from geometry_msgs.msg import Twist
class MultiagentTurtleBot2Env(robot_gazebo_env.RobotGazeboEnv):
"""Superclass for all CubeSingleDisk environments.
"""
def __init__(self):
"""
Initializes a new multi-TurtleBot2Env environment.
Turtlebot2 doesnt use controller_manager, therefore we wont reset the
controllers in the standard fashion. For the moment we wont reset them.
To check any topic we need to have the simulations running, we need to do two things:
1) Unpause the simulation: without that th stream of data doesnt flow. This is for simulations
that are pause for whatever the reason
2) If the simulation was running already for some reason, we need to reset the controlers.
This has to do with the fact that some plugins with tf, dont understand the reset of the simulation
and need to be reseted to work properly.
The Sensors: The sensors accesible are the ones considered usefull for AI learning.
Sensor Topic List:
* /odom : Odometry readings of the Base of the Robot
* /camera/depth/image_raw: 2d Depth image of the depth sensor.
* /camera/depth/points: Pointcloud sensor readings
* /camera/rgb/image_raw: RGB camera
* /kobuki/laser/scan: Laser Readings
Actuators Topic List: /cmd_vel,
Args:
"""
rospy.logdebug("Start TurtleBot2Env INIT...")
# Variables that we give through the constructor.
# None in this case
# Internal Vars
# Doesnt have any accesibles
self.controllers_list = []
# It doesnt use namespace
self.robot_name_space = ""
# We launch the init function of the Parent Class robot_gazebo_env.RobotGazeboEnv
super(MultiagentTurtleBot2Env, self).__init__(controllers_list=self.controllers_list,
robot_name_space=self.robot_name_space,
reset_controls=False,
start_init_physics_parameters=False,
reset_world_or_sim="WORLD")
self.gazebo.unpauseSim()
#self.controllers_object.reset_controllers()
self._check_all_sensors_ready()
# We Start all the ROS related Subscribers and publishers
# rospy.Subscriber("/odom", Odometry, self._odom_callback)
rospy.Subscriber("marobot1/odom", Odometry, self._odom_callback_marobot1)
rospy.Subscriber("marobot2/odom", Odometry, self._odom_callback_marobot2)
rospy.Subscriber("marobot3/odom", Odometry, self._odom_callback_marobot3)
rospy.Subscriber("odom_data_3", Odometry, self._odom_callback_spark1)
rospy.Subscriber("odom_data_4", Odometry, self._odom_callback_spark2)
rospy.Subscriber("odom_data_5", Odometry, self._odom_callback_spark3)
#rospy.Subscriber("/camera/depth/image_raw", Image, self._camera_depth_image_raw_callback)
#rospy.Subscriber("/camera/depth/points", PointCloud2, self._camera_depth_points_callback)
#rospy.Subscriber("/camera/rgb/image_raw", Image, self._camera_rgb_image_raw_callback)
# rospy.Subscriber("/kobuki/laser/scan", LaserScan, self._laser_scan_callback)
# rospy.Subscriber("marobot1/kobuki/laser/scan", LaserScan, self._laser_scan_callback_marobot1)
rospy.Subscriber("marobot1/laser/scan", LaserScan, self._laser_scan_callback_marobot1)
rospy.Subscriber("marobot2/laser/scan", LaserScan, self._laser_scan_callback_marobot2)
rospy.Subscriber("marobot3/laser/scan", LaserScan, self._laser_scan_callback_marobot3)
rospy.Subscriber("laser_data_3", LaserScan, self._laser_scan_callback_spark1)
rospy.Subscriber("laser_data_4", LaserScan, self._laser_scan_callback_spark2)
rospy.Subscriber("laser_data_5", LaserScan, self._laser_scan_callback_spark3)
# self._cmd_vel_pub = rospy.Publisher('/cmd_vel', Twist, queue_size=1)
self._cmd_vel_pub_marobot1 = rospy.Publisher('marobot1/cmd_vel', Twist, queue_size=10)
self._cmd_vel_pub_marobot2= rospy.Publisher('marobot2/cmd_vel', Twist, queue_size=10)
self._cmd_vel_pub_marobot3= rospy.Publisher('marobot3/cmd_vel', Twist, queue_size=10)
self._cmd_vel_pub_spark1 = rospy.Publisher('spark3/cmd_vel_3', Twist, queue_size=1)
self._cmd_vel_pub_spark2 = rospy.Publisher('spark4/cmd_vel_4', Twist, queue_size=1)
self._cmd_vel_pub_spark3 = rospy.Publisher('spark5/cmd_vel_5', Twist, queue_size=1)
self._check_publishers_connection_1()
self._check_publishers_connection_2()
self._check_publishers_connection_3()
self.gazebo.pauseSim()
rospy.logdebug("Finished TurtleBot2Env INIT...")
# Methods needed by the RobotGazeboEnv
# ----------------------------
def _check_all_systems_ready(self):
"""
Checks that all the sensors, publishers and other simulation systems are
operational.
"""
self._check_all_sensors_ready()
return True
# CubeSingleDiskEnv virtual methods
# ----------------------------
def _check_all_sensors_ready(self):
rospy.logdebug("START ALL SENSORS READY")
self._check_odom_ready()
# We dont need to check for the moment, takes too long
#self._check_camera_depth_image_raw_ready()
#self._check_camera_depth_points_ready()
#self._check_camera_rgb_image_raw_ready()
self._check_laser_scan_ready()
rospy.logdebug("ALL SENSORS READY")
def _check_odom_ready(self):
self.odom_marobot1 = None
self.odom_marobot2 = None
self.odom_marobot3 = None
#add
self.odom_spark1 = None
self.odom_spark2 = None
self.odom_spark3 = None
rospy.logdebug("Waiting for /odom to be READY...")
while self.odom_marobot1 is None and self.odom_marobot2 is None and self.odom_marobot3 is None and not rospy.is_shutdown():
try:
# self.odom = rospy.wait_for_message("/odom", Odometry, timeout=5.0)
self.odom_marobot1 = rospy.wait_for_message("marobot1/odom", Odometry, timeout=5.0)
self.odom_marobot2 = rospy.wait_for_message("marobot2/odom", Odometry, timeout=5.0)
self.odom_marobot3 = rospy.wait_for_message("marobot3/odom", Odometry, timeout=5.0)
# self.odom_spark1 = rospy.wait_for_message("spark3/odom", Odometry, timeout=5.0)
# self.odom_spark2 = rospy.wait_for_message("spark4/odom", Odometry, timeout=5.0)
# self.odom_spark3 = rospy.wait_for_message("spark5/odom", Odometry, timeout=5.0)
rospy.logdebug("Current /odom READY=>")
except:
rospy.logerr("Current /odom not ready yet, retrying for getting odom")
# return self.odom
return [self.odom_marobot1, self.odom_marobot2, self.odom_marobot3]
# def _check_camera_depth_image_raw_ready(self):
# self.camera_depth_image_raw = None
# rospy.logdebug("Waiting for /camera/depth/image_raw to be READY...")
# while self.camera_depth_image_raw is None and not rospy.is_shutdown():
# try:
# self.camera_depth_image_raw = rospy.wait_for_message("/camera/depth/image_raw", Image, timeout=5.0)
# rospy.logdebug("Current /camera/depth/image_raw READY=>")
#
# except:
# rospy.logerr("Current /camera/depth/image_raw not ready yet, retrying for getting camera_depth_image_raw")
# return self.camera_depth_image_raw
# def _check_camera_depth_points_ready(self):
# self.camera_depth_points = None
# rospy.logdebug("Waiting for /camera/depth/points to be READY...")
# while self.camera_depth_points is None and not rospy.is_shutdown():
# try:
# self.camera_depth_points = rospy.wait_for_message("/camera/depth/points", PointCloud2, timeout=10.0)
# rospy.logdebug("Current /camera/depth/points READY=>")
#
# except:
# rospy.logerr("Current /camera/depth/points not ready yet, retrying for getting camera_depth_points")
# return self.camera_depth_points
# def _check_camera_rgb_image_raw_ready(self):
# self.camera_rgb_image_raw = None
# rospy.logdebug("Waiting for /camera/rgb/image_raw to be READY...")
# while self.camera_rgb_image_raw is None and not rospy.is_shutdown():
# try:
# self.camera_rgb_image_raw = rospy.wait_for_message("/camera/rgb/image_raw", Image, timeout=5.0)
# rospy.logdebug("Current /camera/rgb/image_raw READY=>")
#
# except:
# rospy.logerr("Current /camera/rgb/image_raw not ready yet, retrying for getting camera_rgb_image_raw")
# return self.camera_rgb_image_raw
def _check_laser_scan_ready(self):
# self.laser_scan_maro = None
self.laser_scan_marobot1 = None
self.laser_scan_marobot2 = None
self.laser_scan_marobot3 = None
self.laser_scan_spark1 = None
self.laser_scan_spark2 = None
self.laser_scan_spark3 = None
rospy.logdebug("Waiting for /kobuki/laser/scan to be READY...")
# while self.laser_scan is None and not rospy.is_shutdown():
while self.laser_scan_marobot1 is None and self.laser_scan_marobot2 is None and self.laser_scan_marobot3 is None and not rospy.is_shutdown():
try:
# self.laser_scan = rospy.wait_for_message("/kobuki/laser/scan", LaserScan, timeout=5.0)
# self.laser_scan_marobot1 = rospy.wait_for_message("marobot1/kobuki/laser/scan", LaserScan, timeout=5.0)
self.laser_scan_marobot1 = rospy.wait_for_message("marobot1/laser/scan", LaserScan, timeout=5.0)
self.laser_scan_marobot2 = rospy.wait_for_message("marobot2/laser/scan", LaserScan, timeout=5.0)
self.laser_scan_marobot3 = rospy.wait_for_message("marobot3/laser/scan", LaserScan, timeout=5.0)
# self.laser_scan_marobot1 = rospy.wait_for_message("spark3/scan", LaserScan, timeout=5.0)
# self.laser_scan_marobot2 = rospy.wait_for_message("spark4/scan", LaserScan, timeout=5.0)
# self.laser_scan_marobot3 = rospy.wait_for_message("spark5/scan", LaserScan, timeout=5.0)
rospy.logdebug("Current /kobuki/laser/scan READY=>")
except:
# rospy.logerr("Current /kobuki/laser/scan not ready yet, retrying for getting laser_scan")
rospy.logerr("Current /kobuki/laser/scan not ready yet, retrying for getting laser_scan")
# return self.laser_scan
return [self.laser_scan_marobot1, self.laser_scan_marobot2, self.laser_scan_marobot3]
# def _odom_callback(self, data):
# self.odom = data
def _odom_callback_marobot1(self, data):
self.odom_marobot1 = data
def _odom_callback_marobot2(self, data):
self.odom_marobot2 = data
def _odom_callback_marobot3(self, data):
self.odom_marobot3 = data
def _odom_callback_spark1(self, data):
self.odom_spark1 = data
def _odom_callback_spark2(self, data):
self.odom_spark2 = data
def _odom_callback_spark3(self, data):
self.odom_spark3 = data
# def _odom_callback_spark1(self, data):
# self.odom_spark1 = data
#
# def _odom_callback_spark2(self, data):
# self.odom_spark2 = data
#
# def _odom_callback_spark3(self, data):
# self.odom_spark3 = data
# def _camera_depth_image_raw_callback(self, data):
# self.camera_depth_image_raw = data
#
# def _camera_depth_points_callback(self, data):
# self.camera_depth_points = data
#
# def _camera_rgb_image_raw_callback(self, data):
# self.camera_rgb_image_raw = data
# def _laser_scan_callback(self, data):
# self.laser_scan = data
def _laser_scan_callback_marobot1(self, data):
self.laser_scan_marobot1 = data
def _laser_scan_callback_marobot2(self, data):
self.laser_scan_marobot2 = data
def _laser_scan_callback_marobot3(self, data):
self.laser_scan_marobot3 = data
def _laser_scan_callback_spark1(self, data):
self.laser_scan_spark1 = data
def _laser_scan_callback_spark2(self, data):
self.laser_scan_spark2 = data
def _laser_scan_callback_spark3(self, data):
self.laser_scan_spark3 = data
def _check_publishers_connection_1(self):
"""
Checks that all the publishers are working
:return:
"""
rate = rospy.Rate(1000) # 10hz
# while self._cmd_vel_pub.get_num_connections() == 0 and not rospy.is_shutdown():
while self._cmd_vel_pub_marobot1.get_num_connections() == 0 and not rospy.is_shutdown():
rospy.logdebug("No susbribers to _cmd_vel_pub yet so we wait and try again")
try:
rate.sleep()
except rospy.ROSInterruptException:
# This is to avoid error when world is rested, time when backwards.
pass
rospy.logdebug("_cmd_vel_pub_marobot1 Publisher Connected")
rospy.logdebug("All Publishers READY")
def _check_publishers_connection_2(self):
"""
Checks that all the publishers are working
:return:
"""
rate = rospy.Rate(1000) # 10hz
# while self._cmd_vel_pub.get_num_connections() == 0 and not rospy.is_shutdown():
while self._cmd_vel_pub_marobot2.get_num_connections() == 0 and not rospy.is_shutdown():
rospy.logdebug("No susbribers to _cmd_vel_pub yet so we wait and try again")
try:
rate.sleep()
except rospy.ROSInterruptException:
# This is to avoid error when world is rested, time when backwards.
pass
rospy.logdebug("_cmd_vel_pub_marobot2 Publisher Connected")
rospy.logdebug("All Publishers READY")
def _check_publishers_connection_3(self):
"""
Checks that all the publishers are working
:return:
"""
rate = rospy.Rate(1000) # 10hz
# while self._cmd_vel_pub.get_num_connections() == 0 and not rospy.is_shutdown():
while self._cmd_vel_pub_marobot3.get_num_connections() == 0 and not rospy.is_shutdown():
rospy.logdebug("No susbribers to _cmd_vel_pub yet so we wait and try again")
try:
rate.sleep()
except rospy.ROSInterruptException:
# This is to avoid error when world is rested, time when backwards.
pass
rospy.logdebug("_cmd_vel_pub_marobot3 Publisher Connected")
rospy.logdebug("All Publishers READY")
# Methods that the TrainingEnvironment will need to define here as virtual
# because they will be used in RobotGazeboEnv GrandParentClass and defined in the
# TrainingEnvironment.
# ----------------------------
def _set_init_pose(self):
"""Sets the Robot in its init pose
"""
raise NotImplementedError()
def _init_env_variables(self):
"""Inits variables needed to be initialised each time we reset at the start
of an episode.
"""
raise NotImplementedError()
def _compute_reward(self, observations, done):
"""Calculates the reward to give based on the observations given.
"""
raise NotImplementedError()
def _set_action(self, action):
"""Applies the given action to the simulation.
"""
raise NotImplementedError()
def _get_obs(self):
raise NotImplementedError()
def _is_done(self, observations):
"""Checks if episode done based on observations given.
"""
raise NotImplementedError()
# Methods that the TrainingEnvironment will need.
# ----------------------------
def move_base_1(self, linear_speed, angular_speed, epsilon=0.05, update_rate=10, min_laser_distance=0.5):
"""
It will move the base based on the linear and angular speeds given.
It will wait untill those twists are achived reading from the odometry topic.
:param linear_speed: Speed in the X axis of the robot base frame
:param angular_speed: Speed of the angular turning of the robot base frame
:param epsilon: Acceptable difference between the speed asked and the odometry readings
:param update_rate: Rate at which we check the odometry.
:return:
"""
cmd_vel_value = Twist()
cmd_vel_value.linear.x = linear_speed
cmd_vel_value.angular.z = angular_speed
rospy.logdebug("TurtleBot2_marobot1 Base Twist Cmd>>" + str(cmd_vel_value))
self._check_publishers_connection_1()
# self._cmd_vel_pub.publish(cmd_vel_value)
self._cmd_vel_pub_marobot1.publish(cmd_vel_value)
self._cmd_vel_pub_spark1.publish(cmd_vel_value)
# self._cmd_vel_pub_marobot2.publish(cmd_vel_value)
# self._cmd_vel_pub_marobot3.publish(cmd_vel_value)
time.sleep(0.02)
# time.sleep(0.02)
#time.sleep(0.2)
"""
self.wait_until_twist_achieved(cmd_vel_value,
epsilon,
update_rate,
min_laser_distance)
"""
def move_base_2(self, linear_speed, angular_speed, epsilon=0.05, update_rate=10, min_laser_distance=0.5):
"""
It will move the base based on the linear and angular speeds given.
It will wait untill those twists are achived reading from the odometry topic.
:param linear_speed: Speed in the X axis of the robot base frame
:param angular_speed: Speed of the angular turning of the robot base frame
:param epsilon: Acceptable difference between the speed asked and the odometry readings
:param update_rate: Rate at which we check the odometry.
:return:
"""
cmd_vel_value = Twist()
cmd_vel_value.linear.x = linear_speed
cmd_vel_value.angular.z = angular_speed
rospy.logdebug("TurtleBot2 Base Twist Cmd>>" + str(cmd_vel_value))
self._check_publishers_connection_2()
# self._cmd_vel_pub.publish(cmd_vel_value)
# self._cmd_vel_pub_marobot1.publish(cmd_vel_value)
self._cmd_vel_pub_marobot2.publish(cmd_vel_value)
self._cmd_vel_pub_spark2.publish(cmd_vel_value)
# self._cmd_vel_pub_marobot3.publish(cmd_vel_value)
time.sleep(0.02)
# time.sleep(1)
# time.sleep(0.2)
"""
self.wait_until_twist_achieved(cmd_vel_value,
epsilon,
update_rate,
min_laser_distance)
"""
def move_base_3(self, linear_speed, angular_speed, epsilon=0.05, update_rate=10, min_laser_distance=0.5):
"""
It will move the base based on the linear and angular speeds given.
It will wait untill those twists are achived reading from the odometry topic.
:param linear_speed: Speed in the X axis of the robot base frame
:param angular_speed: Speed of the angular turning of the robot base frame
:param epsilon: Acceptable difference between the speed asked and the odometry readings
:param update_rate: Rate at which we check the odometry.
:return:
"""
cmd_vel_value = Twist()
cmd_vel_value.linear.x = linear_speed
cmd_vel_value.angular.z = angular_speed
rospy.logdebug("TurtleBot2 Base Twist Cmd>>" + str(cmd_vel_value))
self._check_publishers_connection_3()
# self._cmd_vel_pub.publish(cmd_vel_value)
# self._cmd_vel_pub_marobot1.publish(cmd_vel_value)
# self._cmd_vel_pub_marobot2.publish(cmd_vel_value)
self._cmd_vel_pub_marobot3.publish(cmd_vel_value)
self._cmd_vel_pub_spark3.publish(cmd_vel_value)
time.sleep(0.02)
# time.sleep(0.2)
# time.sleep(1)
"""
self.wait_until_twist_achieved(cmd_vel_value,
epsilon,
update_rate,
min_laser_distance)
"""
def wait_until_twist_achieved(self, cmd_vel_value, epsilon, update_rate, min_laser_distance=-1):
"""
We wait for the cmd_vel twist given to be reached by the robot reading
from the odometry.
:param cmd_vel_value: Twist we want to wait to reach.
:param epsilon: Error acceptable in odometry readings.
:param update_rate: Rate at which we check the odometry.
:return:
"""
rospy.logwarn("START wait_until_twist_achieved...")
rate = rospy.Rate(update_rate)
start_wait_time = rospy.get_rostime().to_sec()
end_wait_time = 0.0
epsilon = 0.05
rospy.logdebug("Desired Twist Cmd>>" + str(cmd_vel_value))
rospy.logdebug("epsilon>>" + str(epsilon))
linear_speed = cmd_vel_value.linear.x
angular_speed = cmd_vel_value.angular.z
linear_speed_plus = linear_speed + epsilon
linear_speed_minus = linear_speed - epsilon
angular_speed_plus = angular_speed + epsilon
angular_speed_minus = angular_speed - epsilon
while not rospy.is_shutdown():
crashed_into_something = self.has_crashed(min_laser_distance)
current_odometry = self._check_odom_ready()
odom_linear_vel = current_odometry.twist.twist.linear.x
odom_angular_vel = current_odometry.twist.twist.angular.z
rospy.logdebug("Linear VEL=" + str(odom_linear_vel) + ", ?RANGE=[" + str(linear_speed_minus) + ","+str(linear_speed_plus)+"]")
rospy.logdebug("Angular VEL=" + str(odom_angular_vel) + ", ?RANGE=[" + str(angular_speed_minus) + ","+str(angular_speed_plus)+"]")
linear_vel_are_close = (odom_linear_vel <= linear_speed_plus) and (odom_linear_vel > linear_speed_minus)
angular_vel_are_close = (odom_angular_vel <= angular_speed_plus) and (odom_angular_vel > angular_speed_minus)
if linear_vel_are_close and angular_vel_are_close:
rospy.logwarn("Reached Velocity!")
end_wait_time = rospy.get_rostime().to_sec()
break
if crashed_into_something:
rospy.logerr("TurtleBot has crashed, stopping movement!")
break
rospy.logwarn("Not there yet, keep waiting...")
rate.sleep()
delta_time = end_wait_time- start_wait_time
rospy.logdebug("[Wait Time=" + str(delta_time)+"]")
rospy.logwarn("END wait_until_twist_achieved...")
return delta_time
# def has_crashed(self, min_laser_distance):
# """
# It states based on the laser scan if the robot has crashed or not.
# Crashed means that the minimum laser reading is lower than the
# min_laser_distance value given.
# If min_laser_distance == -1, it returns always false, because its the way
# to deactivate this check.
# """
# robot_has_crashed = False
#
# if min_laser_distance != -1:
# laser_data = self.get_laser_scan()
# for i, item in enumerate(laser_data.ranges):
# if item == float ('Inf') or numpy.isinf(item):
# pass
# elif numpy.isnan(item):
# pass
# else:
# # Has a Non Infinite or Nan Value
# if (item < min_laser_distance):
# rospy.logerr("TurtleBot HAS CRASHED >>> item=" + str(item)+"< "+str(min_laser_distance))
# robot_has_crashed = True
# break
# return robot_has_crashed
def has_crashed(self, min_laser_distance, laser_data, agent_num):
"""
It states based on the laser scan if the robot has crashed or not.
Crashed means that the minimum laser reading is lower than the
min_laser_distance value given.
If min_laser_distance == -1, it returns always false, because its the way
to deactivate this check.
"""
robot_has_crashed = False
if min_laser_distance != -1:
# for i, item in enumerate(laser_data.ranges):
for i, item in enumerate(laser_data):
if item == float('Inf') or numpy.isinf(item):
pass
elif numpy.isnan(item):
pass
else:
# Has a Non Infinite or Nan Value
if (item <= min_laser_distance):
rospy.logerr("Crashed agent number is"+agent_num+"And"+"TurtleBot HAS CRASHED >>> item=" + str(item) + "< " + str(min_laser_distance))
robot_has_crashed = True
break
return robot_has_crashed
def get_odom(self):
return [self.odom_marobot1, self.odom_marobot2, self.odom_marobot3]
def get_odom_spark(self):
return [self.odom_spark1, self.odom_spark2, self.odom_spark3]
# def get_camera_depth_image_raw(self):
# return self.camera_depth_image_raw
#
# def get_camera_depth_points(self):
# return self.camera_depth_points
#
# def get_camera_rgb_image_raw(self):
# return self.camera_rgb_image_raw
def get_laser_scan(self):
# return self.laser_scan
return [self.laser_scan_marobot1, self.laser_scan_marobot2, self.laser_scan_marobot3]
def get_laser_scan_spark(self):
# return self.laser_scan
return [self.laser_scan_spark1, self.laser_scan_spark2, self.laser_scan_spark3]
def reinit_sensors(self):
"""
This method is for the tasks so that when reseting the episode
the sensors values are forced to be updated with the real data and
"""
| [] |
2024-01-10 | JunfengChen-robotics/MultiRoboLearn | algorithms~algorithms_example~scripts~multi-sac~sac_training_continous_V1.py | #!/usr/bin/env python
import argparse, math, os
import rospy
# from gym import spaces
import gym
import time
from gym import wrappers
# ROS packages required
import rospy
import rospkg
# import our training environment
from openai_ros.robot_envs import multiagent_turtlebot2_env
from openai_ros.task_envs.turtlebot2 import continous_multiagent_turtlebot2_goal
from geometry_msgs.msg import Point
#import algorithms environment
import numpy as np
import os
import random
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.distributions import Normal
from tensorboardX import SummaryWriter
from collections import namedtuple
from itertools import count
# from environments.agents_landmarks.env import agentslandmarks
import glob
from SAC_DUAL_Q_net import SAC
ARG_LIST = ['tau', 'target_update_interval', 'gradient_steps', 'learning_rate', 'gamma', 'capacity',
'iteration', 'batch_size', 'seed', 'num_hidden_units_per_layer', 'num_hidden_layers', 'activation', 'sample_frequency']
class NormalizedActions(gym.ActionWrapper):
def _action(self, action):
low = self.action_space.low
high = self.action_space.high
action = low + (action + 1.0) * 0.5 * (high - low)
action = np.clip(action, low, high)
return action
def _reverse_action(self, action):
low = self.action_space.low
high = self.action_space.high
action = 2 * (action - low) / (high - low) - 1
action = np.clip(action, low, high)
return action
def is_in_desired_position(desired_point, current_position, epsilon=0.2):
"""
It return True if the current position is similar to the desired poistion
"""
is_in_desired_pos = False
x_pos_plus = desired_point.x + epsilon
x_pos_minus = desired_point.x - epsilon
y_pos_plus = desired_point.y + epsilon
y_pos_minus = desired_point.y - epsilon
x_current = current_position.x
y_current = current_position.y
x_pos_are_close = (x_current <= x_pos_plus) and (x_current > x_pos_minus)
y_pos_are_close = (y_current <= y_pos_plus) and (y_current > y_pos_minus)
is_in_desired_pos = x_pos_are_close and y_pos_are_close
return is_in_desired_pos
def get_name_rewards(args):
file_name_str = '_'.join([x for x in ARG_LIST])
return '/home/guoxiyue/cjf/results_SAC/rewards_files/' + file_name_str + '.csv'
def get_name_timesteps(args):
file_name_str = '_'.join([x for x in ARG_LIST])
return '/home/guoxiyue/cjf/results_SAC/timesteps_files/' + file_name_str + '.csv'
def get_name_successrate(args):
file_name_str = '_'.join([x for x in ARG_LIST])
return '/home/guoxiyue/cjf/results_SAC/successrate_files/' + file_name_str + '.csv'
def run(env, agents, file1, file2, file3, episodes_number, max_ts,marobot1_desired_point, marobot2_desired_point, marobot3_desired_point, test,log_interval):
# for experiment_num in range(5):
if test:
for i, agent in enumerate(agents):
agent.load()
total_step = 0
rewards_list = []
timesteps_list = []
success_list = []
# max_score = -10000
max_score = [-10000, -10000, -10000]
for episode_num in range(episodes_number):
state = env.reset()
# print("initial state is:", state)
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print("epsiode number is:", episode_num)
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
# actions = []
# for i, agent in enumerate(agents):
# action = env.action_space.sample()
# action_list = action.tolist()
# action_np = np.array(action_list)
# actions.append(action_np)
#ADD
# actions.append(np.array([0.0,0.0]))
# actions.append(np.array([0.0,0.0]))
# print("initial actions are:",actions)
# print("initioal actions type is :", type(actions))
# state, _, _,info = env.step(actions)
# converting list of positions to an array
# for a series of data transformation, transfer multi list to single list
# state includes three parts: position and laser and position vector
position_vector_1 = [state[0][0][0]-marobot1_desired_point.x,state[0][0][1]-marobot1_desired_point.y]
position_vector_2 = [state[1][0][0]-marobot2_desired_point.x,state[1][0][1]-marobot2_desired_point.y]
position_vector_3 = [state[2][0][0]-marobot3_desired_point.x,state[2][0][1]-marobot3_desired_point.y]
# state_1 = state[0][0]+state[0][1]+position_vector_1
# state_2 = state[1][0]+state[1][1]+position_vector_2
# state_3 = state[2][0]+state[2][1]+position_vector_3
# state_1 = state[0][0]+state[0][1]
# state_2 = state[1][0]+state[1][1]
# state_3 = state[2][0]+state[2][1]
state_1 = state[0][0] +state[0][1]
state_2 = state[1][0] +state[1][1]
state_3 = state[2][0] +state[1][1]
state_1 = np.asarray(state_1)
state_1 = state_1.ravel()
state_2 = np.asarray(state_2)
state_2 = state_2.ravel()
state_3 = np.asarray(state_3)
state_3 = state_3.ravel()
state_all = [state_1, state_2, state_3]
# state_all_tensor = [torch.Tensor(state_1),torch.Tensor(state_2),torch.Tensor(state_3)]
dones = False # refer to all the robots reach the desired points and whether end given episode
# reward_all = 0
reward_all = [0, 0, 0]
time_step = 0
done = [False,False,False]
sub_episode_done = []
if_done_index = [False,False,False]
# label means the dones is whether first or not
if_done_label = [0, 0, 0]
while not dones and time_step < max_ts:
# while time_step < max_ts:
print("time step number is:", time_step)
actions = []
for i, agent in enumerate(agents):
action = agent.select_action(state_all[i])
print("action is:",action)
# actions type need to transfer
# action = np.array(action)
actions.append(action)
#add
# actions.append(np.array([0.0,0.0]))
# actions.append(np.array([0.0,0.0]))
print("actions are:", actions)
# decide each agent whether done, decide whether stop training
# index = [i for i in range(len(done)) if done[i] == True]
index = [i for i in range(len(done)) if done[i] == True]
for i in index:
actions[i] = np.array([0.0,0.0])
next_state, reward, done, info = env.step(actions)
print("Env done are:", done)
dones = done[0] and done[1] and done[2]
# record current position so that they can decide whether reach desired position or done
current_position_marobot1 = next_state[0][0]
current_position_marobot2 = next_state[1][0]
current_position_marobot3 = next_state[2][0]
#state includes three parts: position and laser and position vector
position_vector_1 = [next_state[0][0][0] - marobot1_desired_point.x, next_state[0][0][1] - marobot1_desired_point.y]
position_vector_2 = [next_state[1][0][0] - marobot2_desired_point.x, next_state[1][0][1] - marobot2_desired_point.y]
position_vector_3 = [next_state[2][0][0] - marobot3_desired_point.x, next_state[2][0][1] - marobot3_desired_point.y]
# next_state_1 = next_state[0][0] + next_state[0][1] + position_vector_1
# next_state_2 = next_state[1][0] + next_state[1][1] + position_vector_2
# next_state_3 = next_state[2][0] + next_state[2][1] + position_vector_3
next_state_1 = next_state[0][0] + next_state[0][1]
next_state_2 = next_state[1][0] + next_state[1][1]
next_state_3 = next_state[2][0] + next_state[2][1]
# next_state_1 = next_state[0][0]
# next_state_2 = next_state[1][0]
# next_state_3 = next_state[2][0]
next_state_1 = np.asarray(next_state_1)
next_state_1 = next_state_1.ravel()
next_state_2 = np.asarray(next_state_2)
next_state_2 = next_state_2.ravel()
next_state_3 = np.asarray(next_state_3)
next_state_3 = next_state_3.ravel()
next_state_all = [next_state_1, next_state_2, next_state_3]
# next_state_all_tensor = [torch.Tensor(next_state_1), torch.Tensor(next_state_2), torch.Tensor(next_state_3)]
# print("next_state is:", next_state)
if not test:
print("total_step is:",total_step)
print("filling_steps is",filling_steps)
for i, agent in enumerate(agents):
state = state_all[i]
next_state = next_state_all[i]
# agent.observe((state, actions, reward[i], next_state, dones))
# done_mask = 0.0 if done[i] else 1.0
if done[i] is True and if_done_index[i] is False:
if_done_index[i] = True
if_done_label[i] = time_step
# agent.store_transition(state, actions[i], done[i], next_state, reward[i])
agent.store(state, actions[i], reward[i], next_state, done[i])
# if agent.max_action > agent.capacity:
print("<--------------------------------------------->")
print("num_transitio is-------------->>>>>>>>>>>>>>>>>:", agent.num_transition)
if agent.num_transition > agent.capacity:
agent.update()
elif if_done_index[i] is False:
# agent.store_transition(state, actions[i], done[i], next_state, reward[i])
agent.store(state, actions[i], reward[i], next_state, done[i])
if agent.num_transition > agent.capacity:
agent.update()
for i, agent in enumerate(agents):
if if_done_index[i] is True and time_step > if_done_label[i]:
reward[i] = 0
total_step += 1
time_step += 1
# state = next_state
state_1 = next_state_1
state_2 = next_state_2
state_3 = next_state_3
state_all = [state_1, state_2, state_3]
reward_all_np = np.add(np.array(reward_all), np.array(reward))
reward_all = reward_all_np.tolist()
else:
total_step += 1
time_step += 1
# state = next_state
state_1 = next_state_1
state_2 = next_state_2
state_3 = next_state_3
state_all = [state_1, state_2, state_3]
# state_all_tensor = [torch.Tensor(state_1), torch.Tensor(state_2), torch.Tensor(state_3)]
# reward_all += reward
# reward_all = sum(reward) + reward_all
# in each episode, we will decide if each agent reach desired point and calculate success rate
if dones == True or time_step >= max_ts:
current_position_1 = Point()
current_position_2 = Point()
current_position_3 = Point()
# for marobot1:
current_position_1.x = current_position_marobot1[0]
current_position_1.y = current_position_marobot1[1]
current_position_1.z = 0.0
# for marobot2:
current_position_2.x = current_position_marobot2[0]
current_position_2.y = current_position_marobot2[1]
current_position_2.z = 0.0
# for marobot3:
current_position_3.x = current_position_marobot3[0]
current_position_3.y = current_position_marobot3[1]
current_position_3.z = 0.0
# MAX_X = 10.0
# MIN_X = -10.0
# MAX_Y = 10.0
# MIN_Y = -10.0
desired_current_position = {str(current_position_1): marobot1_desired_point,
str(current_position_2): marobot2_desired_point,
str(current_position_3): marobot3_desired_point}
_episode_done = False
for current_position in [current_position_1, current_position_2, current_position_3]:
# We see if it got to the desired point
if is_in_desired_position(desired_current_position[str(current_position)],
current_position):
_episode_done = True
else:
_episode_done = False
# sub_episode_done = sub_episode_done.append(self._episode_done)
sub_episode_done.append(_episode_done)
_episode_dones = sub_episode_done[:]
rewards_list.append(reward_all)
timesteps_list.append(time_step)
# we can calculate success rate whether each agent reach desired point
success_percent = round(_episode_dones.count(True)/3.0,2)
success_list.append(success_percent)
for i, agent in enumerate(agents):
if episode_num % log_interval == 0:
agent.save()
agent.writer.add_scalar('reward_episode', reward_all[i], global_step=episode_num)
print("Episode {p}, Score: {s}, Final Step: {t}, Goal: {g}".format(p=episode_num, s=reward_all,
t=time_step, g=done))
# agent.writer.add_scalar('reward', rewards, i_episode)
# print("episode:{}, reward:{}, buffer_capacity:{}".format(episode_num, reward_all))
# if not test:
if episode_num % 1 == 0:
df = pd.DataFrame(rewards_list, columns=['score-1','score-2','score-3'])
print("file1 name is:", file1)
df.to_csv(file1)
df = pd.DataFrame(timesteps_list, columns=['steps'])
df.to_csv(file2)
if total_step >= filling_steps:
for i, agent in enumerate(agents):
# if reward_all > max_score:
# # for agent in agents:
# # agent.save_model()
# max_score = reward_all
if reward_all[i] > max_score[i]:
max_score[i] = reward_all[i]
# record success rate
df = pd.DataFrame(success_list, columns=['success_rate'])
df.to_csv(file3)
if __name__ =="__main__":
rospy.init_node('sac_training_continous_V1', anonymous=True, log_level=rospy.WARN)
# use the cuda
device = 'cuda' if torch.cuda.is_available() else 'cpu'
device = 'cpu'
seed = rospy.get_param("turtlebot2/seed")
test = rospy.get_param("turtlebot2/test")
# play
experiment_num = rospy.get_param("/turtlebot2/experiment_num")
episodes_number = rospy.get_param("/turtlebot2/iteration")
max_ts = rospy.get_param("/turtlebot2/max_timestep")
# network
hidden_size = rospy.get_param("/turtlebot2/hidden_size")
# replay
memory_size = rospy.get_param("/turtlebot2/memory_size")
batch_size = rospy.get_param("/turtlebot2/batch_size")
# learning
gamma = rospy.get_param("/turtlebot2/gamma")
lr = rospy.get_param("/turtlebot2/lr")
tau = rospy.get_param("/turtlebot2/tau")
update_iteration = rospy.get_param("/turtlebot2/update_iteration")
directory = rospy.get_param("/turtlebot2/directory")
target_update_interval = rospy.get_param("/turtlebot2/target_update_interval")
gradient_steps = rospy.get_param("/turtlebot2/gradient_steps")
capacity = rospy.get_param("/turtlebot2/capacity")
num_hidden_layers = rospy.get_param("/turtlebot2/num_hidden_layers")
num_hidden_units_per_layer = rospy.get_param("/turtlebot2/num_hidden_units_per_layer")
sample_frequency = rospy.get_param("/turtlebot2/sample_frequency")
activation = rospy.get_param("/turtlebot2/activation")
log_interval = rospy.get_param("/turtlebot2/log_interval")
load = rospy.get_param("/turtlebot2/load")
# DQN Parameters
test = rospy.get_param("/turtlebot2/test")
filling_steps = rospy.get_param("/turtlebot2/first_step_memory")
max_random_moves = rospy.get_param("/turtlebot2/max_random_moves")
num_agents = rospy.get_param("/turtlebot2/agents_number")
learning_rate = rospy.get_param("/turtlebot2/learning_rate")
memory_capacity = rospy.get_param("/turtlebot2/memory_capacity")
prioritization_scale = rospy.get_param("/turtlebot2/prioritization_scale")
target_frequency = rospy.get_param("/turtlebot2/target_frequency")
maximum_exploration = rospy.get_param("/turtlebot2/maximum_exploration")
# self.test = rospy.get_param("/turtlebot2/test")
memory_size = rospy.get_param("/turtlebot2/memory_size")
batch_size = rospy.get_param("/turtlebot2/batch_size")
agent_name = rospy.get_param("/turtlebot2/agent_name")
marobot1_desired_point = Point()
marobot1_desired_point.x = rospy.get_param("/turtlebot2/marobot1/desired_pose/x")
marobot1_desired_point.y = rospy.get_param("/turtlebot2/marobot1/desired_pose/y")
marobot1_desired_point.z = rospy.get_param("/turtlebot2/marobot1/desired_pose/z")
marobot2_desired_point = Point()
marobot2_desired_point.x = rospy.get_param("/turtlebot2/marobot2/desired_pose/x")
marobot2_desired_point.y = rospy.get_param("/turtlebot2/marobot2/desired_pose/y")
marobot2_desired_point.z = rospy.get_param("/turtlebot2/marobot2/desired_pose/z")
marobot3_desired_point = Point()
marobot3_desired_point.x = rospy.get_param("/turtlebot2/marobot3/desired_pose/x")
marobot3_desired_point.y = rospy.get_param("/turtlebot2/marobot3/desired_pose/y")
marobot3_desired_point.z = rospy.get_param("/turtlebot2/marobot3/desired_pose/z")
# env
env = gym.make("MultiagentTurtleBot2-v1")
env = NormalizedActions(env)
rospy.loginfo("Gym environment done")
#set seeds
env.seed(seed)
torch.manual_seed(seed)
np.random.seed(seed)
state_dim = env.observation_space.shape[0]
print("state_dim is:", state_dim)
action_dim = env.action_space.shape[0]
print("action_dim is:", action_dim)
max_action = float(env.action_space.high[0])
min_Val = torch.tensor(1e-7).float().to(device)
Transition = namedtuple('Transition', ['s', 'a', 'r', 's_', 'd'])
# action_space = rospy.get_param("/turtlebot2/n_actions")
# state_size = rospy.get_param("/turtlebot2/n_observations")
all_agents = []
for i in range(num_agents):
agent_name = "SAC"+ str(i)
agent = SAC(state_dim = state_dim, action_dim = action_dim, min_Val=min_Val, Transition=Transition, learning_rate=learning_rate,
capacity=capacity, gradient_steps=gradient_steps, batch_size=batch_size, gamma=gamma, tau=tau, max_action=max_action, device=device, agent_id=i)
all_agents.append(agent)
# rewards_file = []
# timesteps_file = []
# successrate_file = []
# for i in range(experiment_num):
# rewards_file.append(get_name_rewards(ARG_LIST + [str(i)]))
# print("ARG_LIST is:", ARG_LIST + [str(i)])
# timesteps_file.append(get_name_timesteps(ARG_LIST + [str(i)]))
# successrate_file.append(get_name_successrate(ARG_LIST + [str(i)]))
rewards_file = get_name_rewards(ARG_LIST)
timesteps_file = get_name_timesteps(ARG_LIST)
successrate_file = get_name_successrate(ARG_LIST)
run(env, agents=all_agents, file1=rewards_file, file2=timesteps_file, file3=successrate_file, episodes_number=episodes_number,
max_ts=max_ts, marobot1_desired_point=marobot1_desired_point, marobot2_desired_point=marobot2_desired_point, marobot3_desired_point=marobot3_desired_point, test=test, log_interval=log_interval)
env.close()
| [] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.