Ë
    Q/æjöJ  ã                   óè  — d dl Z d dlZd dlZd dlZd dlmZmZmZmZm	Z	m
Z
mZmZmZmZ d dlmZ d dlmZmZmZmZ g d¢Z ed«      Z edd¬	«      Zeeef   Zeed
f   Z edee«      Z G d„ dee   «      Z G d„ dee   ee   «      Z G d„ deeed
f      «      Z G d„ dee   «      Z  G d„ dee   «      Z! G d„ de«      Z" G d„ dee   «      Z#efdee   deee$e%f      de
e   de	e#e      fd„Z&y)é    N)
ÚcastÚDictÚGenericÚIterableÚListÚOptionalÚSequenceÚTupleÚTypeVarÚUnion)Ú
deprecated)Údefault_generatorÚ	GeneratorÚrandpermÚTensor)ÚDatasetÚIterableDatasetÚTensorDatasetÚStackDatasetÚConcatDatasetÚChainDatasetÚSubsetÚrandom_splitÚ_TÚ_T_coT)Ú	covariant.Ú_T_stackc                   ó$   — e Zd ZdZdefd„Zdd„Zy)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                 ó   — t        d«      ‚)Nz3Subclasses of Dataset should implement __getitem__.)ÚNotImplementedError©ÚselfÚindexs     ú[/root/repos/pocs/video-evals/.venv/lib/python3.12/site-packages/torch/utils/data/dataset.pyÚ__getitem__zDataset.__getitem__>   s   € Ü!Ð"WÓXÐXó    c                 ó   — t        | |g«      S ©N)r   ©r#   Úothers     r%   Ú__add__zDataset.__add__E   s   € Ü˜d E˜]Ó+Ð+r'   N)r+   zDataset[_T_co]r   zConcatDataset[_T_co])Ú__name__Ú
__module__Ú__qualname__Ú__doc__r   r&   r,   © r'   r%   r   r   +   s   „ ñð$Y Eó Yô,r'   r   c                   ó"   — e Zd ZdZdee   fd„Zy)r   aH  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 code 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)
        >>> # Mult-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 code 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                 ó   — t        | |g«      S r)   )r   r*   s     r%   r,   zIterableDataset.__add__º   s   € Ü˜T 5˜MÓ*Ð*r'   N)r-   r.   r/   r0   r   r   r,   r1   r'   r%   r   r   M   s   „ ñjðX+˜W U™^ô +r'   r   c                   óB   — e Zd ZU dZeedf   ed<   deddfd„Zd„ Zd„ Z	y)	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                 óJ   ‡— t        ˆfd„‰D «       «      sJ d«       ‚‰| _        y )Nc              3   ój   •K  — | ]*  }‰d    j                  d «      |j                  d «      k(  –— Œ, y­w)r   N)Úsize)Ú.0Útensorr5   s     €r%   ú	<genexpr>z)TensorDataset.__init__.<locals>.<genexpr>Í   s0   øè ø€ ò 
Ø5;ˆG�A‰J�O‰O˜AÓ &§+¡+¨a£.Õ0ñ
ùs   ƒ03zSize mismatch between tensors)Úallr5   )r#   r5   s    `r%   Ú__init__zTensorDataset.__init__Ì   s3   ø€ Üó 
Ø?Fô
ô 
ð 	+à*ó	+ð 
ð ˆ�r'   c                 ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3   ó(   •K  — | ]	  }|‰   –— Œ y ­wr)   r1   )r9   r:   r$   s     €r%   r;   z,TensorDataset.__getitem__.<locals>.<genexpr>Ó   s   øè ø€ Ò> v�V˜E•]Ñ>ùó   ƒ)Útupler5   r"   s    `r%   r&   zTensorDataset.__getitem__Ò   s   ø€ ÜÓ>°·±Ô>Ó>Ð>r'   c                 ó>   — | j                   d   j                  d«      S ©Nr   )r5   r8   ©r#   s    r%   Ú__len__zTensorDataset.__len__Õ   s   € Ø�|‰|˜A‰×#Ñ# AÓ&Ð&r'   )
r-   r.   r/   r0   r
   r   Ú__annotations__r=   r&   rE   r1   r'   r%   r   r   Á   s5   … ñð �6˜3�;ÑÓð ð ¨Dó ò?ó'r'   r   c                   ó^   — e Zd ZU dZeeef   ed<   dee	   dee	   ddfd„Z
