code: def _load_data_set(self):
      # self.v3d_2d_to_ours = np.arange(17)
      if self.is_train:
          print(
              "start loading surreal {} data.".format(
                  "train" if self.is_train else "test"
              )
          )
      key = "original_joint_2d_gt" if self.use_gt else "joint_2d_pre"
      assert self.use_gt
      fp = h5py.File(self.data_path, "r")
      self.kp2ds = np.array(fp[key])
      self.kp2ds[:, :, 0] = (self.kp2ds[:, :, 0] - 160.0) / 160.0
      self.kp2ds[:, :, 1] = (self.kp2ds[:, :, 1] - 160.0) / 160.0
      # locate root at the origin
      # self.kp2ds[:, 12] = (self.kp2ds[:, 8] + self.kp2ds[:, 9]) / 2
      self.kp2ds = self.kp2ds - self.kp2ds[:, 13:14]
      self.kp2ds[:, 13] = 1e-5
      # imagenames will be used to sample frames
      self.imagenames = [name.decode() for name in fp["imagename"][:]]
      if "seqname" not in fp.keys():
          fp.close()
          print("Process corresponding dataset...")
          process_dataset_for_video(self.data_path, is_surreal=True)
          fp = h5py.File(self.data_path, "r")
      self.sequence_lens = np.array(fp["seqlen"])
      self.sequence_names = [name.decode() for name in fp["seqname"][:]]
      self.indices_in_seq = np.array(fp["index_in_seq"])
  
      # normlize again so that the mean distance of head and root is 1/c
      if not self.use_same_norm_2d:
          factor_gt = self.head_root_distance / (
              np.tile(
                  np.linalg.norm(
                      self.kp2ds[:, -1] - self.kp2ds[:, 13], axis=1
                  ).reshape(-1, 1, 1),
                  (1, 17, 2),
              )
              + 1e-8
          )
      else:
          factor_gt = (
              self.head_root_distance
              / np.linalg.norm(
                  self.kp2ds[:, -1] - self.kp2ds[:, 13], axis=1
              ).mean()
          )
      self.kp2ds = self.kp2ds * factor_gt
  
      self.kp3ds = np.array(fp["joint_3d_gt"])
      # self.kp3ds[:, 12] = (self.kp3ds[:, 8] + self.kp3ds[:, 9]) / 2
      factor_3d = np.linalg.norm(
          self.kp3ds[:, -1] - self.kp3ds[:, 13], axis=1
      ).mean()
      factor_filename = "../data/surreal_{}_factor_3d.pkl".format(
          "train" if self.is_train else "test"
      )
      if not self.use_same_norm_3d and not osp.exists(factor_filename):
          factor_3d = (
              np.tile(
                  np.linalg.norm(
                      self.kp3ds[:, -1] - self.kp3ds[:, 13], axis=1
                  ).reshape(-1, 1, 1),
                  (1, 17, 3),
              )
              + 1e-8
          )
          with open(factor_filename, "wb") as f:
              pkl.dump(factor_3d, f)
  
      fp.close()
      print(
          "finished load surreal {} data, total {} samples".format(
              "train" if self.is_train else "test", self.kp2ds.shape[0]
          )
      )
  
      # get random diff1
      self.diff_indices = []
      for index in range(self.kp2ds.shape[0]):
          index_in_seq = self.indices_in_seq[index]
          seq_len = self.sequence_lens[index]
          if seq_len == 1:
              diff1_index = index
          elif index_in_seq + self.frame_interval < seq_len:
              diff_index = index + self.frame_interval
          else:
              diff_index = index - self.frame_interval
          self.diff_indices.append(diff_index)
  
      # generate the rotation factors
      num_examples = self.kp2ds.shape[0]
      np.random.seed(2019)
      rotation_y = (
          2 * np.random.random_sample((num_examples, 1)) - 1
      ) * self.bound_azim
      rotation_x = (
          2 * np.random.random_sample((num_examples, 1)) - 1
      ) * self.bound_elev
      rotation_z = (
          (2 * np.random.random_sample((num_examples, 1)) - 1)
          * self.bound_elev
          / 2
      )
      rotation_1 = np.concatenate(
          (rotation_y, rotation_x, rotation_z), axis=1
      )
      rotation_2 = rotation_1.copy()
      rotation_2[:, 0] = rotation_2[:, 0] + np.pi
      self.rotation = np.concatenate((rotation_1, rotation_2), axis=0)
      np.random.shuffle(self.rotation)
      self.rotation = torch.from_numpy(self.rotation).float()
  
      self.kp2ds = torch.from_numpy(self.kp2ds).float()
      self.kp3ds = torch.from_numpy(self.kp3ds).float()
  
imports: import sys
  from torch.utils.data import Dataset, DataLoader
  import os
  import os.path
  import glob
  import numpy
  import random
  import cv2
  import pickle
  import json
  import h5py
  import torch
  import matplotlib.pyplot
  from lib.utils.misc import process_dataset_for_video
label_desc: Use image node_id 3 for calling the SurrealDataset obj's underlying member method code with example usage: obj._load_data_set() without return types