def __init__(self,
                 learner_config,
                 env_config,
                 session_config,
                 agent_id,
                 agent_mode,
                 render=False):
        '''
        Constructor for DDPGAgent class.
        Important attributes:
            learner_config, env_config, session_config: experiment configurations
            agent_id: unique id in the range [0, num_agents)
            agent_mode: toggles between agent noise and deterministic behavior
        '''
        super().__init__(
            learner_config=learner_config,
            env_config=env_config,
            session_config=session_config,
            agent_id=agent_id,
            agent_mode=agent_mode,
            render=render,
        )

        self.agent_id = agent_id
        self.action_dim = self.env_config.action_spec.dim[0]
        self.obs_spec = self.env_config.obs_spec
        self.use_layernorm = self.learner_config.model.use_layernorm
        self.sleep_time = self.env_config.sleep_time

        self.param_noise = None
        self.param_noise_type = self.learner_config.algo.exploration.param_noise_type
        self.param_noise_sigma = self.learner_config.algo.exploration.param_noise_sigma
        self.param_noise_alpha = self.learner_config.algo.exploration.param_noise_alpha
        self.param_noise_target_stddev = self.learner_config.algo.exploration.param_noise_target_stddev

        self.frame_stack_concatenate_on_env = self.env_config.frame_stack_concatenate_on_env

        self.noise_type = self.learner_config.algo.exploration.noise_type

        if env_config.num_agents == 1:
            # If only one agent, we don't want a sigma of 0
            self.sigma = self.learner_config.algo.exploration.max_sigma / 3.0
        else:
            self.sigma = self.learner_config.algo.exploration.max_sigma * (
            float(agent_id) / (env_config.num_agents))
        #self.sigma = self.learner_config.algo.exploration.sigma
        print('Using exploration sigma', self.sigma)

        if torch.cuda.is_available():
            self.gpu_ids = 'cuda:all'
            if self.agent_mode not in ['eval_deterministic_local', 'eval_stochastic_local']:
                self.log.info('DDPG agent is using GPU')
                # Note that user is responsible for only providing one GPU for the program
                self.log.info('cudnn version: {}'.format(torch.backends.cudnn.version()))
            torch.backends.cudnn.benchmark = True
        else:
            self.gpu_ids = 'cpu'
            if self.agent_mode not in ['eval_deterministic_local', 'eval_stochastic_local']:
                self.log.info('DDPG agent is using CPU')

        with tx.device_scope(self.gpu_ids):
            self.model = DDPGModel(
                obs_spec=self.obs_spec,
                action_dim=self.action_dim,
                use_layernorm=self.use_layernorm,
                actor_fc_hidden_sizes=self.learner_config.model.actor_fc_hidden_sizes,
                critic_fc_hidden_sizes=self.learner_config.model.critic_fc_hidden_sizes,
                conv_out_channels=self.learner_config.model.conv_spec.out_channels,
                conv_kernel_sizes=self.learner_config.model.conv_spec.kernel_sizes,
                conv_strides=self.learner_config.model.conv_spec.strides,
                conv_hidden_dim=self.learner_config.model.conv_spec.hidden_output_dim,
            )
            self.model.eval()

            self._init_noise()

        Constructor for DDPGAgent class.
        Important attributes:
            learner_config, env_config, session_config: experiment configurations
            agent_id: unique id in the range [0, num_agents)
            agent_mode: toggles between agent noise and deterministic behavior
        
surreal/agent/ddpg_agent.py