d„ Zd	efd
„Zd„ Zy)r   a�  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                 óV  ‡ — |rG|rt        d«      ‚t        |d   «      ‰ _        t        ˆ fd„|D «       «      rt        d«      ‚|‰ _        y |rSt        |j                  «       «      }t        |d   «      ‰ _        t        ˆ fd„|D «       «      rt        d«      ‚|‰ _        y t        d«      ‚)NztSupported either ``tuple``- (via ``args``) or``dict``- (via ``kwargs``) like input/output, but both types are given.r   c              3   óN   •K  — | ]  }‰j                   t        |«      k7  –— Œ y ­wr)   ©Ú_lengthÚlen©r9   Údatasetr#   s     €r%   r;   z(StackDataset.__init__.<locals>.<genexpr>ö   s   øè ø€ ÒD°G�4—<‘<¤3 w£<Õ/ÑDùó   ƒ"%zSize mismatch between datasetsc              3   óN   •K  — | ]  }‰j                   t        |«      k7  –— Œ y ­wr)   rM   rP   s     €r%   r;   z(StackDataset.__init__.<locals>.<genexpr>ü   s   øè ø€ ÒC°G�4—<‘<¤3 w£<Õ/ÑCùrR   z%At least one dataset should be passed)Ú
ValueErrorrO   rN   ÚanyrH   ÚlistÚvalues)r#   rI   rJ   Útmps   `   r%   r=   zStackDataset.__init__î   s�   ø€ ÙÙÜ ð^óð ô ˜t A™w›<ˆDŒLÜÓD¸tÔDÔDÜ Ð!AÓBÐBØ ˆD�MÙÜ�v—}‘}“Ó'ˆCÜ˜s 1™v›;ˆDŒLÜÓC¸sÔCÔCÜ Ð!AÓBÐBØ"ˆD�MäÐDÓEÐEr'   c                 óâ   ‡— t        | j                  t        «      r1| j                  j                  «       D ��ci c]  \  }}||‰   “Œ c}}S t	        ˆfd„| j                  D «       «      S c c}}w )Nc              3   ó(   •K  — | ]	  }|‰   –— Œ y ­wr)   r1   )r9   rQ   r$   s     €r%   r;   z+StackDataset.__getitem__.<locals>.<genexpr>  s   øè ø€ ÒA¨�W˜U•^ÑAùr@   )Ú
isinstancerH   ÚdictÚitemsrA   )r#   r$   ÚkrQ   s    `  r%   r&   zStackDataset.__getitem__  sW   ø€ Ü�d—m‘m¤TÔ*Ø8<¿¹×8KÑ8KÓ8M×N©*¨!¨W�A�w˜u‘~Ñ%ÓNÐNÜÓA°4·=±=ÔAÓAÐAùó Os   ¹A+Úindicesc           	      óº  — t        | j                  t        «      rÊ|D �cg c]  }i ‘Œ }}| j                  j                  «       D ]œ  \  }}t	        t        |dd «      «      re|j                  |«      }t        |«      t        |«      k7  r#t        dt        |«      › dt        |«      › �«      ‚t        ||«      D ]
  \  }}|||<   Œ Œ�t        ||«      D ]  \  }	}||	   ||<   Œ Œž |S |D �cg c]  }g ‘Œ }
}| j                  D ]±  }t	        t        |dd «      «      rq|j                  |«      }t        |«      t        |«      k7  r#t        dt        |«      › dt        |«      › �«      ‚t        ||
«      D ]  \  }}|j                  |«       Œ ŒŠt        ||
«      D ]  \  }	}|j                  ||	   «       Œ Œ³ |
D �cg c]  }t        |«      ‘Œ }}|S c c}w c c}w c c}w )NÚ__getitems__z0Nested dataset's output size mismatch. Expected z, got )r[   rH   r\   r]   ÚcallableÚgetattrra   rO   rT   ÚzipÚappendrA   )r#   r_   Ú_Ú
dict_batchr^   rQ   r]   ÚdataÚd_sampleÚidxÚ
list_batchÚt_sampleÚsampleÚtuple_batchs                 r%   ra   zStackDataset.__getitems__  sÿ  € ä�d—m‘m¤TÔ*Ø5<Ö(=°ªÐ(=ˆJÐ(=Ø"Ÿm™m×1Ñ1Ó3ò 3‘
��7ÜœG G¨^¸TÓBÔCØ#×0Ñ0°Ó9�EÜ˜5“z¤S¨£\Ò1Ü(ð)Ü),¨W«¨°f¼SÀ»Z¸LðJóð ô +.¨e°ZÓ*@ò +™˜˜hØ&*˜ šñ+ô *-¨W°jÓ)Aò 3™˜˜XØ&-¨c¡l˜ šñ3ð3ð Ðð /6Ö!6¨¢"Ð!6ˆ
Ð!6Ø—}‘}ò 	2ˆGÜœ ¨¸Ó>Ô?Ø×,Ñ,¨WÓ5�Ü�u“:¤ W£Ò-Ü$ð%Ü%(¨£\ N°&¼¸U»¸ðFóð ô '*¨%°Ó&<ò *‘N�D˜(Ø—O‘O DÕ)ñ*ô &)¨°*Ó%=ò 2‘M�C˜Ø—O‘O G¨C¡LÕ1ñ2ð	2ð DNÖ&N¸¤u¨V¥}Ð&NˆÐ&NØÐùòA )>ùò" "7ùò 'Os   Ÿ	GÃ)	GÆ8Gc                 ó   — | j                   S r)   )rN   rD   s    r%   rE   zStackDataset.__len__,  s   € Ø�|‰|Ðr'   )r-   r.   r/   r0   r   rA   r\   rF   r   r   r=   r&   rV   ra   rE   r1   r'   r%   r   r   Ù   sV   … ñð$ �E˜4�KÑ Ó ðF˜g e™nð F¸À¹ð FÈ4ó Fò(Bð
# Dó #óJr'   r   c                   ó    ‡ — e Zd ZU dZeee      ed<   ee   ed<   e	d„ «       Z
dee   ddfˆ fd„Zd„ Zd	„ Ze ed
e¬«      d„ «       «       Zˆ xZS )r   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
    rH   Úcumulative_sizesc                 ód   — g d}}| D ]&  }t        |«      }|j                  ||z   «       ||z  }Œ( |S rC   )rO   re   )ÚsequenceÚrÚsÚeÚls        r%   ÚcumsumzConcatDataset.cumsum<  sB   € à�1ˆ1ˆØò 	ˆAÜ�A“ˆAØ�H‰H�Q˜‘UŒOØ�‰F‰Að	ð ˆr'   r   Nc                 ó  •— t         ‰| �  «        t        |«      | _        t	        | j                  «      dkD  sJ d«       ‚| j                  D ]  }t        |t        «      sŒJ d«       ‚ | j                  | j                  «      | _        y )Nr   z(datasets should not be an empty iterablez.ConcatDataset does not support IterableDataset)	Úsuperr=   rV   rH   rO   r[   r   rx   rq   )r#   rH   ÚdÚ	__class__s      €r%   r=   zConcatDataset.__init__E  sƒ   ø€ Ü‰ÑÔÜ˜X›ˆŒÜ�4—=‘=Ó! AÒ%ÐQÐ'QÓQÐ%Ø—‘ò 	@ˆAÜ!Ø”?õð @à?ó@ð ð	@ð !%§¡¨D¯M©MÓ :ˆÕr'   c                 ó    — | j                   d   S )Néÿÿÿÿ©rq   rD   s    r%   rE   zConcatDataset.__len__O  s   € Ø×$Ñ$ RÑ(Ð(r'   c                 óú   — |dk  r(| t        | «      kD  rt        d«      ‚t        | «      |z   }t        j                  | j                  |«      }|dk(  r|}n|| j                  |dz
     z
  }| j
                  |   |   S )Nr   z8absolute value of index should not exceed dataset lengthé   )rO   rT   ÚbisectÚbisect_rightrq   rH   )r#   rj   Údataset_idxÚ
