Ë
    [^(hL  ã                   óä  — d dl Z d dlZd dlZd dlZd dlmZ d dl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)ÚSequence)ÚcastÚGenericÚIterableÚOptionalÚ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     úV/var/www/skyplay_api_hub/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__A   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   aI  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)
        >>> # 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 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,   r-   r   r   r)   r.   r$   r"   r   r   I   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Útensorr2   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)Úallr2   )r    r2   s    `r"   Ú__init__zTensorDataset.__init__È   s3   ø€ Üó 
Ø?Fô
ô 
ð 	+à*ó	+ð 
ð ˆ�r$   c                 ó@   ‡— t        ˆfd„| j                  D «       «      S )Nc              3   ó(   •K  — | ]	  }|‰   –— Œ y ­wr&   r.   )r6   r7   r!   s     €r"   r8   z,TensorDataset.__getitem__.<locals>.<genexpr>Ï   s   øè ø€ Ò> v�V˜E•]Ñ>ùó   ƒ)Útupler2   r   s    `r"   r#   zTensorDataset.__getitem__Î   s   ø€ ÜÓ>°·±Ô>Ó>Ð>r$   c                 ó>   — | j                   d   j                  d«      S ©Nr   )r2   r5   ©r    s    r"   Ú__len__zTensorDataset.__len__Ñ   s   € Ø�|‰|˜A‰×#Ñ# AÓ&Ð&r$   )
r*   r+   r,   r-   r>   r   Ú__annotations__r:   r#   rB   r.   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©r6   Údatasetr    s     €r"   r8   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&   rJ   rM   s     €r"   r8   z(StackDataset.__init__.<locals>.<genexpr>ø   s   øè ø€ ÒC°G�4—<‘<¤3 w£<Õ/ÑCùrO   z%At least one dataset should be passed)Ú
ValueErrorrL   rK   ÚanyrE   ÚlistÚvalues)r    rF   rG   Ú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&   r.   )r6   rN   r!   s     €r"   r8   z+StackDataset.__getitem__.<locals>.<genexpr>  s   øè ø€ ÒA¨�W˜U•^ÑAùr=   )Ú
isinstancerE   ÚdictÚitemsr>   )r    r!   ÚkrN   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 )rX   rE   rY   rZ   ÚcallableÚgetattrr^   rL   rQ   ÚzipÚappendr>   )r    r\   Ú_Ú
dict_batchr[   rN   rZ   ÚdataÚd_sampleÚidxÚ
list_batchÚt_sampleÚsampleÚtuple_batchs                 r"   r^   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&   )rK   rA   s    r"   rB   zStackDataset.__len__(  s   € Ø�|‰|Ðr$   )r*   r+   r,   r-   r	   r>   rY   rC   r   r   r:   r#   rS   r^   rB   r.   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
    rE   Úcumulative_sizesc                 ód   — g d}}| D ]&  }t        |«      }|j                  ||z   «       ||z  }Œ( |S r@   )rL   rb   )ÚsequenceÚrÚsÚeÚls        r"   ÚcumsumzConcatDataset.cumsum8  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:   rS   rE   rL   rX   r   ru   rn   )r    rE   ÚdÚ	__class__s      €r"   r:   zConcatDataset.__init__A  sƒ   ø€ Ü‰ÑÔÜ˜X›ˆŒÜ�4—=‘=Ó! AÒ%ÐQÐ'QÓQÐ%Ø—‘ò 	@ˆAÜ!Ø”?õð @à?ó@ð ð	@ð !%§¡¨D¯M©MÓ :ˆÕr$   c                 ó    — | j                   d   S )Néÿÿÿÿ©rn   rA   s    r"   rB   zConcatDataset.__len__K  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é   )rL   rQ   ÚbisectÚbisect_rightrn   rE   )r    rg   Údataset_idxÚ
sample_idxs       r"   r#   zConcatDataset.__getitem__N  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|   rA   s    r"   Úcummulative_sizeszConcatDataset.cummulative_sizes\  s   € ð ×$Ñ$Ð$r$   )r*   r+   r,   r-   rS   r   r   rC   ÚintÚstaticmethodru   r   r:   rB   r#   Úpropertyr
   ÚFutureWarningr…   Ú__classcell__©ry   s   @r"   r   r   ,  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
    rE   r   Nc                 ó0   •— t         ‰| �  «        || _        y r&   )rw   r:   rE   )r    rE   ry   s     €r"   r:   zChainDataset.__init__p  s   ø€ Ü‰ÑÔØ ˆ�r$   c              #   ót   K  — | j                   D ]#  }t        |t        «      sJ d«       ‚|E d {  –—†  Œ% y 7 Œ­w)Nú*ChainDataset only supports IterableDataset)rE   rX   r   )r    rx   s     r"   Ú__iter__zChainDataset.__iter__t  sF   è ø€ Ø—‘ò 	ˆAÜØ”?ôð <à;ó<ð ð �L‰Lñ		ð ús   ‚,8®6¯8c                 óv   — d}| j                   D ]'  }t        |t        «      sJ d«       ‚|t        |«      z  }Œ) |S )Nr   r�   )rE   rX   r   rL   )r    Útotalrx   s      r"   rB   zChainDataset.__len__{  sO   € ØˆØ—‘ò 	ˆAÜØ”?ôð <à;ó<ð ð ”S˜“V‰O‰Eð		ð
 ˆr$   )
r*   r+   r,   r-   r   r   r:   r�   rB   rŠ   r‹   s   @r"   r   r   e  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
    rN   r\   r   Nc                 ó    — || _         || _        y r&   )rN   r\   )r    rN   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&   )rX   rS   rN   r\   )r    rg   Ú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 )Nr^   )r_   r`   rN   r^   r\   )r    r\   rg   s      r"   r^   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&   )rL   r\   rA   s    r"   rB   zSubset.__len__¢  s   € Ü�4—<‘<Ó Ð r$   )r*   r+   r,   r-   r   r   rC   r   r†   r:   r#   rS   r^   rB   r.   r$   r"   r   r   …  sg   … ñð �U‰^ÓØ�c‰]Óð ¨¡ð ¸À#¹ð È4ó ò/ð
H D¨¡Ið H°$°u±+ó Hó!r$   r   rN   Ú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Ú	enumeraterQ   r†   ÚfloorrL   rb   ÚrangeÚwarningsÚwarnr   Útolistr   r   ra   Ú	itertoolsÚ
accumulater   )rN   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¢   Úcollections.abcr   Útypingr   r   r   r   r   r	   Útyping_extensionsr
   Útorchr   r   r   r   Ú__all__r   r   rY   ÚstrÚ_T_dictr>   Ú_T_tupler   r   r   r   r   r   r   r   r†   ÚfloatrS   r   r.   r$   r"   ú<module>r·      sF  ðã Û Û Û Ý $÷ E× DÝ (÷ 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$   