ó
    "EñiØQ  ã                   óÖ  • S SK r S SKrS SKrS SKrS SKJr  S SKJrJrJ	r	J
r
  S SKJr  S SKJrJrJrJr  / SQr\
" S5      r\
" SS	S
9r\\\4   r\\S4   r\
" S\\5      r " S S\\   5      r " S S\\   \	\   5      r " S S\\\S4      5      r " S S\\   5      r " S S\\   5      r " S S\5      r  " S S\\   5      r!\4S\\   S\\"\#-     S\S-  S\$\!\      4S jjr%g) é    N)ÚSequence)ÚcastÚGenericÚIterableÚTypeVar)Ú
deprecated)Údefault_generatorÚ	GeneratorÚrandpermÚTensor)ÚDatasetÚIterableDatasetÚTensorDatasetÚStackDatasetÚConcatDatasetÚChainDatasetÚSubsetÚrandom_splitÚ_TÚ_T_coT)Ú	covariant.Ú_T_stackc                   ó0   • \ rS rSrSrS\4S jrSS jrSrg)	r   é'   a}  An abstract class representing a :class:`Dataset`.

All datasets that represent a map from keys to data samples should subclass
it. All subclasses should overwrite :meth:`__getitem__`, supporting fetching a
data sample for a given key. Subclasses could also optionally overwrite
:meth:`__len__`, which is expected to return the size of the dataset by many
:class:`~torch.utils.data.Sampler` implementations and the default options
of :class:`~torch.utils.data.DataLoader`. Subclasses could also
optionally implement :meth:`__getitems__`, for speedup batched samples
loading. This method accepts list of indices of samples of batch and returns
list of samples.

.. note::
  :class:`~torch.utils.data.DataLoader` by default constructs an index
  sampler that yields integral indices.  To make it work with a map-style
  dataset with non-integral indices/keys, a custom sampler must be provided.
Úreturnc                 ó   • [        S5      e)Nz3Subclasses of Dataset should implement __getitem__.)ÚNotImplementedError©ÚselfÚindexs     ÚU/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/utils/data/dataset.pyÚ__getitem__ÚDataset.__getitem__:   s   € Ü!Ð"WÓXÐXó    c                 ó   • [        X/5      $ ©N)r   ©r   Úothers     r!   Ú__add__ÚDataset.__add__A   s   € Ü˜d˜]Ó+Ð+r$   © N)r(   zDataset[_T_co]r   zConcatDataset[_T_co])	Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   r"   r)   Ú__static_attributes__r+   r$   r!   r   r   '   s   † ñð$Y Eô Y÷,r$   r   c                   ó,   • \ rS rSrSrS\\   4S jrSrg)r   éI   aÏ  An iterable Dataset.

All datasets that represent an iterable of data samples should subclass it.
Such form of datasets is particularly useful when data come from a stream.

All subclasses should overwrite :meth:`__iter__`, which would return an
iterator of samples in this dataset.

When a subclass is used with :class:`~torch.utils.data.DataLoader`, each
item in the dataset will be yielded from the :class:`~torch.utils.data.DataLoader`
iterator. When :attr:`num_workers > 0`, each worker process will have a
different copy of the dataset object, so it is often desired to configure
each copy independently to avoid having duplicate data returned from the
workers. :func:`~torch.utils.data.get_worker_info`, when called in a worker
process, returns information about the worker. It can be used in either the
dataset's :meth:`__iter__` method or the :class:`~torch.utils.data.DataLoader` 's
:attr:`worker_init_fn` option to modify each copy's behavior.