sample_idxs       r%   r&   zConcatDataset.__getitem__R  sˆ   € Ø�Š7Øˆt”c˜$“iÒÜ ØNóð ô �d“)˜c‘/ˆCÜ×)Ñ)¨$×*?Ñ*?ÀÓEˆØ˜!ÒØ‰Jà˜t×4Ñ4°[À1±_ÑEÑEˆJØ�}‰}˜[Ñ)¨*Ñ5Ð5r'   z>`cummulative_sizes` attribute is renamed to `cumulative_sizes`)Úcategoryc                 ó   — | j                   S r)   r   rD   s    r%   Úcummulative_sizeszConcatDataset.cummulative_sizes`  s   € ð ×$Ñ$Ð$r'   )r-   r.   r/   r0   r   r   r   rF   ÚintÚstaticmethodrx   r   r=   rE   r&   Úpropertyr   ÚFutureWarningrˆ   Ú__classcell__©r|   s   @r%   r   r   0  s~   ø… ñð �7˜5‘>Ñ"Ó"Ø˜3‘iÓàñó ðð; ¨'Ñ!2ð ;°tõ ;ò)ò6ð ÙØHØôñ%ó	ó ô
%r'   r   c                   ó>   ‡ — e Zd ZdZdee   ddfˆ fd„Zd„ Zd„ Zˆ xZ	S )r   a_  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
    rH   r   Nc                 ó0   •— t         ‰| �  «        || _        y r)   )rz   r=   rH   )r#   rH   r|   s     €r%   r=   zChainDataset.__init__t  s   ø€ Ü‰ÑÔØ ˆ�r'   c              #   ót   K  — | j                   D ]#  }t        |t        «      sJ d«       ‚|E d {  –—†  Œ% y 7 Œ­w)Nú*ChainDataset only supports IterableDataset)rH   r[   r   )r#   r{   s     r%   Ú__iter__zChainDataset.__iter__x  sF   è ø€ Ø—‘ò 	ˆAÜØ”?ôð <à;ó<ð ð �L‰Lñ		ð ús   ‚,8®6¯8c                 óv   — d}| j                   D ]'  }t        |t        «      sJ d«       ‚|t        |«      z  }Œ) |S )Nr   r’   )rH   r[   r   rO   )r#   Útotalr{   s      r%   rE   zChainDataset.__len__  sO   € ØˆØ—‘ò 	ˆAÜØ”?ôð <à;ó<ð ð ”S˜“V‰O‰Eð		ð
 ˆr'   )
