Ë
    éÓ^jha  ã                   óX  — d 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mZmZ ddlZddlmZmZmZ ddlmZ ddlmZ dd	lmZ 	 	 	 dd
ededee   dededefd„Z G d„ d«      Zdeeee
eef   f      dee	e      dee	e      de
e	e
eef      e	e   ef   fd„Z  G d„ de«      Z!y)a   Dynamic Sequence Length Datasets for Variable Resolution Image Processing

Implements two dataset wrappers:
1. NaFlexMapDatasetWrapper - Map-style dataset that returns batches with variable sequence lengths
TODO: 2. NaFlexIterableDatasetWrapper - Iterable dataset that yields batches with variable sequence lengths

Both support:
- Pre-initialized transforms for efficiency
- Distributed training
- Multiple workers
- Variable batch sizes based on sequence length

Hacked together by / Copyright 2025, Ross Wightman, Hugging Face
é    N)Úpartial)ÚAnyÚIteratorÚListÚTupleÚDictÚOptionalÚUnionÚCallable)ÚDatasetÚIterableDatasetÚ
DataLoader)ÚImageé   )ÚPatchify)Ú	to_2tupleÚtokens_per_batchÚseq_lenÚmax_sizeÚdivisorÚroundingÚreturnc                 ó  — | |z  }|dkD  rT|dk(  rt        j                  ||z  «      |z  }n>|dk(  rt        j                  ||z  «      |z  }nt        ||z  «      |z  }nt	        |«      }t        d|«      }|�t        ||«      }|S )a£  Calculate batch size based on sequence length with divisibility constraints.

    Args:
        tokens_per_batch: Target number of tokens per batch.
        seq_len: Sequence length for this batch.
        max_size: Optional maximum batch size.
        divisor: Ensure batch size is divisible by this value.
        rounding: Rounding method ('floor', 'ceil', 'round').

    Returns:
        Calculated batch size.
    r   ÚfloorÚceil)Úmathr   r   ÚroundÚintÚmaxÚmin)r   r   r   r   r   Úraw_batch_sizeÚ
batch_sizes          úc/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/timm/data/naflex_dataset.pyÚcalculate_naflex_batch_sizer$      s�   € ð( &¨Ñ/€Nð �‚{Ø�wÒÜŸ™ N°WÑ$<Ó=ÀÑG‰JØ˜ÒÜŸ™ >°GÑ#;Ó<¸wÑF‰Jä˜~°Ñ7Ó8¸7ÑB‰Jô ˜Ó(ˆ
ô �Q˜
Ó#€JàÐÜ˜ XÓ.ˆ
àÐó    c                   óÂ   — e Zd ZdZ	 ddee   ddfd„Zdeee	e
ej                  f   eeej                  f   f      dee	e
ej                  f   ej                  f   fd„Zy)	ÚNaFlexCollatorzECustom collator for batching NaFlex-style variable-resolution images.NÚmax_seq_lenr   c                 ó   — |xs d| _         y)zqInitialize NaFlexCollator.

        Args:
            max_seq_len: Maximum sequence length for batching.
        é@  N)r(   )Úselfr(   s     r#   Ú__init__zNaFlexCollator.__init__L   s   € ð 'Ò-¨#ˆÕr%   Úbatchc                 ó$  — t        |d   t        «      sJ ‚t        |«      }|D �cg c]  }|d   ‘Œ	 }}t        |d   t        j                  «      rt        j
                  |«      }n%t        j                  |t        j                  ¬«      }|D �cg c]  }|d   ‘Œ	 }}| j                  �| j                  }nt        d„ |D «       «      }|d   d   }|j                  dk(  }|r:|j                  dd }	t        j                  ||g|	¢­t        j                  ¬«      }
n7|j                  d   }t        j                  |||ft        j                  ¬«      }
t        j                  ||dft        j                  ¬«      }t        j                  ||ft        j                  ¬«      }t        |«      D ]N  \  }}t!        |d   j                  d   |«      }|d   d| |
|d|…f<   |d	   d| ||d|…f<   |d
   d| ||d|…f<   ŒP |
