+
    &jQ                        ^ 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   "p/Users/jameslopez/projects/CWCArchive/cwc-podcast/.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)
    ...

    >>> # 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]
c                0   < V ^8  d   QhRS[ S[,          /# )r   r+   r   r   )r   r   s   "r   r    IterableDataset.__annotate__   s     + +WU^ +r"   c                    \        W.4      # r.   )r   r/   s   &&r   r0   IterableDataset.__add__   s    TM**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   zDataset 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'wqzq!V[[^3's   7:TFzSize mismatch between tensorsN)anyAssertionErrorrB   )r&   rB   s   &jr   __init__TensorDataset.__init__   s7    3J'J333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     >vE]]   )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      63; 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gen 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     DtG4<<3w</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     CsG4<<3w</srl   z%At least one dataset should be passedN)
ValueErrorrh   rg   rK   datasetslistvalues)r&   ra   rb   tmps   f*, r   rM   StackDataset.__init__   s     ^  tAw<DLsDtDsssDtDDD !ABB DMv}}'Cs1v;DLsCsCsssCsCCC !ABB"DM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    dmmT**8<8K8K8MN8M*!Au~%8MNNuA4==AuAuA4==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  rWY,          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  rV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   dmmT**5<(=WWJ(="mm113
GG^TBCC#009E5zS\1()),WfSZLJ  +.e*M&* +N *-W)N&-l *O 4  /6!6g"g
!6}}G>??,,W5u:W-$%%(\N&UF  '*%D&INDOOD) 'J &)T%JMCOOGL1 &K % DN&N:uV}:&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     & dl' 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+  zDataset 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    11AAAHHQUOFA  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  !%DMM :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tc$i N  d)c/C))$*?*?E!J44[1_EEJ}}[)*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,      75>""  3i 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LL  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VOE  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    c4  <<# >#Qa# >??||DLL-.. !?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{     GDLL.$?@@<<,,7-S7Cll3.?.?7-STT?FGwLLc!233w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[>cEk"> 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):$& )GAax4!8 #5aS8O!PQQ#zz#g,*=>!!"23	 *
 L3~#66	y!AN 33M)Q.) " !"7+IA{/s 3= >  , 7|s7|#R
 	
 s7|y9@@BG8C='*G ")"6"6w"?QUVVNF 	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(
sEz
:x1,gen ,Dn+genhuo n+h'GE&#+./ '.T78$ Tn6%GEN 6%r? <<!WU^ <!D #4> >r"   