r-   r.   r/   r0   r   r   r=   r“   rE   r�   rŽ   s   @r%   r   r   i  s*   ø„ ñð! ¨'Ñ!2ð !°tõ !òör'   r   c                   óz   — e Zd ZU dZee   ed<   ee   ed<   dee   dee   ddfd„Z	d„ Z
dee   dee   fd„Zd	„ Zy)
r   z´
    Subset of a dataset at specified indices.

    Args:
        dataset (Dataset): The whole Dataset
        indices (sequence): Indices in the whole set selected for subset
    rQ   r_   r   Nc                 ó    — || _         || _        y r)   )rQ   r_   )r#   rQ   r_   s      r%   r=   zSubset.__init__•  s   € ØˆŒØˆ�r'   c                 ó¸   — t        |t        «      r*| j                  |D �cg c]  }| j                  |   ‘Œ c}   S | j                  | j                  |      S c c}w r)   )r[   rV   rQ   r_   )r#   rj   Úis      r%   r&   zSubset.__getitem__™  sK   € Ü�cœ4Ô Ø—<‘<¸#Ö >°Q §¡¨a£Ò >Ñ?Ð?Ø�|‰|˜DŸL™L¨Ñ-Ñ.Ð.ùò !?s    Ac                 ó  — t        t        | j                  dd «      «      r6| j                  j                  |D �cg c]  }| j                  |   ‘Œ c}«      S |D �cg c]  }| j                  | j                  |      ‘Œ  c}S c c}w c c}w )Nra   )rb   rc   rQ   ra   r_   )r#   r_   rj   s      r%   ra   zSubset.__getitems__ž  sn   € ô ”G˜DŸL™L¨.¸$Ó?Ô@Ø—<‘<×,Ñ,È7Ö-SÀC¨d¯l©l¸3Ó.?Ò-SÓTÐTà?FÖG¸�D—L‘L §¡¨cÑ!2Ó3ÒGÐGùò .TùâGs   ºBÁ#Bc                 ó,   — t        | j                  «      S r)   )rO   r_   rD   s    r%   rE   zSubset.__len__¦  s   € Ü�4—<‘<Ó Ð r'   )r-   r.   r/   r0   r   r   rF   r	   r‰   r=   r&   r   ra   rE   r1   r'   r%   r   r   ‰  sg   … ñð �U‰^ÓØ�c‰]Óð ¨¡ð ¸À#¹ð È4ó ò/ð