|||dœ}||fS c c}w c c}w )ao  Collate batch of NaFlex samples.

        Args:
            batch: List of tuples (patch_dict, target).

        Returns:
            A tuple of (input_dict, targets) where input_dict contains:
                - patches: Padded tensor of patches
                - patch_coord: Coordinates for each patch (y, x)
                - patch_valid: Valid indicators
        r   r   )ÚdtypeNc              3   ó@   K  — | ]  }|d    j                   d   –— Œ y­w)Úpatchesr   N)Úshape)Ú.0Úitems     r#   ú	<genexpr>z*NaFlexCollator.__call__.<locals>.<genexpr>u   s   è ø€ ÒO¸4˜d 9™o×3Ñ3°AÕ6ÑOùs   ‚r1   é   é   Úpatch_coordÚpatch_valid)r1   r8   r9   r   )Ú
isinstanceÚtupleÚlenÚtorchÚTensorÚstackÚtensorÚint64r(   r   Úndimr2   ÚzerosÚfloat32ÚboolÚ	enumerater    )r+   r-   r"   r4   ÚtargetsÚpatch_dictsÚmax_patchesÚpatches_tensorÚis_unflattenedÚ
patch_dimsr1   Ú	patch_dimr8   r9   ÚiÚ
patch_dictÚnum_patchesÚresults                     r#   Ú__call__zNaFlexCollator.__call__W   s+  € ô ˜% ™(¤EÔ*Ð*Ð*Ü˜“Zˆ
ð (-Ö-˜t�4˜“7Ð-ˆÐ-Ü�g˜a‘j¤%§,¡,Ô/Ü—k‘k 'Ó*‰Gä—l‘l 7´%·+±+Ô>ˆGð ,1Ö1 4�t˜A“wÐ1ˆÐ1ð ×ÑÐ'Ø×*Ñ*‰Kô ÑOÀ;ÔOÓOˆKð % Q™¨	Ñ2ˆØ'×,Ñ,°Ñ1ˆáð (×-Ñ-¨a¨bÐ1ˆJÜ—k‘k :¨{Ð"H¸ZÑ"HÔPU×P]ÑP]Ô^‰Gð '×,Ñ,¨QÑ/ˆIÜ—k‘k :¨{¸IÐ"FÌeÏmÉmÔ\ˆGô —k‘k :¨{¸AÐ">ÄeÇkÁkÔRˆÜ—k‘k :¨{Ð";Ä5Ç:Á:ÔNˆô ' {Ó3ò 	S‰MˆAˆzÜ˜j¨Ñ3×9Ñ9¸!Ñ<¸kÓJˆKà'1°)Ñ'<¸\¸kÐ'JˆG�A�|˜�|�OÑ$Ø+5°mÑ+DÀ\ÀkÐ+RˆK˜˜<˜K˜<˜Ñ(Ø+5°mÑ+DÀ\ÀkÐ+RˆK˜˜<˜K˜<˜Ò(ð	Sð Ø&Ø&Ø"ñ	
ˆð �wˆÐùòc .ùò 2s   ¥HÂH)N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r	   r   r,   r   r   r   Ústrr=   r>   r
   rR   © r%   r#   r'   r'   I   sŸ   „ ÙOð *.ñ	.à! #™ð	.ð 
ó	.ðA˜d 5¨¨c°5·<±<Ð.?Ñ)@À%ÈÈUÏ\É\ÐHYÑBZÐ)ZÑ#[Ñ\ð AÐafÐgkÐloÐqv×q}Ñq}Ðl}Ñg~ð  AF÷  AMñ  AMð  hMñ  bNô Ar%   r'   Ú
patch_sizeÚpatch_size_choicesÚpatch_size_choice_probsc                 óœ  — | €|€d} | du |du k(  rt        d«      ‚| �t        | «      g}dg}d}n�|D �cg c]  }t        |«      ‘Œ }}|€dt        |«      z  gt        |«      z  }nXt        |«      t        |«      k7  rt        d«      ‚t        t	        |«      «      }|dk  rt        d«      ‚|D �cg c]  }||z  ‘Œ	 }}d	}|||fS c c}w c c}w )
a¡  Resolve patch size configuration.

    Args:
        patch_size: Single patch size to use.
        patch_size_choices: List of patch sizes to choose from.
        patch_size_choice_probs: Probabilities for each patch size choice.

    Returns:
        Tuple of (sizes, probs, variable) where sizes is list of patch size tuples,
        probs is list of probabilities, and variable indicates if patch size varies.
    Né   z<Specify exactly one of `patch_size` or `patch_size_choices`.g      ð?Fz*`patch_size_choice_probs` length mismatch.r   z&`patch_size_choice_probs` sum to zero.T)Ú