Example 1: splitting workload across all workers in :meth:`__iter__`::

    >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_DATALOADER)
    >>> # xdoctest: +SKIP("Fails on MacOS12")
    >>> class MyIterableDataset(torch.utils.data.IterableDataset):
    ...     def __init__(self, start, end):
    ...         super(MyIterableDataset).__init__()
    ...         assert end > start, "this example only works with end >= start"
    ...         self.start = start
    ...         self.end = end
    ...
    ...     def __iter__(self):
    ...         worker_info = torch.utils.data.get_worker_info()
    ...         if worker_info is None:  # single-process data loading, return the full iterator
    ...             iter_start = self.start
    ...             iter_end = self.end
    ...         else:  # in a worker process
    ...             # split workload
    ...             per_worker = int(math.ceil((self.end - self.start) / float(worker_info.num_workers)))
    ...             worker_id = worker_info.id
    ...             iter_start = self.start + worker_id * per_worker
    ...             iter_end = min(iter_start + per_worker, self.end)
    ...         return iter(range(iter_start, iter_end))
    ...
    >>> # should give same set of data as range(3, 7), i.e., [3, 4, 5, 6].
    >>> ds = MyIterableDataset(start=3, end=7)

    >>> # Single-process loading
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=0)))
    [tensor([3]), tensor([4]), tensor([5]), tensor([6])]

    >>> # xdoctest: +REQUIRES(POSIX)
    >>> # Multi-process loading with two worker processes
    >>> # Worker 0 fetched [3, 4].  Worker 1 fetched [5, 6].
    >>> # xdoctest: +IGNORE_WANT("non deterministic")
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=2)))
    [tensor([3]), tensor([5]), tensor([4]), tensor([6])]

    >>> # With even more workers
    >>> # xdoctest: +IGNORE_WANT("non deterministic")
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=12)))
    [tensor([3]), tensor([5]), tensor([4]), tensor([6])]

Example 2: splitting workload across all workers using :attr:`worker_init_fn`::

    >>> # xdoctest: +REQUIRES(env:TORCH_DOCTEST_DATALOADER)
    >>> class MyIterableDataset(torch.utils.data.IterableDataset):
    ...     def __init__(self, start, end):
    ...         super(MyIterableDataset).__init__()
    ...         assert end > start, "this example only works with end >= start"
    ...         self.start = start
    ...         self.end = end
    ...
    ...     def __iter__(self):
    ...         return iter(range(self.start, self.end))
    ...
    >>> # should give same set of data as range(3, 7), i.e., [3, 4, 5, 6].
    >>> ds = MyIterableDataset(start=3, end=7)

    >>> # Single-process loading
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=0)))
    [3, 4, 5, 6]
    >>>
    >>> # Directly doing multi-process loading yields duplicate data
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=2)))
    [3, 3, 4, 4, 5, 5, 6, 6]

    >>> # Define a `worker_init_fn` that configures each dataset copy differently
    >>> def worker_init_fn(worker_id):
    ...     worker_info = torch.utils.data.get_worker_info()
    ...     dataset = worker_info.dataset  # the dataset copy in this worker process
    ...     overall_start = dataset.start
    ...     overall_end = dataset.end
    ...     # configure the dataset to only process the split workload
    ...     per_worker = int(math.ceil((overall_end - overall_start) / float(worker_info.num_workers)))
    ...     worker_id = worker_info.id
    ...     dataset.start = overall_start + worker_id * per_worker
    ...     dataset.end = min(dataset.start + per_worker, overall_end)
    ...

    >>> # Mult-process loading with the custom `worker_init_fn`
    >>> # Worker 0 fetched [3, 4].  Worker 1 fetched [5, 6].
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=2, worker_init_fn=worker_init_fn)))
    [3, 5, 4, 6]

    >>> # With even more workers
    >>> print(list(torch.utils.data.DataLoader(ds, num_workers=12, worker_init_fn=worker_init_fn)))
    [3, 4, 5, 6]
r(   c                 ó   • [        X/5      $ r&   )r   r'   s     r!   r)   ÚIterableDataset.__add__¶   s   € Ü˜T˜MÓ*Ð*r$   r+   N)	r,   r-   r.   r/   r0   r   r   r)   r1   r+   r$   r!   r   r   I   s   † ñjðX+˜W U™^÷ +r$   r   c                   óT   • \ rS rSr% Sr\\S4   \S'   S\SS4S jrS r	S\
4S	 jrS
rg)r   é½   z¾Dataset wrapping tensors.

Each sample will be retrieved by indexing tensors along the first dimension.

Args:
    *tensors (Tensor): tensors that have the same size of the first dimension.
