def set_data(self, data: Sequence):
        """
        Set the input data and run deterministic transforms to generate cache content.
        Note: should call this func after an entire epoch and must set `persistent_workers=False`
        in PyTorch DataLoader, because it needs to create new worker processes based on new
        generated cache content.
        """

        self.data = data
        self._cache = []
        self._hash_keys = []
        self.cache_num = min(int(self.set_num), int(len(self.data) * self.set_rate), len(self.data))

        if self.cache_num <= 0:
            return

        if self.hash_as_key:
            # only compute cache for the unique items of dataset
            mapping = {self.hash_func(v): v for v in data}
            data = list(mapping.values())[: self.cache_num]
            self._hash_keys = list(mapping)[: self.cache_num]

        self._cache = self._fill_cache(data)

    def _fill_cache(self, data) -> List:
        if self.cache_num <= 0:
            return []
        if self.progress and not has_tqdm:
            warnings.warn("tqdm is not installed, will not show the caching progress bar.")
        with ThreadPool(self.num_workers) as p:
            if self.progress and has_tqdm:
                return list(
                    tqdm(
                        p.imap(self._load_cache_item, data),
                        total=len(data),
                        desc="Loading dataset",
                    )
                )
            return list(p.imap(self._load_cache_item, data))

    def _load_cache_item(self, item):
        """
        Args:
            item: element from the input data sequence.
        """
        for _transform in self.transform.transforms:  # type:ignore
            # execute all the deterministic transforms
            if isinstance(_transform, Randomizable) or not isinstance(_transform, Transform):
                break
            _xform = deepcopy(_transform) if isinstance(_transform, ThreadUnsafe) else _transform
            item = apply_transform(_xform, item)
        if self.as_contiguous:
            item = convert_to_contiguous(item, memory_format=torch.contiguous_format)
        return item

def set_data(self, data: Sequence):
     """
     Set the input data and run deterministic transforms to generate cache content.
     Note: should call this func after an entire epoch and must set `persistent_workers=False`
     in PyTorch DataLoader, because it needs to create new worker processes based on new
     generated cache content.
     """

     self.data = data
     self._cache = []
     self._hash_keys = []
     self.cache_num = min(int(self.set_num), int(len(self.data) * self.set_rate), len(self.data))

     if self.cache_num <= 0:
         return

     if self.hash_as_key:
         # only compute cache for the unique items of dataset
         mapping = {self.hash_func(data[i]): i for i in range(len(data))}
         self._hash_keys = list(mapping)[: self.cache_num]
         indices = list(mapping.values())[: self.cache_num]
     else:
         indices = list(range(self.cache_num))

     self._cache = self._fill_cache(indices)

 def _fill_cache(self, indices=None) -> List:

     if self.cache_num <= 0:
         return []

     if indices is None:
         indices = list(range(self.cache_num))

     if self.progress and not has_tqdm:
         warnings.warn("tqdm is not installed, will not show the caching progress bar.")
     with ThreadPool(self.num_workers) as p:
         if self.progress and has_tqdm:
             return list(
                 tqdm(
                     p.imap(self._load_cache_item, indices),
                     total=len(indices),
                     desc="Loading dataset",
                 )
             )
         return list(p.imap(self._load_cache_item, indices))