ValueErrorr   r<   ÚfloatÚsum)rY   rZ   r[   ÚsizesÚprobsÚvariableÚpÚss           r#   Ú_resolve_patch_cfgrf   ›   s  € ð" ÐÐ0Ð8Øˆ
à�dÐÐ 2°dÐ :Ò;ÜØJó
ð 	
ð ÐÜ˜:Ó&Ð'ˆØ�ˆØ‰à'9Ö: !”˜1•Ð:ˆÐ:Ø"Ð*Øœ3˜u›:Ñ%Ð&¬¨U«Ñ3‰EäÐ*Ó+¬s°5«zÒ9Ü Ð!MÓNÐNÜ”cÐ1Ó2Ó3ˆAØ�AŠvÜ Ð!IÓJÐJØ$;Ö<˜q�Q˜“UÐ<ˆEÐ<ØˆØ�%˜Ð!Ð!ùò ;ùò =s   ³CÂ/C	c            #       óL  ‡ — e Zd ZdZ	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 ddedeeeeeef   f      dee	e      dee	e
      deedf   d	ed
ee   dee   dededededededededdf"ˆ fd„Zd„ Zdefd„Zdeddfd„Zdefd„Zdeeeeej,                  f   ej,                  f      fd„Zˆ xZS )ÚNaFlexMapDatasetWrapperañ  
    IterableDataset wrapper for a map-style base dataset.

    Yields batches with variable sequence lengths. It calculates a canonical
    batch schedule (sequence length, batch size pairs) once based on the
    total dataset size (padded for distribution). Each epoch, it shuffles
    the order of this canonical schedule and the dataset indices.
    This ensures a consistent number of batches and samples per epoch
    across all ranks. Handles distributed training and multiple workers.
    NÚbase_datasetrY   rZ   r[   Úseq_lens.Úmax_tokens_per_batchÚtransform_factoryÚmixup_fnÚseedÚshuffleÚdistributedÚrankÚ
world_sizeÚepochÚbatch_divisorÚpatchify_channels_lastr   c                 ó¬  •— t         ‰| �  «        t        |d«      rt        |d«      st        d«      ‚|| _        t        t        t        |«      «      «      | _        || _	        |	| _
        |
| _        || _        |r|nd| _        |r|nd| _        || _        || _        t#        |||«      \  | _        | _        | _        i | _        i | _        g | _        | j                  D ]  }t1        |«      | j,                  |<   Œ t3        | j$                  «      D ]u  \  }}| j.                  j5                  t7        || j(                   |¬«      «       | j                  D ]/  }||f}|r |||¬«      | j*                  |<   Œ!d| j*                  |<   Œ1 Œw || _        g | _        d| _        d| _        | jA                  «        g | _!        | jE                  | j                  «       y)	aD  Initialize NaFlexMapDatasetWrapper.

        Args:
            base_dataset: Map-style dataset to wrap.
            patch_size: Single patch size to use.
            patch_size_choices: List of patch sizes to randomly select from.
            patch_size_choice_probs: Probabilities for each patch size.
            seq_lens: Sequence lengths to use for batching.
            max_tokens_per_batch: Target tokens per batch.
            transform_factory: Factory function for creating transforms.
            mixup_fn: Optional mixup function.
            seed: Random seed.
            shuffle: Whether to shuffle data.
            distributed: Whether using distributed training.
            rank: Process rank for distributed training.
            world_size: Total number of processes.
            epoch: Starting epoch.
            batch_divisor: Ensure batch size is divisible by this.
            patchify_channels_last: If True, per-patch flat layout is P-P-C
                (channel index varies fastest). If False, C-P-P (channels first,
                Gemma4 / HF native).
        Ú__len__Ú__getitem__zLbase_dataset must be a map-style dataset (implement __len__ and __getitem__)r   r   )rY   Úflatten_patchesÚchannels_last)r(   rY   N)#Úsuperr,   ÚhasattrÚ	TypeErrorri   ÚsortedÚlistÚsetrj   rk   rn   ro   rp   rq   rr   rs   rt   rf   Úpatch_sizesÚpatch_size_probsÚvariable_patch_sizeÚ