H D¨¡Ið H°$°u±+ó Hó!r'   r   rQ   ÚlengthsÚ	generatorr   c           
      ód  — t        j                  t        |«      d«      rít        |«      dk  rßg }t        |«      D ]Y  \  }}|dk  s|dkD  rt	        d|› d�«      ‚t        t        j                  t        | «      |z  «      «      }|j                  |«       Œ[ t        | «      t        |«      z
  }t        |«      D ]  }|t        |«      z  }||xx   dz  cc<   Œ |}t        |«      D ]$  \  }}	|	dk(  sŒt        j                  d|› d�«       Œ& t        |«      t        | «      k7  rt	        d«      ‚t        t        |«      |¬«      j                  «       }
t        t        t
           |«      }t!        t#        j$                  |«      |«      D ��	cg c]  \  }}	t'        | |
||	z
  | «      ‘Œ c}	}S c c}	}w )	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.zDSum of input lengths does not equal the length of the input dataset!)r�   )ÚmathÚiscloseÚsumÚ	enumeraterT   r‰   ÚfloorrO   re   ÚrangeÚwarningsÚwarnr   Útolistr   r	   rd   Ú	itertoolsÚ
accumulater   )rQ   rœ   r�   Úsubset_lengthsr™   ÚfracÚn_items_in_splitÚ	remainderÚidx_to_add_atÚlengthr_   Úoffsets               r%   r   r   ª  s´  € ô< ‡|�|”C˜“L !Ô$¬¨W«¸Ò):Ø$&ˆÜ  Ó)ò 	4‰GˆAˆtØ�aŠx˜4 !š8Ü Ð#5°a°SÐ8OÐ!PÓQÐQÜ"Ü—
‘
œ3˜w›<¨$Ñ.Ó/ó Ðð ×!Ñ!Ð"2Õ3ð	4ô ˜“L¤3 ~Ó#6Ñ6ˆ	ä�yÓ!ò 	/ˆAØ¤ NÓ 3Ñ3ˆMØ˜=Ó)¨QÑ.Ô)ð	/ð !ˆÜ" 7Ó+ò 	‰IˆAˆvØ˜‹{Ü—‘Ø/°¨sð 3=ð >õð	ô ˆ7ƒ|”s˜7“|Ò#ÜØRó
ð 	
ô ”s˜7“|¨yÔ9×@Ñ@ÓB€GÜ”8œC‘= 'Ó*€Gô "¤)×"6Ñ"6°wÓ"?ÀÓI÷áˆF�Fô 	ˆw˜ ¨¡°&Ð9Õ:óð ùó s   ÆF,)'r‚   r¨   rŸ   r¥   Útypingr   r   r   r   r   r   r	   r
   r   r   Útyping_extensionsr   Útorchr   r   r   r   Ú__all__r   r   ÚstrÚ_T_dictÚ_T_tupler   r   r   r   r   r   r   r   r‰   Úfloatr   r1   r'   r%   ú<module>r¹      sK  ðã Û Û Û ÷÷ ÷ õ )÷ AÓ @ò	€ñ ˆTƒ]€Ù� 4Ô(€Ø
ˆs�EˆzÑ
€Ø�˜�Ñ€Ù�:˜x¨Ó1€ô,ˆg�e‰nô ,ôDn+�g˜e‘n h¨u¡oô n+ôh'�G˜E &¨# +Ñ.Ñ/ô 'ô0T�7˜8Ñ$ô Tôn6%�G˜E‘Nô 6%ôr�?ô ô@!ˆW�U‰^ô !ðH &7ñ?Ø�R‰[ð?à�e˜C ˜JÑ'Ñ(ð?ð ˜	Ñ"ð?ð 
ˆ&�‰*Ñô	?r'   