class_docstr: Implementations of DRL algorithms
  Attributes
  ----------
      env: gym environment class
          user-defined class
  Methods
  -------
      get_model()
          setup DRL algorithms
      train_model()
          train DRL algorithms in a train dataset
          and output the trained model
      DRL_prediction()
          make a prediction in a test dataset and get results
code: def DRL_prediction(
      model_name, cwd, net_dimension, environment, env_args
  ):
      import torch
  
      gpu_id = 0  # >=0 means GPU ID, -1 means CPU
      agent_class = MODELS[model_name]
      stock_dim = env_args["price_array"].shape[1]
      state_dim = (
          1 + 2 + 3 * stock_dim + env_args["tech_array"].shape[1]
      )
      action_dim = stock_dim
      env_args = {
          "env_num": 1,
          "env_name": "StockEnv",
          "state_dim": state_dim,
          "action_dim": action_dim,
          "if_discrete": False,
          "max_step": env_args["price_array"].shape[0] - 1,
          "config": env_args,
      }
  
      actor_path = f"{cwd}/act.pth"
      net_dim = [2**7]
  
      """init"""
      env = environment
      env_class = env
      args = Config(
          agent_class=agent_class,
          env_class=env_class,
          env_args=env_args,
      )
      args.cwd = cwd
      act = agent_class(
          net_dim,
          env.state_dim,
          env.action_dim,
          gpu_id=gpu_id,
          args=args,
      ).act
      parameters_dict = {}
      act = torch.load(actor_path)
      for name, param in act.named_parameters():
          parameters_dict[name] = torch.tensor(
              param.detach().cpu().numpy()
          )
  
      act.load_state_dict(parameters_dict)
  
      if_discrete = env.if_discrete
      device = next(act.parameters()).device
      state = env.reset()
      episode_returns = []  # the cumulative_return / initial_account
      episode_total_assets = [env.initial_total_asset]
      max_step = env.max_step
      for steps in range(max_step):
          s_tensor = torch.as_tensor(
              state, dtype=torch.float32, device=device
          ).unsqueeze(0)
          a_tensor = (
              act(s_tensor).argmax(dim=1)
              if if_discrete
              else act(s_tensor)
          )
          action = (
              a_tensor.detach().cpu().numpy()[0]
          )  # not need detach(), because using torch.no_grad() outside
          state, reward, done, _ = env.step(action)
          total_asset = (
              env.amount + (env.price_ary[env.day] * env.stocks).sum()
          )
          episode_total_assets.append(total_asset)
          episode_return = total_asset / env.initial_total_asset
          episode_returns.append(episode_return)
          if done:
              break
      print("Test Finished!")
      print("episode_retuen", episode_return)
      return episode_total_assets
  
file_path: FinRL/finrl/agents/elegantrl/models.py
imports: from __future__ import annotations
  import torch
  from elegantrl.agents import *
  from elegantrl.train.config import Config
  from elegantrl.train.run import train_agent
label_desc: Use image node_id 4 for calling the DRLAgent obj's underlying member method code with example usage: obj.DRL_prediction(model_name, cwd, net_dimension, environment, env_args) and returns: episode_total_assets