transformsÚcollate_fnsÚpatchifiersr'   rF   Úappendr   rm   Ú_canonical_batch_scheduleÚ_num_batches_per_rankÚ_padded_samples_per_rankÚ_create_canonical_scheduleÚ_epoch_batchesÚ_prepare_epoch_batches)r+   ri   rY   rZ   r[   rj   rk   rl   rm   rn   ro   rp   rq   rr   rs   rt   ru   r   Ú	patch_idxÚpatch_size_tupleÚkeyÚ	__class__s                        €r#   r,   z NaFlexMapDatasetWrapper.__init__Ó   sß  ø€ ôR 	‰ÑÔÜ�| YÔ/´w¸|È]Ô7[ÜÐjÓkÐkà(ˆÔÜœt¤C¨£MÓ2Ó3ˆŒØ$8ˆÔ!ØˆŒ	ØˆŒØ&ˆÔÙ'‘D¨QˆŒ	Ù(3™*¸ˆŒØˆŒ
Ø*ˆÔô M_ØØØ#óM
ÑIˆÔ˜$Ô/°Ô1Ið FHˆŒØ02ˆÔØ+-ˆÔà—}‘}ò 	@ˆGÜ(6°wÓ(?ˆD×Ñ˜WÒ%ð	@ô ,5°T×5EÑ5EÓ+Fò 	0Ñ'ˆIÐ'à×Ñ×#Ñ#¤HØ+Ø$(×$<Ñ$<Ð <Ø4ô%ô ð  Ÿ=™=ò 0�Ø 	Ð*�Ù$Ù+<ÈÐ]mÔ+n�D—O‘O CÒ(à+/�D—O‘O CÒ(ñ0ð	0ð  !ˆŒð ACˆÔ&Ø*+ˆÔ"Ø-.ˆÔ%Ø×'Ñ'Ô)ð <>ˆÔØ×#Ñ# D§J¡JÕ/r%   c           
      óú  — t        | j                  «      }|}|}| j                  r¡| j                  dkD  r’|| j                  z  dk7  rA| j                  || j                  z  z
  }||z  }t	        d| j
                  › d|› d|› d�«       nd}|| j                  z  dk7  rt        d|› d| j                  › �«      ‚|| j                  z  }n| j                  r| j                  dk  r	 || _        |dk(  rg | _        d| _	        y	t        j                  «       }|j                  | j                  «       g }|}d}|dkD  rÊt        j                  dt        | j                  «      d
|¬«      j!                  «       }	| j                  |	   }
t#        | j$                  |
|| j&                  d¬«      }t)        d|«      }t+        ||«      }|dk  rt-        j.                  d|
› d|› d�«       n#|j1                  |
|f«       ||z  }||z  }|dkD  rŒÊ||k7  r+t-        j.                  d| j
                  › d|› d|› d|› �«       || _        t        |«      | _	        t	        d| j
                  › d| j                  › d| j                  › d�«       y	)a%  
        Calculates the canonical batch schedule (seq_len, batch_size pairs)
        based on the dataset size, padded for distributed training.
        This schedule is the *same* for all ranks and ensures consistent
        epoch length. It is calculated once during initialization.
        r   r   úRank z: Padding dataset with z. samples for distributed training (total size z).z$Internal Error: Padded total length z not divisible by world size N)r   ©Ú	generatorr   )r   r   r   r   r   z$Calculated batch size <= 0 (seq_len=z, remaining=z&). Stopping schedule generation early.z": Canonical schedule accounts for z samples, but expected z˜ samples per rank. This might happen if min_batch_size or batch_divisor constraints prevent utilizing all samples. Check parameters. Remaining samples: z": Created canonical schedule with z batches for z samples/rank.)r<   ri   rp   rr   Úprintrq   ÚRuntimeErrorrŠ   rˆ   r‰   r=   Ú	GeneratorÚmanual_seedrn   Úrandintrj   r4   r$   rk   rt   r   r    ÚwarningsÚwarnr‡   )r+   Ú	total_lenÚpadded_total_lenÚnum_samples_per_rankÚpad_sizeÚgÚcurrent_scheduleÚremaining_samplesÚtotal_scheduled_samplesÚseq_idxr   r"   s               r#   r‹   z2NaFlexMapDatasetWrapper._create_canonical_schedule7  sô  € ô ˜×)Ñ)Ó*ˆ	Ø$ÐØ(Ðà×Ò §¡°!Ò 3à˜4Ÿ?™?Ñ*¨aÒ/Ø ŸO™O¨y¸4¿?¹?Ñ/JÑK�Ø! XÑ-Ð!Ü˜˜tŸy™y˜kÐ)@ÀÀ
