code: def _load(
      pickle_fp,
      map_location,
      picklemoudle,
      pickle_file="data.pkl",
      zip_file=None,
  ):
      load_module_mapping: Dict[str, str] = {
          "torch.tensor": "torch._tensor"
      }
  
      class LazyUnpickler(picklemoudle.Unpickler):
          def __init__(
              self,
              fp: IO[bytes],
              data_base_path: str,
              zip_file: zipfile.ZipFile,
          ):
              super().__init__(fp)
              self.data_base_path = data_base_path
              self.zip_file = zip_file
  
          def persistent_load(self, pid):
              data_type = pid[1].dtype
              filename_stem = pid[2]
              filename = f"{self.data_base_path}/{filename_stem}"
              info = self.zip_file.getinfo(filename)
  
              def load(offset: int, elm_count: int):
                  dtype = data_type
                  fp = self.zip_file.open(info)
                  fp.seek(offset * item_size[dtype])
                  size = elm_count * item_size[dtype]
                  data = fp.read(size)
                  return torch.frombuffer(bytearray(data), dtype=dtype)
  
              description = (
                  f"storage data_type={data_type} "
                  "path-in-zip={filename} path={self.zip_file.filename}"
              )
              return LazyStorage(
                  load=load, kind=pid[1], description=description
              )
  
          @staticmethod
          def lazy_rebuild_tensor_v2(
              storage: Any,
              storage_offset: Any,
              size: Any,
              stride: Any,
              requires_grad: Any,
              backward_hooks: Any,
              metadata: Any = None,
          ) -> LazyTensor:
              invalidInputError(
                  isinstance(storage, LazyStorage),
                  "storage should be an instance of class `LazyStorage`, "
                  f"but get {type(storage)}.",
              )
  
              def load() -> torch.Tensor:
                  elm_count = stride[0] * size[0]
                  return storage.load(
                      storage_offset, elm_count
                  ).reshape(size)
  
              description = f"pickled storage_offset={storage_offset} in {storage.description}"
              return LazyTensor(
                  load, list(size), storage.kind.dtype, description
              )
  
          @staticmethod
          def rebuild_from_type_v2(func, new_type, args, state):
              return func(*args)
  
          CLASSES: dict[tuple[str, str], Any] = {
              ("torch._tensor", "_rebuild_from_type_v2"): getattr(
                  rebuild_from_type_v2, "__func__"
              ),
              ("torch._utils", "_rebuild_tensor_v2"): getattr(
                  lazy_rebuild_tensor_v2, "__func__"
              ),
              ("torch", "Tensor"): LazyTensor,
          }
  
          def find_class(self, mod_name, name):
              if (mod_name, name) in self.CLASSES:
                  return self.CLASSES[(mod_name, name)]
              if type(name) is str and "Storage" in name:
                  try:
                      return StorageType(name)
                  except KeyError:
                      pass
              mod_name = load_module_mapping.get(mod_name, mod_name)
              return super().find_class(mod_name, name)
  
      unpickler = LazyUnpickler(
          pickle_fp, data_base_path=pickle_file, zip_file=zip_file
      )
      result = unpickler.load()
  
      return result
  
file_path: BigDL/python/llm/src/bigdl/llm/utils/lazy_load_torch.py
imports: import torch
  from torch.serialization import StorageType
  import pickle
  import zipfile
  import io
  from typing import Dict, IO, Any, Callable, List
  from dataclasses import dataclass
  from .common import invalidInputError
label_desc: Use image node_id 1 for calling a global function with example usage: _load(pickle_fp, map_location, picklemoudle, pickle_file, zip_file) and returns: result, LazyStorage, LazyTensor, func, super, torch, storage, self, StorageType