code: def run_remote_sample(self):
      remote_actor = Actor(
          difficulty=args.difficulty,
          vel_penalty_coeff=args.vel_penalty_coeff,
          muscle_penalty_coeff=args.muscle_penalty_coeff,
          penalty_coeff=args.penalty_coeff,
          only_first_target=args.only_first_target,
      )
  
      actor_state = ActorState()
  
      while True:
          actor_state.model_name = self.cur_model
          actor_state.reset()
  
          obs = remote_actor.reset()
  
          while True:
              if actor_state.model_name != self.cur_model:
                  break
  
              actor_state.memory.append(
                  TransitionExperience(
                      obs=obs,
                      action=None,
                      reward=None,
                      info=None,
                      timestamp=time.time(),
                  )
              )
  
              action = self.pred_batch(obs)
  
              obs, reward, done, info = remote_actor.step(action)
  
              actor_state.memory[-1].reward = reward
              actor_state.memory[-1].info = info
              actor_state.memory[-1].action = action
              if done:
                  self._parse_memory(actor_state)
                  break
  
imports: import os
  import parl
  import queue
  import six
  import threading
  import time
  import numpy
  from actor import Actor
  from opensim_model import OpenSimModel
  from opensim_agent import OpenSimAgent
  from parl.utils import logger, summary, get_gpu_count
  from parl.utils.window_stat import WindowStat
  from parl.remote.client import get_global_client
  from parl.utils import machine_info
  from shutil import copy2
label_desc: Use image node_id 5 for calling the Evaluator obj's underlying member method code with example usage: obj.run_remote_sample() without return types