ÐJxð  zJð  yKð  KMð  Nõ  Oà�à $§/¡/Ñ1°QÒ6ä#Ð&JÐK[ÐJ\Ð\yÐz~÷  {Jñ  {Jð  zKð  %Ló  Mð  Mà#3°t·±Ñ#FÑ Ø×Ò $§/¡/°QÒ"6àà(<ˆÔ%à 1Ò$Ø.0ˆTÔ+Ø*+ˆTÔ'Øô �O‰OÓˆØ	�‰�d—i‘iÔ à24ÐØ0ÐØ"#Ðà !Ò#ä—m‘m A¤s¨4¯=©=Ó'9¸4È1ÔM×RÑRÓTˆGØ—m‘m GÑ,ˆGô 5Ø!%×!:Ñ!:Øà*Ø×*Ñ*Ø ôˆJô ˜Q 
Ó+ˆJÜ˜ZÐ):Ó;ˆJà˜QŠÜ—‘Ð!EÀgÀYÈlÐ[lÐZmð  nTð   Uô  VØà×#Ñ# W¨jÐ$9Ô:Ø Ñ+ÐØ# zÑ1Ð#ð1   !Ó#ð6 #Ð&:Ò:Ü�M‰MØ˜Ÿ	™	�{Ð"DÐE\ÐD]ð ^ Ø 4Ð5ð 68à8IÐ7JðLôð *:ˆÔ&Ü%(Ð)9Ó%:ˆÔ"Ü��d—i‘i�[Ð BÀ4×C]ÑC]ÐB^Ð^kÐlp÷  mJñ  mJð  lKð  KYð  Zõ  	[r%   c                 óÚ  — t        j                  «       }|j                  | j                  |z   «       t	        | j
                  «      }| j                  r&t        j                  ||¬«      j                  «       }nt        t        |«      «      }|}| j                  rb| j                  dkD  rS| j                  | j                  z  }||kD  r||z
  }||d| z   }t	        |«      |k7  rt        dt	        |«      › d|› �«      ‚| j                  r,| j                  dkD  r|| j                  d| j                  …   }n|}t	        |«      | j                  k7  rat!        j"                  d| j                  › dt	        |«      › d| j                  › d	�«       t%        t	        |«      | j                  «      }	|d|	 }n| j                  }	| j                  rLt        j                  | j&                  |¬«      j                  «       }
|
D �cg c]  }| j(                  |   ‘Œ }}nt        | j(                  «      }g | _        d
}d
}|D ]x  \  }}t%        ||	|z
  «      }|d