.Útensorsr   Nc                 ó^   ^• [        U4S jT 5       5      (       a  [        S5      eTU l        g )Nc              3   óp   >#   • U  H+  nTS    R                  S 5      UR                  S 5      :g  v •  M-     g7f)r   N)Úsize)Ú.0Útensorr8   s     €r!   Ú	<genexpr>Ú)TensorDataset.__init__.<locals>.<genexpr>É   s+   øé € ÐJÂ'¸ˆw�q‰z�‰˜qÓ! V§[¡[°£^Ö3Â'ùs   ƒ36zSize mismatch between tensors)ÚanyÚAssertionErrorr8   )r   r8   s    `r!   Ú__init__ÚTensorDataset.__init__È   s'   ø€ ÜÔJÁ'ÓJ×JÑJÜ Ð!@ÓAÐAØˆ�r$   c                 óB   ^• [        U4S jU R                   5       5      $ )Nc              3   ó,   >#   • U  H	  oT   v •  M     g 7fr&   r+   )r<   r=   r    s     €r!   r>   Ú,TensorDataset.__getitem__.<locals>.<genexpr>Î   s   øé € Ð>² v˜E–]²ùó   ƒ)Útupler8   r   s    `r!   r"   ÚTensorDataset.__getitem__Í   s   ø€ ÜÔ>°·²Ó>Ó>Ð>r$   c                 ó>   • U R                   S   R                  S5      $ ©Nr   )r8   r;   ©r   s    r!   Ú__len__ÚTensorDataset.__len__Ð   s   € Ø�|‰|˜A‰×#Ñ# AÓ&Ð&r$   )r8   )r,   r-   r.   r/   r0   rH   r   Ú__annotations__rB   r"   ÚintrM   r1   r+   r$   r!   r   r   ½   s<   ‡ ñð �6˜3�;ÑÓð ð ¨Dô ò
?ð'˜÷ 'r$   r   c                   ón   • \ rS rSr% Sr\\-  \S'   S\\	   S\\	   SS4S jr
S	 rS
\4S jrS\4S jrSrg)r   éÔ   aM  Dataset as a stacking of multiple datasets.

This class is useful to assemble different parts of complex input data, given as datasets.

Example:
    >>> # xdoctest: +SKIP
    >>> images = ImageDataset()
    >>> texts = TextDataset()
    >>> tuple_stack = StackDataset(images, texts)
    >>> tuple_stack[0] == (images[0], texts[0])
    >>> dict_stack = StackDataset(image=images, text=texts)
    >>> dict_stack[0] == {"image": images[0], "text": texts[0]}

Args:
    *args (Dataset): Datasets for stacking returned as tuple.
    **kwargs (Dataset): Datasets for stacking returned as dict.
ÚdatasetsÚargsÚkwargsr   Nc                 óŒ  ^ • U(       aR  U(       a  [        S5      e[        US   5      T l        [        U 4S jU 5       5      (       a  [        S5      eUT l        g U(       aY  [        UR                  5       5      n[        US   5      T l        [        U 4S jU 5       5      (       a  [        S5      eUT l        g [        S5      e)NztSupported either ``tuple``- (via ``args``) or``dict``- (via ``kwargs``) like input/output, but both types are given.r   c              3   óT   >#   • U  H  nTR                   [        U5      :g  v •  M     g 7fr&   ©Ú_lengthÚlen©r<   Údatasetr   s     €r!   r>   Ú(StackDataset.__init__.<locals>.<genexpr>ñ   s   øé € ÐDºt°G�4—<‘<¤3 w£<Ö/ºtùó   ƒ%(zSize mismatch between datasetsc              3   óT   >#   • U  H  nTR                   [        U5      :g  v •  M     g 7fr&   rX   r[   s     €r!   r>   r]   ÷   s   øé € ÐCºs°G�4—<‘<¤3 w£<Ö/ºsùr^   z%At least one dataset should be passed)Ú
ValueErrorrZ   rY   r@   rS   ÚlistÚvalues)r   rT   rU   Útmps   `   r!   rB   ÚStackDataset.__init__é   s£   ø€ ÞÞÜ ð^óð ô ˜t A™w›<ˆDŒLÜÔD¹tÓD×DÑDÜ Ð!AÓBÐBØ ˆD�MÞÜ�v—}‘}“Ó'ˆCÜ˜s 1™v›;ˆDŒLÜÔC¹sÓC×CÑCÜ Ð!AÓBÐBØ"ˆD�MäÐDÓEÐEr$   c                 óð   ^• [        U R                  [        5      (       a2  U R                  R                  5        VVs0 s H
  u  p#X#T   _M     snn$ [	        U4S jU R                   5       5      $ s  snnf )Nc              3   ó,   >#   • U  H	  oT   v •  M     g 7fr&   r+   )r<   r\   r    s     €r!   r>   Ú+StackDataset.__getitem__.<locals>.<genexpr>   s   øé € ÐA²=¨˜U–^²=ùrG   )Ú
isinstancerS   ÚdictÚitemsrH   )r   r    Úkr\   s    `  r!   r"   ÚStackDataset.__getitem__ý   s\   ø€ Ü�d—m‘m¤T×*Ñ*Ø8<¿¹×8KÑ8KÔ8MÔNÒ8M©*¨!�A˜u‘~Ò%Ñ8MÒNÐNÜÔA°4·=²=ÓAÓAÐAùó Os   ¾A2Úindicesc           	      óè  • [        U R                  [        5      (       aÐ  U Vs/ s H  n0 PM     nnU R                  R                  5        Hž  u  pE[	        [        USS 5      5      (       ae  UR                  U5      n[        U5      [        U5      :w  a#  [        S[        U5       S[        U5       35      e[        XcSS9 H	  u  pxXxU'   M     M…  [        XSS9 H  u  p˜XY   X„'   M     M      U$ U Vs/ s H  n/ PM     n
nU R                   H¶  n[	        [        USS 5      5      (       ar  UR                  U5      n[        U5      [        U5      :w  a#  [        S[        U5       S[        U5       35      e[        XjSS9 H  u  p{UR                  U5        M     M�  [        XSS9 H  u  p›UR                  XY   5        M     M¸     U
 Vs/ s H  n[        U5      PM     nnU$ s  snf s  snf s  snf )NÚ__getitems__z0Nested dataset's output size mismatch. Expected z, got T©Ústrict)rh   rS   ri   rj   ÚcallableÚgetattrro   rZ   r`   ÚzipÚappendrH   )r   rm   Ú_Ú
dict_batchrk   r\   rj   ÚdataÚd_sampleÚidxÚ
list_batchÚt_sampleÚsampleÚtuple_batchs                 r!   ro   ÚStackDataset.__getitems__  sß  € ä�d—m‘m¤T×*Ñ*Ù5<Ó(=²W°«±WˆJÐ(=Ø"Ÿm™m×1Ñ1Ö3‘
�ÜœG G¨^¸TÓB×CÑCØ#×0Ñ0°Ó9�EÜ˜5“z¤S¨£\Ó1Ü(ð)Ü),¨W«¨°f¼SÀ»Z¸LðJóð ô +.¨eÈÔ*M™˜Ø&* ›ó +Nô *-¨WÈÔ)N™˜Ø&-¡l˜›ó *Oñ 4ð Ðñ /6Ó!6ªg¨£"©gˆ
Ð!6Ø—}”}ˆGÜœ ¨¸Ó>×?Ñ?Ø×,Ñ,¨WÓ5�Ü�u“:¤ W£Ó-Ü$ð%Ü%(¨£\ N°&¼¸U»¸ðFóð ô '*¨%ÀDÔ&I‘N�DØ—O‘O DÖ)ó 'Jô &)¨ÀTÔ%J‘M�CØ—O‘O G¡LÖ1ó &Kñ %ñ DNÓ&NÂ:¸¤u¨V¦}Á:ˆÐ&NØÐùòA )>ùò" "7ùò 'Os   ¤G%Ã4G*ÇG/c                 ó   • U R                   $ r&   )rY   rL   s    r!   rM   ÚStackDataset.__len__'  s   € Ø�|‰|Ðr$   )rY   rS   )r,   r-   r.   r/   r0   rH   ri   rO   r   r   rB   r"   ra   ro   rP   rM   r1   r+   r$   r!   r   r   Ô   sX   ‡ ñð$ �d‰lÓðF˜g e™nð F¸À¹ð FÈ4ô Fò(Bð
# Dô #ðJ˜÷ r$   r   c                   ó®   ^ • \ rS rSr% Sr\\\      \S'   \\	   \S'   \
S 5       rS\\   SS4U 4S jjrS\	4S	 jrS
 r\\" S\S9S 5       5       rSrU =r$ )r   i+  z´Dataset as a concatenation of multiple datasets.

This class is useful to assemble different existing datasets.

Args:
    datasets (sequence): List of datasets to be concatenated
rS   Úcumulative_sizesc                 ób   • / Sp!U  H%  n[        U5      nUR                  XB-   5        X$-  nM'     U$ rK   )rZ   ru   )ÚsequenceÚrÚsÚeÚls        r!   ÚcumsumÚConcatDataset.cumsum7  s7   € à�1ˆ1ÛˆAÜ�A“ˆAØ�H‰H�Q‘UŒOØ‰FŠAñ ð ˆr$   r   Nc                 ó0  >• [         TU ]  5         [        U5      U l        [	        U R                  5      S:X  a  [        S5      eU R                   H#  n[        U[        5      (       d  M  [        S5      e   U R                  U R                  5      U l	        g )Nr   z(datasets should not be an empty iterablez.ConcatDataset does not support IterableDataset)
ÚsuperrB   ra   rS   rZ   rA   rh   r   rŠ   rƒ   )r   rS   ÚdÚ	__class__s      €r!   rB   ÚConcatDataset.__init__@  st   ø€ Ü‰ÑÔÜ˜X›ˆŒÜˆt�}‰}Ó Ó"Ü Ð!KÓLÐLØ—”ˆAÜ˜!œ_×-Ó-Ü$Ð%UÓVÐVñ ð !%§¡¨D¯M©MÓ :ˆÕr$   c                 ó    • U R                   S   $ )Néÿÿÿÿ©rƒ   rL   s    r!   rM   ÚConcatDataset.__len__J  s   € Ø×$Ñ$ RÑ(Ð(r$   c                 ó   • US:  a)  U* [        U 5      :”  a  [        S5      e[        U 5      U-   n[        R                  " U R                  U5      nUS:X  a  UnOXR                  US-
     -
  nU R
                  U   U   $ )Nr   z8absolute value of index should not exceed dataset lengthé   )rZ   r`   ÚbisectÚbisect_rightrƒ   rS   )r   rz   Údataset_idxÚ
sample_idxs       r!   r"   ÚConcatDataset.__getitem__M  s†   € Ø�‹7Øˆt”c˜$“iÓÜ ØNóð ô �d“)˜c‘/ˆCÜ×)Ò)¨$×*?Ñ*?ÀÓEˆØ˜!ÓØ‰Jà×4Ñ4°[À1±_ÑEÑEˆJØ�}‰}˜[Ñ)¨*Ñ5Ð5r$   z>`cummulative_sizes` attribute is renamed to `cumulative_sizes`)Úcategoryc                 ó   • U R                   $ r&   r“   rL   s    r!   Úcummulative_sizesÚConcatDataset.cummulative_sizes[  s   € ð ×$Ñ$Ð$r$   )rƒ   rS   )r,   r-   r.   r/   r0   ra   r   r   rO   rP   ÚstaticmethodrŠ   r   rB   rM   r"   Úpropertyr   ÚFutureWarningrž   r1   Ú__classcell__©r�   s   @r!   r   r   +  s…   ø‡ ñð �7˜5‘>Ñ"Ó"Ø˜3‘iÓàñó ðð; ¨'Ñ!2ð ;°t÷ ;ð)˜ô )ò6ð ÙØHØññ%ó	ó ö
%r$   r   c                   óR   ^ • \ rS rSrSrS\\   SS4U 4S jjrS rS\	4S jr
S	rU =r$ )
r   id  aG  Dataset for chaining multiple :class:`IterableDataset` s.

This class is useful to assemble different existing dataset streams. The
chaining operation is done on-the-fly, so concatenating large-scale
datasets with this class will be efficient.

Args:
    datasets (iterable of IterableDataset): datasets to be chained together
rS   r   Nc                 ó.   >• [         TU ]  5         Xl        g r&   )r�   rB   rS   )r   rS   r�   s     €r!   rB   ÚChainDataset.__init__o  s   ø€ Ü‰ÑÔØ �r$   c              #   óŠ   #   • U R                    H-  n[        U[        5      (       d  [        S5      eU S h  v•N   M/     g  N	7f)Nú*ChainDataset only supports IterableDataset)rS   rh   r   rA   )r   rŽ   s     r!   Ú__iter__ÚChainDataset.__iter__s  s8   é € Ø—”ˆAÜ˜a¤×1Ñ1Ü$Ð%QÓRÐRØ�LŠLò ñ ùs   ‚5A·A¸
Ac                 óŒ   • SnU R                    H1  n[        U[        5      (       d  [        S5      eU[	        U5      -  nM3     U$ )Nr   r©   )rS   rh   r   rA   rZ   )r   ÚtotalrŽ   s      r!   rM   ÚChainDataset.__len__y  sB   € ØˆØ—”ˆAÜ˜a¤×1Ñ1Ü$Ð%QÓRÐRØ”S˜“V‰OŠEñ ð ˆr$   )rS   )r,   r-   r.   r/   r0   r   r   rB   rª   rP   rM   r1   r£   r¤   s   @r!   r   r   d  s6   ø† ñð! ¨'Ñ!2ð !°t÷ !òð˜÷ ò r$   r   c                   óŽ   • \ rS rSr% Sr\\   \S'   \\	   \S'   S\\   S\\	   SS4S jr
S rS\\	   S\\   4S	 jrS\	4S
 jrSrg)r   i‚  a  
Subset of a dataset at specified indices.

.. note::
    When subclassing `Subset` and overriding `__getitem__`, you **must** also
    override `__getitems__` to ensure `DataLoader` works correctly with your
    custom logic. If you override only `__getitem__`, a `NotImplementedError`
    will be raised when using `DataLoader`.

    A simple implementation of `__getitems__` can delegate to `__getitem__`:

    .. code-block:: python

        def __getitems__(self, indices):
            return [self.__getitem__(idx) for idx in indices]

    For better performance, consider implementing batch-aware logic in
    `__getitems__` instead of calling `__getitem__` multiple times.

Args:
    dataset (Dataset): The whole Dataset
    indices (sequence): Indices in the whole set selected for subset
r\   rm   r   Nc                 óø   • Xl         X l        [        U 5      R                  [        R                  LaH  [        U 5      R
                  [        R
                  L a!  [        [        U 5      R                   S35      eg g )Na2   overrides __getitem__ but not __getitems__. When subclassing Subset and overriding __getitem__, you must also override __getitems__ to ensure DataLoader works correctly with your custom logic. A simple implementation:

def __getitems__(self, indices):
    return [self.__getitem__(idx) for idx in indices])r\   rm   Útyper"   r   ro   r   r,   )r   r\   rm   s      r!   rB   ÚSubset.__init__ž  sq   € ØŒØŒô �‹J×"Ñ"¬&×*<Ñ*<Ò<Ü�T“
×'Ñ'¬6×+>Ñ+>Ò>ä%Ü˜“:×&Ñ&Ð'ð (Hð Hóð ð ?ð =r$   c                 óÆ   • [        U[        5      (       a,  U R                  U Vs/ s H  o R                  U   PM     sn   $ U R                  U R                  U      $ s  snf r&   )rh   ra   r\   rm   )r   rz   Úis      r!   r"   ÚSubset.__getitem__°  sP   € Ü�cœ4× Ñ Ø—<‘<¹#Ó >º#°Q§¡¨a¤¹#Ñ >Ñ?Ð?Ø�|‰|˜DŸL™L¨Ñ-Ñ.Ð.ùò !?s   ¥Ac                 ó(  • [        [        U R                  SS 5      5      (       a8  U R                  R                  U Vs/ s H  o R                  U   PM     sn5      $ U Vs/ s H  o R                  U R                  U      PM      sn$ s  snf s  snf )Nro   )rr   rs   r\   ro   rm   )r   rm   rz   s      r!   ro   ÚSubset.__getitems__µ  su   € ô ”G˜DŸL™L¨.¸$Ó?×@Ñ@Ø—<‘<×,Ñ,É7Ó-SÊ7ÀC¯l©l¸3Ô.?É7Ñ-SÓTÐTá?FÓGºw¸—L‘L §¡¨cÑ!2Ô3¹wÑGÐGùò .TùâGs   ¿B
Á"%Bc                 ó,   • [        U R                  5      $ r&   )rZ   rm   rL   s    r!   rM   ÚSubset.__len__½  s   € Ü�4—<‘<Ó Ð r$   )r\   rm   )r,   r-   r.   r/   r0   r   r   rO   r   rP   rB   r"   ra   ro   rM   r1   r+   r$   r!   r   r   ‚  sn   ‡ ñð0 �U‰^ÓØ�c‰]Óð ¨¡ð ¸À#¹ð È4ô ò$/ð
H D¨¡Ið H°$°u±+ô Hð!˜÷ !r$   r   r\   ÚlengthsÚ	generatorr   c           
      ól  • [         R                  " [        U5      S5      (       aí  [        U5      S::  aÞ  / n[        U5       HS  u  pEUS:  d  US:”  a  [	        SU S35      e[         R
                  " [        U 5      U-  5      nUR                  U5        MU     [        U 5      [        U5      -
  n[        U5       H  nU[        U5      -  nX8==   S-  ss'   M     Un[        U5       H&  u  pIU	S:X  d  M  [        R                  " SU S3SS9  M(     [        U5      [        U 5      :w  a  [	        S	5      e[        [        U5      US
9R                  5       n
[        [        [           U5      n[!        ["        R$                  " U5      USS9 VV	s/ s H  u  p¹['        X
X¹-
  U 5      PM     sn	n$ s  sn	nf )aš  
Randomly split a dataset into non-overlapping new datasets of given lengths.

If a list of fractions that sum up to 1 is given,
the lengths will be computed automatically as
floor(frac * len(dataset)) for each fraction provided.

After computing the lengths, if there are any remainders, 1 count will be
distributed in round-robin fashion to the lengths
until there are no remainders left.

Optionally fix the generator for reproducible results, e.g.:

Example:
    >>> # xdoctest: +SKIP
    >>> generator1 = torch.Generator().manual_seed(42)
    >>> generator2 = torch.Generator().manual_seed(42)
    >>> random_split(range(10), [3, 7], generator=generator1)
    >>> random_split(range(30), [0.3, 0.3, 0.4], generator=generator2)

Args:
    dataset (Dataset): Dataset to be split
    lengths (sequence): lengths or fractions of splits to be produced
    generator (Generator): Generator used for the random permutation.
r–   r   zFraction at index z is not between 0 and 1zLength of split at index z- is 0. This might result in an empty dataset.é   )Ú
stacklevelzDSum of input lengths does not equal the length of the input dataset!)r»   Trp   )ÚmathÚiscloseÚsumÚ	enumerater`   ÚfloorrZ   ru   ÚrangeÚwarningsÚwarnr   Útolistr   r   rP   rt   Ú	itertoolsÚ
accumulater   )r\   rº   r»   Úsubset_lengthsr´   ÚfracÚn_items_in_splitÚ	remainderÚidx_to_add_atÚlengthrm   Úoffsets               r!   r   r   Á  s�  € ô< ‡|‚|”C˜“L !×$Ñ$¬¨W«¸Ó):Ø$&ˆÜ  Ö)‰GˆAØ�a‹x˜4 !›8Ü Ð#5°a°SÐ8OÐ!PÓQÐQÜ#Ÿzšz¬#¨g«,¸Ñ*=Ó>ÐØ×!Ñ!Ð"2Ö3ñ	 *ô
 ˜“L¤3 ~Ó#6Ñ6ˆ	ä�yÖ!ˆAØ¤ NÓ 3Ñ3ˆMØÓ)¨QÑ.Õ)ñ "ð !ˆÜ" 7Ö+‰IˆAØ˜�{Ü—’Ø/°¨sð 3=ð >à ôñ ,ô ˆ7ƒ|”s˜7“|Ó#ÜØRó
ð 	
ô ”s˜7“|¨yÑ9×@Ñ@ÓB€GÜ”8œC‘= 'Ó*€Gô "¤)×"6Ò"6°wÓ"?ÀÐQUÒVôâV‰NˆFô 	ˆw ¡°&Ð9Ö:ÙVòð ùó s   ÆF0)&r—   rÈ   r¿   rÅ   Úcollections.abcr   Útypingr   r   r   r   Útyping_extensionsr   Útorchr	   r
   r   r   Ú__all__r   r   ri   ÚstrÚ_T_dictrH   Ú_T_tupler   r   r   r   r   r   r   r   rP   Úfloatra   r   r+   r$   r!   Ú<module>rÚ      s?  ðã Û Û Û Ý $÷ 4Ó 3Ý (÷ AÓ @ò	€ñ ˆTƒ]€Ù� 4Ñ(€Ø
ˆs�EˆzÑ
€Ø�˜�Ñ€Ù�:˜x¨Ó1€ô,ˆg�e‰nô ,ôDn+�g˜e‘n h¨u¡oô n+ôh'�G˜E &¨# +Ñ.Ñ/ô 'ô.T�7˜8Ñ$ô Tôn6%�G˜E‘Nô 6%ôr�?ô ô<<!ˆW�U‰^ô <!ðD #4ñ>Ø�R‰[ð>à�c˜E‘kÑ"ð>ð ˜4Ñð>ð 
ˆ&�‰*Ñö	>r$   