code: def run_dualdice_test(model_path: str, alpha: float):
      device = (
          torch.device("cuda") if torch.cuda.is_available() else None
      )
      logger.info(f"Device - {device}")
      model = torch.jit.load(model_path)
      model = model.dqn_with_preprocessor.model
  
      random_policy = RandomRLPolicy(ActionSpace(2))
      model_policy = PyTorchPolicy(ActionSpace(2), model)
      target_policy = ComboPolicy(
          ActionSpace(2), [0.7, 0.3], [model_policy, random_policy]
      )
      behavior_policy = ComboPolicy(
          ActionSpace(2),
          [0.55 + 0.15 * alpha, 0.45 - 0.15 * alpha],
          [model_policy, random_policy],
      )
  
      ground_truth = estimate_value(
          NUM_EPISODES, MAX_HORIZON, target_policy, GAMMA
      )
      log_policy_value = estimate_value(
          NUM_EPISODES, MAX_HORIZON, behavior_policy, GAMMA
      )
      trained_policy_value = estimate_value(
          NUM_EPISODES, MAX_HORIZON, model_policy, GAMMA
      )
  
      logger.info(f"Target Policy Ground Truth value: {ground_truth}")
      logger.info(
          f"Behavior Policy Ground Truth value: {log_policy_value}"
      )
      logger.info(
          f"Model Policy Ground Truth value: {trained_policy_value}"
      )
  
      log = generate_logs(NUM_EPISODES, MAX_HORIZON, behavior_policy)
  
      inp = RLEstimatorInput(
          gamma=GAMMA,
          log=log,
          target_policy=target_policy,
          discrete_states=False,
      )
      ips = IPSEstimator()
      dualdice_losses = []
      dualdice_values = []
      dualdice = NeuralDualDICE(
          state_dim=4,
          action_dim=2,
          deterministic_env=True,
          average_next_v=False,
          value_lr=0.003,
          zeta_lr=0.003,
          batch_size=2048,
          reporting_frequency=1000,
          training_samples=100000,
          loss_callback_fn=zeta_nu_loss_callback(
              dualdice_losses, dualdice_values, inp
          ),
          device=device,
      )
  
      ips_result = ips.evaluate(inp)
      dd_result = dualdice.evaluate(inp)
  
      return {
          "ips_estimate": ips_result,
          "dualdice_estimate": dd_result,
          "ground_truth": ground_truth,
          "dualdice_losses": dualdice_losses,
          "dualdice_estimates_per_epoch": dualdice_values,
      }
  
imports: import logging
  import gym
  import torch
  from reagent.ope.estimators.sequential_estimators import Action, ActionDistribution, ActionSpace, IPSEstimator, Model, NeuralDualDICE, RandomRLPolicy, RewardProbability, RLEstimatorInput, RLPolicy, State, StateDistribution, Transition
  from reagent.ope.utils import RunningAverage
label_desc: Use image node_id 4 for calling a global function with example usage: run_dualdice_test(model_path, alpha) and returns: dict