k  r0||	k  r)t!        j"                  d| j                  › d|› d|	› d�«        n1||||z    }| j*                  j-                  ||f«       ||z  }||z  }Œz ||	k7  r0t!        j"                  d| j                  › d|› d|	› d|	|z
  › d�	«       yyc c}w )a  
        Prepares the batches for the current epoch by:
        1. Shuffling the full dataset indices (using epoch seed).
        2. Applying padding if in distributed mode.
        3. Selecting indices for the current rank.
        4. Shuffling the *order* of the canonical batch schedule (using epoch seed).
        5. Assigning the rank's indices to the shuffled batches.
        r”   r   Nz)Internal Error: Padded index list length z does not match expected r“   z#: Number of indices for this rank (z3) does not match expected padded samples per rank (z*). Epoch generation might be inconsistent.r   z: Ran out of samples (ú/z?) before processing entire schedule. Check schedule generation.z: Assigned z" samples to batches, but expected z2 effective samples this epoch. Indices remaining: ú.)r=   r˜   r™   rn   r<   ri   ro   ÚrandpermÚtolistr   Úrangerp   rr   rŠ   r—   rq   r›   rœ   r    r‰   rˆ   rŒ   r‡   )r+   rs   r¡   r�   Úall_indices_shuffledÚindices_for_ranksrž   r    Úindices_this_rankÚeffective_samples_this_rankÚschedule_permrN   Úshuffled_scheduleÚidx_posÚscheduled_samples_countr   ÚbsÚ	actual_bsÚbatch_indicess                      r#   r�   z.NaFlexMapDatasetWrapper._prepare_epoch_batches�  sE  € ô �O‰OÓˆØ	�‰�d—i‘i %Ñ'Ô(ô ˜×)Ñ)Ó*ˆ	Ø�<Š<Ü#(§>¡>°)ÀqÔ#I×#PÑ#PÓ#RÑ ä#'¬¨iÓ(8Ó#9Ð ð 1ÐØ×Ò §¡°!Ò 3Ø#×<Ñ<¸t¿¹ÑNÐØ )Ò+Ø+¨iÑ7�à$8Ð;OÐPYÐQYÐ;ZÑ$ZÐ!äÐ$Ó%Ð)9Ò9Ü#Ð&OÔPSÐTeÓPfÐOgð  hAð  BRð  ASð  %Tó  Uð  Uð ×Ò §¡°!Ò 3Ø 1°$·)±)Ð2L¸T¿_¹_Ð2LÑ MÑà 1Ðô Ð Ó! T×%BÑ%BÒBä�]‰]Ø˜Ÿ™˜Ð#FÄsÐK\ÓG]ÐF^ð _EØEI×EbÑEbÐDcð d;ð<ôô ,/¬sÐ3DÓ/EÀt×GdÑGdÓ+eÐ(Ø!2Ð3OÐ4OÐ!PÑð ,0×+HÑ+HÐ(ð �<Š<Ü!ŸN™N¨4×+EÑ+EÐQRÔS×ZÑZÓ\ˆMØLYÖ ZÀq ×!?Ñ!?ÀÓ!BÐ ZÐÑ Zä $ T×%CÑ%CÓ DÐð !ˆÔØˆØ"#ÐØ,ò 	1‰KˆG�Rä˜BÐ ;¸gÑ EÓFˆIØ˜AŠ~Ø+Ð.IÒIä—]‘] U¨4¯9©9¨+Ð5KÈGÈ9ÐTUÐVqÐUrð  srð  $sô  tÙà-¨g¸À)Ñ8KÐLˆMØ×Ñ×&Ñ&¨°Ð'?Ô@Ø�yÑ ˆGØ# yÑ0Ñ#ð	1ð #Ð&AÒAÜ�]‰]Ø˜Ÿ	™	�{ +Ð.EÐ-Fð G Ø ;Ð<ð =&Ø&AÐD[Ñ&[Ð%\Ð\]ð_õð Bùò/ ![s   Ç<K(c                 óT   — || j                   k7  r|| _         | j                  |«       yy)zxUpdates the epoch, regenerating the epoch-specific batches.

        Args:
            epoch: New epoch number.
        N)rs   r�   )r+   rs   s     r#   Ú	set_epochz!NaFlexMapDatasetWrapper.set_epochã  s*   € ð �D—J‘JÒØˆDŒJØ×'Ñ'¨Õ.ð r%   c                 ó   — | j                   S )z’Returns the number of batches per worker for the current epoch.

        Returns:
            Number of batches this worker will process.
        )r‰   )r+   s    r#   rw   zNaFlexMapDatasetWrapper.__len__î  s   € ð ×)Ñ)Ð)r%   c           
   #   ó*  K  — t         j                  j                  j                  «       }|r|j                  nd}|r|j
                  nd}| j                  |d|…   }|D �]T  \  }}|sŒ
d}| j                  rAt        j                  t        j                  | j                  «      d«      j                  «       }||f}| j                  j                  |«      }	| j                  |   }
g }g }|D ]_  }	 | j                  |   \  }}|	r |	|«      n|}|€t!        j"                  d|› d�«       Œ>|j%                  |«       |j%                  |«       Œa | j*                  �| j+                  ||«      \  }}|D �cg c]
  } |
|«      ‘Œ }}t-        t/        ||«      «      }|s�Œ> | j0                  |   |«      –— �ŒW y# t&        $ r t!        j"                  d|› d�«       Y Œðt(        $ r'}t!        j"                  d|› d	|› d�«       Y d}~�Œd}~ww xY wc c}w ­w)
z“Iterates through pre-calculated batches for the current epoch.

        Yields:
            Tuple of (input_dict, targets) for each batch.
        r   r   Nz"Transform returned None for index z. Skipping sample.z!IndexError encountered for index z= (possibly due to padding/repeated indices). Skipping sample.zError processing sample index z	. Error: )r=   ÚutilsÚdataÚget_worker_infoÚnum_workersÚidrŒ   rƒ   Úmultinomialr@   r‚   r4   r„   Úgetr†   ri   r›   rœ   r‡   Ú
