code: def _test_abc_batch(
      self, steps=100000, require_success=True, gpu=-1, load_model=False
  ):
      env, _ = self.make_vec_env_and_successful_return(test=False)
      (
          test_env,
          successful_return,
      ) = self.make_vec_env_and_successful_return(test=True)
  
      agent = self.make_agent(env, gpu)
  
      if load_model:
          print("Load agent from", self.agent_dirname)
          agent.load(self.agent_dirname)
  
      max_episode_len = None if self.episodic else 2
  
      # Train
      train_agent_batch_with_evaluation(
          agent=agent,
          env=env,
          eval_env=test_env,
          steps=steps,
          outdir=self.tmpdir,
          eval_interval=200,
          eval_n_steps=None,
          eval_n_episodes=5,
          successful_score=successful_return,
          max_episode_len=max_episode_len,
      )
      env.close()
  
      # Test
      n_test_runs = 5
      eval_returns, _ = batch_run_evaluation_episodes(
          test_env,
          agent,
          n_steps=None,
          n_episodes=n_test_runs,
          max_episode_len=max_episode_len,
      )
      test_env.close()
      if require_success:
          n_succeeded = np.sum(
              np.asarray(eval_returns) >= successful_return
          )
          assert n_succeeded == n_test_runs
  
      # Save
      agent.save(self.agent_dirname)
  
imports: import os
  import tempfile
  import numpy
  import pytest
  import torch
  from torch import distributions, nn
  import pfrl
  from pfrl.envs.abc import ABC
  from pfrl.experiments import train_agent_batch_with_evaluation, train_agent_with_evaluation
  from pfrl.experiments.evaluator import batch_run_evaluation_episodes, run_evaluation_episodes
  from pfrl.nn.lmbda import Lambda
label_desc: Use image node_id 11 for calling the TestSoftActorCritic obj's underlying member method code with example usage: obj._test_abc_batch(steps, require_success, gpu, load_model) without return types