class_docstr: Proximal Policy Optimization algorithm (MPI version).
  Paper: https://arxiv.org/abs/1707.06347
  
  :param env: (Gym environment or str) The environment to learn from (if registered in Gym, can be str)
  :param policy: (ActorCriticPolicy or str) The policy model to use (MlpPolicy, CnnPolicy, CnnLstmPolicy, ...)
  :param timesteps_per_actorbatch: (int) timesteps per actor per update
  :param clip_param: (float) clipping parameter epsilon
  :param entcoeff: (float) the entropy loss weight
  :param optim_epochs: (float) the optimizer's number of epochs
  :param optim_stepsize: (float) the optimizer's stepsize
  :param optim_batchsize: (int) the optimizer's the batch size
  :param gamma: (float) discount factor
  :param lam: (float) advantage estimation
  :param adam_epsilon: (float) the epsilon value for the adam optimizer
  :param schedule: (str) The type of scheduler for the learning rate update ('linear', 'constant',
      'double_linear_con', 'middle_drop' or 'double_middle_drop')
  :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.
code: def __init__(
      self,
      policy,
      env,
      gamma=0.99,
      timesteps_per_actorbatch=256,
      clip_param=0.2,
      entcoeff=0.01,
      optim_epochs=4,
      optim_stepsize=1e-3,
      optim_batchsize=64,
      lam=0.95,
      adam_epsilon=1e-5,
      schedule="linear",
      verbose=0,
      tensorboard_log=None,
      _init_setup_model=True,
      policy_kwargs=None,
      full_tensorboard_log=False,
      seed=None,
      n_cpu_tf_sess=1,
  ):
      super().__init__(
          policy=policy,
          env=env,
          verbose=verbose,
          requires_vec_env=False,
          _init_setup_model=_init_setup_model,
          policy_kwargs=policy_kwargs,
          seed=seed,
          n_cpu_tf_sess=n_cpu_tf_sess,
      )
  
      self.gamma = gamma
      self.timesteps_per_actorbatch = timesteps_per_actorbatch
      self.clip_param = clip_param
      self.entcoeff = entcoeff
      self.optim_epochs = optim_epochs
      self.optim_stepsize = optim_stepsize
      self.optim_batchsize = optim_batchsize
      self.lam = lam
      self.adam_epsilon = adam_epsilon
      self.schedule = schedule
      self.tensorboard_log = tensorboard_log
      self.full_tensorboard_log = full_tensorboard_log
  
      self.graph = None
      self.sess = None
      self.policy_pi = None
      self.loss_names = None
      self.lossandgrad = None
      self.adam = None
      self.assign_old_eq_new = None
      self.compute_losses = None
      self.params = None
      self.step = None
      self.proba_step = None
      self.initial_state = None
      self.summary = None
  
      if _init_setup_model:
          self.setup_model()
  
imports: import time
  from collections import deque
  import gym
  import numpy
  import tensorflow
  from mpi4py import MPI
  from stable_baselines.common import Dataset, explained_variance, fmt_row, zipsame, ActorCriticRLModel, SetVerbosity, TensorboardWriter
  from stable_baselines import logger
  import stable_baselines.common.tf_util
  from stable_baselines.common.tf_util import total_episode_reward_logger
  from stable_baselines.common.policies import ActorCriticPolicy
  from stable_baselines.common.mpi_adam import MpiAdam
  from stable_baselines.common.mpi_moments import mpi_moments
  from stable_baselines.common.misc_util import flatten_lists
  from stable_baselines.common.runners import traj_segment_generator
  from stable_baselines.trpo_mpi.utils import add_vtarg_and_adv
label_desc: Use image node_id 1 to create a new PPO1 object from inherited base classes: ActorCriticRLModel with example: obj = PPO1(policy, env, gamma, timesteps_per_actorbatch, clip_param, entcoeff, optim_epochs, optim_stepsize, optim_batchsize, lam, adam_epsilon, schedule, verbose, tensorboard_log, _init_setup_model, policy_kwargs, full_tensorboard_log, seed, n_cpu_tf_sess)