Datasets:
Sub-tasks:
image-captioning
Languages:
English
Multilinguality:
multilingual
Size Categories:
n>1T
Language Creators:
found
Annotations Creators:
no-annotation
Source Datasets:
original
ArXiv:
License:
timeout
#12
by
j35t3r
- opened
Downloading and preparing dataset diffusiondb/large_random_5k to /home/DATA/ITWM/user/huggingface/poloclub___diffusiondb/large_random_5k/0.9.1/b3bc1e64570dc7149af62c4bac49ecfbce16b683dd4fee083292fae1afa95f7c...
Downloading data: 2%|█████ | 12.0M/619M [06:35<5:33:34, 30.3kB/s]
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/urllib3/respo │
│ nse.py:438 in _error_catcher │
│ │
│ 435 │ │ │
│ 436 │ │ try: │
│ 437 │ │ │ try: │
│ ❱ 438 │ │ │ │ yield │
│ 439 │ │ │ │
│ 440 │ │ │ except SocketTimeout: │
│ 441 │ │ │ │ # FIXME: Ideally we'd like to include the url in the ReadTimeoutError bu │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/urllib3/respo │
│ nse.py:519 in read │
│ │
│ 516 │ │ │ │ flush_decoder = True │
│ 517 │ │ │ else: │
│ 518 │ │ │ │ cache_content = False │
│ ❱ 519 │ │ │ │ data = self._fp.read(amt) if not fp_closed else b"" │
│ 520 │ │ │ │ if ( │
│ 521 │ │ │ │ │ amt != 0 and not data │
│ 522 │ │ │ │ ): # Platform-specific: Buggy versions of Python. │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/http/client.py:463 in read │
│ │
│ 460 │ │ if amt is not None: │
│ 461 │ │ │ # Amount is given, implement using readinto │
│ 462 │ │ │ b = bytearray(amt) │
│ ❱ 463 │ │ │ n = self.readinto(b) │
│ 464 │ │ │ return memoryview(b)[:n].tobytes() │
│ 465 │ │ else: │
│ 466 │ │ │ # Amount is not given (unbounded read) so we must check self.length │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/http/client.py:507 in │
│ readinto │
│ │
│ 504 │ │ # we do not use _safe_read() here because this may be a .will_close │
│ 505 │ │ # connection, and the user is reading more bytes than will be provided │
│ 506 │ │ # (for example, reading in 1k chunks) │
│ ❱ 507 │ │ n = self.fp.readinto(b) │
│ 508 │ │ if not n and b: │
│ 509 │ │ │ # Ideally, we would raise IncompleteRead if the content-length │
│ 510 │ │ │ # wasn't satisfied, but it might break compatibility. │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/socket.py:704 in readinto │
│ │
│ 701 │ │ │ raise OSError("cannot read from timed out object") │
│ 702 │ │ while True: │
│ 703 │ │ │ try: │
│ ❱ 704 │ │ │ │ return self._sock.recv_into(b) │
│ 705 │ │ │ except timeout: │
│ 706 │ │ │ │ self._timeout_occurred = True │
│ 707 │ │ │ │ raise │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/ssl.py:1241 in recv_into │
│ │
│ 1238 │ │ │ │ raise ValueError( │
│ 1239 │ │ │ │ "non-zero flags not allowed in calls to recv_into() on %s" % │
│ 1240 │ │ │ │ self.__class__) │
│ ❱ 1241 │ │ │ return self.read(nbytes, buffer) │
│ 1242 │ │ else: │
│ 1243 │ │ │ return super().recv_into(buffer, nbytes, flags) │
│ 1244 │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/ssl.py:1099 in read │
│ │
│ 1096 │ │ │ raise ValueError("Read on closed or unwrapped SSL socket.") │
│ 1097 │ │ try: │
│ 1098 │ │ │ if buffer is not None: │
│ ❱ 1099 │ │ │ │ return self._sslobj.read(len, buffer) │
│ 1100 │ │ │ else: │
│ 1101 │ │ │ │ return self._sslobj.read(len) │
│ 1102 │ │ except SSLError as x: │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
timeout: The read operation timed out
During handling of the above exception, another exception occurred:
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/requests/mode │
│ ls.py:816 in generate │
│ │
│ 813 │ │ │ # Special case for urllib3. │
│ 814 │ │ │ if hasattr(self.raw, "stream"): │
│ 815 │ │ │ │ try: │
│ ❱ 816 │ │ │ │ │ yield from self.raw.stream(chunk_size, decode_content=True) │
│ 817 │ │ │ │ except ProtocolError as e: │
│ 818 │ │ │ │ │ raise ChunkedEncodingError(e) │
│ 819 │ │ │ │ except DecodeError as e: │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/urllib3/respo │
│ nse.py:576 in stream │
│ │
│ 573 │ │ │ │ yield line │
│ 574 │ │ else: │
│ 575 │ │ │ while not is_fp_closed(self._fp): │
│ ❱ 576 │ │ │ │ data = self.read(amt=amt, decode_content=decode_content) │
│ 577 │ │ │ │ │
│ 578 │ │ │ │ if data: │
│ 579 │ │ │ │ │ yield data │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/urllib3/respo │
│ nse.py:541 in read │
│ │
│ 538 │ │ │ │ │ │ # addressing it here to make sure IncompleteRead is │
│ 539 │ │ │ │ │ │ # raised during streaming, so all calls with incorrect │
│ 540 │ │ │ │ │ │ # Content-Length are caught. │
│ ❱ 541 │ │ │ │ │ │ raise IncompleteRead(self._fp_bytes_read, self.length_remaining) │
│ 542 │ │ │
│ 543 │ │ if data: │
│ 544 │ │ │ self._fp_bytes_read += len(data) │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/contextlib.py:137 in │
│ __exit__ │
│ │
│ 134 │ │ │ │ # tell if we get the same exception back │
│ 135 │ │ │ │ value = typ() │
│ 136 │ │ │ try: │
│ ❱ 137 │ │ │ │ self.gen.throw(typ, value, traceback) │
│ 138 │ │ │ except StopIteration as exc: │
│ 139 │ │ │ │ # Suppress StopIteration *unless* it's the same exception that │
│ 140 │ │ │ │ # was passed to throw(). This prevents a StopIteration │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/urllib3/respo │
│ nse.py:443 in _error_catcher │
│ │
│ 440 │ │ │ except SocketTimeout: │
│ 441 │ │ │ │ # FIXME: Ideally we'd like to include the url in the ReadTimeoutError bu │
│ 442 │ │ │ │ # there is yet no clean way to get at it from this context. │
│ ❱ 443 │ │ │ │ raise ReadTimeoutError(self._pool, None, "Read timed out.") │
│ 444 │ │ │ │
│ 445 │ │ │ except BaseSSLError as e: │
│ 446 │ │ │ │ # FIXME: Is there a better way to differentiate between SSLErrors? │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ReadTimeoutError: HTTPSConnectionPool(host='cdn-lfs.huggingface.co', port=443): Read timed out.
During handling of the above exception, another exception occurred:
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /home/user/DeepfakeDetection/gen.py:485 in <module> │
│ │
│ 482 │ │ elif args.mode == 'adv': │
│ 483 │ │ │ from helper_gen.diffusiondb import ( train_loader ) │
│ 484 │ │ │ │
│ ❱ 485 │ │ │ train_loader(args, image_size=32) │
│ 486 │ │
│ 487 │ │
│ 488 │ else: │
│ │
│ /home/user/DeepfakeDetection/helper_gen/diffusiondb.py:9 in train_loader │
│ │
│ 6 │
│ 7 def train_loader(args, dataset_id, image_size=32): │
│ 8 │ from cfg import huggingface_cache_path │
│ ❱ 9 │ dataset = load_dataset('poloclub/diffusiondb', 'large_random_5k', cache_dir=huggingf │
│ 10 │ │
│ 11 │ breakpoint() │
│ 12 │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/load │
│ .py:1791 in load_dataset │
│ │
│ 1788 │ try_from_hf_gcs = path not in _PACKAGED_DATASETS_MODULES │
│ 1789 │ │
│ 1790 │ # Download and prepare data │
│ ❱ 1791 │ builder_instance.download_and_prepare( │
│ 1792 │ │ download_config=download_config, │
│ 1793 │ │ download_mode=download_mode, │
│ 1794 │ │ verification_mode=verification_mode, │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/buil │
│ der.py:891 in download_and_prepare │
│ │
│ 888 │ │ │ │ │ │ │ prepare_split_kwargs["max_shard_size"] = max_shard_size │
│ 889 │ │ │ │ │ │ if num_proc is not None: │
│ 890 │ │ │ │ │ │ │ prepare_split_kwargs["num_proc"] = num_proc │
│ ❱ 891 │ │ │ │ │ │ self._download_and_prepare( │
│ 892 │ │ │ │ │ │ │ dl_manager=dl_manager, │
│ 893 │ │ │ │ │ │ │ verification_mode=verification_mode, │
│ 894 │ │ │ │ │ │ │ **prepare_split_kwargs, │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/buil │
│ der.py:1651 in _download_and_prepare │
│ │
│ 1648 │ │ yield job_id, True, (total_num_examples, total_num_bytes, writer._features, num_ │
│ 1649 │ │
│ 1650 │ def _download_and_prepare(self, dl_manager, verification_mode, **prepare_splits_kwar │
│ ❱ 1651 │ │ super()._download_and_prepare( │
│ 1652 │ │ │ dl_manager, │
│ 1653 │ │ │ verification_mode, │
│ 1654 │ │ │ check_duplicate_keys=verification_mode == VerificationMode.BASIC_CHECKS │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/buil │
│ der.py:964 in _download_and_prepare │
│ │
│ 961 │ │ # Generating data for all splits │
│ 962 │ │ split_dict = SplitDict(dataset_name=self.name) │
│ 963 │ │ split_generators_kwargs = self._make_split_generators_kwargs(prepare_split_kwarg │
│ ❱ 964 │ │ split_generators = self._split_generators(dl_manager, **split_generators_kwargs) │
│ 965 │ │ │
│ 966 │ │ # Checksums verification │
│ 967 │ │ if verification_mode == VerificationMode.ALL_CHECKS and dl_manager.record_checks │
│ │
│ /home/user/.cache/huggingface/modules/datasets_modules/datasets/poloclub--diffusiondb/b3bc1e6 │
│ 4570dc7149af62c4bac49ecfbce16b683dd4fee083292fae1afa95f7c/diffusiondb.py:310 in │
│ _split_generators │
│ │
│ 307 │ │ │
│ 308 │ │ for cur_part_id in self.config.part_ids: │
│ 309 │ │ │ cur_url = urls[cur_part_id] │
│ ❱ 310 │ │ │ data_dir = dl_manager.download_and_extract(cur_url) │
│ 311 │ │ │ │
│ 312 │ │ │ data_dirs.append(data_dir) │
│ 313 │ │ │ json_paths.append(join(data_dir, f"part-{cur_part_id:06}.json")) │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/down │
│ load/download_manager.py:564 in download_and_extract │
│ │
│ 561 │ │ Returns: │
│ 562 │ │ │ extracted_path(s): `str`, extracted paths of given URL(s). │
│ 563 │ │ """ │
│ ❱ 564 │ │ return self.extract(self.download(url_or_urls)) │
│ 565 │ │
│ 566 │ def get_recorded_sizes_checksums(self): │
│ 567 │ │ return self._recorded_sizes_checksums.copy() │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/down │
│ load/download_manager.py:427 in download │
│ │
│ 424 │ │ download_func = partial(self._download, download_config=download_config) │
│ 425 │ │ │
│ 426 │ │ start_time = datetime.now() │
│ ❱ 427 │ │ downloaded_path_or_paths = map_nested( │
│ 428 │ │ │ download_func, │
│ 429 │ │ │ url_or_urls, │
│ 430 │ │ │ map_tuple=True, │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/util │
│ s/py_utils.py:435 in map_nested │
│ │
│ 432 │ │
│ 433 │ # Singleton │
│ 434 │ if not isinstance(data_struct, dict) and not isinstance(data_struct, types): │
│ ❱ 435 │ │ return function(data_struct) │
│ 436 │ │
│ 437 │ disable_tqdm = disable_tqdm or not logging.is_progress_bar_enabled() │
│ 438 │ iterable = list(data_struct.values()) if isinstance(data_struct, dict) else data_str │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/down │
│ load/download_manager.py:453 in _download │
│ │
│ 450 │ │ if is_relative_path(url_or_filename): │
│ 451 │ │ │ # append the relative path to the base_path │
│ 452 │ │ │ url_or_filename = url_or_path_join(self._base_path, url_or_filename) │
│ ❱ 453 │ │ return cached_path(url_or_filename, download_config=download_config) │
│ 454 │ │
│ 455 │ def iter_archive(self, path_or_buf: Union[str, io.BufferedReader]): │
│ 456 │ │ """Iterate over files within an archive. │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/util │
│ s/file_utils.py:183 in cached_path │
│ │
│ 180 │ │
│ 181 │ if is_remote_url(url_or_filename): │
│ 182 │ │ # URL, so get it from the cache (downloading if necessary) │
│ ❱ 183 │ │ output_path = get_from_cache( │
│ 184 │ │ │ url_or_filename, │
│ 185 │ │ │ cache_dir=cache_dir, │
│ 186 │ │ │ force_download=download_config.force_download, │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/util │
│ s/file_utils.py:611 in get_from_cache │
│ │
│ 608 │ │ │ elif scheme not in ("http", "https"): │
│ 609 │ │ │ │ fsspec_get(url, temp_file, storage_options=storage_options, desc=downloa │
│ 610 │ │ │ else: │
│ ❱ 611 │ │ │ │ http_get( │
│ 612 │ │ │ │ │ url, │
│ 613 │ │ │ │ │ temp_file, │
│ 614 │ │ │ │ │ proxies=proxies, │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/datasets/util │
│ s/file_utils.py:403 in http_get │
│ │
│ 400 │ │ desc=desc or "Downloading", │
│ 401 │ │ disable=not logging.is_progress_bar_enabled(), │
│ 402 │ ) as progress: │
│ ❱ 403 │ │ for chunk in response.iter_content(chunk_size=1024): │
│ 404 │ │ │ progress.update(len(chunk)) │
│ 405 │ │ │ temp_file.write(chunk) │
│ 406 │
│ │
│ /home/user/.conda/envs/cuda--11-1-1--pytorch--1-9-0/lib/python3.9/site-packages/requests/mode │
│ ls.py:822 in generate │
│ │
│ 819 │ │ │ │ except DecodeError as e: │
│ 820 │ │ │ │ │ raise ContentDecodingError(e) │
│ 821 │ │ │ │ except ReadTimeoutError as e: │
│ ❱ 822 │ │ │ │ │ raise ConnectionError(e) │
│ 823 │ │ │ │ except SSLError as e: │
│ 824 │ │ │ │ │ raise RequestsSSLError(e) │
│ 825 │ │ │ else: │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ConnectionError: HTTPSConnectionPool(host='cdn-lfs.huggingface.co', port=443): Read timed out.
Thanks for reaching out to us! The ConnectionError looks like some network hiccup. Does it work for you now?
Yes, It works now.
j35t3r
changed discussion status to
closed