o i9F@sUddlmZddlZddlmZmZddlmZmZddl Z dIdJddZ dKddZ eddGdddZ eddGdddZ eddGdddZeege fZee geeeee jdBffZdLddZeZded<dMd"d#ZeZd$ed%<dNd(d)ZdNd*d+ZdOd.d/ZdPdQd1d2ZdPdQd3d4ZdRd6d7Z Gd8d9d9eZ!dSd=d>Z"dTdCdDZ#eddGdEdFdFZ$eddGdGdHdHZ%dS)U) annotationsN) dataclassreplace)Callable NamedTupleFlengthint ramp_left ramp_rightleft_starts_from_0boolreturn torch.TensorcCs|dkrtdtdt||}tdt||}t|}|dkrH|r'|dn|d}tdd|dd}|s>|dd}|d||9<|dkretjdd|dd dd}|| d|9<|ddS) a Generate a 1D trapezoidal blending mask with linear ramps. Args: length: Output length of the mask. ramp_left: Fade-in length on the left. ramp_right: Fade-out length on the right. left_starts_from_0: Whether the ramp starts from 0 or first non-zero value. Useful for temporal tiles where the first tile is causal. Returns: A 1D tensor of shape `(length,)` with values in [0, 1]. rMask length must be positive.gg?N)steps) ValueErrormaxmintorchoneslinspaceclamp_)rr r r maskinterval_lengthfade_infade_outr;/home/ubuntu/LTX-2/packages/ltx-core/src/ltx_core/tiling.pycompute_trapezoidal_mask_1d s   r! left_ramp right_rampcCsH|dkrtdt|}|dkrd|d|<|dkr"d|| d<|S)aG Generate a 1D rectangular (pulse) mask. Args: length: Output length of the mask. left_ramp: Number of elements at the start of the mask to set to 0. right_ramp: Number of elements at the end of the mask to set to 0. Returns: A 1D tensor of shape `(length,)` with values 0 or 1. rrN)rrr)rr"r#rrrr compute_rectangular_mask_1d1s  r$T)frozenc@s.eZdZUded<ded<ded<ded<dS)DimensionIntervalrstartendr"r#N)__name__ __module__ __qualname____annotations__rrrr r&Js  r&c@seZdZUdZded<dS)DimensionIntervalsaIntervals which a single dimension of the latent space is split into. Each interval is defined by its start, end, left ramp, and right ramp. The start and end are the indices of the first and last element (exclusive) in the interval. Ramps are regions of the interval where the value of the mask tensor is interpolated between 0 and 1 for blending with neighboring intervals. The left ramp and right ramp values are the lengths of the left and right ramps. zlist[DimensionInterval] intervalsNr)r*r+__doc__r,rrrr r-Rs  r-c@s"eZdZUdZded<ded<dS)LatentIntervalszIntervals which the latent tensor of given shape is split into. Each dimension of the latent space is split into intervals based on the length along said dimension. torch.Sizeoriginal_shapeztuple[DimensionIntervals, ...]dimension_intervalsNr/rrrr r1_s  r1cCsttd|dddgdS)Nrr'r(r"r#r.)r-r&)rrrr default_split_operationosr7SplitOperationDEFAULT_SPLIT_OPERATION _intervals-tuple[list[slice], list[torch.Tensor | None]]cCstddgdgfS)Nr)slice)r:rrr default_mapping_operationvsr=MappingOperationDEFAULT_MAPPING_OPERATIONsizeoverlapcsNdkr tddkskrtddd fd d }|S) aSplit a dimension into overlapping tiles of a given size. Tiles are sized ``size`` with ``overlap`` shared elements between consecutive tiles. The last tile may be shorter if the dimension doesn't divide evenly. Args: size: Target tile size (in axis units). overlap: Overlap between consecutive tiles. Returns: A split operation that divides a dimension into tiles. rzsize must be > 0, got z6overlap must satisfy 0 <= overlap < size, got overlap=z, size=dimension_sizerr r-cs|krt|S|dd}tdddgfddtd|dDt|d|dd}t|dS)Nrrrr5c3s4|]}t||dVqdS)r5N)r&).0irAr@rr s  z/split_by_size..split..r6)r9r&ranger-)rBamountr.rErr splits    zsplit_by_size..splitNrBrr r-rr@rArIrrEr split_by_sizes  rMct|dfdd }|S) aSplit a temporal axis into overlapping tiles with causal handling. Each tile after the first is shifted back by 1 and its left ramp is increased by 1, ensuring causal continuity through the blend ramps. Args: size: Tile size in axis units. overlap: Overlap between tiles in the same units. Returns: Split operation that divides temporal dimension with causal handling. rBrr r-csF|krt|S|}|jdgdd|jddD}t|dS)NrcS&g|]}t||jd|jddqSr)r'r"rr'r"rCintervalrrr z8split_temporal_causal..split..rr6)r9r.r-rB dim_intervalsmodified_intervalsnon_causal_splitr@rr rIs  z$split_temporal_causal..splitNrJrMrLrrYr split_temporal_causals  r\tile_size_framesoverlap_framescrN) a4Split a temporal axis in video frame space into overlapping tiles. Args: tile_size_frames: Tile length in frames. overlap_frames: Overlap between consecutive tiles in frames. Returns: Split operation that takes frame count and returns DimensionIntervals in frame indices. rBrr r-csN|krt|S|}dd|jddDt|jdddg}t|dS)NcSs g|] }t||jdddqS)rr)r(r#)rr(rRrrr rTsz1split_temporal..split..rr)r#r6)r9r.rr-rVrZr]rr rIs  zsplit_temporal..splitNrJr[)r]r^rIrr_r split_temporals  r` num_tilescst||dfdd }|S) aSplit a temporal dimension by count with causal handling. Wraps :func:`split_by_count` with the same causal adjustment as :func:`split_temporal_causal`: each tile after the first is shifted back by 1 and its left ramp is increased by 1. Args: num_tiles: Number of tiles. Must be >= 1. overlap: Overlap between adjacent tiles (default 0). Returns: A split operation that divides a temporal dimension into tiles. rBrr r-csH|}t|jdkr |S|jdgdd|jddD}t|dS)NrrcSrOrPrQrRrrr rTrUzAsplit_by_count_temporal_causal..split..r6)lenr.r-rVrZrr rIs  z-split_by_count_temporal_causal..splitNrJ)split_by_countrarArIrrcr split_by_count_temporal_causals  rfcs@dkr tddkrtdd fd d }|S) aSplit a dimension into a given number of tiles with overlap. Computes the tile size as ``(dim_size + overlap * (num_tiles - 1)) // num_tiles`` so that ``num_tiles`` tiles of that size with ``overlap`` shared elements cover the dimension evenly. Delegates to :func:`split_by_size` for the actual interval construction. When the total ``dim_size + overlap * (num_tiles - 1)`` is not evenly divisible by ``num_tiles``, the first ``remainder`` tiles each absorb one extra unit. Args: num_tiles: Number of tiles. Must be >= 1. overlap: Overlap between adjacent tiles (default 0). Must be >= 0 and less than the computed tile size. Returns: A split operation that divides a dimension into tiles. rnum_tiles must be >= 1, got roverlap must be >= 0, got dim_sizerr r-c s|krtdd|ddkrt|S|d}|}|}t|||j}g}t|D]#\}}t||}||krFdnd} |t||j||j || dq7t |dS)Nz num_tiles (z) exceeds dim_size (z*). Cannot assign at least 1 unit per tile.rr)r'r(r6) rr9rMr. enumeraterappendrr'r(r-) ritotal tile_size remainderbase_intervalsr.rDivshiftgrowrarArr rI s  & zsplit_by_count..splitN)rirr r-rKrerrsr rds rdr.cCsNg}g}|jD]}|t|j|j|t|j|j|j|jq||fS)aMap each DimensionInterval to an output region at the same position, with trapezoidal blend masks. For every interval the output start/end matches the input start/end and a 1-D blending mask is built from the interval's left_ramp and right_ramp. )r.rkr<r'r(r!r"r#)r. out_slicesmasksrprrr identity_mapping_operation*s   rvc@s8eZdZUdZded<ded<ded<ed d d Zd S) Tilea Represents a single tile. Attributes: in_coords: Tuple of slices specifying where to cut the tile from the INPUT tensor. out_coords: Tuple of slices specifying where this tile's OUTPUT should be placed in the reconstructed OUTPUT tensor. masks_1d: Per-dimension masks in OUTPUT units. These are used to create all-dimensional blending mask. Methods: blend_mask: Create a single N-D mask from the per-dimension masks. ztuple[slice, ...] in_coords out_coordsztuple[torch.Tensor | None, ...]masks_1dr rc Cst|j}g}t|D]1}|j|}dg|}|dur-td}d||<||j|q |jd||<||j|q |d}|ddD]}||}qG|S)Nrr) rbryrGrzrrrkviewshape) selfnum_dimsper_dimension_masksdim_idxmask_1d view_shapeone combined_maskrrrr blend_maskKs      zTile.blend_maskN)r r)r)r*r+r0r,propertyrrrrr rw7s rwmapperslist[MappingOperation] list[Tile]c Csg}g}g}tt|jD]K}|j|}dd|jD}|||\}} t|} t|| ks4t| | krItd|dt|dt| d| d |||||| q ddttj |tj |tj |d d DS) NcSsg|] }t|j|jqSr)r<r'r(rRrrr rTpsz;create_tiles_from_intervals_and_mappers..zAxis z: mapper produced z output slices and z masks for z input intervalscSs g|] \}}}t|||dqS))rxryrz)rw)rCin_coord out_coordrrrr rT|s Tstrict) rGrbr3r4r.rrkzip itertoolsproduct) r.rfull_dim_input_slicesfull_dim_output_slicesfull_dim_masks_1d axis_indexr4 input_slices output_slicesrz n_intervalsrrr 'create_tiles_from_intervals_and_mappersgs6    r latent_shaper2 splitterslist[SplitOperation]cCst|t|krtdt|dt|t|t|kr,tdt|dt|ddt||ddD}t|t|d}t||S) NzONumber of splitters must be equal to number of dimensions in latent shape, got z and zMNumber of mappers must be equal to number of dimensions in latent shape, got cSsg|]\}}||qSrr)rCsplitterrrrr rTsz create_tiles..Tr)r3r4)rbrrr1tupler)rrrr.latent_intervalsrrr create_tiless& rc@s@eZdZUdZded<dZded<ddd Zeddd d ZdS)DimensionTilingConfigarTiling parameters for a single dimension of the patchified grid. Attributes: num_tiles: Number of tiles along this dimension. overlap: Overlap between adjacent tiles, in latent grid units. Adjacent tiles share ``overlap`` grid cells at their boundary, producing an overlap zone blended with trapezoidal masks. rrarrAr NonecCs8|jdkr td|j|jdkrtd|jdS)Nrrgrrh)rarrA)r}rrr __post_init__s  z#DimensionTilingConfig.__post_init__rirmcCs$t||}||}|t|j|dS)aSCreate config by computing ``num_tiles`` from dimension size and tile size. Args: dim_size: Total length of the dimension. tile_size: Desired tile size. overlap: Overlap between consecutive tiles. Returns: A ``DimensionTilingConfig`` with the computed ``num_tiles``. rs)rMrbr.)clsrirmrAsplit_opr.rrr from_tile_sizes z$DimensionTilingConfig.from_tile_sizeN)r rr)rirrmrrArr r) r)r*r+r0r,rAr classmethodrrrrr rs   rc@sNeZdZUdZedddZded<edddZded<edddZded<d S) TileCountConfiganTiling layout for a ``(F, H, W)`` grid. Specifies tile *counts* per dimension (as opposed to tile *sizes* which are used by the single-GPU VAE ``TilingConfig``). Attributes: frames: Tiling along the temporal (frames) dimension. height: Tiling along the latent height dimension. width: Tiling along the latent width dimension. rrrsrframesheightwidthN) r)r*r+r0rrr,rrrrrr rs  r)F) rrr rr rr r r r)rrr"rr#rr r)rrr r-)r:r-r r;)r@rrArr r8)r]rr^rr r8r)rarrArr r8)r.r-r r;)r.r1rrr r)rr2rrrrr r)& __future__rr dataclassesrrtypingrrrr!r$r&r-r1rr8rlistr<Tensorr>r7r9r,r=r?rMr\r`rfrdrvrwrrrrrrrr sB '  $      (    5 0 "