IndexErrorÚ	Exceptionrm   r   Úzipr…   )r+   Úworker_infor¾   Ú	worker_idÚbatches_for_workerr   ÚindicesrŽ   Útransform_keyÚ	transformÚbatch_patchifierÚ
batch_imgsÚbatch_targetsÚidxÚimgÚlabelÚprocessed_imgÚeÚbatch_sampless                      r#   Ú__iter__z NaFlexMapDatasetWrapper.__iter__ö  s(  è ø€ ô —k‘k×&Ñ&×6Ñ6Ó8ˆÙ1<�k×-Ò-À!ˆÙ&1�K—N’N°qˆ	ð "×0Ñ0°Ð1G¸KÐ1GÑHÐØ 2ó /	?ÑˆG�WÙØð ˆIØ×'Ò'ä!×-Ñ-¬e¯l©l¸4×;PÑ;PÓ.QÐSTÓU×ZÑZÓ\�	ð % iÐ0ˆMØŸ™×+Ñ+¨MÓ:ˆIØ#×/Ñ/°	Ñ:ÐàˆJØˆMØò �ðà!%×!2Ñ!2°3Ñ!7‘J�C˜ñ 7@¡I¨c¤NÀS�MØ$Ð,Ü Ÿ™Ð(JÈ3È%ÐOaÐ&bÔcØ à×%Ñ% mÔ4Ø!×(Ñ(¨Õ/ðð. �}‰}Ð(Ø,0¯M©M¸*ÀmÓ,TÑ)�
˜Mà;EÖF°CÑ*¨3Õ/ÐFˆJÐFÜ ¤ Z°Ó!?Ó@ˆMÛà/�d×&Ñ& wÑ/°Ó>Ô>ñ_/	?øô@ "ò Ü—]‘]Ð%FÀsÀeð  LIð  $Jô  KÙÜ ò ä—M‘MÐ$BÀ3À%ÀyÐQRÐPSÐSeÐ"fÔgÝûðüò GùsZ   ‚C-HÃ09F8Ä)HÄ*"F8Å'HÅ3HÆHÆHÆ8"HÇHÇHÇ$HÈ HÈHÈH)NNN)é€   é   r*   i  i   i @  NNé*   TFr   r   r   é   T)rS   rT   rU   rV   r   r	   r
   r   r   r   r_   r   rE   r,   r‹   r�   r¸   rw   r   r   rW   r=   r>   rÔ   Ú__classcell__)r‘   s   @r#   rh   rh   Ç   s—  ø„ ñ	ð AEØ6:Ø=AØ(BØ(0Ø48Ø+/ØØ Ø %ØØØØ!"Ø+/ñ#b0à!ðb0ð !  s¨E°#°s°(©OÐ';Ñ!<Ñ=ðb0ð !)¨¨c©Ñ 3ð	b0ð
 &.¨d°5©kÑ%:ðb0ð ˜C ˜H‘oðb0ð #&ðb0ð  (¨Ñ1ðb0ð ˜xÑ(ðb0ð ðb0ð ðb0ð ðb0ð ðb0ð ðb0ð ðb0ð  ð!b0ð" %)ð#b0ð$ 
õ%b0òHS[ðlT¨Có Tðl	/˜sð 	/ tó 	/ð*˜ó *ð<?˜( 5¨¨c°5·<±<Ð.?Ñ)@À%Ç,Á,Ð)NÑ#OÑP÷ <?r%   rh   )Nr   r   )"rV   r   Úrandomr›   Ú	functoolsr   Útypingr   r   r   r   r   r	   r
   r   r=   Útorch.utils.datar   r   r   ÚPILr   Únaflex_transformsr   Útimm.layersr   r   rW   r$   r'   r_   rE   rf   rh   rX   r%   r#   ú<module>rá      s  ðñó Û Û Ý ß N× NÓ Nã ß AÑ AÝ å 'Ý !ð #'ØØñ(Øð(àð(ð ˜3‘-ð(ð ð	(ð
 ð(ð 	ó(÷VOñ Oðd)"Ø˜U 3¨¨c°3¨h©Ð#7Ñ8Ñ9ð)"à$ T¨#¡YÑ/ð)"ð "*¨$¨u©+Ñ!6ð)"ð ˆ4��c˜3�h‘Ñ  $ u¡+¨tÐ3Ñ4ó	)"ôXk?˜oõ k?r%   