+
    ˜°³jÙQ  ã                   óü  € ^ RI t ^ RIt^ RIt^ RIt^ RIHt ^ RIHtHtH	t	H
t
 ^ RIHt ^ RIHtHtHtHt . ROt]
! R4      t]
! RRR7      t]]]3,          t]]R3,          t]
! R]]4      t ! R R]],          4      t ! R R]],          ]	],          4      t ! R R]]]R3,          ,          4      t ! R R	]],          4      t ! R R
]],          4      t ! R R]4      t  ! R R]],          4      t!]3R R llt"R# )é    N)ÚSequence)ÚcastÚGenericÚIterableÚTypeVar)Ú
deprecated)Údefault_generatorÚ	GeneratorÚrandpermÚTensorÚDatasetÚIterableDatasetÚTensorDatasetÚStackDatasetÚConcatDatasetÚChainDatasetÚSubsetÚ_TÚ_T_coT)Ú	covariant.Ú_T_stackc                   óH   a € ] tR t^'t o RtV 3R lR ltV 3R lR ltRtV tR# )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.
c                ó    <€ V ^8„  d   QhRS[ /# ©é   Úreturn)r   )ÚformatÚ__classdict__s   "€ÚY/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/utils/data/dataset.pyÚ__annotate__ÚDataset.__annotate__:   s   ø€ ÷ Yñ Y¡Eñ Yó    c                ó   € \        R 4      h)z3Subclasses of Dataset should implement __getitem__.)ÚNotImplementedError©ÚselfÚindexs   &&r   Ú__getitem__ÚDataset.__getitem__:   s   € Ü!Ð"WÓXÐXr"   c                ó"   <€ V ^8„  d   QhRRRR/# )r   ÚotherzDataset[_T_co]r   zConcatDataset[_T_co]© )r   r   s   "€r   r    r!   A   s   ø€ ÷ ,ñ ,Ð-ð ,Ð2Hñ ,r"   c                ó   € \        W.4      # ©N)r   ©r&   r+   s   &&r   Ú__add__ÚDataset.__add__A   s   € Ü˜d˜]Ó+Ð+r"   r,   N)	Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r(   r0   Ú__static_attributes__Ú__classdictcell__©r   s   @r   r   r   '   s    ø‡ € ñ÷$Yð Y÷,ö ,r"   c                   ó6   a € ] tR t^It o RtV 3R lR ltRtV tR# )r   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)
    ...

    >>> # Multi-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]
c                ó0   <€ V ^8„  d   QhRS[ S[,          /# )r   r+   ©r   r   )r   r   s   "€r   r    ÚIterableDataset.__annotate__¶   s   ø€ ÷ +ñ +™W¡U�^ñ +r"   c                ó   € \        W.4      # r.   )r   r/   s   &&r   r0   ÚIterableDataset.__add__¶   s   € Ü˜T˜MÓ*Ð*r"   r,   N)r2   r3   r4   r5   r6   r0   r7   r8   r9   s   @r   r   r   I   s   ø‡ € ñj÷X+ö +r"   c                   óZ   a € ] tR t^½t o RtV 3R lR ltR tV 3R lR ltV 3R ltRt	V t
R	# )
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.
c                ó$   <€ V ^8„  d   QhRS[ RR/# )r   Útensorsr   N)r   )r   r   s   "€r   r    ÚTensorDataset.__annotate__È   s   ø€ ÷ ñ ¡ð ¨Dñ r"   c                ó¬   a€ \         ;QJ d    V3R  lS 4       F  '       g   K   RM	  RM! V3R  lS 4       4      '       d   \        R4      hSV n        R# )c              3   óx   <"  € T F/  pS^ ,          P                  ^ 4      VP                  ^ 4      8g  x € K1  	  R# 5i)r   N)Úsize)Ú.0ÚtensorrB   s   & €r   Ú	<genexpr>Ú)TensorDataset.__init__.<locals>.<genexpr>É   s+   øé € ÐJÁ'¸ˆw�q�z�‰˜qÓ! V§[¡[°£^Ö3Ã'ùs   ƒ7:TFzSize mismatch between tensorsN)ÚanyÚAssertionErrorrB   )r&   rB   s   &jr   Ú__init__ÚTensorDataset.__init__È   s7   ø€ ß‹3ÔJÁ'ÓJ�3�3Š3ÔJÁ'ÓJ×JÒJÜ Ð!@ÓAÐAØˆŽr"   c                ó�   a€ \         ;QJ d!    . V3R  lV P                   4       F  NK  	  5# ! V3R  lV P                   4       4      # )c              3   ó4   <"  € T F  qS,          x € K  	  R # 5ir.   r,   )rG   rH   r'   s   & €r   rI   Ú,TensorDataset.__getitem__.<locals>.<genexpr>Î   s   øé € Ð>± v˜E—]’]³ùó   ƒ)ÚtuplerB   r%   s   &fr   r(   ÚTensorDataset.__getitem__Í   s-   ø€ ßŒuÔ>°·²Ó>�uÐ>ˆuÔ>°·²Ó>Ó>Ð>r"   c                ó    <€ V ^8„  d   QhRS[ /# r   ©Úint)r   r   s   "€r   r    rC   Ð   s   ø€ ÷ 'ñ '™ñ 'r"   c                óF   € V P                   ^ ,          P                  ^ 4      # ©r   )rB   rF   ©r&   s   &r   Ú__len__ÚTensorDataset.__len__Ð   s   € Ø�|‰|˜A�×#Ñ# AÓ&Ð&r"   c                ó:   <€ V ^8„  d   Qh/ S[ S[R3,          ;R&   # )r   .rB   )rS   r   )r   r   s   "€r   r    rC   ½   s   ø‡ ‚ ñ ‘6˜3�;ÕÑò r"   )rB   N)r2   r3   r4   r5   r6   rM   r(   r[   Ú__annotate_func__r7   r8   r9   s   @r   r   r   ½   s*   ø‡ € ñ÷ð ò
?÷'ð '÷' ƒ r"   c                   ól   a € ] tR t^Ôt o RtV 3R lR ltR tV 3R lR ltV 3R lR ltV 3R	 lt	R
t
V tR# )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.
c                óJ   <€ V ^8„  d   QhRS[ S[,          RS[ S[,          RR/# )r   ÚargsÚkwargsr   Nr<   )r   r   s   "€r   r    ÚStackDataset.__annotate__é   s/   ø€ ÷ Fñ F™g¡e�nð F¹Á½ð FÈ4ñ Fr"   c                ó>  a € V'       d   V'       d   \        R 4      h\        V^ ,          4      S n        \        ;QJ d    V 3R lV 4       F  '       g   K   RM	  RM! V 3R lV 4       4      '       d   \        R4      hVS n        R# V'       d…   \        VP                  4       4      p\        V^ ,          4      S n        \        ;QJ d    V 3R lV 4       F  '       g   K   RM	  RM! V 3R lV 4       4      '       d   \        R4      hVS n        R# \        R4      h)ztSupported either ``tuple``- (via ``args``) or``dict``- (via ``kwargs``) like input/output, but both types are given.c              3   óT   <"  € T F  pSP                   \        V4      8g  x € K  	  R # 5ir.   ©Ú_lengthÚlen©rG   Údatasetr&   s   & €r   rI   Ú(StackDataset.__init__.<locals>.<genexpr>ñ   s   øé € ÐD¹t°G�4—<‘<¤3 w£<Ö/»tùó   ƒ%(TFzSize mismatch between datasetsc              3   óT   <"  € T F  pSP                   \        V4      8g  x € K  	  R # 5ir.   rf   ri   s   & €r   rI   rk   ÷   s   øé € ÐC¹s°G�4—<‘<¤3 w£<Ö/»sùrl   z%At least one dataset should be passedN)Ú
ValueErrorrh   rg   rK   ÚdatasetsÚlistÚvalues)r&   ra   rb   Útmps   f*, r   rM   ÚStackDataset.__init__é   sÃ   ø€ ßßÜ ð^óð ô ˜t A�w›<ˆDŒLß‹sÔD¹tÓD�s�sŠsÔD¹tÓD×DÒDÜ Ð!AÓBÐBØ ˆDŽMßÜ�v—}‘}“Ó'ˆCÜ˜s 1�v›;ˆDŒLß‹sÔC¹sÓC�s�sŠsÔC¹sÓC×CÒCÜ Ð!AÓBÐBØ"ˆDŽMäÐDÓEÐEr"   c                óF  a€ \        V P                  \        4      '       d6   V P                  P                  4        UUu/ uF  w  r#W#S,          bK  	  upp# \        ;QJ d!    . V3R  lV P                   4       F  NK  	  5# ! V3R  lV P                   4       4      # u uppi )c              3   ó4   <"  € T F  qS,          x € K  	  R # 5ir.   r,   )rG   rj   r'   s   & €r   rI   Ú+StackDataset.__getitem__.<locals>.<genexpr>   s   øé € ÐA±=¨˜U—^’^³=ùrR   )Ú
isinstancero   ÚdictÚitemsrS   )r&   r'   Úkrj   s   &f  r   r(   ÚStackDataset.__getitem__ý   sq   ø€ Ü�d—m‘m¤T×*Ò*Ø8<¿¹×8KÑ8KÔ8MÔNÑ8M©*¨!�A˜u•~Ò%Ñ8MÒNÐNßŒuÔA°4·=²=ÓA�uÐAˆuÔA°4·=²=ÓAÓAÐAùó Os   ¿Bc                ó    <€ V ^8„  d   QhRS[ /# )r   Úindices)rp   )r   r   s   "€r   r    rc     s   ø€ ÷ #ñ #¡Dñ #r"   c           	     ó  € \        V P                  \        4      '       dÜ   V Uu. uF  p/ NK  	  ppV P                  P                  4        Fª  w  rE\	        \        VR R4      4      '       dj   VP                  V4      p\        V4      \        V4      8w  d$   \        R\        V4       R\        V4       24      h\        WcRR7       F	  w  rxWxV&   K  	  KŠ  \        WRR7       F  w  r˜WY,          W„&   K  	  K¬  	  V# V Uu. uF  p. NK  	  p
pV P                   FÂ  p\	        \        VR R4      4      '       dw   VP                  V4      p\        V4      \        V4      8w  d$   \        R\        V4       R\        V4       24      h\        WjRR7       F  w  r{VP                  V4       K  	  K•  \        WRR7       F  w  r›VP                  WY,          4       K  	  KÄ  	  V
 Uu. uF  p\        V4      NK  	  ppV# u upi u upi u upi )Ú__getitems__Nz0Nested dataset's output size mismatch. Expected z, got T©Ústrict)rw   ro   rx   ry   ÚcallableÚgetattrr   rh   rn   ÚzipÚappendrS   )r&   r}   Ú_Ú
dict_batchrz   rj   ry   ÚdataÚd_sampleÚidxÚ
list_batchÚt_sampleÚsampleÚtuple_batchs   &&            r   r   Ú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;Ä H Ç#Hc                ó    <€ V ^8„  d   QhRS[ /# r   rV   )r   r   s   "€r   r    rc   '  s   ø€ ÷ ñ ™ñ r"   c                ó   € V P                   # r.   )rg   rZ   s   &r   r[   ÚStackDataset.__len__'  s   € Ø�|‰|Ðr"   c                ó6   <€ V ^8„  d   Qh/ S[ S[,          ;R&   # )r   ro   )rS   rx   )r   r   s   "€r   r    rc   Ô   s   ø‡ ‚ ñ& ‘d�lÑò' r"   )rg   ro   N©r2   r3   r4   r5   r6   rM   r(   r   r[   r^   r7   r8   r9   s   @r   r   r   Ô   s9   ø‡ € ñ÷(Fð Fò(B÷
#ð #÷Jð ÷g ƒ r"   c                   ó    a a€ ] tR tRt oRt]R 4       tV3R lV 3R lltV3R lR ltR t	]
]! R	]R
7      R 4       4       tV3R ltRtVtV ;t# )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
c                ór   € . ^ r!V  F-  p\        V4      pVP                  WB,           4       W$,          pK/  	  V# rY   )rh   r…   )ÚsequenceÚrÚsÚeÚls   &    r   ÚcumsumÚConcatDataset.cumsum7  s7   € à�1ˆ1ÛˆAÜ�A“ˆAØ�H‰H�Q•UŒOØ�FŠAñ ð ˆr"   c                ó4   <€ V ^8„  d   QhRS[ S[,          RR/# ©r   ro   r   N©r   r   )r   r   s   "€r   r    ÚConcatDataset.__annotate__@  s    ø€ ÷ ;ñ ;¡©'Õ!2ð ;°tñ ;r"   c                ó6  <€ \         SV `  4        \        V4      V n        \	        V P                  4      ^ 8X  d   \        R4      hV P                   F$  p\        V\        4      '       g   K  \        R4      h	  V P                  V P                  4      V n	        R# )r   z(datasets should not be an empty iterablez.ConcatDataset does not support IterableDatasetN)
ÚsuperrM   rp   ro   rh   rL   rw   r   rœ   Úcumulative_sizes)r&   ro   ÚdÚ	__class__s   && €r   rM   ÚConcatDataset.__init__@  st   ø€ Ü‰ÑÔÜ˜X›ˆŒÜˆt�}‰}Ó Ô"Ü Ð!KÓLÐLØ—”ˆAÜ˜!œ_×-Ô-Ü$Ð%UÓVÐVñ ð !%§¡¨D¯M©MÓ :ˆÖr"   c                ó    <€ V ^8„  d   QhRS[ /# r   rV   )r   r   s   "€r   r    r¡   J  s   ø€ ÷ )ñ )™ñ )r"   c                ó(   € V P                   R,          # )é   éÿÿÿÿ©r¤   rZ   s   &r   r[   ÚConcatDataset.__len__J  s   € Ø×$Ñ$ RÕ(Ð(r"   c                ó6  € V^ 8  d/   V) \        V 4      8”  d   \        R4      h\        V 4      V,           p\        P                  ! V P                  V4      pV^ 8X  d   TpM WP                  V^,
          ,          ,
          pV P
                  V,          V,          # )r   z8absolute value of index should not exceed dataset length)rh   rn   ÚbisectÚbisect_rightr¤   ro   )r&   rŠ   Ú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                ó   € V P                   # r.   r¬   rZ   s   &r   Úcummulative_sizesÚConcatDataset.cummulative_sizes[  s   € ð ×$Ñ$Ð$r"   c                ób   <€ V ^8„  d   Qh/ S[ S[S[,          ,          ;R&   S[ S[,          ;R&   # )r   ro   r¤   )rp   r   r   rW   )r   r   s   "€r   r    r¡   +  s,   ø‡ ‚ ñ ‘7™5•>Õ"Ñ"ñ ñ ™3•iÑò r"   )r¤   ro   )r2   r3   r4   r5   r6   Ústaticmethodrœ   rM   r[   r(   Úpropertyr   ÚFutureWarningr¶   r^   r7   r8   Ú__classcell__©r¦   r   s   @@r   r   r   +  sf   ù‡ € ñð ñó ð÷;ó ;÷)ð )ò6ð ÙØHØôñ%ó	ó ð
%÷k … r"   c                   óZ   a a€ ] tR tRt oRtV3R lV 3R lltR tV3R lR ltRtVt	V ;t
# )	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
c                ó4   <€ V ^8„  d   QhRS[ S[,          RR/# rŸ   r    )r   r   s   "€r   r    ÚChainDataset.__annotate__o  s    ø€ ÷ !ñ !¡©'Õ!2ð !°tñ !r"   c                ó0   <€ \         SV `  4        Wn        R # r.   )r£   rM   ro   )r&   ro   r¦   s   &&€r   rM   ÚChainDataset.__init__o  s   ø€ Ü‰ÑÔØ Žr"   c              #  óŽ   "  € V P                    F.  p\        V\        4      '       g   \        R 4      hT Rj  x€L
  K0  	  R#  L
5i)ú*ChainDataset only supports IterableDatasetN)ro   rw   r   rL   )r&   r¥   s   & r   Ú__iter__ÚChainDataset.__iter__s  s8   é € Ø—”ˆAÜ˜a¤×1Ò1Ü$Ð%QÓRÐRØ�LŠLó ñ ùs   ‚6A¸A¹Ac                ó    <€ V ^8„  d   QhRS[ /# r   rV   )r   r   s   "€r   r    rÀ   y  s   ø€ ÷ ñ ™ñ r"   c                ó–   € ^ pV P                    F6  p\        V\        4      '       g   \        R4      hV\	        V4      ,          pK8  	  V# )r   rÄ   )ro   rw   r   rL   rh   )r&   Útotalr¥   s   &  r   r[   ÚChainDataset.__len__y  sB   € ØˆØ—”ˆAÜ˜a¤×1Ò1Ü$Ð%QÓRÐRØ”S˜“V�OŠEñ ð ˆr"   )ro   )r2   r3   r4   r5   r6   rM   rÅ   r[   r7   r8   r¼   r½   s   @@r   r   r   d  s(   ù‡ € ñ÷!ó !ò÷÷ ð r"   c                   ól   a € ] tR tRt o RtV 3R lR ltR tV 3R lR ltV 3R lR	 ltV 3R
 lt	Rt
V tR# )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
c                óJ   <€ V ^8„  d   QhRS[ S[,          RS[S[,          RR/# )r   rj   r}   r   N©r   r   r   rW   )r   r   s   "€r   r    ÚSubset.__annotate__ž  s*   ø€ ÷ ñ ¡©¥ð ¹Á#½ð È4ñ r"   c                ó   € Wn         W n        \        V 4      P                  \        P                  JdK   \        V 4      P
                  \        P
                  J d"   \        \        V 4      P                   R 24      hR# R# )a2   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]N)rj   r}   Útyper(   r   r   r$   r2   )r&   rj   r}   s   &&&r   rM   ÚSubset.__init__ž  sq   € ØŒØŒô �‹J×"Ñ"¬&×*<Ñ*<Ó<Ü�T“
×'Ñ'¬6×+>Ñ+>Ó>ä%Ü˜“:×&Ñ&Ð'ð (Hð Hóð ñ ?ñ =r"   c                óæ   € \        V\        4      '       d4   V P                  V Uu. uF  q P                  V,          NK  	  up,          # V P                  V P                  V,          ,          # u upi r.   )rw   rp   rj   r}   )r&   rŠ   Úis   && r   r(   ÚSubset.__getitem__°  sR   € Ü�cœ4× Ò Ø—<‘<¹#Ó >¹#°Q§¡¨a§ ¹#Ñ >Õ?Ð?Ø�|‰|˜DŸL™L¨Õ-Õ.Ð.ùò !?s   ¦A.c                óF   <€ V ^8„  d   QhRS[ S[,          RS[ S[,          /# )r   r}   r   )rp   rW   r   )r   r   s   "€r   r    rÎ   µ  s'   ø€ ÷ Hñ H¡D©¥Ið H±$±uµ+ñ Hr"   c                ó>  € \        \        V P                  R R4      4      '       d<   V P                  P                  V Uu. uF  q P                  V,          NK  	  up4      # V Uu. uF&  q P                  V P                  V,          ,          NK(  	  up# u upi u upi )r   N)r‚   rƒ   rj   r   r}   )r&   r}   rŠ   s   && r   r   ÚSubset.__getitems__µ  s{   € ô ”G˜DŸL™L¨.¸$Ó?×@Ò@Ø—<‘<×,Ñ,É7Ó-SÉ7ÀC¯l©l¸3×.?Ð.?É7Ñ-SÓTÐTá?FÓG¹w¸—L‘L §¡¨cÕ!2×3Ð3¹wÑGÐGùò .TùâGs   Á BÁ&,Bc                ó    <€ V ^8„  d   QhRS[ /# r   rV   )r   r   s   "€r   r    rÎ   ½  s   ø€ ÷ !ñ !™ñ !r"   c                ó,   € \        V P                  4      # r.   )rh   r}   rZ   s   &r   r[   ÚSubset.__len__½  s   € Ü�4—<‘<Ó Ð r"   c                óR   <€ V ^8„  d   Qh/ S[ S[,          ;R&   S[S[,          ;R&   # )r   rj   r}   rÍ   )r   r   s   "€r   r    rÎ   ‚  s'   ø‡ ‚ ñ2 ‘U�^Ññ3 ñ4 ‘c�]Ñò5 r"   )rj   r}   Nr”   r9   s   @r   r   r   ‚  s7   ø‡ € ñ÷6ð ò$/÷
Hð H÷!ð !÷w ƒ r"   c          
      óÄ   € V ^8„  d   QhR\         \        ,          R\        \        \        ,          ,          R\
        R,          R\        \        \        ,          ,          /# )r   rj   ÚlengthsÚ	generatorNr   )r   r   r   rW   Úfloatr
   rp   r   )r   s   "r   r    r    Á  sK   € ÷ >ñ >Ü”R�[ð>ä”cœE•kÕ"ð>ô ˜4Õð>ô 
Œ&”�*Õñ	>r"   c           
     óÂ  € \         P                  ! \        V4      ^4      '       Ed	   \        V4      ^8:  dù   . p\        V4       FY  w  rEV^ 8  g   V^8”  d   \	        RV R24      h\         P
                  ! \        V 4      V,          4      pVP                  V4       K[  	  \        V 4      \        V4      ,
          p\        V4       F)  pV\        V4      ,          pW8;;,          ^,          uu&   K+  	  Tp\        V4       F*  w  rIV	^ 8X  g   K  \        P                  ! RV R2^R7       K,  	  \        V4      \        V 4      8w  d   \	        R4      h\        \        V4      VR7      P                  4       p
\        \        \        ,          V4      p\!        \"        P$                  ! V4      VRR	7       UU	u. uF  w  r¹\'        W
W¹,
          V 4      NK  	  up	p# u up	pi )
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.
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Þ   Tr€   )ÚmathÚiscloseÚsumÚ	enumeratern   Úfloorrh   r…   ÚrangeÚwarningsÚwarnr   Útolistr   r   rW   r„   Ú	itertoolsÚ
accumulater   )rj   rÝ   rÞ   Úsubset_lengthsrÓ   ÚfracÚn_items_in_splitÚ	remainderÚidx_to_add_atÚlengthr}   Úoffsets   &&&         r   Úrandom_splitrô   Á  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   Æ8G)r   r   r   r   r   r   r   rô   )#r¯   rë   râ   rè   Úcollections.abcr   Útypingr   r   r   r   Útyping_extensionsr   Útorchr	   r
   r   r   Ú__all__r   r   rx   ÚstrÚ_T_dictrS   Ú_T_tupler   r   r   r   r   r   r   r   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"   