diff --git a/contrib/models/ltx2-video-audio/README.md b/contrib/models/ltx2-video-audio/README.md new file mode 100644 index 00000000..7da014db --- /dev/null +++ b/contrib/models/ltx2-video-audio/README.md @@ -0,0 +1,319 @@ +# LTX-2 on AWS Trainium (NxDI) + +Port of the [Lightricks LTX-2](https://huggingface.co/Lightricks/LTX-2) 19B-parameter audio-video diffusion model to AWS Neuron (Trainium/Inferentia) using the NxDI (NeuronX Distributed Inference) framework. + +## Architecture + +LTX-2 generates synchronized video + audio from text prompts. The model has three main components: + +| Component | Parameters | Runs on | Notes | +|-----------|-----------|---------|-------| +| Text encoder (Gemma 3-12B) | 12B | **Neuron TP=4** | Compiled with custom encoder | +| DiT transformer (48 blocks) | ~6B | **Neuron TP=4** | The denoising bottleneck | +| Video VAE decoder | ~1B | **Neuron TP=4** | Tiled spatial decode (8×8 or 4×16 tiles) | +| Audio VAE decoder + vocoder | ~0.1B | CPU | Run once per generation | + +Both the text encoder and DiT transformer backbone are compiled for Neuron. They coexist on the same 4 NeuronCores (TP=4) and execute sequentially: text encoding then denoising. + +The video VAE decoder is also compiled for Neuron using tensor-parallel tiled decoding. The optimal tile shape is 4x16 latent (128x512 pixels), which fits within the 64-element SRAM budget while minimizing tile count for large resolutions. + +## Performance + +Tested on trn2.3xlarge (1 NeuronDevice, 4 logical NeuronCores with LNC=2) with Neuron SDK 2.28: + +| Metric | Neuron (trn2) | GPU (g5.12xlarge) | +|--------|--------------|-------------------| +| Generation time (warm, CFG, 8 steps) | ~22s | ~48s | +| First generation (includes warmup) | ~64s | ~48s | + +The Neuron pipeline produces nearly identical output to the GPU reference. + +## Compatibility Matrix + +| Instance Type | Neuron SDK | Status | +|--------------|-----------|--------| +| trn2.3xlarge | 2.28 | Tested | +| trn2.3xlarge | 2.27 | Tested | +| Inf2 | — | Not tested | +| Trn1 | — | Not tested (requires TP=4 with LNC=2) | + +## Example Checkpoints + +* [Lightricks/LTX-2](https://huggingface.co/Lightricks/LTX-2) — HuggingFace Hub (downloaded automatically by the scripts) + +## Requirements + +- **Instance**: trn2.3xlarge (sa-east-1 or ap-southeast-4) +- **AMI**: Deep Learning AMI Neuron (Ubuntu 24.04) 20260227 (SDK 2.28) +- **Python env**: `/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/` +- **Diffusers**: 0.37.0.dev0 (install from git main) +- **Disk**: ~100GB for model weights + compilation cache + +## Quick Start + +### 1. Instance Setup + +```bash +# SSH into your trn2.3xlarge instance +ssh -i your-key.pem ubuntu@ + +# Activate Neuron environment +source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate + +# Install diffusers from git (LTX-2 requires dev version) +pip install git+https://github.com/huggingface/diffusers.git +pip install imageio imageio-ffmpeg + +# Upload this package +# scp -r ltx2-neuron/ ubuntu@:/home/ubuntu/ +``` + +### 2. Compile Models (First Run Only) + +```bash +cd /home/ubuntu/ltx2-neuron/src + +# Compile the DiT transformer backbone (~2 minutes) +NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python compile_gemma3.py + +# Pre-shard Gemma3 weights for fast loading (~2 minutes) +python shard_gemma3_weights.py + +# Compile VAE decoder for Neuron +# For 25-frame videos (default E2E config): use 8x8 tiles (~6 min) +NEURON_RT_VISIBLE_CORES=0-3 python compile_vae.py \ + --tp-degree 4 --height 256 --width 256 --num-frames 25 \ + --output-dir /home/ubuntu/ltx2_vae_tp4_256x256_f25 + +# For 121-frame videos: use 4x16 tiles (~15 min, requires trn2.48xlarge) +# NEURON_RT_VISIBLE_CORES=0-3 python compile_vae.py \ +# --tp-degree 4 --height 128 --width 512 --num-frames 121 \ +# --output-dir /home/ubuntu/ltx2_vae_tp4_128x512_f121 +``` + +The DiT backbone is compiled automatically on first use by the E2E script. + +### 3. Generate Video + Audio + +```bash +cd /home/ubuntu/ltx2-neuron/examples + +# With Neuron VAE (set compile dir to enable) +LTX2_VAE_COMPILE_DIR=/home/ubuntu/ltx2_vae_tp4_256x256_f25 \ +NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python neuron_e2e.py + +# Without Neuron VAE (falls back to CPU decode) +NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python neuron_e2e.py +``` + +### 4. Notebook + +For an interactive walkthrough, use the Jupyter notebook: + +```bash +cd /home/ubuntu/ltx2-neuron/notebooks +jupyter notebook ltx2_neuron_inference.ipynb +``` + +## Testing + +Run integration tests (requires compiled models — see Quick Start steps 1-2 first): + +```bash +cd /home/ubuntu/ltx2-video-audio + +# With pytest +NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + pytest test/integration/test_model.py -v --capture=tee-sys + +# Or standalone +NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python test/integration/test_model.py +``` + +The test suite includes: +- **Smoke test**: Pipeline loads without errors +- **Generation test**: Produces expected number of frames at correct resolution +- **Accuracy test**: SSIM comparison between Neuron output and GPU reference frames (threshold: SSIM > 0.7) +- **Performance test**: Warm generation completes within 120s + +## File Structure + +``` +ltx2-video-audio/ +├── README.md +├── src/ # Core NxDI package +│ ├── __init__.py +│ ├── modeling_ltx2.py # DiT backbone: TP sharding, SPMD, config +│ ├── modeling_vae.py # VAE decoder: TP Conv3d, tiled compilation +│ ├── modeling_gemma3_encoder.py # Gemma3 text encoder for Neuron +│ ├── application.py # NeuronLTX2Application orchestrator +│ ├── pipeline.py # NeuronTransformerWrapper + NeuronTiledVAEDecoder +│ ├── compile_gemma3.py # Gemma3 encoder compilation script +│ ├── compile_vae.py # VAE decoder compilation script +│ ├── tiled_vae_decode.py # Tiled VAE decode runtime (standalone + library) +│ ├── shard_gemma3_weights.py # Pre-shard Gemma3 weights to disk +│ └── generate_ltx2.py # CLI entry point with argument parsing +├── test/ +│ └── integration/ +│ └── test_model.py # Accuracy + performance integration tests +├── notebooks/ +│ └── ltx2_neuron_inference.ipynb # Step-by-step compile + generate notebook +├── examples/ +│ ├── neuron_e2e.py # Full E2E: load + generate (both on Neuron) +│ └── gpu_generate.py # GPU reference generation script +└── samples/ + ├── neuron/ # Output from Neuron (trn2.3xlarge) + │ ├── frame_0000.png + │ ├── frame_0012.png + │ └── frame_0024.png + └── gpu/ # GPU reference (g5.12xlarge, same seed) + ├── frame_0000.png + ├── frame_0012.png + └── frame_0024.png +``` + +## Generation Settings + +Both Neuron and GPU samples were generated with identical settings: + +```python +prompt = ("A golden retriever puppy runs across a sunny green meadow, " + "its ears flapping in the wind. The camera follows from a low angle. " + "Birds chirp in the background.") +height = 384 +width = 512 +num_frames = 25 +num_inference_steps = 8 +guidance_scale = 4.0 # CFG (pipeline default) +max_sequence_length = 1024 # Pipeline default +seed = 42 +model = "Lightricks/LTX-2" +``` + +## Technical Details + +### CFG (Classifier-Free Guidance) on Neuron + +With `guidance_scale=4.0`, the pipeline runs the text encoder twice (positive + negative prompt) and the DiT backbone twice per denoising step (uncond + cond). Since the Neuron backbone is compiled for `batch_size=1`, the `NeuronTransformerWrapper` handles CFG by splitting the batch and calling the backbone twice per step, then concatenating results. + +### 22-Input Transformer Signature + +The compiled Neuron DiT model takes 22 positional tensor arguments, all preprocessed on CPU: + +| # | Input | Shape | Description | +|---|-------|-------|-------------| +| 1 | hidden_states | (1, 768, 4096) | Video latents after proj_in | +| 2 | audio_hidden_states | (1, 26, 2048) | Audio latents after audio_proj_in | +| 3 | encoder_hidden_states | (1, 1024, 4096) | Text embeddings for video | +| 4 | audio_encoder_hidden_states | (1, 1024, 2048) | Text embeddings for audio | +| 5-8 | temb, temb_audio, embedded_ts, audio_embedded_ts | various | Time embeddings | +| 9-12 | cross-attn scale/shift/gate | various | Cross-attention conditioning | +| 13-16 | video/audio rotary cos/sin | various | Self-attention RoPE | +| 17-20 | cross-attn video/audio rotary cos/sin | various | Cross-attention RoPE | +| 21-22 | encoder/audio_attention_mask | (1, 1, 1024) | Additive attention bias | + +### Critical Implementation Details + +- **SPMDRank RoPE**: Uses NxD `SPMDRank` module (not a Python int) for per-rank RoPE slicing. A Python int gets baked as constant 0 during SPMD XLA tracing, causing all ranks to apply the same RoPE shard. + +- **DistributedRMSNorm**: QK-norm uses all-reduce across TP ranks to compute global variance. + +- **BMM SDPA**: Replaces `torch.nn.functional.scaled_dot_product_attention` with explicit BMM operations for Neuron XLA compatibility. + +- **RoPE BF16 cast**: RoPE modules return float32 for numerical precision. Tensors must be cast to bfloat16 before passing to the compiled Neuron model. + +- **Additive attention mask**: Binary masks are converted to additive bias format (-10000 for masked positions) before compilation. + +- **Pre-sharded weights**: Gemma3 weights are pre-sharded to disk (~5.5 GB per rank) using `.contiguous().clone()` to avoid serializing the full unsharded storage backing sliced tensors. + +### Compiler Flags + +``` +--model-type=transformer -O1 --auto-cast=none --enable-saturate-infinity +--enable-mixed-precision-accumulation --lnc=2 +--tensorizer-options='--enable-ccop-compute-overlap' +``` + +VAE decoder uses different compiler flags: +``` +--model-type=unet-inference -O1 --auto-cast none --enable-fast-loading-neuron-binaries +``` + +### Neuron VAE Decoder (Tiled Decode) + +The LTX-2 VAE decoder (128 input channels, 3D convolutions with 3 upsampler blocks) cannot be compiled at full resolution due to SRAM limits. Instead, we compile it at a small tile size and decode the full image by tiling with overlap blending. + +**Compilation boundary**: `H_latent * W_latent <= 64` elements. Above this, the compiler fails with `NCC_IGCA030` (SRAM allocation failure). + +#### Pipeline Integration + +The Neuron VAE is integrated as a drop-in replacement for `pipe.vae.decoder`. The `NeuronTiledVAEDecoder` class in `pipeline.py` wraps the compiled model and handles tiling transparently — the Diffusers pipeline calls `vae.decode()` as usual without any changes. + +To enable in `neuron_e2e.py`, set `LTX2_VAE_COMPILE_DIR` to the compiled model directory. If the directory doesn't exist, the pipeline falls back to CPU VAE decode automatically. + +```bash +# Enable Neuron VAE decode +LTX2_VAE_COMPILE_DIR=/home/ubuntu/ltx2_vae_tp4_256x256_f25 python neuron_e2e.py + +# Configure tile shape (defaults: 8x8 with overlap 2x2) +LTX2_VAE_TILE_H=8 LTX2_VAE_TILE_W=8 LTX2_VAE_OVERLAP_H=2 LTX2_VAE_OVERLAP_W=2 + +# For use from Python directly: +from pipeline import NeuronLTX2Pipeline +pipe = NeuronLTX2Pipeline.from_pretrained("Lightricks/LTX-2") +pipe._swap_vae_to_neuron("/path/to/compiled_vae", tile_latent_h=8, tile_latent_w=8) +``` + +#### Tile Shape vs Frame Count + +**The compiled VAE is fixed to a specific temporal dimension.** The tile shape must be chosen based on the number of video frames: + +| Video Frames | Latent T | Recommended Tile | Notes | +|-------------|----------|-----------------|-------| +| 25 | 4 | **8×8** (256×256 px) | 4×16 fails at latent_t=4 (SRAM issue) | +| 121 | 16 | **4×16** (128×512 px) | 12.5% faster per-tile, fewer tiles at high res | + +- **Short videos (25 frames)**: Use 8×8 tiles. The 4×16 tile fails to compile at latent_t=4 due to `NCC_IBIR229` state buffer allocation failure. 8×8 compiles in ~6 minutes. +- **Long videos (121 frames)**: Use 4×16 tiles for best performance. Compiles in ~15 minutes but requires trn2.48xlarge (2TB RAM) — the compiler OOMs on trn2.3xlarge (124GB) for rectangular tiles. + +Compile examples: +```bash +# Short videos (25 frames, 8x8 tiles) +NEURON_RT_VISIBLE_CORES=0-3 python compile_vae.py \ + --tp-degree 4 --height 256 --width 256 --num-frames 25 \ + --output-dir /home/ubuntu/ltx2_vae_tp4_256x256_f25 + +# Long videos (121 frames, 4x16 tiles — requires trn2.48xlarge) +NEURON_RT_VISIBLE_CORES=0-3 python compile_vae.py \ + --tp-degree 4 --height 128 --width 512 --num-frames 121 \ + --output-dir /home/ubuntu/ltx2_vae_tp4_128x512_f121 +``` + +#### Performance + +**Short videos (384×512, 25 frames, 8×8 tiles, trn2.48xlarge)**: + +| Overlap | Tiles | Neuron | CPU | Speedup | +|---------|-------|--------|-----|---------| +| 2×2 | 6 | 2.4s | 3.2s | 1.3x | + +**Long videos (1024×1536, 121 frames, trn2.48xlarge)**: + +| Tile | Overlap (h×w) | Tiles | Neuron | CPU | Speedup | Cos Sim | +|------|--------------|-------|--------|-----|---------|---------| +| 8×8 | 4×4 | 77 | 111.5s | 100s | 0.90x | 0.901 | +| **4×16** | **1×0** | **33** | **42.4s** | **99s** | **2.3x** | **0.892** | +| 4×16 | 0×0 | 24 | 30.9s | 98s | 3.2x | 0.872 | + +The speedup is most significant for long videos at high resolution, where the tile count matters. For short 25-frame videos at 384×512, the VAE decode is already fast (~3s CPU) and the Neuron advantage is modest. + +Environment variables: +```bash +NEURON_FUSE_SOFTMAX=1 +NEURON_CUSTOM_SILU=1 +NEURON_RT_STOCHASTIC_ROUNDING_EN=0 +``` diff --git a/contrib/models/ltx2-video-audio/examples/gpu_generate.py b/contrib/models/ltx2-video-audio/examples/gpu_generate.py new file mode 100644 index 00000000..4616bc93 --- /dev/null +++ b/contrib/models/ltx2-video-audio/examples/gpu_generate.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +""" +Generate reference video on GPU using same settings as Neuron E2E test. + +Settings must match the Neuron pipeline (uses pipeline defaults): + - Prompt: "A golden retriever puppy runs across a sunny green meadow, ..." + - Resolution: 512x384 + - Frames: 25 + - Steps: 8 + - Guidance scale: 4.0 (pipeline default) + - Seed: 42 + - Max sequence length: 1024 (pipeline default) + - Model: Lightricks/LTX-2 + +Usage: + pip install diffusers transformers accelerate imageio-ffmpeg + python gpu_generate.py +""" + +import os +import time +import torch + +print("=" * 60) +print("LTX-2 GPU Reference Generation") +print("=" * 60) + +# 1. Load pipeline +print("\n[1/3] Loading LTX2Pipeline on GPU...") +t0 = time.time() +from diffusers import LTX2Pipeline + +pipe = LTX2Pipeline.from_pretrained( + "Lightricks/LTX-2", + torch_dtype=torch.bfloat16, +) +pipe.enable_sequential_cpu_offload() +print(f" Loaded in {time.time() - t0:.1f}s (with sequential CPU offload)") + +# Print GPU info +for i in range(torch.cuda.device_count()): + props = torch.cuda.get_device_properties(i) + print(f" GPU {i}: {props.name}, {props.total_mem / 1e9:.1f} GB") + +# 2. Generate — EXACT same settings as Neuron E2E test +PROMPT = ( + "A golden retriever puppy runs across a sunny green meadow, " + "its ears flapping in the wind. The camera follows from a low angle. " + "Birds chirp in the background." +) +HEIGHT = 384 +WIDTH = 512 +NUM_FRAMES = 25 +NUM_STEPS = 8 + +print(f"\n[2/3] Generating video...") +print(f" Prompt: {PROMPT[:80]}...") +print(f" {WIDTH}x{HEIGHT}, {NUM_FRAMES} frames, {NUM_STEPS} steps, seed=42") + +generator = torch.Generator(device="cpu").manual_seed(42) + +t0 = time.time() +output = pipe( + prompt=PROMPT, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + num_inference_steps=NUM_STEPS, + generator=generator, + output_type="pil", +) +gen_time = time.time() - t0 +print(f" Generated in {gen_time:.1f}s") + +# 3. Save output +print("\n[3/3] Saving output...") +output_dir = "/tmp/ltx2_gpu_output/" +os.makedirs(output_dir, exist_ok=True) + +frames = output.frames[0] +frames_dir = os.path.join(output_dir, "frames") +os.makedirs(frames_dir, exist_ok=True) +for i, frame in enumerate(frames): + frame.save(os.path.join(frames_dir, f"frame_{i:04d}.png")) +print(f" Saved {len(frames)} frames to {frames_dir}/") + +try: + from diffusers.utils import export_to_video + + video_path = os.path.join(output_dir, "output.mp4") + export_to_video(frames, video_path, fps=24) + size_kb = os.path.getsize(video_path) / 1024 + print(f" Video: {video_path} ({size_kb:.1f} KB)") +except Exception as e: + print(f" Video export failed: {e}") + +print(f"\n{'=' * 60}") +print(f"Summary:") +print(f" Generation time: {gen_time:.1f}s") +print(f" Output frames: {len(frames)}") +print(f" Output dir: {output_dir}") +print(f"{'=' * 60}") diff --git a/contrib/models/ltx2-video-audio/examples/neuron_e2e.py b/contrib/models/ltx2-video-audio/examples/neuron_e2e.py new file mode 100644 index 00000000..fd9064f3 --- /dev/null +++ b/contrib/models/ltx2-video-audio/examples/neuron_e2e.py @@ -0,0 +1,369 @@ +#!/usr/bin/env python3 +""" +LTX-2 E2E: Neuron Text Encoder + Neuron DiT Backbone + Neuron VAE Decoder +========================================================================= +All three components can run on Neuron (TP=4). They coexist on the same +4 NeuronCores and execute sequentially: + text encoding -> denoising -> VAE decode (tiled) + +The VAE decoder is optional — if LTX2_VAE_COMPILE_DIR is not set or the +directory doesn't exist, falls back to CPU VAE decode (the Diffusers default). + +Uses correct pipeline defaults: + - guidance_scale=4.0 (CFG with batch-splitting for Neuron) + - max_sequence_length=1024 + +Prerequisites: + 1. DiT compiled: python ../src/compile_gemma3.py (or use notebook) + 2. Gemma3 compiled: (produces tp_0.pt ... tp_3.pt) + 3. Gemma3 sharded: python ../src/shard_gemma3_weights.py + 4. VAE compiled (optional): python ../src/compile_vae.py + +Usage: + source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate + NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python neuron_e2e.py +""" + +import gc +import json +import os +import sys +import time + +import torch + +os.environ.setdefault("NEURON_FUSE_SOFTMAX", "1") +os.environ.setdefault("NEURON_CUSTOM_SILU", "1") +os.environ.setdefault("NEURON_RT_STOCHASTIC_ROUNDING_EN", "0") +os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") + +# Add src directory to path +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src")) + +from modeling_ltx2 import ( + LTX2BackboneInferenceConfig, + NeuronLTX2BackboneApplication, + replace_sdpa_with_bmm, +) +from pipeline import NeuronTransformerWrapper +from neuronx_distributed_inference.models.config import NeuronConfig + +# Directories — adjust these to your instance layout +DIT_COMPILE_DIR = os.environ.get( + "LTX2_DIT_COMPILE_DIR", "/home/ubuntu/ltx2_nxdi_compiled_1024/" +) +GEMMA3_COMPILE_DIR = os.environ.get( + "LTX2_GEMMA3_COMPILE_DIR", "/home/ubuntu/gemma3_encoder_compiled_1024/" +) +GEMMA3_SHARDED_DIR = os.environ.get( + "LTX2_GEMMA3_SHARDED_DIR", "/home/ubuntu/gemma3_encoder_sharded/" +) +VAE_COMPILE_DIR = os.environ.get( + "LTX2_VAE_COMPILE_DIR", "/home/ubuntu/ltx2_vae_tp4_128x512/" +) +VAE_TILE_LATENT_H = int(os.environ.get("LTX2_VAE_TILE_H", "8")) +VAE_TILE_LATENT_W = int(os.environ.get("LTX2_VAE_TILE_W", "8")) +VAE_OVERLAP_H = int(os.environ.get("LTX2_VAE_OVERLAP_H", "2")) +VAE_OVERLAP_W = int(os.environ.get("LTX2_VAE_OVERLAP_W", "2")) +OUTPUT_DIR = os.environ.get("LTX2_OUTPUT_DIR", "/home/ubuntu/ltx2_output/") +TP_DEGREE = 4 +HEIGHT, WIDTH, NUM_FRAMES = 384, 512, 25 +NUM_STEPS = 8 +PROMPT = ( + "A golden retriever puppy runs across a sunny green meadow, " + "its ears flapping in the wind. The camera follows from a low angle. " + "Birds chirp in the background." +) +SEED = 42 + + +# -- Neuron Gemma3 Text Encoder ----------------------------------------------- + + +def load_neuron_gemma3(sharded_dir, compile_dir, tp_degree): + """Load TP=4 compiled Gemma3 encoder with pre-sharded weights.""" + import torch_neuronx + from neuronx_distributed.trace.trace import ( + replace_weights, + TensorParallelNeuronModel, + ) + + models = [] + for rank in range(tp_degree): + t0 = time.time() + rank_ckpt_path = os.path.join(sharded_dir, f"rank_{rank}.pt") + ckpt = torch.load(rank_ckpt_path, weights_only=True) + + neff_path = os.path.join(compile_dir, f"tp_{rank}.pt") + with torch_neuronx.contexts.disable_nrt_load(): + traced_model = torch.jit.load(neff_path) + + replace_weights(traced_model, ckpt) + print(f" [Gemma3 rank {rank}] {time.time() - t0:.1f}s") + models.append(traced_model) + del ckpt + gc.collect() + + compiled = TensorParallelNeuronModel(models) + print(f" Gemma3: all {tp_degree} ranks loaded") + return compiled + + +class NeuronTextEncoderOutput: + def __init__(self, hidden_states): + self.hidden_states = hidden_states + + +class NeuronTextEncoderWrapper: + """Drop-in replacement for Gemma3ForConditionalGeneration.""" + + def __init__(self, compiled_gemma3, dtype=torch.bfloat16): + self.compiled_model = compiled_gemma3 + self.dtype = dtype + self._device = torch.device("cpu") + self.config = type("Config", (), {"output_hidden_states": True})() + + def __call__( + self, input_ids=None, attention_mask=None, output_hidden_states=True, **kwargs + ): + with torch.no_grad(): + stacked = self.compiled_model(input_ids, attention_mask) + num_states = stacked.shape[-1] + hidden_states = tuple(stacked[:, :, :, i] for i in range(num_states)) + return NeuronTextEncoderOutput(hidden_states=hidden_states) + + def eval(self): + return self + + def to(self, *args, **kwargs): + return self + + @property + def device(self): + return self._device + + +# -- Main Pipeline ------------------------------------------------------------- + + +def main(): + replace_sdpa_with_bmm() + + print("=" * 60) + print(f"LTX-2 E2E: Neuron Text Encoder + DiT + VAE (TP={TP_DEGREE})") + print("=" * 60) + t_total = time.time() + + # Check if VAE compiled dir exists + use_neuron_vae = os.path.isdir(VAE_COMPILE_DIR) and os.path.exists( + os.path.join(VAE_COMPILE_DIR, "tp_0.pt") + ) + if use_neuron_vae: + print(f" Neuron VAE: {VAE_COMPILE_DIR}") + else: + print(f" Neuron VAE: NOT FOUND at {VAE_COMPILE_DIR} (using CPU fallback)") + + # 1. Create DiT config + print("\n[1/7] Creating DiT config...") + from huggingface_hub import hf_hub_download + + config_path = hf_hub_download("Lightricks/LTX-2", "transformer/config.json") + with open(config_path) as f: + hf_config = json.load(f) + + num_heads = hf_config["num_attention_heads"] + head_dim = hf_config["attention_head_dim"] + inner_dim = num_heads * head_dim + audio_num_heads = hf_config["audio_num_attention_heads"] + audio_head_dim = hf_config["audio_attention_head_dim"] + audio_inner_dim = audio_num_heads * audio_head_dim + audio_ca_dim = hf_config.get("audio_cross_attention_dim", audio_inner_dim) + + latent_num_frames = (NUM_FRAMES - 1) // 8 + 1 + latent_height = HEIGHT // 32 + latent_width = WIDTH // 32 + video_seq = latent_num_frames * latent_height * latent_width + audio_num_frames = round((NUM_FRAMES / 24.0) * 24.97) + + backbone_neuron_config = NeuronConfig( + tp_degree=TP_DEGREE, + world_size=TP_DEGREE, + torch_dtype=torch.bfloat16, + ) + + config = LTX2BackboneInferenceConfig( + neuron_config=backbone_neuron_config, + num_layers=hf_config["num_layers"], + num_attention_heads=num_heads, + attention_head_dim=head_dim, + inner_dim=inner_dim, + audio_num_attention_heads=audio_num_heads, + audio_attention_head_dim=audio_head_dim, + audio_inner_dim=audio_inner_dim, + audio_cross_attention_dim=audio_ca_dim, + caption_channels=hf_config.get("caption_channels", 3840), + video_seq=video_seq, + audio_seq=audio_num_frames, + text_seq=1024, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + ) + config.hf_config_dict = hf_config + print(f" 48 blocks, TP={TP_DEGREE}, {HEIGHT}x{WIDTH}, {NUM_FRAMES} frames") + + # 2. Load diffusers pipeline (CPU) + print("\n[2/7] Loading Diffusers LTX2Pipeline (CPU)...") + t0 = time.time() + from diffusers import LTX2Pipeline + + pipe = LTX2Pipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16) + print(f" Loaded in {time.time() - t0:.1f}s") + + # 3. Load Neuron DiT backbone + print(f"\n[3/7] Loading Neuron DiT backbone from {DIT_COMPILE_DIR}...") + from huggingface_hub import snapshot_download + + local_transformer_path = snapshot_download( + "Lightricks/LTX-2", allow_patterns=["transformer/*"] + ) + local_transformer_path = os.path.join(local_transformer_path, "transformer") + + cpu_transformer = pipe.transformer + + t0 = time.time() + backbone_app = NeuronLTX2BackboneApplication( + model_path=local_transformer_path, config=config + ) + backbone_app.load(DIT_COMPILE_DIR) + print(f" DiT loaded in {time.time() - t0:.1f}s") + + # Swap DiT transformer + wrapper = NeuronTransformerWrapper( + compiled_backbone=backbone_app, cpu_transformer=cpu_transformer, text_seq=1024 + ) + del cpu_transformer.transformer_blocks + del cpu_transformer.norm_out, cpu_transformer.proj_out + del cpu_transformer.audio_norm_out, cpu_transformer.audio_proj_out + gc.collect() + pipe.transformer = wrapper + print(" DiT swapped") + + # 4. Swap text encoder: CPU -> Neuron + print("\n[4/7] Swapping text encoder to Neuron...") + t0 = time.time() + del pipe.text_encoder + gc.collect() + print(" Freed CPU text encoder") + + compiled_gemma3 = load_neuron_gemma3( + GEMMA3_SHARDED_DIR, GEMMA3_COMPILE_DIR, TP_DEGREE + ) + pipe.text_encoder = NeuronTextEncoderWrapper(compiled_gemma3) + print(f" Neuron text encoder loaded in {time.time() - t0:.1f}s") + + # 5. Swap VAE decoder: CPU -> Neuron (if compiled) + if use_neuron_vae: + print(f"\n[5/7] Swapping VAE decoder to Neuron...") + t0 = time.time() + + from pipeline import NeuronTiledVAEDecoder + + original_decoder = pipe.vae.decoder + neuron_decoder = NeuronTiledVAEDecoder( + compiled_dir=VAE_COMPILE_DIR, + tile_latent_h=VAE_TILE_LATENT_H, + tile_latent_w=VAE_TILE_LATENT_W, + overlap_latent_h=VAE_OVERLAP_H, + overlap_latent_w=VAE_OVERLAP_W, + original_decoder=original_decoder, + ) + del original_decoder + gc.collect() + + pipe.vae.decoder = neuron_decoder + print(f" Neuron VAE loaded in {time.time() - t0:.1f}s") + + # Warmup VAE + print(" Warming up VAE...") + neuron_decoder.warmup(num_frames=NUM_FRAMES) + print(" VAE warmup done") + else: + print(f"\n[5/7] Skipping Neuron VAE (using CPU fallback)") + + # 6. Generate + print("\n[6/7] Generating video+audio...") + print(f" Prompt: {PROMPT[:80]}...") + print(f" {WIDTH}x{HEIGHT}, {NUM_FRAMES} frames, {NUM_STEPS} steps") + + generator = torch.Generator(device="cpu").manual_seed(SEED) + + t0 = time.time() + output = pipe( + prompt=PROMPT, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + num_inference_steps=NUM_STEPS, + generator=generator, + output_type="pil", + ) + gen_time = time.time() - t0 + print(f" Generated in {gen_time:.1f}s") + + # 7. Save outputs + os.makedirs(OUTPUT_DIR, exist_ok=True) + frames = output.frames[0] + frames_dir = os.path.join(OUTPUT_DIR, "frames") + os.makedirs(frames_dir, exist_ok=True) + for i, frame in enumerate(frames): + frame.save(os.path.join(frames_dir, f"frame_{i:04d}.png")) + print(f" Saved {len(frames)} frames to {frames_dir}/") + + try: + from diffusers.utils import export_to_video + + video_path = os.path.join(OUTPUT_DIR, "output.mp4") + export_to_video(frames, video_path, fps=24) + print(f" Video: {video_path}") + except Exception as e: + print(f" Video export failed: {e}") + + metadata = { + "model": "Lightricks/LTX-2", + "prompt": PROMPT, + "resolution": f"{WIDTH}x{HEIGHT}", + "num_frames": NUM_FRAMES, + "num_steps": NUM_STEPS, + "guidance_scale": 4.0, + "max_sequence_length": 1024, + "seed": SEED, + "generation_time_s": gen_time, + "total_time_s": time.time() - t_total, + "text_encoder": f"Neuron Gemma3-12B (TP={TP_DEGREE})", + "dit": f"Neuron LTX2 DiT 48 blocks (TP={TP_DEGREE})", + "vae_decoder": f"Neuron tiled 4x16 (TP={TP_DEGREE})" + if use_neuron_vae + else "CPU (Diffusers default)", + } + with open(os.path.join(OUTPUT_DIR, "metadata.json"), "w") as f: + json.dump(metadata, f, indent=2) + + total_time = time.time() - t_total + print(f"\n{'=' * 60}") + print("Summary:") + print(f" Total time: {total_time:.1f}s") + print(f" Generation time: {gen_time:.1f}s") + print(f" Output frames: {len(frames)}") + print(f" Text encoder: Neuron Gemma3-12B") + print(f" DiT: Neuron LTX2 (48 blocks)") + print( + f" VAE decoder: {'Neuron tiled 4x16' if use_neuron_vae else 'CPU (fallback)'}" + ) + print(f" Output dir: {OUTPUT_DIR}") + print("=" * 60) + + +if __name__ == "__main__": + main() diff --git a/contrib/models/ltx2-video-audio/notebooks/ltx2_neuron_inference.ipynb b/contrib/models/ltx2-video-audio/notebooks/ltx2_neuron_inference.ipynb new file mode 100644 index 00000000..6e7a83bf --- /dev/null +++ b/contrib/models/ltx2-video-audio/notebooks/ltx2_neuron_inference.ipynb @@ -0,0 +1,597 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# LTX-2 Video+Audio Generation on AWS Trainium\n", + "\n", + "This notebook demonstrates how to compile and run the [Lightricks LTX-2](https://huggingface.co/Lightricks/LTX-2) 19B-parameter audio-video diffusion model on AWS Trainium using NxDI (NeuronX Distributed Inference).\n", + "\n", + "**What gets compiled for Neuron:**\n", + "- DiT transformer backbone (48 blocks, ~6B params) \u2192 Neuron TP=4\n", + "- Gemma 3-12B text encoder \u2192 Neuron TP=4\n", + "\n", + "**What stays on CPU:**\n", + "- Video + Audio VAE decoders (~1B params)\n", + "- Tokenizer, scheduler, vocoder\n", + "\n", + "**Hardware:** trn2.3xlarge (1 NeuronDevice, 4 logical NeuronCores with LNC=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Prerequisites\n", + "\n", + "Run this notebook on a **trn2.3xlarge** instance with the Deep Learning AMI Neuron (Ubuntu 24.04).\n", + "\n", + "```bash\n", + "# Activate the pre-installed Neuron environment\n", + "source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate\n", + "\n", + "# Install diffusers (LTX-2 requires dev version)\n", + "pip install git+https://github.com/huggingface/diffusers.git\n", + "pip install imageio imageio-ffmpeg ipywidgets\n", + "\n", + "# Upload this package to the instance\n", + "# scp -r ltx2-neuron/ ubuntu@:/home/ubuntu/\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import gc\n", + "import json\n", + "import os\n", + "import sys\n", + "import time\n", + "\n", + "import torch\n", + "\n", + "# Environment variables for Neuron compiler/runtime\n", + "os.environ.setdefault(\"NEURON_FUSE_SOFTMAX\", \"1\")\n", + "os.environ.setdefault(\"NEURON_CUSTOM_SILU\", \"1\")\n", + "os.environ.setdefault(\"NEURON_RT_STOCHASTIC_ROUNDING_EN\", \"0\")\n", + "os.environ.setdefault(\"TOKENIZERS_PARALLELISM\", \"false\")\n", + "\n", + "# Add the src directory to path\n", + "# When running as a notebook, use the notebook's directory; when running via nbconvert, use cwd\n", + "try:\n", + " _nb_dir = os.path.dirname(os.path.abspath(__file__))\n", + "except NameError:\n", + " _nb_dir = os.getcwd()\n", + "PACKAGE_DIR = os.path.abspath(os.path.join(_nb_dir, \"..\", \"src\"))\n", + "if not os.path.isdir(PACKAGE_DIR):\n", + " PACKAGE_DIR = os.path.abspath(os.path.join(_nb_dir, \"src\"))\n", + "sys.path.insert(0, PACKAGE_DIR)\n", + "print(f\"Package dir: {PACKAGE_DIR}\")\n", + "\n", + "print(f\"PyTorch: {torch.__version__}\")\n", + "try:\n", + " import torch_neuronx\n", + " print(f\"torch-neuronx: {torch_neuronx.__version__}\")\n", + "except ImportError:\n", + " print(\"WARNING: torch_neuronx not found. Are you on a Neuron instance?\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Configuration\n", + "\n", + "Set the video resolution, frame count, and output directories." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Video generation settings\n", + "HEIGHT, WIDTH, NUM_FRAMES = 384, 512, 25\n", + "NUM_STEPS = 8 # Distilled model uses 8 steps\n", + "TP_DEGREE = 4 # Tensor parallelism across 4 NeuronCores\n", + "SEED = 42\n", + "\n", + "PROMPT = (\n", + " \"A golden retriever puppy runs across a sunny green meadow, \"\n", + " \"its ears flapping in the wind. The camera follows from a low angle. \"\n", + " \"Birds chirp in the background.\"\n", + ")\n", + "\n", + "# Compiled model directories (persist across reboots if on /home/ubuntu/)\n", + "DIT_COMPILE_DIR = \"/home/ubuntu/ltx2_nxdi_compiled_1024/\"\n", + "GEMMA3_COMPILE_DIR = \"/home/ubuntu/gemma3_encoder_compiled_1024/\"\n", + "GEMMA3_SHARDED_DIR = \"/home/ubuntu/gemma3_encoder_sharded/\"\n", + "OUTPUT_DIR = \"/home/ubuntu/ltx2_output/\"\n", + "\n", + "print(f\"Video: {WIDTH}x{HEIGHT}, {NUM_FRAMES} frames, {NUM_STEPS} steps\")\n", + "print(f\"TP degree: {TP_DEGREE}\")\n", + "print(f\"Prompt: {PROMPT[:80]}...\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Compile the DiT Transformer Backbone\n", + "\n", + "The DiT backbone is the denoising workhorse \u2014 48 transformer blocks that run 8 times per generation (once per denoising step), doubled with CFG. This is the component that benefits most from Neuron acceleration.\n", + "\n", + "Compilation traces the model with NxDI's SPMD infrastructure and produces a single `model.pt` NEFF file. **First compilation takes ~2 minutes; subsequent runs load from cache.**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from modeling_ltx2 import (\n", + " LTX2BackboneInferenceConfig,\n", + " NeuronLTX2BackboneApplication,\n", + " replace_sdpa_with_bmm,\n", + ")\n", + "from neuronx_distributed_inference.models.config import NeuronConfig\n", + "\n", + "# Replace SDPA with BMM for Neuron XLA compatibility\n", + "replace_sdpa_with_bmm()\n", + "\n", + "# Load transformer config from HuggingFace\n", + "from huggingface_hub import hf_hub_download\n", + "config_path = hf_hub_download(\"Lightricks/LTX-2\", \"transformer/config.json\")\n", + "with open(config_path) as f:\n", + " hf_config = json.load(f)\n", + "\n", + "# Compute latent dimensions\n", + "num_heads = hf_config[\"num_attention_heads\"]\n", + "head_dim = hf_config[\"attention_head_dim\"]\n", + "inner_dim = num_heads * head_dim\n", + "audio_num_heads = hf_config[\"audio_num_attention_heads\"]\n", + "audio_head_dim = hf_config[\"audio_attention_head_dim\"]\n", + "audio_inner_dim = audio_num_heads * audio_head_dim\n", + "audio_ca_dim = hf_config.get(\"audio_cross_attention_dim\", audio_inner_dim)\n", + "\n", + "latent_num_frames = (NUM_FRAMES - 1) // 8 + 1\n", + "latent_height = HEIGHT // 32\n", + "latent_width = WIDTH // 32\n", + "video_seq = latent_num_frames * latent_height * latent_width\n", + "audio_num_frames = round((NUM_FRAMES / 24.0) * 24.97)\n", + "\n", + "backbone_neuron_config = NeuronConfig(\n", + " tp_degree=TP_DEGREE,\n", + " world_size=TP_DEGREE,\n", + " torch_dtype=torch.bfloat16,\n", + ")\n", + "\n", + "config = LTX2BackboneInferenceConfig(\n", + " neuron_config=backbone_neuron_config,\n", + " num_layers=hf_config[\"num_layers\"],\n", + " num_attention_heads=num_heads,\n", + " attention_head_dim=head_dim,\n", + " inner_dim=inner_dim,\n", + " audio_num_attention_heads=audio_num_heads,\n", + " audio_attention_head_dim=audio_head_dim,\n", + " audio_inner_dim=audio_inner_dim,\n", + " audio_cross_attention_dim=audio_ca_dim,\n", + " caption_channels=hf_config.get(\"caption_channels\", 3840),\n", + " video_seq=video_seq,\n", + " audio_seq=audio_num_frames,\n", + " text_seq=1024,\n", + " height=HEIGHT,\n", + " width=WIDTH,\n", + " num_frames=NUM_FRAMES,\n", + ")\n", + "config.hf_config_dict = hf_config\n", + "\n", + "print(f\"DiT: {hf_config['num_layers']} blocks, inner_dim={inner_dim}, audio_inner_dim={audio_inner_dim}\")\n", + "print(f\"Video: {video_seq} tokens, Audio: {audio_num_frames} tokens, Text: 1024 tokens\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the NxDI backbone application\n", + "from huggingface_hub import snapshot_download\n", + "\n", + "local_transformer_path = snapshot_download(\n", + " \"Lightricks/LTX-2\", allow_patterns=[\"transformer/*\"]\n", + ")\n", + "local_transformer_path = os.path.join(local_transformer_path, \"transformer\")\n", + "\n", + "backbone_app = NeuronLTX2BackboneApplication(\n", + " model_path=local_transformer_path,\n", + " config=config,\n", + ")\n", + "\n", + "# Compile if not already cached\n", + "compiled_model_file = os.path.join(DIT_COMPILE_DIR, \"model.pt\")\n", + "if os.path.exists(compiled_model_file):\n", + " size_gb = os.path.getsize(compiled_model_file) / 1e9\n", + " print(f\"Found cached DiT compiled model: {compiled_model_file} ({size_gb:.2f} GB)\")\n", + "else:\n", + " print(f\"Compiling DiT backbone to {DIT_COMPILE_DIR} (first run, ~2 min)...\")\n", + " t0 = time.time()\n", + " os.makedirs(DIT_COMPILE_DIR, exist_ok=True)\n", + " backbone_app.compile(DIT_COMPILE_DIR)\n", + " print(f\"Compiled in {time.time() - t0:.1f}s\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Compile the Gemma 3-12B Text Encoder\n", + "\n", + "LTX-2 uses Gemma 3-12B as its text encoder. We compile a custom encoder that outputs all 49 hidden states (embedding + 48 layers), which LTX-2 stacks and projects into text embeddings.\n", + "\n", + "**First compilation takes ~3 minutes.** We also pre-shard the weights to disk (~5.5 GB per rank) so loading only requires ~6 GB peak memory instead of ~24 GB." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check if Gemma3 encoder is already compiled\n", + "gemma3_compiled = os.path.exists(os.path.join(GEMMA3_COMPILE_DIR, \"tp_0.pt\"))\n", + "gemma3_sharded = os.path.exists(os.path.join(GEMMA3_SHARDED_DIR, \"rank_0.pt\"))\n", + "\n", + "if gemma3_compiled:\n", + " size_gb = os.path.getsize(os.path.join(GEMMA3_COMPILE_DIR, \"tp_0.pt\")) / 1e9\n", + " print(f\"Found cached Gemma3 compiled encoder: {GEMMA3_COMPILE_DIR} ({size_gb:.1f} GB per rank)\")\n", + "else:\n", + " print(\"Gemma3 encoder not compiled yet.\")\n", + " print(\"Run: python ../src/compile_gemma3.py\")\n", + " print(\"This takes ~3 minutes and produces tp_0.pt through tp_3.pt\")\n", + "\n", + "if gemma3_sharded:\n", + " size_gb = os.path.getsize(os.path.join(GEMMA3_SHARDED_DIR, \"rank_0.pt\")) / 1e9\n", + " print(f\"Found pre-sharded Gemma3 weights: {GEMMA3_SHARDED_DIR} ({size_gb:.1f} GB per rank)\")\n", + "else:\n", + " print(\"Gemma3 weights not pre-sharded yet.\")\n", + " print(\"Run: python ../src/shard_gemma3_weights.py\")\n", + " print(\"This takes ~2 minutes and produces rank_0.pt through rank_3.pt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Load the Diffusers Pipeline\n", + "\n", + "We load the full Diffusers LTX2Pipeline first (text encoder, transformer, VAEs, vocoder all on CPU), then swap the text encoder and transformer with Neuron-compiled versions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(\"Loading Diffusers LTX2Pipeline (CPU)...\")\n", + "t0 = time.time()\n", + "from diffusers import LTX2Pipeline\n", + "\n", + "pipe = LTX2Pipeline.from_pretrained(\n", + " \"Lightricks/LTX-2\",\n", + " torch_dtype=torch.bfloat16,\n", + ")\n", + "print(f\"Pipeline loaded in {time.time() - t0:.1f}s\")\n", + "print(f\"Components: {', '.join(k for k, v in pipe.components.items() if v is not None)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Load DiT Backbone onto Neuron\n", + "\n", + "Load the compiled NEFF, shard the transformer weights across 4 NeuronCores, and warm up." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pipeline import NeuronTransformerWrapper\n", + "\n", + "print(f\"Loading DiT backbone from {DIT_COMPILE_DIR}...\")\n", + "cpu_transformer = pipe.transformer\n", + "\n", + "t0 = time.time()\n", + "backbone_app.load(DIT_COMPILE_DIR)\n", + "print(f\"DiT loaded in {time.time() - t0:.1f}s\")\n", + "\n", + "# Swap the pipeline's transformer with the Neuron wrapper\n", + "wrapper = NeuronTransformerWrapper(\n", + " compiled_backbone=backbone_app,\n", + " cpu_transformer=cpu_transformer,\n", + " text_seq=1024,\n", + ")\n", + "\n", + "# Free heavy transformer blocks (preprocessing layers are kept via wrapper refs)\n", + "del cpu_transformer.transformer_blocks\n", + "del cpu_transformer.norm_out, cpu_transformer.proj_out\n", + "del cpu_transformer.audio_norm_out, cpu_transformer.audio_proj_out\n", + "gc.collect()\n", + "\n", + "pipe.transformer = wrapper\n", + "print(\"DiT transformer swapped to Neuron\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Load Gemma3 Text Encoder onto Neuron\n", + "\n", + "Swap the CPU text encoder with the Neuron-compiled Gemma3 encoder using pre-sharded per-rank weights." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import torch_neuronx\n", + "from neuronx_distributed.trace.trace import (\n", + " replace_weights,\n", + " TensorParallelNeuronModel,\n", + ")\n", + "\n", + "# Free CPU text encoder (~24 GB)\n", + "del pipe.text_encoder\n", + "gc.collect()\n", + "print(\"Freed CPU text encoder\")\n", + "\n", + "# Load Neuron Gemma3 encoder from pre-sharded per-rank checkpoints\n", + "print(f\"Loading Gemma3 encoder from {GEMMA3_COMPILE_DIR}...\")\n", + "t0 = time.time()\n", + "\n", + "models = []\n", + "for rank in range(TP_DEGREE):\n", + " tr = time.time()\n", + " rank_ckpt_path = os.path.join(GEMMA3_SHARDED_DIR, f\"rank_{rank}.pt\")\n", + " ckpt = torch.load(rank_ckpt_path, weights_only=True)\n", + " \n", + " neff_path = os.path.join(GEMMA3_COMPILE_DIR, f\"tp_{rank}.pt\")\n", + " with torch_neuronx.contexts.disable_nrt_load():\n", + " traced_model = torch.jit.load(neff_path)\n", + " \n", + " replace_weights(traced_model, ckpt)\n", + " models.append(traced_model)\n", + " del ckpt\n", + " gc.collect()\n", + " print(f\" [rank {rank}] {time.time() - tr:.1f}s\")\n", + "\n", + "compiled_gemma3 = TensorParallelNeuronModel(models)\n", + "print(f\"Gemma3 encoder loaded in {time.time() - t0:.1f}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a wrapper that mimics the HF text encoder interface\n", + "class NeuronTextEncoderOutput:\n", + " def __init__(self, hidden_states):\n", + " self.hidden_states = hidden_states\n", + "\n", + "class NeuronTextEncoderWrapper:\n", + " \"\"\"Drop-in replacement for Gemma3ForConditionalGeneration.\"\"\"\n", + " def __init__(self, compiled_gemma3, dtype=torch.bfloat16):\n", + " self.compiled_model = compiled_gemma3\n", + " self.dtype = dtype\n", + " self._device = torch.device(\"cpu\")\n", + " self.config = type(\"Config\", (), {\"output_hidden_states\": True})()\n", + "\n", + " def __call__(self, input_ids=None, attention_mask=None, output_hidden_states=True, **kwargs):\n", + " with torch.no_grad():\n", + " # Neuron model returns (B, seq_len, hidden_size, num_layers+1)\n", + " stacked = self.compiled_model(input_ids, attention_mask)\n", + " num_states = stacked.shape[-1]\n", + " hidden_states = tuple(stacked[:, :, :, i] for i in range(num_states))\n", + " return NeuronTextEncoderOutput(hidden_states=hidden_states)\n", + "\n", + " def eval(self): return self\n", + " def to(self, *args, **kwargs): return self\n", + "\n", + " @property\n", + " def device(self): return self._device\n", + "\n", + "pipe.text_encoder = NeuronTextEncoderWrapper(compiled_gemma3)\n", + "print(\"Text encoder swapped to Neuron Gemma3\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Generate Video + Audio\n", + "\n", + "Run the full pipeline with the default parameters:\n", + "- `guidance_scale=4.0` (classifier-free guidance \u2014 the DiT runs twice per step)\n", + "- `max_sequence_length=1024`\n", + "- 8 denoising steps (distilled model)\n", + "\n", + "The pipeline handles text encoding, denoising loop, VAE decoding, and vocoder automatically.\n", + "\n", + "**Note:** The first generation includes a one-time warmup overhead (Neuron runtime initialization). Subsequent generations are faster." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f\"Generating (first run, includes warmup): {PROMPT[:80]}...\")\n", + "print(f\"{WIDTH}x{HEIGHT}, {NUM_FRAMES} frames, {NUM_STEPS} steps\")\n", + "\n", + "generator = torch.Generator(device=\"cpu\").manual_seed(SEED)\n", + "\n", + "t0 = time.time()\n", + "output = pipe(\n", + " prompt=PROMPT,\n", + " height=HEIGHT,\n", + " width=WIDTH,\n", + " num_frames=NUM_FRAMES,\n", + " num_inference_steps=NUM_STEPS,\n", + " generator=generator,\n", + " output_type=\"pil\",\n", + ")\n", + "first_gen_time = time.time() - t0\n", + "print(f\"First generation (with warmup): {first_gen_time:.1f}s\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Save and Display Results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Save frames and video\n", + "os.makedirs(OUTPUT_DIR, exist_ok=True)\n", + "frames = output.frames[0]\n", + "\n", + "frames_dir = os.path.join(OUTPUT_DIR, \"frames\")\n", + "os.makedirs(frames_dir, exist_ok=True)\n", + "for i, frame in enumerate(frames):\n", + " frame.save(os.path.join(frames_dir, f\"frame_{i:04d}.png\"))\n", + "print(f\"Saved {len(frames)} frames to {frames_dir}/\")\n", + "\n", + "try:\n", + " from diffusers.utils import export_to_video\n", + " video_path = os.path.join(OUTPUT_DIR, \"output.mp4\")\n", + " export_to_video(frames, video_path, fps=24)\n", + " print(f\"Video: {video_path}\")\n", + "except Exception as e:\n", + " print(f\"Video export failed: {e}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Display sample frames\n", + "from IPython.display import display\n", + "import PIL.Image\n", + "\n", + "sample_indices = [0, len(frames) // 4, len(frames) // 2, 3 * len(frames) // 4, len(frames) - 1]\n", + "for idx in sample_indices:\n", + " print(f\"Frame {idx:04d}:\")\n", + " display(frames[idx].resize((256, 192))) # Thumbnail for display" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Save metadata\n", + "metadata = {\n", + " \"model\": \"Lightricks/LTX-2\",\n", + " \"prompt\": PROMPT,\n", + " \"resolution\": f\"{WIDTH}x{HEIGHT}\",\n", + " \"num_frames\": NUM_FRAMES,\n", + " \"num_steps\": NUM_STEPS,\n", + " \"guidance_scale\": 4.0,\n", + " \"max_sequence_length\": 1024,\n", + " \"seed\": SEED,\n", + " \"first_generation_time_s\": first_gen_time,\n", + " \"text_encoder\": f\"Neuron Gemma3-12B (TP={TP_DEGREE})\",\n", + " \"dit\": f\"Neuron LTX2 DiT 48 blocks (TP={TP_DEGREE})\",\n", + "}\n", + "\n", + "with open(os.path.join(OUTPUT_DIR, \"metadata.json\"), \"w\") as f:\n", + " json.dump(metadata, f, indent=2)\n", + "\n", + "print(f\"\\nFirst generation time (with warmup): {first_gen_time:.1f}s\")\n", + "print(f\"Output: {OUTPUT_DIR}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Try Your Own Prompt (Warm Generation)\n", + "\n", + "With models already loaded, this generation reflects steady-state performance without warmup overhead. Change the prompt below and re-run to generate a different video." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Change this prompt to generate different content\n", + "my_prompt = \"A cat sitting on a windowsill watches rain falling outside, with soft piano music playing.\"\n", + "\n", + "generator = torch.Generator(device=\"cpu\").manual_seed(123)\n", + "\n", + "t0 = time.time()\n", + "output2 = pipe(\n", + " prompt=my_prompt,\n", + " height=HEIGHT,\n", + " width=WIDTH,\n", + " num_frames=NUM_FRAMES,\n", + " num_inference_steps=NUM_STEPS,\n", + " generator=generator,\n", + " output_type=\"pil\",\n", + ")\n", + "warm_gen_time = time.time() - t0\n", + "print(f\"Warm generation time: {warm_gen_time:.1f}s\")\n", + "\n", + "# Display first and last frame\n", + "from IPython.display import display\n", + "frames2 = output2.frames[0]\n", + "print(f\"Frame 0:\")\n", + "display(frames2[0].resize((256, 192)))\n", + "print(f\"Frame {len(frames2)-1}:\")\n", + "display(frames2[-1].resize((256, 192)))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/contrib/models/ltx2-video-audio/notebooks/ltx2_neuron_inference_executed.ipynb b/contrib/models/ltx2-video-audio/notebooks/ltx2_neuron_inference_executed.ipynb new file mode 100644 index 00000000..786562af --- /dev/null +++ b/contrib/models/ltx2-video-audio/notebooks/ltx2_neuron_inference_executed.ipynb @@ -0,0 +1,9862 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# LTX-2 Video+Audio Generation on AWS Trainium\n", + "\n", + "This notebook demonstrates how to compile and run the [Lightricks LTX-2](https://huggingface.co/Lightricks/LTX-2) 19B-parameter audio-video diffusion model on AWS Trainium using NxDI (NeuronX Distributed Inference).\n", + "\n", + "**What gets compiled for Neuron:**\n", + "- DiT transformer backbone (48 blocks, ~6B params) → Neuron TP=4\n", + "- Gemma 3-12B text encoder → Neuron TP=4\n", + "\n", + "**What stays on CPU:**\n", + "- Video + Audio VAE decoders (~1B params)\n", + "- Tokenizer, scheduler, vocoder\n", + "\n", + "**Hardware:** trn2.3xlarge (1 NeuronDevice, 4 logical NeuronCores with LNC=2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Prerequisites\n", + "\n", + "Run this notebook on a **trn2.3xlarge** instance with the Deep Learning AMI Neuron (Ubuntu 24.04).\n", + "\n", + "```bash\n", + "# Activate the pre-installed Neuron environment\n", + "source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate\n", + "\n", + "# Install diffusers (LTX-2 requires dev version)\n", + "pip install git+https://github.com/huggingface/diffusers.git\n", + "pip install imageio imageio-ffmpeg ipywidgets\n", + "\n", + "# Upload this package to the instance\n", + "# scp -r ltx2-neuron/ ubuntu@:/home/ubuntu/\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:11:16.410615Z", + "iopub.status.busy": "2026-03-06T00:11:16.410477Z", + "iopub.status.idle": "2026-03-06T00:11:34.888268Z", + "shell.execute_reply": "2026-03-06T00:11:34.887313Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Package dir: /home/ubuntu/ltx2-neuron-release/src\n", + "PyTorch: 2.9.0+cu128\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch-neuronx: 2.9.0.2.12.22436+0f1dac25\n" + ] + } + ], + "source": [ + "import gc\n", + "import json\n", + "import os\n", + "import sys\n", + "import time\n", + "\n", + "import torch\n", + "\n", + "# Environment variables for Neuron compiler/runtime\n", + "os.environ.setdefault(\"NEURON_FUSE_SOFTMAX\", \"1\")\n", + "os.environ.setdefault(\"NEURON_CUSTOM_SILU\", \"1\")\n", + "os.environ.setdefault(\"NEURON_RT_STOCHASTIC_ROUNDING_EN\", \"0\")\n", + "os.environ.setdefault(\"TOKENIZERS_PARALLELISM\", \"false\")\n", + "\n", + "# Add the src directory to path\n", + "# When running as a notebook, use the notebook's directory; when running via nbconvert, use cwd\n", + "try:\n", + " _nb_dir = os.path.dirname(os.path.abspath(__file__))\n", + "except NameError:\n", + " _nb_dir = os.getcwd()\n", + "PACKAGE_DIR = os.path.abspath(os.path.join(_nb_dir, \"..\", \"src\"))\n", + "if not os.path.isdir(PACKAGE_DIR):\n", + " PACKAGE_DIR = os.path.abspath(os.path.join(_nb_dir, \"src\"))\n", + "sys.path.insert(0, PACKAGE_DIR)\n", + "print(f\"Package dir: {PACKAGE_DIR}\")\n", + "\n", + "print(f\"PyTorch: {torch.__version__}\")\n", + "try:\n", + " import torch_neuronx\n", + " print(f\"torch-neuronx: {torch_neuronx.__version__}\")\n", + "except ImportError:\n", + " print(\"WARNING: torch_neuronx not found. Are you on a Neuron instance?\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Configuration\n", + "\n", + "Set the video resolution, frame count, and output directories." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:11:34.891200Z", + "iopub.status.busy": "2026-03-06T00:11:34.890927Z", + "iopub.status.idle": "2026-03-06T00:11:34.894739Z", + "shell.execute_reply": "2026-03-06T00:11:34.893915Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Video: 512x384, 25 frames, 8 steps\n", + "TP degree: 4\n", + "Prompt: A golden retriever puppy runs across a sunny green meadow, its ears flapping in ...\n" + ] + } + ], + "source": [ + "# Video generation settings\n", + "HEIGHT, WIDTH, NUM_FRAMES = 384, 512, 25\n", + "NUM_STEPS = 8 # Distilled model uses 8 steps\n", + "TP_DEGREE = 4 # Tensor parallelism across 4 NeuronCores\n", + "SEED = 42\n", + "\n", + "PROMPT = (\n", + " \"A golden retriever puppy runs across a sunny green meadow, \"\n", + " \"its ears flapping in the wind. The camera follows from a low angle. \"\n", + " \"Birds chirp in the background.\"\n", + ")\n", + "\n", + "# Compiled model directories (persist across reboots if on /home/ubuntu/)\n", + "DIT_COMPILE_DIR = \"/home/ubuntu/ltx2_nxdi_compiled_1024/\"\n", + "GEMMA3_COMPILE_DIR = \"/home/ubuntu/gemma3_encoder_compiled_1024/\"\n", + "GEMMA3_SHARDED_DIR = \"/home/ubuntu/gemma3_encoder_sharded/\"\n", + "OUTPUT_DIR = \"/home/ubuntu/ltx2_output/\"\n", + "\n", + "print(f\"Video: {WIDTH}x{HEIGHT}, {NUM_FRAMES} frames, {NUM_STEPS} steps\")\n", + "print(f\"TP degree: {TP_DEGREE}\")\n", + "print(f\"Prompt: {PROMPT[:80]}...\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Compile the DiT Transformer Backbone\n", + "\n", + "The DiT backbone is the denoising workhorse — 48 transformer blocks that run 8 times per generation (once per denoising step), doubled with CFG. This is the component that benefits most from Neuron acceleration.\n", + "\n", + "Compilation traces the model with NxDI's SPMD infrastructure and produces a single `model.pt` NEFF file. **First compilation takes ~2 minutes; subsequent runs load from cache.**" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:11:34.896733Z", + "iopub.status.busy": "2026-03-06T00:11:34.896591Z", + "iopub.status.idle": "2026-03-06T00:11:52.526802Z", + "shell.execute_reply": "2026-03-06T00:11:52.525790Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/parallel_layers/layers.py:16: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from .mappings import (\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/parallel_layers/layers.py:16: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from .mappings import (\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/parallel_layers/layers.py:16: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from .mappings import (\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:74: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:74: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:74: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:74: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:74: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:74: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/blockwise.py:76: UserWarning: Warning: Failed to import blockwise_mm_baseline_shard_n_k1_while_2loops: No module named 'neuronxcc.nki._private.blockwise_matmul_while'\n", + " warnings.warn(f\"Warning: {error}\")\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/moe_fused_tkg.py:49: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/moe_fused_tkg.py:49: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/modules/moe/moe_fused_tkg.py:49: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " component, error = import_nki(config)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed_inference/modules/attention/utils.py:13: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from neuronx_distributed_inference.modules.custom_calls import neuron_cumsum\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed_inference/modules/lora_serving/lora_checkpoint.py:9: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from neuronx_distributed_inference.modules.attention.gqa import replicate_kv\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed_inference/modules/lora_serving/lora_checkpoint.py:9: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from neuronx_distributed_inference.modules.attention.gqa import replicate_kv\n", + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed_inference/modules/lora_serving/lora_checkpoint.py:9: DeprecationWarning: torch_neuronx.nki_jit is deprecated, use nki.jit instead.\n", + " from neuronx_distributed_inference.modules.attention.gqa import replicate_kv\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DiT: 48 blocks, inner_dim=4096, audio_inner_dim=2048\n", + "Video: 768 tokens, Audio: 26 tokens, Text: 1024 tokens\n" + ] + } + ], + "source": [ + "from modeling_ltx2 import (\n", + " LTX2BackboneInferenceConfig,\n", + " NeuronLTX2BackboneApplication,\n", + " replace_sdpa_with_bmm,\n", + ")\n", + "from neuronx_distributed_inference.models.config import NeuronConfig\n", + "\n", + "# Replace SDPA with BMM for Neuron XLA compatibility\n", + "replace_sdpa_with_bmm()\n", + "\n", + "# Load transformer config from HuggingFace\n", + "from huggingface_hub import hf_hub_download\n", + "config_path = hf_hub_download(\"Lightricks/LTX-2\", \"transformer/config.json\")\n", + "with open(config_path) as f:\n", + " hf_config = json.load(f)\n", + "\n", + "# Compute latent dimensions\n", + "num_heads = hf_config[\"num_attention_heads\"]\n", + "head_dim = hf_config[\"attention_head_dim\"]\n", + "inner_dim = num_heads * head_dim\n", + "audio_num_heads = hf_config[\"audio_num_attention_heads\"]\n", + "audio_head_dim = hf_config[\"audio_attention_head_dim\"]\n", + "audio_inner_dim = audio_num_heads * audio_head_dim\n", + "audio_ca_dim = hf_config.get(\"audio_cross_attention_dim\", audio_inner_dim)\n", + "\n", + "latent_num_frames = (NUM_FRAMES - 1) // 8 + 1\n", + "latent_height = HEIGHT // 32\n", + "latent_width = WIDTH // 32\n", + "video_seq = latent_num_frames * latent_height * latent_width\n", + "audio_num_frames = round((NUM_FRAMES / 24.0) * 24.97)\n", + "\n", + "backbone_neuron_config = NeuronConfig(\n", + " tp_degree=TP_DEGREE,\n", + " world_size=TP_DEGREE,\n", + " torch_dtype=torch.bfloat16,\n", + ")\n", + "\n", + "config = LTX2BackboneInferenceConfig(\n", + " neuron_config=backbone_neuron_config,\n", + " num_layers=hf_config[\"num_layers\"],\n", + " num_attention_heads=num_heads,\n", + " attention_head_dim=head_dim,\n", + " inner_dim=inner_dim,\n", + " audio_num_attention_heads=audio_num_heads,\n", + " audio_attention_head_dim=audio_head_dim,\n", + " audio_inner_dim=audio_inner_dim,\n", + " audio_cross_attention_dim=audio_ca_dim,\n", + " caption_channels=hf_config.get(\"caption_channels\", 3840),\n", + " video_seq=video_seq,\n", + " audio_seq=audio_num_frames,\n", + " text_seq=1024,\n", + " height=HEIGHT,\n", + " width=WIDTH,\n", + " num_frames=NUM_FRAMES,\n", + ")\n", + "config.hf_config_dict = hf_config\n", + "\n", + "print(f\"DiT: {hf_config['num_layers']} blocks, inner_dim={inner_dim}, audio_inner_dim={audio_inner_dim}\")\n", + "print(f\"Video: {video_seq} tokens, Audio: {audio_num_frames} tokens, Text: 1024 tokens\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:11:52.529954Z", + "iopub.status.busy": "2026-03-06T00:11:52.529585Z", + "iopub.status.idle": "2026-03-06T00:19:55.346500Z", + "shell.execute_reply": "2026-03-06T00:19:55.345586Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "329713961c8f41a48341f006b777a0f8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 10 files: 0%| | 0/10 [00:00 initializing tensor model parallel with size 4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.474: I neuronx_distributed/parallel_layers/parallel_state.py:639] > initializing pipeline model parallel with size 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.474: I neuronx_distributed/parallel_layers/parallel_state.py:640] > initializing context model parallel with size 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.475: I neuronx_distributed/parallel_layers/parallel_state.py:641] > initializing data parallel with size 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.475: I neuronx_distributed/parallel_layers/parallel_state.py:642] > initializing world size to 4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.476: I neuronx_distributed/parallel_layers/parallel_state.py:387] [rank_0_pp-1_tp-1_dp-1_cp-1] Chosen Logic for replica groups ret_logic=, 'Ascending Ring PG Group')>\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.487: I neuronx_distributed/parallel_layers/parallel_state.py:666] [rank_0_pp-1_tp-1_dp-1_cp-1] tp_groups: replica_groups.tp_groups=[[0, 1, 2, 3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.488: I neuronx_distributed/parallel_layers/parallel_state.py:667] [rank_0_pp-1_tp-1_dp-1_cp-1] dp_groups: replica_groups.dp_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.489: I neuronx_distributed/parallel_layers/parallel_state.py:668] [rank_0_pp-1_tp-1_dp-1_cp-1] pp_groups: replica_groups.pp_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.489: I neuronx_distributed/parallel_layers/parallel_state.py:669] [rank_0_pp-1_tp-1_dp-1_cp-1] cp_groups: replica_groups.cp_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.490: I neuronx_distributed/parallel_layers/parallel_state.py:670] [rank_0_pp-1_tp-1_dp-1_cp-1] ep_model_groups: replica_groups.ep_model_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:14:07.490: I neuronx_distributed/parallel_layers/parallel_state.py:671] [rank_0_pp-1_tp-1_dp-1_cp-1] ep_data_groups: replica_groups.ep_data_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Generating 1 hlos for key: NeuronLTX2TransformerBackbone\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Minimal metadata will be added to HLO\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Started loading module NeuronLTX2TransformerBackbone\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Finished loading module NeuronLTX2TransformerBackbone in 103.63559699058533 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: generating HLO: NeuronLTX2TransformerBackbone, input example shape = torch.Size([1, 768, 4096])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/parallel_layers/layers.py:532: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n", + " with torch.cuda.amp.autocast(enabled=False):\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Finished generating HLO for NeuronLTX2TransformerBackbone in 11.574875354766846 seconds, input example shape = torch.Size([1, 768, 4096])\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Generated all HLOs in 117.11173963546753 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Starting compilation for the priority HLO\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: 'NeuronLTX2TransformerBackbone' is the priority model with bucket rank 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/libneuronxla/neuron_cc_wrapper.py:284: SyntaxWarning: str format compiler_flags is discouraged as its handling involves repeated joining and splitting, which can easily make mistakes if something is quoted or escaped. Use list[str] instead. Refer to documentation of the Python subprocess module for details.\n", + " warnings.warn(SyntaxWarning(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Compiler status PASS\n", + "2026-03-06 00:16:39.000631: 16529 [INFO]: Compilation Successfully Completed for model.MODULE_97fc5b5ba2b82b41edb7+56b90e7a.hlo_module.pb\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Done compilation for the priority HLO in 35.078224658966064 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Done optimizing weight layout for all HLOs in 0.34688591957092285 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Starting compilation for all HLOs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Finished Compilation for all HLOs in 0.010555028915405273 seconds\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 48]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2,) with (3,) / latency=8,321; shape=(128, 2, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 3, 2) / latency=12,067; shape=(128, 2, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 2; efficiency: 15]\n", + " tiled_pf_transpose: Fix prefix (0, 1) and permute (2,) with (3,) / latency=12,067; shape=(2, 2, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 3, 2) / latency=12,067; shape=(2, 2, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 2; efficiency: 19]\n", + " tiled_pf_transpose: Fix prefix () and permute (0, 1) with (2,) / latency=12,067; shape=(6, 32, 128); dtype_size=2\n", + " dve_j_optimized : Fix prefix (2,) and permute (0,) with (1,) / latency=8,232; shape=(6, 32, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 1; efficiency: 30]\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (2,) / latency=12,067; shape=(2, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 2) / latency=12,067; shape=(8, 2, 64); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2) and permute (3,) with (4,) / latency=66,568; shape=(8, 2, 64, 32, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2) with (4, 3) / latency=96,540; shape=(8, 2, 64, 32, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2,) with (3,) / latency=66,568; shape=(8, 512, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (3, 2) / latency=96,540; shape=(8, 512, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1,) / latency=12,067; shape=(8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2,) with (3,) / latency=66,568; shape=(8, 128, 32, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (3, 2) / latency=96,540; shape=(8, 128, 32, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0, 1) with (2,) / latency=12,067; shape=(8, 2, 32); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 42]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=16,642; shape=(8, 2, 32, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0, 1, 2) with (3, 5, 4) / latency=24,135; shape=(8, 2, 32, 2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 2; efficiency: 15]\n", + " tiled_pf_transpose: Fix prefix (0, 1) and permute (2,) with (3,) / latency=12,067; shape=(6, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 3, 2) / latency=12,067; shape=(6, 2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 42]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=16,642; shape=(2, 2, 4, 128, 8, 64); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0, 1) and permute (2, 3) with (5, 4) / latency=24,135; shape=(2, 2, 4, 128, 8, 64); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 2) / latency=12,067; shape=(4, 2, 64); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 42]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=16,642; shape=(4, 2, 64, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0, 1, 2) with (3, 5, 4) / latency=24,135; shape=(4, 2, 64, 2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 1; efficiency: 30]\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1,) / latency=12,067; shape=(32, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2, 3) with (4,) / latency=66,568; shape=(8, 128, 2, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (4, 2, 3) / latency=96,540; shape=(8, 128, 2, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=66,568; shape=(4, 2, 128, 2, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2) with (3, 5, 4) / latency=96,540; shape=(4, 2, 128, 2, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0, 1) with (2,) / latency=12,067; shape=(4, 2, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1,) / latency=12,067; shape=(8, 64); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 42]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2) and permute (3,) with (4,) / latency=16,642; shape=(8, 64, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0, 1) with (2, 4, 3) / latency=24,135; shape=(8, 64, 2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 1; efficiency: 30]\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (2,) / latency=12,067; shape=(2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 42]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=16,642; shape=(2, 2, 2, 64, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2, 3) with (5, 4) / latency=24,135; shape=(2, 2, 2, 64, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 1; efficiency: 30]:\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 2, 3) / latency=12,067; shape=(4, 2, 2, 32); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 39]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=33,284; shape=(4, 2, 2, 32, 32, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2, 3) with (5, 4) / latency=48,270; shape=(4, 2, 2, 32, 32, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 39]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2,) with (3,) / latency=33,284; shape=(8, 512, 8, 64); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (3, 2) / latency=48,270; shape=(8, 512, 8, 64); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 39]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2) and permute (3,) with (4,) / latency=33,284; shape=(4, 2, 64, 32, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2) with (4, 3) / latency=48,270; shape=(4, 2, 64, 32, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 36]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2) and permute (3,) with (4,) / latency=266,273; shape=(8, 512, 4, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (2, 4, 3) / latency=386,159; shape=(8, 512, 4, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 36]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2,) with (3,) / latency=266,273; shape=(32, 128, 32, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1,) with (3, 2) / latency=386,159; shape=(32, 128, 32, 128); dtype_size=2\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=66,568; shape=(2, 4, 2, 128, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0, 1) and permute (2, 3) with (5, 4) / latency=96,540; shape=(2, 4, 2, 128, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 1; efficiency: 30]\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1,) / latency=12,067; shape=(16, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 37]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=66,568; shape=(4, 4, 128, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2) with (3, 5, 4) / latency=96,540; shape=(4, 4, 128, 2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 36]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=266,273; shape=(2, 4, 512, 4, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0, 1) and permute (2,) with (3, 5, 4) / latency=386,159; shape=(2, 4, 512, 4, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 36]:\n", + " dve_j_optimized : Fix prefix (0, 1, 2, 3) and permute (4,) with (5,) / latency=266,273; shape=(16, 2, 128, 2, 16, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix (0,) and permute (1, 2) with (3, 5, 4) / latency=386,159; shape=(16, 2, 128, 2, 16, 128); dtype_size=2\n", + "\n", + "Roundtrip constructed a transpose sequence [rounds: 2; efficiency: 33]:\n", + " dve_j_optimized : Fix prefix (0, 1) and permute (2,) with (3,) / latency=8,321; shape=(128, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 3, 2) / latency=12,067; shape=(128, 2, 8, 128); dtype_size=2\n", + "\n", + "Roundtrip rolls back... [rounds: 2; efficiency: 15]\n", + " tiled_pf_transpose: Fix prefix (0, 1) and permute (2,) with (3,) / latency=12,067; shape=(2, 2, 8, 128); dtype_size=2\n", + " tiled_pf_transpose: Fix prefix () and permute (0,) with (1, 3, 2) / latency=12,067; shape=(2, 2, 8, 128); dtype_size=2\n", + "\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (128, 2, 16, 128), dtype: bfloat16), in_shape = [128, 2, 16, 128], permutation = [0, 1, 3, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (128, 2, 128, 16), dtype: bfloat16), in_shape = [128, 2, 128, 16], permutation = [1, 2, 3, 0])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 2, 64), dtype: bfloat16), in_shape = [8, 2, 64], permutation = [1, 2, 0])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 2, 64, 32, 128), dtype: bfloat16), in_shape = [8, 2, 64, 32, 128], permutation = [0, 1, 2, 4, 3])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 2, 64, 128, 32), dtype: bfloat16), in_shape = [8, 2, 64, 128, 32], permutation = [0, 3, 4, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 512, 8, 128), dtype: bfloat16), in_shape = [8, 512, 8, 128], permutation = [0, 1, 3, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 512, 128, 8), dtype: bfloat16), in_shape = [8, 512, 128, 8], permutation = [0, 2, 3, 1])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 128), dtype: bfloat16), in_shape = [8, 128], permutation = [1, 0])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 128, 32, 128), dtype: bfloat16), in_shape = [8, 128, 32, 128], permutation = [0, 1, 3, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 128, 128, 32), dtype: bfloat16), in_shape = [8, 128, 128, 32], permutation = [0, 2, 3, 1])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 2, 32), dtype: bfloat16), in_shape = [8, 2, 32], permutation = [2, 0, 1])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 2, 32, 2, 8, 128), dtype: bfloat16), in_shape = [8, 2, 32, 2, 8, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 2, 32, 2, 128, 8), dtype: bfloat16), in_shape = [8, 2, 32, 2, 128, 8], permutation = [3, 4, 5, 0, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (2, 2, 4, 128, 8, 64), dtype: bfloat16), in_shape = [2, 2, 4, 128, 8, 64], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (2, 2, 4, 128, 64, 8), dtype: bfloat16), in_shape = [2, 2, 4, 128, 64, 8], permutation = [0, 1, 4, 5, 2, 3])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 64), dtype: bfloat16), in_shape = [4, 2, 64], permutation = [1, 2, 0])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (4, 2, 64, 2, 8, 128), dtype: bfloat16), in_shape = [4, 2, 64, 2, 8, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 64, 2, 128, 8), dtype: bfloat16), in_shape = [4, 2, 64, 2, 128, 8], permutation = [3, 4, 5, 0, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (32, 128), dtype: bfloat16), in_shape = [32, 128], permutation = [1, 0])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 128, 2, 16, 128), dtype: bfloat16), in_shape = [8, 128, 2, 16, 128], permutation = [0, 1, 4, 2, 3])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 128, 128, 2, 16), dtype: bfloat16), in_shape = [8, 128, 128, 2, 16], permutation = [0, 2, 3, 4, 1])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (4, 2, 128, 2, 16, 128), dtype: bfloat16), in_shape = [4, 2, 128, 2, 16, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 128, 2, 128, 16), dtype: bfloat16), in_shape = [4, 2, 128, 2, 128, 16], permutation = [0, 3, 4, 5, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 128), dtype: bfloat16), in_shape = [4, 2, 128], permutation = [2, 0, 1])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 64), dtype: bfloat16), in_shape = [8, 64], permutation = [1, 0])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 64, 2, 8, 128), dtype: bfloat16), in_shape = [8, 64, 2, 8, 128], permutation = [0, 1, 2, 4, 3])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 64, 2, 128, 8), dtype: bfloat16), in_shape = [8, 64, 2, 128, 8], permutation = [2, 3, 4, 0, 1])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (2, 2, 2, 64, 16, 128), dtype: bfloat16), in_shape = [2, 2, 2, 64, 16, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (2, 2, 2, 64, 128, 16), dtype: bfloat16), in_shape = [2, 2, 2, 64, 128, 16], permutation = [0, 4, 5, 1, 2, 3])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 2, 32), dtype: bfloat16), in_shape = [4, 2, 2, 32], permutation = [1, 2, 3, 0])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (4, 2, 2, 32, 32, 128), dtype: bfloat16), in_shape = [4, 2, 2, 32, 32, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 2, 32, 128, 32), dtype: bfloat16), in_shape = [4, 2, 2, 32, 128, 32], permutation = [0, 4, 5, 1, 2, 3])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 512, 8, 64), dtype: bfloat16), in_shape = [8, 512, 8, 64], permutation = [0, 1, 3, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 512, 64, 8), dtype: bfloat16), in_shape = [8, 512, 64, 8], permutation = [0, 2, 3, 1])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (4, 2, 64, 32, 128), dtype: bfloat16), in_shape = [4, 2, 64, 32, 128], permutation = [0, 1, 2, 4, 3])\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "." + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 2, 64, 128, 32), dtype: bfloat16), in_shape = [4, 2, 64, 128, 32], permutation = [0, 3, 4, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (8, 512, 4, 8, 128), dtype: bfloat16), in_shape = [8, 512, 4, 8, 128], permutation = [0, 1, 2, 4, 3])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (8, 512, 4, 128, 8), dtype: bfloat16), in_shape = [8, 512, 4, 128, 8], permutation = [0, 2, 3, 4, 1])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (32, 128, 32, 128), dtype: bfloat16), in_shape = [32, 128, 32, 128], permutation = [0, 1, 3, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (32, 128, 128, 32), dtype: bfloat16), in_shape = [32, 128, 128, 32], permutation = [0, 2, 3, 1])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (2, 4, 2, 128, 16, 128), dtype: bfloat16), in_shape = [2, 4, 2, 128, 16, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (2, 4, 2, 128, 128, 16), dtype: bfloat16), in_shape = [2, 4, 2, 128, 128, 16], permutation = [0, 1, 4, 5, 2, 3])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (4, 4, 128, 2, 8, 128), dtype: bfloat16), in_shape = [4, 4, 128, 2, 8, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (4, 4, 128, 2, 128, 8), dtype: bfloat16), in_shape = [4, 4, 128, 2, 128, 8], permutation = [0, 3, 4, 5, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (2, 4, 512, 4, 8, 128), dtype: bfloat16), in_shape = [2, 4, 512, 4, 8, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (2, 4, 512, 4, 128, 8), dtype: bfloat16), in_shape = [2, 4, 512, 4, 128, 8], permutation = [0, 1, 3, 4, 5, 2])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (16, 2, 128, 2, 16, 128), dtype: bfloat16), in_shape = [16, 2, 128, 2, 16, 128], permutation = [0, 1, 2, 3, 5, 4])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (16, 2, 128, 2, 128, 16), dtype: bfloat16), in_shape = [16, 2, 128, 2, 128, 16], permutation = [0, 3, 4, 5, 1, 2])\n", + "Neuron NKI - Kernel call: tiled_dve_transpose_10(in_tensor = Tensor(shape: (128, 2, 8, 128), dtype: bfloat16), in_shape = [128, 2, 8, 128], permutation = [0, 1, 3, 2])\n", + "Neuron NKI - Kernel call: tiled_pf_transpose(in_tensor = Tensor(shape: (128, 2, 128, 8), dtype: bfloat16), in_shape = [128, 2, 128, 8], permutation = [1, 2, 3, 0])\n", + "\n", + "Compiler status PASS\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Done preparing weight layout transformation\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Finished building model in 347.74278807640076 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: SKIPPING pre-sharding the checkpoints. The checkpoints will be sharded during load time.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compiled in 348.2s\n" + ] + } + ], + "source": [ + "# Create the NxDI backbone application\n", + "from huggingface_hub import snapshot_download\n", + "\n", + "local_transformer_path = snapshot_download(\n", + " \"Lightricks/LTX-2\", allow_patterns=[\"transformer/*\"]\n", + ")\n", + "local_transformer_path = os.path.join(local_transformer_path, \"transformer\")\n", + "\n", + "backbone_app = NeuronLTX2BackboneApplication(\n", + " model_path=local_transformer_path,\n", + " config=config,\n", + ")\n", + "\n", + "# Compile if not already cached\n", + "compiled_model_file = os.path.join(DIT_COMPILE_DIR, \"model.pt\")\n", + "if os.path.exists(compiled_model_file):\n", + " size_gb = os.path.getsize(compiled_model_file) / 1e9\n", + " print(f\"Found cached DiT compiled model: {compiled_model_file} ({size_gb:.2f} GB)\")\n", + "else:\n", + " print(f\"Compiling DiT backbone to {DIT_COMPILE_DIR} (first run, ~2 min)...\")\n", + " t0 = time.time()\n", + " os.makedirs(DIT_COMPILE_DIR, exist_ok=True)\n", + " backbone_app.compile(DIT_COMPILE_DIR)\n", + " print(f\"Compiled in {time.time() - t0:.1f}s\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Compile the Gemma 3-12B Text Encoder\n", + "\n", + "LTX-2 uses Gemma 3-12B as its text encoder. We compile a custom encoder that outputs all 49 hidden states (embedding + 48 layers), which LTX-2 stacks and projects into text embeddings.\n", + "\n", + "**First compilation takes ~3 minutes.** We also pre-shard the weights to disk (~5.5 GB per rank) so loading only requires ~6 GB peak memory instead of ~24 GB." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:19:55.349586Z", + "iopub.status.busy": "2026-03-06T00:19:55.349451Z", + "iopub.status.idle": "2026-03-06T00:19:55.353739Z", + "shell.execute_reply": "2026-03-06T00:19:55.352823Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found cached Gemma3 compiled encoder: /home/ubuntu/gemma3_encoder_compiled_1024/ (5.9 GB per rank)\n", + "Found pre-sharded Gemma3 weights: /home/ubuntu/gemma3_encoder_sharded/ (5.9 GB per rank)\n" + ] + } + ], + "source": [ + "# Check if Gemma3 encoder is already compiled\n", + "gemma3_compiled = os.path.exists(os.path.join(GEMMA3_COMPILE_DIR, \"tp_0.pt\"))\n", + "gemma3_sharded = os.path.exists(os.path.join(GEMMA3_SHARDED_DIR, \"rank_0.pt\"))\n", + "\n", + "if gemma3_compiled:\n", + " size_gb = os.path.getsize(os.path.join(GEMMA3_COMPILE_DIR, \"tp_0.pt\")) / 1e9\n", + " print(f\"Found cached Gemma3 compiled encoder: {GEMMA3_COMPILE_DIR} ({size_gb:.1f} GB per rank)\")\n", + "else:\n", + " print(\"Gemma3 encoder not compiled yet.\")\n", + " print(\"Run: python ../src/compile_gemma3.py\")\n", + " print(\"This takes ~3 minutes and produces tp_0.pt through tp_3.pt\")\n", + "\n", + "if gemma3_sharded:\n", + " size_gb = os.path.getsize(os.path.join(GEMMA3_SHARDED_DIR, \"rank_0.pt\")) / 1e9\n", + " print(f\"Found pre-sharded Gemma3 weights: {GEMMA3_SHARDED_DIR} ({size_gb:.1f} GB per rank)\")\n", + "else:\n", + " print(\"Gemma3 weights not pre-sharded yet.\")\n", + " print(\"Run: python ../src/shard_gemma3_weights.py\")\n", + " print(\"This takes ~2 minutes and produces rank_0.pt through rank_3.pt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Load the Diffusers Pipeline\n", + "\n", + "We load the full Diffusers LTX2Pipeline first (text encoder, transformer, VAEs, vocoder all on CPU), then swap the text encoder and transformer with Neuron-compiled versions." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:19:55.355729Z", + "iopub.status.busy": "2026-03-06T00:19:55.355619Z", + "iopub.status.idle": "2026-03-06T00:26:51.145317Z", + "shell.execute_reply": "2026-03-06T00:26:51.144244Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading Diffusers LTX2Pipeline (CPU)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Cannot initialize model with low cpu memory usage because `accelerate` was not found in the environment. Defaulting to `low_cpu_mem_usage=False`. It is strongly recommended to install `accelerate` for faster and less memory-intense model loading. You can do so with: \n", + "```\n", + "pip install accelerate\n", + "```\n", + ".\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7e516904ea444588a0296e5fe2a8a944", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Fetching 55 files: 0%| | 0/55 [00:00 initializing tensor model parallel with size 4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.412: I neuronx_distributed/parallel_layers/parallel_state.py:639] > initializing pipeline model parallel with size 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.412: I neuronx_distributed/parallel_layers/parallel_state.py:640] > initializing context model parallel with size 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.412: I neuronx_distributed/parallel_layers/parallel_state.py:641] > initializing data parallel with size 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.412: I neuronx_distributed/parallel_layers/parallel_state.py:642] > initializing world size to 4\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.413: I neuronx_distributed/parallel_layers/parallel_state.py:387] [rank_0_pp-1_tp-1_dp-1_cp-1] Chosen Logic for replica groups ret_logic=, 'Ascending Ring PG Group')>\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.414: I neuronx_distributed/parallel_layers/parallel_state.py:666] [rank_0_pp-1_tp-1_dp-1_cp-1] tp_groups: replica_groups.tp_groups=[[0, 1, 2, 3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.414: I neuronx_distributed/parallel_layers/parallel_state.py:667] [rank_0_pp-1_tp-1_dp-1_cp-1] dp_groups: replica_groups.dp_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.414: I neuronx_distributed/parallel_layers/parallel_state.py:668] [rank_0_pp-1_tp-1_dp-1_cp-1] pp_groups: replica_groups.pp_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.414: I neuronx_distributed/parallel_layers/parallel_state.py:669] [rank_0_pp-1_tp-1_dp-1_cp-1] cp_groups: replica_groups.cp_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.415: I neuronx_distributed/parallel_layers/parallel_state.py:670] [rank_0_pp-1_tp-1_dp-1_cp-1] ep_model_groups: replica_groups.ep_model_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2026-03-06 00:26:51.415: I neuronx_distributed/parallel_layers/parallel_state.py:671] [rank_0_pp-1_tp-1_dp-1_cp-1] ep_data_groups: replica_groups.ep_data_groups=[[0], [1], [2], [3]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/lib/python3.12/site-packages/neuronx_distributed/trace/trace.py:642: UserWarning: Removing redundant keys from checkpoint: []\n", + " warnings.warn(f\"Removing redundant keys from checkpoint: {keys_to_delete}\")\n", + "Neuron: casting transformer_blocks.0.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.0.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.0.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.0.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.1.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.1.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.1.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.1.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.2.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.2.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.2.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.2.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.3.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.3.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.3.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.3.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.4.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.4.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.4.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.4.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.5.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.5.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.5.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.5.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.6.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.6.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.6.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.6.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.7.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.7.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.7.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.7.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.8.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.8.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.8.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.8.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.9.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.9.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.9.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.9.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.10.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.10.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.10.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.10.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.11.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.11.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.11.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.11.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.12.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.12.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.12.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.12.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.13.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.13.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.13.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.13.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.14.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.14.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.14.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.14.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.15.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.15.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.15.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.15.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.16.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.16.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.16.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.16.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.17.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.17.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.17.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.17.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.18.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.18.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.18.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.18.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.19.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.19.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.19.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.19.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.20.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.20.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.20.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.20.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.21.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.21.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.21.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.21.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.22.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.22.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.22.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.22.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.23.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.23.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.23.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.23.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.24.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.24.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.24.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.24.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.25.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.25.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.25.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.25.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.26.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.26.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.26.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.26.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.27.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.27.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.27.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.27.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.28.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.28.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.28.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.28.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.29.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.29.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.29.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.29.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.30.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.30.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.30.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.30.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.31.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.31.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.31.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.31.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.32.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.32.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.32.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.32.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.33.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.33.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.33.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.33.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.34.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.34.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.34.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.34.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.35.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.35.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.35.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.35.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.36.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.36.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.36.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.36.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.37.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.37.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.37.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.37.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.38.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.38.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.38.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.38.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.39.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.39.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.39.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.39.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.40.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.40.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.40.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.40.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.41.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.41.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.41.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.41.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.42.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.42.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.42.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.42.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.43.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.43.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.43.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.43.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.44.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.44.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.44.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.44.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.45.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.45.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.45.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.45.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.46.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.46.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.46.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.46.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.47.scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.47.audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.47.video_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting transformer_blocks.47.audio_a2v_cross_attn_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: casting audio_scale_shift_table from torch.float32 to torch.bfloat16\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Done Sharding weights in 231.8803112380001\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Finished weights loading in 243.59628633600005 seconds\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Warming up the model.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-Mar-06 00:30:56.0198 16529:18322 [2] int nccl_net_ofi_create_plugin(nccl_net_ofi_plugin_t**):219 CCOM WARN NET/OFI Failed to initialize rdma protocol\n", + "2026-Mar-06 00:30:56.0200 16529:18322 [2] int nccl_net_ofi_create_plugin(nccl_net_ofi_plugin_t**):354 CCOM WARN NET/OFI aws-ofi-nccl initialization failed\n", + "2026-Mar-06 00:30:56.0203 16529:18322 [2] ncclResult_t nccl_net_ofi_init_no_atexit_fini_v6(ncclDebugLogger_t):183 CCOM WARN NET/OFI Initializing plugin failed\n", + "2026-Mar-06 00:30:56.0205 16529:18322 [2] net_plugin.cc:97 CCOM WARN OFI plugin initNet() failed is EFA enabled?\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Neuron: Warmup completed in 0.7151861190795898 seconds.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DiT loaded in 245.4s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DiT transformer swapped to Neuron\n" + ] + } + ], + "source": [ + "from pipeline import NeuronTransformerWrapper\n", + "\n", + "print(f\"Loading DiT backbone from {DIT_COMPILE_DIR}...\")\n", + "cpu_transformer = pipe.transformer\n", + "\n", + "t0 = time.time()\n", + "backbone_app.load(DIT_COMPILE_DIR)\n", + "print(f\"DiT loaded in {time.time() - t0:.1f}s\")\n", + "\n", + "# Swap the pipeline's transformer with the Neuron wrapper\n", + "wrapper = NeuronTransformerWrapper(\n", + " compiled_backbone=backbone_app,\n", + " cpu_transformer=cpu_transformer,\n", + " text_seq=1024,\n", + ")\n", + "\n", + "# Free heavy transformer blocks (preprocessing layers are kept via wrapper refs)\n", + "del cpu_transformer.transformer_blocks\n", + "del cpu_transformer.norm_out, cpu_transformer.proj_out\n", + "del cpu_transformer.audio_norm_out, cpu_transformer.audio_proj_out\n", + "gc.collect()\n", + "\n", + "pipe.transformer = wrapper\n", + "print(\"DiT transformer swapped to Neuron\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Load Gemma3 Text Encoder onto Neuron\n", + "\n", + "Swap the CPU text encoder with the Neuron-compiled Gemma3 encoder using pre-sharded per-rank weights." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:30:57.734380Z", + "iopub.status.busy": "2026-03-06T00:30:57.734218Z", + "iopub.status.idle": "2026-03-06T00:39:16.376192Z", + "shell.execute_reply": "2026-03-06T00:39:16.375252Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Freed CPU text encoder\n", + "Loading Gemma3 encoder from /home/ubuntu/gemma3_encoder_compiled_1024/...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [rank 0] 90.1s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [rank 1] 91.1s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [rank 2] 183.9s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " [rank 3] 132.8s\n", + "Gemma3 encoder loaded in 497.8s\n" + ] + } + ], + "source": [ + "import torch_neuronx\n", + "from neuronx_distributed.trace.trace import (\n", + " replace_weights,\n", + " TensorParallelNeuronModel,\n", + ")\n", + "\n", + "# Free CPU text encoder (~24 GB)\n", + "del pipe.text_encoder\n", + "gc.collect()\n", + "print(\"Freed CPU text encoder\")\n", + "\n", + "# Load Neuron Gemma3 encoder from pre-sharded per-rank checkpoints\n", + "print(f\"Loading Gemma3 encoder from {GEMMA3_COMPILE_DIR}...\")\n", + "t0 = time.time()\n", + "\n", + "models = []\n", + "for rank in range(TP_DEGREE):\n", + " tr = time.time()\n", + " rank_ckpt_path = os.path.join(GEMMA3_SHARDED_DIR, f\"rank_{rank}.pt\")\n", + " ckpt = torch.load(rank_ckpt_path, weights_only=True)\n", + " \n", + " neff_path = os.path.join(GEMMA3_COMPILE_DIR, f\"tp_{rank}.pt\")\n", + " with torch_neuronx.contexts.disable_nrt_load():\n", + " traced_model = torch.jit.load(neff_path)\n", + " \n", + " replace_weights(traced_model, ckpt)\n", + " models.append(traced_model)\n", + " del ckpt\n", + " gc.collect()\n", + " print(f\" [rank {rank}] {time.time() - tr:.1f}s\")\n", + "\n", + "compiled_gemma3 = TensorParallelNeuronModel(models)\n", + "print(f\"Gemma3 encoder loaded in {time.time() - t0:.1f}s\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:39:16.378991Z", + "iopub.status.busy": "2026-03-06T00:39:16.378816Z", + "iopub.status.idle": "2026-03-06T00:39:16.384053Z", + "shell.execute_reply": "2026-03-06T00:39:16.383045Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Text encoder swapped to Neuron Gemma3\n" + ] + } + ], + "source": [ + "# Create a wrapper that mimics the HF text encoder interface\n", + "class NeuronTextEncoderOutput:\n", + " def __init__(self, hidden_states):\n", + " self.hidden_states = hidden_states\n", + "\n", + "class NeuronTextEncoderWrapper:\n", + " \"\"\"Drop-in replacement for Gemma3ForConditionalGeneration.\"\"\"\n", + " def __init__(self, compiled_gemma3, dtype=torch.bfloat16):\n", + " self.compiled_model = compiled_gemma3\n", + " self.dtype = dtype\n", + " self._device = torch.device(\"cpu\")\n", + " self.config = type(\"Config\", (), {\"output_hidden_states\": True})()\n", + "\n", + " def __call__(self, input_ids=None, attention_mask=None, output_hidden_states=True, **kwargs):\n", + " with torch.no_grad():\n", + " # Neuron model returns (B, seq_len, hidden_size, num_layers+1)\n", + " stacked = self.compiled_model(input_ids, attention_mask)\n", + " num_states = stacked.shape[-1]\n", + " hidden_states = tuple(stacked[:, :, :, i] for i in range(num_states))\n", + " return NeuronTextEncoderOutput(hidden_states=hidden_states)\n", + "\n", + " def eval(self): return self\n", + " def to(self, *args, **kwargs): return self\n", + "\n", + " @property\n", + " def device(self): return self._device\n", + "\n", + "pipe.text_encoder = NeuronTextEncoderWrapper(compiled_gemma3)\n", + "print(\"Text encoder swapped to Neuron Gemma3\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Generate Video + Audio\n", + "\n", + "Run the full pipeline with the default parameters:\n", + "- `guidance_scale=4.0` (classifier-free guidance — the DiT runs twice per step)\n", + "- `max_sequence_length=1024`\n", + "- 8 denoising steps (distilled model)\n", + "\n", + "The pipeline handles text encoding, denoising loop, VAE decoding, and vocoder automatically.\n", + "\n", + "**Note:** The first generation includes a one-time warmup overhead (Neuron runtime initialization). Subsequent generations are faster." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:39:16.386669Z", + "iopub.status.busy": "2026-03-06T00:39:16.386524Z", + "iopub.status.idle": "2026-03-06T00:40:20.267793Z", + "shell.execute_reply": "2026-03-06T00:40:20.267100Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating (first run, includes warmup): A golden retriever puppy runs across a sunny green meadow, its ears flapping in ...\n", + "512x384, 25 frames, 8 steps\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "06374e368630466db3dd8df4d2b1197a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/8 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 0006:\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 0012:\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 0018:\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQAAAADACAIAAABkjyoxAAEAAElEQVR4AYT9Z7Mky5Ym5kXqrUodcUUPBjNs48DwjTTy//8HGM34AYDZYLrR3Vecc0pukTr5vK/nrnvbSBBZWbEjI9yXL72Wi/CYvVz+p9k0u0zTbLqM4zRNl+n8+j1epv152k3T/jKdpnxnCsym9Wyaz6bNNK1Un6X8Yprmvrk9Lfyc5ZaLvq6lTO5MlxZwadz1S7PLS8oswXw9Dji59/oJkH5zETLFFtj8hMPr3fwqRU58rgVegfh7LdAraqXu31UfdRUKN3xO0+U8nU/T+Tgd9tP+MB2P08mVQAlti3mqo9FPOKe6i4tpvui5u8UBh92aYx/MD9PhMO2O0/EUaCDle85PzblyPk/7zbS6m27vpvv1tFhOq3kAzuevWGllcKA4Yix8QADIyUAPMCLbEt9sOiym82K6zIMtFhMNZMBcTlcJOiGywf/vIpsXZzAV/v4ZXPFzMMDJuPm9SAr8faFKNtd6MdL/XvM7lO/lXXn9fC+lyt8jMICPGrlVBP4ewDi/4oMtAPbHuHK9/trKtCRaP5RiAC051BQfw88y9Eg2l+mAs1ViPISQc82H78VPXSeB1IpD3seWcStVCGk05Ngq57/DnjaDOTtHSMMaYRN8xrFVyGMQPCStIQUC6vX4N9rGRdcLoX+D2Hc+5jxV20TPQIZkUB34h/jeLQdClG8t4XSKF/AzzSlzSZUgBvmCol4D2oyqBcVrQ86pZkDRcqDKVUdFwsbhXEZDdLCQlTwdAyGq/wp/oK0AIIMiyMYdqFLLDKq9EksAXN3cTNNhnZ8wnJeceT3ad3bVi5WIKzdSX+FBbBApjYXWX71SAq9n//7WteEWhcD3Mrn+/fP356/VMTPthsW5NIqEWNfHpzi7Poo4fgfz9+evpf+P/3K9gdKjk/CosK4nuFxPg9cM4ADOLG6Dq6PcxEQ6waC4hq1Oy68BxHV3h2JFxv3pyjCPgfIo6a5ikU5AVEuAvUL5G9PxJRwAatwaLY4rjq+fv2eBgn/79EcQHrCH4AsK2uX5lcMReVkx2vIzWtXmFPMNpEGOM6j3p9M0/YreHLYtc71OXy8+00VUqWyvmAyrcOSMDokPah05Am573cZqJAH9/VMWwQNk3yAGuLvjSs1goOFuLnNY2q3qA6vx2LmfNZVUb5lYMoD9mZPWxYfvTefWuNpb1wKvJXvt7w5ut8Tf1fi7u//Hp2nRBzJDQD0fV76fXk9GGeXD97/hOe5Ggq8XvzPv9ULg5cMA6mLaHi5UzGnbSbkTvW8ZxVyBk08kXl6zhLTh+jwmwTZiAMM2ZtNN1Tr3W2vwjvakemvBO3desWNRTq9fMEep6qKro6KLbgw3rK3RnCOYaSW3//2xwAcjhqK2xNV3Kp8arfi9di4Vjlrxu/0mC/KlW45ljka1KqngnvNBNdobwXqnYIPVZX7F7HI+X6rls8Nhthug+HjQmMRpOkiHdtNuOx1O03Yz3YC5mjbFcL4MwmnIzzm80njRhugsXmMYZY8QhuFIhMhuN5t2y0bsZRPUS9PXBhmqP8DmBOS2BQbg3/U+DYy2HPspb3L1qqmv1//2d5S4lrteHnDG8W8l/+4sxUeVopGSr6XH39ebrTN+vNa4VvTz9XqRHqj/rQ2EuO8bisZneZ6+vf5WOcJow6K8Uoomlaynd0KOCoRlUsZx9FPB5kKYPkKEE1eSVlKOAo9mF5pbYGoiMmsTqV6TGHAG2NQqTEUUfC17JY+6cJMU6ET/lslcB/zv5Qaoq3j8aKNAJQPWFsnlb0Xek1HgerHXr1XadvRJXq4DsJ12Td/pVvJ1n+blUp1kz5CR96+ntZ9tMQi0xbTnCpr1Hyj6ftq+TC+7pPvg4Ib/iGIAWtm2lZebGMAJYTfT5na6W00rSuwnSItZIqHy2l/O4nRAT0raACJWu6sXgUWH6ct5ellML8vpzITW0wrCy4SXhWLwFA3ArMoLNleOVaYQH4Y782kTl/ztp6J09vr7evn/5A9u/J9WGKJR7LvIB9DvFYvbuPm9OWoJ8zgZLbzi5nxcycXc+XfHXuhheZh+AbR9tSEJlxHPJVCUVGqa6OfAyS2dV/0n4sH6m3N7VOVhvE5N5dAGQRM0AAkrS5gCgCTgFN1V40909xW5nI+gUQj/jmP9EcprorHVY3wbVaB5msin3PE3Kr5oOCrkUQsOsnAMoqyOqfJafkg2bbYARf2uCmmuBnCk+twzM9gn+aa4cJBFYB1YFGtJn1ZNLaYpmQsgLgZgZOKvOMCWaOfhMo8Z7KaXdqnjFKDoOgPYTVsXp/SSZ6d0lJ9lRCrT4PmEsclk8LC9CBq8YR4rHn0m3Qqqeuq9m372y/S4mz4dp2+raXc/LTfBClMweYH1YEbe8W5xOniiun5w6UJR7LkFhkiGMo0kKspQxo77GOBC5ZM/1xMlBl0pe/2EzKGgheDq+Ovy9/OeRkB/+8DtO/xeHT+/Fxhlv9f4+7vfDWMU/htu3ytT4m+tkfqvyhFFJNoqimNY5otB1ZuNwR/pjYGgMYZQ5AKwAcTIw44MFCbFUohB9MDPhBd3TxlW4rAo4u0yhsSi3GVUA3UtRm8KFsbfkca+0NOGxnWqGUUsqoPdgwriJDxgo+vBLJ+BPGFr+rvIXVdgsDtUVw/ShKtwclZvytgYwHEEAQaAUlHIrSYVatHO42JaHaY5feXm76Z1B4jSaEdg4rMBPV/Ol1kKFOC+Yz7BXJbVCHCRBSlH/7TeE6NtlNJ5WMqvw4FmK8yjLxIcMlIkPrT/CvFUP0zgCC979rOfHtujeGh0SsBcJwikiTI8doVcEjnlyCGuzkVeSZjFT5TDeI/qDiWFMWXrlXXVivCwUkv5IakGt7iSlIubGJ8W/JuKh9t/9xk/R43U+rvP+DXgXS/3Uppoo6P83yq5XkyGfN39263vYPkthXKvX5oRx1wn6nxUaHRNKR+6RftJxQDoOFKyuExFK0gejmFk9K0qhFmqh2UdSyWVr6RCnIDMp/tpet+TtfIETDsrFQ2zt+D1etS0FvIdSfnApi1mRKW4OYbJNIbO9YdSoa+Fo4tE6EojRtTdt1THYCCpQP1TGh2yVNE5Xaep9f3yCr4ZFa4wZlahii/NkF+BwFXLcHhuSYsrwMIgtj1wOMxO7j5Pz8/T03baAhKzSBMwo6/aDeYVW2iigcfUZWz5bqen5+nxafokU7qZFjfT/Xl6UJUfGdZekcW6YFjiV+vp9naar6c7sWKTcDEvYtF+rMFMfqrAZ8do/4IBaJYQLxceRNjCtOBem49MyyhEnZczBTLa64ulA+eSGWJB3ncIS8dHEGRyq1lSUF8EF+D/T70cN1vi3x1yvcDH1f/vYldoLXa92/I5fK/476vlF13hPJxFLerUqXUo70UVEexIQGQTu+dOaiHOlVcsFDkpaLxAJF5wwHyYWokGVc+r72cAeniuNHcHzSlRBf5pep41OIjsrzgMNYVn2tJQcIBZ0or8LG5X9EomrHKxYCMqNSOLHht/FIaYusPfR0d93S85LfgKP9Uul0K5GJyRXVSxxlGOkTgwqGY/hTO4hF/n+fkLAikchqA8xQLovL8ctueX3Wx7XhwPy4RE2jGfhZllFPOmu8qfdH930+Fx2q7TCgeB76ddbEDu9Ly7PMp1xD7uvMS8iMbaUkzdsiLpmfjA/O7SkVivKusq62BRuKSwECoEMLNdDCApkCqJ4ZeTpA0ztXOeX06z4+FyOF1cPzNrrW6i+gsIrJyoNARQQhk2r7GT0Z1OhzOnpu357UyiGEuAWMWkej7wd2Wc9JcWryrr6vi2YA5ujc/366n5//czqihW5ig6alwviwAsPnqMqPAzfn0oByzjdZrJYJEEtKJJXvGiY8AHjHbrrccpoMqYNfN9vuS7bbvhTq1I4xfuSkPz6e18ephPt9qV/6jZtoQOWc1WAS6tyTRuN2VNMR/aNLQ8JkGBKu8oQ/UeOXqiWoG844hdwVOUUMZflLawUiBo18VIr2iES+DUytqYBvQsZ7QkDrWM4h0BjNFS1lzyLy4TJvHfFIid7B1O0/K8mdGduFmJz/x8TBhhSKf5ablIX3a2oPHojActt/2M/8ZboJ4vLi71gOlZuxPz5WzNo2Pd7WyxmXFebplc41DyLWmEZ84rvZHVdGaB6+nmJsOpNG9wEOTEZAlP0y3NGXtd7AMHNzAn2NYl0fVZMrZQgNTLcTY7xfWMvkF0Y5WSqsipysjG53Agad5ld7nsU3yJTYeLFs9MpdofjW/owHjMdzFXMFNDOFn+pillKsfcze2yGq8ivIIaOpE7//5TEgIt1FRGrZ4fr3DGhWjzSHj8DruJo4rl3Aen+DleHHPHFy0BMp/eLKYPs+nHWfSYf1I+7rkuP+WdGH27TDyTD4Sj0IuoPn7lXP5TN+/cR7sYQTZJhPTM6EwNbGAZjzMYnGH0XjO2iEFVuPQ6Bh9rwwpjVkJ8TwBXB7+wNVpVgxnOL8FKGccxVUSD/x1DYwsGLiuiGRnrO65pZ3ulMS35/HxOGBQiRjf0SQ9hf9kdZ5fj/HTcbY9yPaJcsKHzkbLNzqCcTqfl5XJzXq8W8+hjsg34YrWfx8uJjz2ezqfH43mx2CznspHzHAKgBFtuXqPvuN4yVoDNVH3jA0dAKSX6a5PHtM35JpZw4dhwAM6wweRhz/XTGsXGG4lAA+/tmWc/JzE22JoPNoYFF3EKm5oyhZ/quqqnzs2vp8tNDUMLbnWoN1HlwHiwfz5P1DAdnWiXS0At0YFlgY53UXQ/WQ7443hma5FLpOe4nl0n16GAqM6OxwY09/2DOSkeIAEVpPMzxUBoUynrinLj6GcyeGX+/tgCbqHQdxiArH24GVkg9tFv/Hq7mp6X00+X6e1r3ABWeagPLQX8praB/3yVxOaO6reTAH5szF1nWh9hxChE9CFfGh+lcLO4OSpMfsgSmHOSmiEyXT23aOdYMlC1DkXK+PSI/xG/YqkzVDqQS3zKRNl93XRxFHPZD93WeMslA1hRDVqiI8hrLtoBmBtFhI28LBowf0nQ3z2fXnaHM3lz+Kl7Wp2P/l1OtPqMNHcO6/X8fn6/5l0NRF6Om6UcgTnBhDaIFeEBFZwvmQOj2xnuXCw3FzcTHygoj647m1USeq77oP1ymr7pYEiTKPTt9LCcHjbXFEVnHWTIu8VfmGfgyMIYsYIbWkU6D2R0uWzOl/XlLBTI3AxapYtCAYsVXzBfzPRJJIFELG4Yp6IhvFf6QsI048QIrFCS8mBO8gfmPksnB01usgVmFM4n9yPmSMF/cBg+xsZPRZdzucpxkbOuZswsuZZQdhPJMrW4LUAqUAcfdTWE85KIAPEJ5jPxMCPUGEupejHN9X5Y6WpcS4rnk1sagA+jhf+rTuODwrFR/kZ6Y5AuBKck3ZLJ6BYDoq6jkrplruA47Y/qd+TURZaDrqGL2KK6CnBAlYrEiadqQcMV8r7iVha1BXdiN6EHR5Q3HjqIl+sCApq7QSVAfKP9TlwZ9BdymN/Co+S1cF1KZEhG9U9DwUsHJ5lYz8ziYIjhOD/sqyMiQC2Whp1p+eG43/H2HPt5SWdofroQGf867HYvh/MTwT4slqfdRRothHC/8a0Yfl6s54vNgrgXi8t6NdssooX7y2VNOc77/XGx302Pl/PjfSLSzd3i4WYhhOrjirc08unb9Ovj6cvd/OFm9nspCneu/+BE6tW8lN6nI1vnIiM3VCUXVWbT7DfxX+cNUsFGoJoN1qWnG3dKFWRKszm7HoNdLAFEWju7mLBjjYJqSkarq5zch+Qn5YdyZyD4iBTs9i9xM47DJ2oQaBkl05KLmET0kZo+kg4MA9Dv77B7YsIQLr3xySE2xtucJJ98UCJV4AhbPMVKgHWsrxottw2nCB4Fr0Cueoko2h+R9esnVLEpNZr9b47Tk2BasWWtVbxAfEkpUiSND8IgYaDTtz2xJEtK+sTIyYyfGE334rgevMuRwXMX47zBdAT2FVU/k37UBdK/TBJJf5NwZIgJfMKoHINe6wdC9D6w8vU3354EDfgkQ3hthCQRu5xd1txwRm+f3VXMOM9iOiSRmU43s9NZD7CasXBFYrO4bAlxdtKSRMgnguGTLrP9ySyvxJ6yzg+cbeagIOPXfLWa12FsHqbNm+nubnEzX+DY7IUsF8HjcqT+u/3p6Th7ul+eP6zevJtt1pfVip9tWwR/OZs0+HWxeBISXzJa+sy176PcgvbzcXox1YAEU3Wr6WY1vamS6VFgi09tg1euAyorlnM0ILdd/GYiFcwM2+PCdMfdhj/zXs1iCfBs/yDqFRbU8Z+m+f5yeuEZGhgkSIAjeqh+OBTOk4QbiRXuqN6ktPoUF+5iPFEy3corzc/knNgnrYoUMTmdq9jA4SDnigK6HruKEBMBSCNzMdUjzWb0AYeRl+YDOf8J2K+r3tD+dq005KKSjmEWucHjPD3JPmX5JhrJkPNOWynjrvb/RljbNLKUb+GkxbSXTzQPomVl1Kvq7mdiawlw7tND4IdxUE7EiI8xP7o5Zz5OTpKUkdY5FLgA7RzT+Dx1tC4WQSCDkmUaYGmu1q7ioJ3L4IUSQBN6k5fryFHZr5fpydwq33/VlZTHFMyIp41QgZvRhvnT8ULmx+NR8I/eh60nefrhsj8ZTQG2QWFxc7qR+FCx4/lmNX9YrG6n9Ztp5etEvPE9LIxL7rfnw2HxslnuTvOtziQL+XH6cHN8WJ6Ym07qXpdadrXefV6cN8ebr8fZ85ZUwg/GQMXxIf0ESKLd+BJJlaGxQGiXojAvUpCfc71kduZHoKeEYBgyccQN/ZEFt5NcaH4+72iVseE9PzHXzY8bimSS6My4A75/Ozs+88pGt2ZZCTJkHWgkXC2NONN4blXoualRpih/lC+Es2F7XInz6oagGo0c6QGG4rBMEad1Hi4ZeIv6BXyskqlw1uk0zht10lhk5W7HBpSr2QGuGXJVfxxDBmRSOidRrOaRciztYege5seEUQUUwzLqmLpwCieic5CE6vjij29AVQXV0tbQ/u+tc1cvoaTVKe4luqudWKA4Gw+CtEAnKrLkjG85oVy6pm1A+Ykpj+d8LQQw/n0/n95BrO0ONNRQMt+qb5CBl+iJEEE9/d3Z1pjjdnp8mb76NteCPZxNe0FoI89OSJSqX1Zc3YplYs1sKfLrwp5lOZghRF5Ou9N5vzuwisVit1nMf7y7/d3D4s1mdrtY6yfdAJHe5O7NdL5tqkmlDSIZOyfpxbRdrPCWk1ss5g8P5/e3hx+Xx7vleREnPTueT5vF4nZ9fzc/Lv7lZbebf1vc0hs9Udm5ldWA34rDUmHfZeYoDEjozJAOliJHI4MPo0OPHNeX89kmOQQVwv+wnYjDeANGi/lyMbvZzI4vl/NusWB9VI/Q5QORPTOpBuyi+nvDaEmZ9OvJJdrEwUSilCBZjhO/GQALuWogrx/V59SqLhrExUhdZagaTNg2NgWnXHEro1JDbxUYSpVK8dQJZPASn2BfTe6d6nN0qNofgwPJHbgxmp67BU8eFAJphrZzq520z0jCGKzsDdFHsfFJ81QJfwvckQbX3AKhYK54wHuo3VBEkM0NPW6nv8p0MWc1vV9ObyW7fGH7EpEKxQNNB0vNVxszdpGuOcQAgnDy7awpMGH0iQs3DfQw/QwIGjFCrQSQsAP/xQQnfnKTdc7JfTNYuZ9ZrvP1afr2PH35Nn3cZdEUlZFRhFegLad3et7rjDmu6ArcHmbr++XN+8Wb97Pnz4uvn/bP37ZJSg/m/vbHk3M+crl7d3v/H96t/nC/ksonQcw8kcwNbUjmoflRTRAVfdDPMYq02x1eRA992jWTk5acM0WV0aXylaJsYjbr3+kPb3afD/+2Oh3Wizu2dDvdm5Y2ZQZtngj72pcb5GsT7bhatiXjzXVd7ZxcaD87IXqDnHWSlR6JxSBY/Xy5nt/czC3rM/8t9OH7mcVnwLRjvx05PZ46iAz5jpKJARTAf92LCDAKHTkmZlSJK6Dor2gjzsA5bWvw9agt6NLmmlD4pkp5Vc/bn7nSjyauSKte40nzaS+3c4Uy0a2ikIsxz94FH2vc5SR82VaG25Iit+8PLlWYxf+9MZaP9dgaTuWbiththKEWopgr2khIvTZdi6q94i/uOyZducRhfzlPHy3QAEejdU537aZz9gyJJ9vM9PpE4rAGhcL0+FJfTognYABPwghbIpQoSwzSMO430aC9c3Tp/ET74TDQa3YUdvObFE4v/zh9klLvps8vly/72WMHgjlIjpNa6JbdW11zmyBAq27Lcbq7Xi/mby6zd3d3h7t3T+f9p93LPz/++Zf9bjPffztuT5fd+/vZ79/Pfn93/mFmiQ5KZp59uQlM+OgIOOIbExgzpxh2fjkdtt++6NttNvfzxfxGj2F5u2AsEXQcAT81O6+W59mb5e9uN7OfNj89X35lEneZB7iFJxcAPvmSwvCOQxZVi4o/gombq2bIeMZAJW6QS3qPcbiO/jr6MBHfzImtcJNoKQeeXi6JOcJGAmmyGiqsTHy8qFB/qjL1BqW+u40GfFlfZYgjloWKAEUvwcB5/XeuBMuoE99PcxIB4ilqCeTS60Cz0jSbtvInh9aKJgLySqnYXTuA+Shd0mi5z7AxLFNao040Y6RZUY6WHTIJw6ARWC0SFTKi5DySFgBhLDsfpJXWXAyiCXjEoDqw2oJ0zmnYafq6n77spyfCkFpYzCjrOEW9IE1+gvhPy9m7ECHNKM6RfTRGHoHUwK8NiEhZuVnqsIxH/3iQSKQzJJ6Aozxz4v6ZLhLgrDBDYkTGGZmNBM9I17d8j8ZtdvPFy/a8P5wNzWx0ywQHQYaDbE/pKFItplthQdzbzDJQTQPuF4s3N2asPrx/2f02Xb7td8vN4u7ucjs7vTnu7tdyfeN6nPd6EyeCEPEAmZyIc5zkenWg9Y/Xv3v4wRQBXTIXtprfQpcIaEaUJYzwj4Yt15e7xewdih5mb8mLQsjT6okQm0/ZRaeZPfn6GS84vrhXHkY/qlukozep4vARpE9tYyG+VUdeWxMBlfy6lVf0XcztUGnVMxl8elQUOPmNrkqrJwMPpGJOJdJ0dUCLugoJD7G0FBEKTExEoSUzKd+5gmEq9Arc9t+ETbeuWouufl1CZrT/9Tu02vUU9mG9eIiMoDdYoEhVE4LE4DOuhwhdQFKXDDxPv3aVVRLK2+lnqbABB8JTBmgQrMSqw6Zq75bTGwVkCBSus6dm+2X5SaL4zo6sqxhe0EI6dDf9AJnmkFqHgoohYCADu4okFBKVFqsrBthJQaM8fVgLghbD/UiIOR23iZuyYdPMTFHgkpv5QhZW4Bi0DlNqmXhCuTOTOp9+uFvdP+oDcIvnp4OB/tnBcOR0+bI9/3aYf7qZGW5/v5nebqYfOrGdSGW0rk7hfD+//Mfbze9vfnf88GPC/Gx/PuvI7m4pcoDLcdkM8uEJlST6tUbcJvLFYnavWTmP0dEShRBgwon0MCHLupMIYR4WpouHunZ4lAeKLJhTeAufMa6NG3VA9DvcK8njAESV1q+ABn/wXcu+qdXULPA6KwYzuIG9zMB/aKC0BnL8MQl2zMIJ8tYtylBYQSfRZzXGzggl6EEy1RQ0aoC3rFrvOoRYfZGJM5rPGg7pHkA3qlXcrhk/IBneyXHo8NXxs5Zqi2O+VYnwp3XLqpLkp2nqryEuZgAnCHOE2sqt+kgsxQWIajJ3ochDP06fj5dP5xmXc4vC2zhL6w05LWZqwEFJeQjADJ//5hoN1JSLSXXCSriYyb+dfiStWTLUMT4jX7obrTvWAmHtFhx4FsTwkZgwGDcQc6RG/JzOvxRaLmEFmEzREgCYaNbEjZXDxEl7MB2GZqgegS3CvD4vpZUcB1tqCeHWTfqLhKefvX43e9jOt7uZgciEiNNsp4vc3F2uJfXWw3PdVDeTFmSSE1a/5xnSmaFrw2GH8AX7YaWEHZaULmeCKqJwW7OYg5MMm+6S62qOrotuhoSVm1PMmGTZGFOAbMUdIXOrIjP24lEYjFPgD4Z3Sof4TBoaGVNdAdLhXGCFsUAN78x047brO5kocvZmn2azteF4kMtC5Wk8uzVFnbS+7irKDTXjk0s+e3bennZ7411xV5qgx+m2hMcu4hYyh+O/GBPe0/7t4fl43s4XJz3s1WwNGrmaAdSLyASjyUh4wnqASJvJRLpKHJdi/PhlrqYZQQjHf3iWUq0GubRL/mFVhc1H7qb/pdQqQV2MaMmew8RF3XZHi+MpW19BsqFhvN12PVMXQvGy6d3Hs9IAhG1dCNUZu4UBXsvsM12FDisE4USfbqf3ZitpqmJMDnKaqMipDipFXho/fD9KUDeMH/2KKqDF8FItx6ZYTk36CEqM5L6pP6Nlz0KNjIua6gCQPYWW4rvuImwpQaA1zogPiJUmma8IixgMHFS5TZX9YZ5ZZ7OtyETyaf4S/Qtnoaew6ziQLqrMvmAjgDjy+PhALoF6z0KEuRRhUPU0j3uYbxwpv0Mp78NiDbTDc32e3dd1Ji8YxXudAqkZWbrYBZf+ht6oWPAfjMIiX9eRQARPHoHSI2qE0QoVd/SJB3SCt0yxYRP/cZIxc0+6ECwBCU3Ih80g8RIviXwBoHVTc35hABZ3WJRh1RMvvoSjIBDY/sErmq05H1cPp/PufNkaeDidrfDbGuY75+mdvfDHxs4sYW44nhMUp3FmkOaIFzgWbwsO1YJNI7kumROltQQ9TZRPvWI8NH34GGQKMNbl4/RfnflJV455HOkTwbBsQxw300/303+Qw9RDh/g6Wov4seO90KErqm3X2z+irNCCq+9L/Q037C6Ou551YKRLxvh4zPBlVqhzbzwxzRjpUwTZc0qDrc4dE2Z7Xtlz4cCgKjbGIENGWKmlREllavfJLhowRW32TPzkhGVkHB3rmDFlBW00AQhUOb90Rl0f9lZk0iUFjWkxSxayvhoP4uOBGuvS8GsVPqKEBohveKvp+g5tRYXHt38Jz0/FWCPHMZx5ipW0rQlH5+eZsRb6Fy8wn2UqXRN15MQZzF0n7H5djwGoP5yf0EpA5UAcXG3AjBgRo0jYdNS6AiPCxwZoPx/RqwLXPT028cfkZsEBtOFTVWm9UGQKoCm8ZD5TtjN2PJy7tU5bQ2pGhJlIRolDZ3DOSqOTtCfdMwag+3fZ75Xk6U9GdTWzmm90+MMu8l/HwBL1yrTBVWTDNn1RDMQQ3EHpOIGDisRQo3HRT1AvxwXS6uDDtLDI8le+h4QUpaDxQ0yq0TAeqAKjpjSAAaS/yGHQWgsMod6ZJsqkipJRhe3020s6r1/rY0iF0CAGPJ5QUOHCuMebTZapvONoYYN1TeNgUyxyJcZWWuMLAyPH8WHc6E9zDVkhXrWmSej0UYW3iPGIQHE/OQKt6axXox/qCq1Kjh58LZDmDbVLfNCbDz9yxYdVkHrPgomv9BrrSdMQCaqTuZbGcLkIRK5CRLKXOCFxCQCoUqMkYL7VsJy4rvqIVMGpUULpRs5ErQyhBm12qF3xLckVrkKA39FurSV4+l8pPEG+RgJttVK+vEW45uiKixluGmlnKRsqBRT2Bh/hOvQjdbo1yIsQwhp5XctjTL5DBedJUY666Eqa0JOIni/ylvl5tXqcdp/MAgv8l8XWjJ0U7RwVJBNLpayJkstR+uPlmQEcTtvdYSsdkl2R2+G0S9c3MYRxJtvQdDkTFK4+wjRgDWAR70/H4hrMOdTzyngT3of3RI7s4zErteSuMGf5qD1jJWdJh6JY8tTTdfka5j50wSYfQB2xLKEcy3rEC1omrVdLfkqQRPiynT5vL8+Pl0/HmUeWXrp2F9bxmtKS2tLdbHp3P/3DZnoj9e8AK+VgGJxfXEOtZQx3Ep58+l2EJGj5F58CBs2DrRa5MfkMnOP8YFV50X48is1ksJzrUKUxIets6pipgJEIxLhd3JKWlK1DgVQAHHPCE8ewOk0gxFFhTeTE9SIcM3CR11SuhQETsiAWgfWKNtUKgdpM3pwToEiIHvvJxgS0oh1a8DwYuYWxUkqepXOZeGJeTLt65zKT28t03xEewAGMFESMc7xP2sI6KttRoAQNqlDkxfY4iCaZV0JgWVOECeUc36AKeHQ6JpRe3Kii+baH6iz3rCd6nusOJaO3Am+zUOmMoriPm5kVfEbNpl+3T3w7oilMlglmXYLffkH7eLzsDqfD4bTfZ92QTHIuwa4TEb4TKw6n54ycpuvtgFySDX8IS5cj/MzTNqSArrhaa1Tpvfg29Ba93L9RkM+Hx697T1O4Oe+A1FnCdIdZ9Q202ag2GyAYErDYUyaNiVgZMbMTJyASj6MisEFB56s5AY0/G7teXx8U0jzbSPpbs2FFgP/oK7PStZBZVi3gnkiSadfpuaaIMKLi6gQKWkIbQlVlRlJuRdpVOPjAIZApTcvALWXi9VNLYRdIQgeOlt9Ns3d5Hm3+PEsSzGjDwVctp+vKg60xdOVW04zYwKC3oSCQaRI1ULROPb0dag0O/tRVhz9FAO0KX8Gq9arZBJPumDJ43vTDCDJVADI4R/0DnE/loW7MtTfIhLYGsfh+vb32W1iF8rAFPD6vjMo8fYMwNcJA4xB6NfQ+CLRk2FJ7CEwNOdbY4l8AwdWaFjODAFZGATQ+2ip2SkKYD2KfDOB0v7qJ0hm/7xRdmHNOFvNmcf8+69iOi93u2/zySPsTCQNOtm+ZbPgc9VH7EnVZ9bDWEY6WGs4w7KYDTSjBP7hmRQaHXwfBktIXwmdV5RcGJOi9iTm49KGrIQhmbRnJ6eViXv/lWdRJcuNzWXrKTsMNuEJkrBa9CSdVbhS62F7jFYPaPy4TfzBgWGVEdIWLNRpl0KBpKGbx7hGqdQoEVuUwXj56xnAmgLjeth7lo0xd0GuERDHNvRXL1FrMfrzESqPtjXdxin3eABG8pg8ih+CjlFL//IzZpko4XYkG0+leqr20bHkmTzDGb0gEhuG+KuNbTEiXf0oGwvs6D8GxKNqWrKbK7VyVQX4SaNyolhAk6jjy66csjYwGyRW9W5ADkPHggYpo57xp7YtbFJrmYSChNgJzJemXA4Uzjh5zqc3zyjjgAhIAogR+JqgCXv1wHTSjKfHfvkVmlAcHSjg/lC8ntYF0pdq6u9CGm4QQw30AN8QZTY3AwrrkolxzeRIXTaUyM2ANVRM0TfLH7v7DygLV1W+Hl1+sjdiZEOG35T0Z8s+S8EVmijkFC2HX5dzSgJfkMWOmSVh0iMNcDdMHa300k+kkaECAT+BApUorBmAt1ilDLNjfETEkwMh109UWa/D78+M+PQ1LmswuWIjVxfRkDFWpXoUHI0pmnJkwJLiGAnVYnwwFUDghYnT8cZnAOv6Tyb+uQPz0OP3JmpkOCLqLB1wgi1SLmPHXPgVmf8QWUVETpAt9SedY/vDbfvpsGEoo6PCR9fd/fjP99jD9F3GDCCs8vs3s2Oft9DG8yHTsD0ZdIrLoQQAiIcLCMAKO42eVuIER7okVK12w08KwGhM1DsOHxRr5vAJRM/6+KYEa0W9dIxkINWq0UZLP1hz5UCyMphCIpSUaBkq7lC93qYgfbKaIgVbEghylpDRjrHNcpExgfmtzSe04EbYbFUiMgrrySYHwv8lSsK0HiaSLABN6aQpkHE8VX1Xi/q31z/rrCjegAjVD84M6A/ajZ8zN1dOBYwDH0ia5q+6Q2Unkfxm0w5VYw9IQiMzIxI/4h5oxlpYJyeJbJo0wvs3y9n55++Pm3e9vdp8O+4/H7af99ml+3M4O27k13keqSQml8efLwfTefJVnjYyxyn4dsZVDDgNz1G7sKiprnvBiBcbBSrv5imYmT97p6poph6eYmP62HMETRovTeUFN93oBRAqU0ViDPcgDrlTFF5YpoOd5bUnYyF4YgFyoa3L08bFSF0oMAs2DSGHQIc7SoxjPT9OXQ/YsAP6ob4CJVmJhOgo9IrI//Hba/dt2s/1p85/u4HfRezYr8s1ygyeWc/lkJgvMr/uPoh6kFudfvix+eT//dDf/o3bFpcPlm0n+7fnT9vKVRt4vf/4w+8dNrBexhD2UmOYJktq9xoGoGKnlQ7mXctCX85f94t/mCzPZOuX0g9sJm6JoVRBurF4AgeniVQsTduvjwQFNr1pwAzemRhaqc9hpI07IiZ9pVRiCavWE6sWzuKaMkiOquMX58fF8jemUuiQ2QLRafzGphNsKW4adQz604AUpms6KQEJPADHz/e0w/SbzGQGcl+lXHpsRJD1LDbd17hlZOZ5nYmBGh7rPEhuOU5dulQ+mFWX/jDxuZdSENCYvMzCq+6FHh2mcJvxRhUyehjklrsa8x8h90lGBn09f3c2W71bL368uvx1MjX/9eNp9PT99nV6eZpen2enp8HxAl1TFczdZwm+igdYlImScgLuvE5N0JG5Q7vRCzLZJUo5mSSy8o/KYsjufDvsn3I/4Fx6xuKPG9Pe0Xz697LZm87GOqTEOKw4tF2s4I2NkE0y79FHojNxjPfrr8yhUsrJVnv+KExq5+/bytDs/XhbyBCpu4uPU5fErz7DhC+7QzcL0AM/KI4DLjJLF3+Ok7gdHy/1z+aR+zHpv3JdEmnZh/hAlmL9+nLZPl//GjtknGb+cPu5Z/HF/t/nxLvT+vg9DPXaqS5RgA8kukiUGAeGYYEiw/eEotznj/Wn+dJ5/JaquobhXgPpWEXHgqtC0TTVfAvANHfkCqwBuUG4/cV9fwhmPK26AY7W9PUuUiceqQ1E75lhgA9DQRXFDVU2Mhmgb58IaKVDz0ni7b112Ti9lR5gsFdGLpXcG11XFZLfw0ESko6kYl0MLk+Oz6r8SA5XFPQg3VWMhjIqFU1bnWhmGihzIxBprqDxg+mYY0s4x1nFq4jlBZGpfPskGHEm532Gc8BEqsZEg0vQ8M2h8803Ecl5Ft6PTy/vbzbvz7rfj3V/3n+6WRM6St9v5l8XmwP0v5OYRGS+TIc2iGn5SWnRCiT4JGu0ehP+Q9swNbbAIZUPpznsRhD1Y3a2rLuHKHBGzT8LW1ClmZIr5qJ1vlRN26H1DNNJqWoyPtDzeNS2G764k1o/8kvuzTn2v5+5+xrOy0lGaZYpj7rG1hRGxD7yakM2IpQT0i1YjnkNaRJZfz9keMDptvfHu/OV4seBxa17EdgTEt2NOx/1y9bJeGyH+JYEwTwy9fLt89myFjJGBbWZvbxe/dRGOJiCPR8lV0utlG6YjkwURb0WMjfEi1jHqU6FesH4mLbWquHgoz0Z+GG3QTGndtddBXryL6teool7VJ3VZbKJlU6bqpGib/aroDS8I1F3blv6xgUTOwoekE/LC2Eht2ECRB1xo5ozNcSbnKdKaYBVxEB3+esHVKm4MSS1e38Kn7YUBMPhwQN3GYeRAMl5M7t7q/H3CdXKkuA8Yus76w50yEEgk6AIpGc0bMaFoZx0y2ciLVtPTOgZgUugNu+0oH26TArqiEE70O+1Fl6UAM/H+YXYxnYclNMSGLiKSNs2YWdF9ebwsu2/F3i4YugUnwyJSARNhC8+ymQJ2Kg3yqFceNB0LhTIKxIF34ZAoQGuYRE3wcju33jyMEZ+b2oQy0wsmGNaenCBasw4WcHs4gKE1W23C2NS2yp3UtgIjCXobqZdsGmZQ6L0hfAM8mbM4GOJ99NzS7vh0uRyI7p56CwKzxbvlGyuQPXxE0k0MYISnHlmSUPKaguLXSBeDZy8dBduyL2K7n3tSfOOxzr2782/Hk+EzJmqycE+EVtKECXPiFCBeXo6/Ps7vVunm+PJGD1CYWZmch1n5rZpsvBplQEh8EO0i5v1x+7x4Wi50NiglifJJcWNX245ehuSKU69Dlig8AqgkKuX0ANFRrOGP4iOH4blSncZPpqVP5atD/8ZFdevvqSxQgVY4+MkdUFm81SqP+yIm7y6/ZYkKF5zhPso6pq7KrUQVnmhYINVXL7ytwlEcqk9hoKdHKGdiMIzna/tULoA4wqxsShVMoQBKhwPlA9IAdy1M0xlQJf3LUOoifcJY0YM7eBE/cU/fXUZ0SUAQweLyQcWWGg/vBmcosRADgD+BkOnKDJGuaOLmfLzPQorV4mTdyuzD8g/b5Xo/+7i/PGLcfnHaXroLk1wQu0+7FxlGyvPrSXYcQaq9MARhd+arU3Fc7u9Xm6zIttI2SVTNAVtWq+Ny8/Xl5bw6GpolYEygsKIMOqGOZhrgL0PC02iMIXyFXvXj/V0GMX93a9XXjFlfdsvd4WJU8XhavuwvL4vZcZFnk6wPtx8IKyJabIvTKuv5Bal9+oXFSPunRZ7210+4uZ2/z2Rnft5Y8ogq6f7j4eNfX/7p45e/nDfPgiEf0G4n4+DEl+ubbGRm6vq3y/HL6fNmbm7hAy5bc2OdmWyNAkTPMAslWW7un2BmAMAju5lG0BnumAZx4gDOOhK/D1PEH0Pg+kh4yxdGY7DbxdrzcJyq0J5yukqJpKoRHVWY1FzATDZAz7TiuoqyDkopwvgwJz5Cju6osDTWzNdnS2JPZ1nQgeIigzJxWaky2yV/4+lNa9RftGNmlDMjgAagO8Y/8Od3qDUlkMcmmkUUwQoao3uNLdWBClqdij7C0SCEyUXRyiszhq82gDPK+FJxYsVhvtqzl9+kDyTOktvbZvB4TX0NaYhLm+Xs02b2lOmCyw951uwiJRdwjeNgsD73cp+cmRe4v8x+PC/3x9nhy+Xx6+XTl+nrt8PT8+HwdHp88gx2VJ/jTtLGEuw5ZGItZqH/PLts1wsLp/Y3DMYjQl1nPruRLlqfezO/uV3e69VEPVYzcw54MsZnBFMqLl5T+hhAHQxsMCLsMOHVHs/D3fQPVkass3ztfSYFE8rk0/zx7rLgBSUuFOi4pKlhNm+05duIreOJT2HW/HAUCjM6FP+nRY6KSk2zO6vbx2p4Sh1r8SDh7P3d+gOK4PX1+Kfd/KADIycxdrVc3q9WtsbJU7az2bf9DIs/S7duZj/dTI/SA5YfkSfomwmO5yZ8TEoCeX7R0/IcXwbB0lGIIGm2WFctNGLhozgmM/5bIvHYA1qqPRB2HapKKJ+g37QwcCg3qSug6VI3AMaz9BMUqpG4zXIMuQgs3DAbyDxGuSFtcP1pgSKpwXRnNb+ZShldEoAsqXrazr5cZp90eNihiZquQn3f3FXHDENBgwTlo/e0k93m5/d2OzAVX9CSaFGeoIfj/47nMOn0IlANW5TKCPjyNsGq0MuvJTvyneexWKqvbwAr6oRkBZkKfTDMIFTyIOh6mc2eT/Pn+eK91XXsk58zMZy8c2atgymEpHyL+Z3kBitv598e1nZ/+eWw+9ff9o/784sepjtL3enYQZ6GSy+BWGfzdG09oJNhkoUs+kj7Y5qX58v2ZuOheGa5pq+rS3ITq7h++/b85mHz9u5Gv/ahTjryq7uqqsSrUUT/uWTO6WYz/Xg3/fFm+sPy8m5ukW8ajx1mrjUP4WMTahGdNDSMDI4YZJIC5c9NTjAC68iDAAgGQwmGujghPK1gnMgo25PP8FRHNvZ2+f73b3/39PiXxy/b3zyWmL69TG72cKdXLAPjS54f7nSobsjBPPTNTL8WSynvTkAgDzDPgefL/Vt2uzsdXzIebJaB2s9eFvMvB8dJN9rjI29fcyEV5EUS3MxGMZKaNFRRMOIk/RYNuPYEZRxohoNkKqWUYpQgo64NJq5ctXCYAWxaMY5DYdo/dNFQCYmICbQC8tKnJmnUSx5C2+SQj/vpo5GDJk4eJFDgXUmWy0ElXpu1qHvM80DJ94b243mRJ+V8oEfbynOC9o3K9jrUqF/Qa2LJDOLmSx0pJ6oAoZkQGZTcEm1wAIFMRU9ycIkxK+85GTE/aBlUxaWVnEWqcn5jUEQ273k3uTM/udv7afTTthgS40wDbFZSpNXN7Lg+flldPi+N/ie1PS7mBlM0IfOV7MtrrE9enrfflov1vf7ijjOzW8a7WzlQllJA89ZD12dx4XifUZjL+Q3e3lmosbwViFg5J9SQnaQQ0gm4kYpUz3Vpx9GiN8VusnhTMmc+NZ055JYXw5dj5ZijNICjri/+UmiKPgr4SahXG8NN5ev/NJpEIraRWk6jKLxFJf2b505cv9/cP9yfvj4d2msW3w67+U4ckwbw6duvz5v7mzwQRfumPz3Ov7xf/+XN9J8fZn/czH4WvuraufPkzZGl8b0sqUA8Bkm7jR6aeIKGDT/ecWZUkOsVSVTsFmD4oOUk/cX5KmDl8YdOVHcTHMKWfAcD44/JnYPvERBNhMY6e8DD9tZiJFHxoZStRRfTkcW0sjHeIUwS2aOOf5RaIAQ/a+FiFDytGeFaRLOn2dkYVzArwwfm2OsLJZyPuju2oWED8PSJDcC/R+RQjPh+WRaFr3K7FfMoITIf1p5h63LG9fhQbUSEOWgPvRErWF34KCf8ZpXxKmv7XLDmOX8XnubHCE8ay+857zxPecRTMIzyLNeL29kNR207jdvVUZ5nvXQyQGuKPVAtPTnJnh/+0+//eDjOd6evPN4Ddzh70y0pyBIum91xvjS2hJqYzdnDGJu7s72bPNOPC/DWVhjkQR67rlruW0VpLyLMWL+dbwz51ifJG6BGUumMyGtVtMDJaSIABYz2F15+0n6McyVskaRieo+1nbK8riRBtobH9vI87vP09fH0y4tJsdnTfvYM7O1q/vP7t5jytD+9PH+7nNYey1pe1jfL9e58eNp+eTkd1+vjcmUenQf4N03bPuTl8svm/JPYdXN+vzjjiDUqSbIvs6/T8mW2sAYLhllQ2YTVziUeYBXEjccbjJd+GD8WceLR696wD7vIGNVoRM5Q2dBFUcaVWgWKQA7HmmDQNiyLNtRgMDDzWQXiYiJJe5DsIZwtWGajWAUWyH46d1fXljkZW+ODwvbXMrTf7nPyJlals2SJgfFotUx0shP40HsfTcSuYNuQG/Tq5jQBtyCpGGLrOFGqgIuxZIgJdwOr0qUYt26c2uybsVrpXDIiKI0IUGy1FQAuFg5l2BlBusxEctmKb7w4nMlxNbvfZ/ujhe3wujOFvTK4rqjE4/nL3XnzQudnyWaKvL7J/G6xeli+X50275f/8MPN+5O+7eXbaSEZerb7ksEJsQbqrktnlhYlybZgl17z/HiQu9jjiGfvgluXjT/IsGl/hw4MtniNSdZ1bBb3rNwYP0TxBSNQFNajKfLEN9/YT5KXa2z0k5ZwmTjixDeePg461fxXEn9piQCaKOlcX2r0mb5c/vzn4z89nr6mr6DOQspjI9kV9X7/cP/Tw/v5/O38fHPcmv04W2By3H3N41Fzs4nGPwwffXk2UTC9rKa/3k0/35x/2J2MR71bXDgMSY/NZX/bz387LL7MY7qRPT4R1cI0fHCD0qORn7orBk1dUM2MFaapvD7qsCJaqD9Qp8hVU46QRjnAUH4UK3PiFFpgkO/oM6IzUNoERPVRsTejNIpF7YJRoQxlr8YrHIWOFFKSECTHfidJkJMmP2ZgF4MiV5OjBsrzTwBqqMhk0EYdQPp1l6t2HiNKk2kXSjBES85HqtPwFb/amEmL0W59u54elKIJgFPVmjQagdAPTBP1hroxn4ezmOyW6wFOfb84wA2ns7QVkq7w6taaKwPV1pdupBvH9W7xfLr98mFthIf+wivhY3tYrE43v7/5Dw83P24OP94d3tpDkvQl/Z9Pf155YGux3VpEd9BDTvwxXP2w1ORSxLBeaGxRgxYPtTzWB5y9s8SYq3U7HEDcO3JJQJ/EnJl1A9kDgJ9DB63F9DiMstQJmqm4Y87xi67UtYts1IifcBfEfOqBRAp8cSE8de6upEhdPeb99Pz56bfPL99MsaWHczGwhFNSncX2mdUKiRs2ebd+dzd/YzBn/byYPX+1e9pu+3LSV7xZLG5McD4JeneW0qy3l/mj7f4ilpl1thmNmZ2fjwbaZt+gitcd6oUPZ++uoQ95bWjJ6HP0JteNKUGPcqSX0vE+yPcuHcKoQbUTRGEOdQ+EUjx0iNr5RB+qCqnUMq6AmYtBLGVGSdX7I4eRb8cZF/L4i2P4PFRzMDcujXNrrk+GYrXRC0mGqGt+EJCkIkE2/1nXRhk+azgpsKvZWmddOk4KSKOG5fNQCSPjS9EDJjI1JmG0N4mQlLXuH4vAZx7pHTWBHFliXACACvcJBxmdb5DzdKRdtHVdEqbSr3WeyQFD4DFTaM/uVqufNpvHx5n8xpDrdTGImd7L/vbd8Y8Plsns362Pxj11HuxofbM8ndMnXH057Kya2RnqXxKyDqM5SpsW5GE1crjnNOG0tN88btnA0awyD9KgVzHmoQTLi5ZZN/d8uX24MbZYXxWXgzP1/ZiSoIK59XmGkpROmOsgoLDofFg/MeOpDxY7z0lr8UN4JCGm/R4sfiOF/bC8P6/+Ybt/Wq5ubtcP6/V7K6sXF+NZ96djxpgE8dv1G52h4/Hl28PHp/1/+Xz409f9v8zslSM5sicOPfW85ezhw/xnQyU3i3eOgplWi7hZNkhnPLu9HUpMNxitwT6eglUkdrGNaoCSdEL04OqUM8qehLucGlqLCYOckFVVDm2g9aqb0HHuO7QhqpD7ud6C4Z6LtGRcbzsJjNdarTvOK5oM6XqMMANToCSsZ8lTbYldxP2XzRSYU8wYq25xHjscO866x5L1EMmRP6Lj2oOAoJGHQFF9kaNbvOBqzIb4u9f3k6O4apDKJABXRcTUiyXQn8KgPUFyxECcrL1BwHWKET70FsYKsHSAbljQYTSDHbIHSd0tt5MMjmhMdct/uOsLpX+5mWWju4fpW1PHTE38tPhh/XC/OC5Mjxkhs7Af6dZVM4Pby1uhHl53OtELX5kCH7a5N8ieGWQ7ExsANAJ/C/+lPJj27w/IIIal+WXEZISJeTrhpO0bf9ncLh7Kr2hJnjeIEWUEt/7pmurUlzin92Tz4md9ZNkbHUqsrxPlU12kPfjlYuQtFZG+WDh0N01vb87/cJMRrly0N1O8BX7xKNaGyBbUxPH8Oa8OP689TWfjqo9nC0wuT4TfMaUgB3+rJg3j6tcGiCGH4cVnt9v5DU+Dc/EZ0Rji5+bjtMCl8ZjpCjyrGWbvrQgkobhGitJsmHx9o4IlIRipq1FnNQ8sckpZRxl3iTZYKZaiPfY82k9LFKjCKaFMFLQQ0I5vNDIO3RXhkAFQ6wCn/i5SoOxDKpGLnkESh3ioxISueyFO100mBMfcyYLKNB0VZ/bQVteDfvwiXgkdbgLmjj6SkWhPY2Ue08iS5UYeeNqfn5vgh6JG9Vhgz0GLxgMglvZRMo1CWHGE8N9jul12oFUT8uyNGVi+uTe9byVbZav/aamOKa2vL8tfPp3+10/HfzovfyUOwuXI+cBD4JjxfEzy+3y00Oduc5+lP9lqyTTX3cOaaNcv51tPb2c91ZKpb5/OrBdWWRuhfd1mo6jWRtu5jOKP5UbGxxO/bMdrzGm1XHy4//DD7Pf2exKyE0l1HAWuJG7kyg3QcsTQe3QO908wwyTcCuVVFCdXqfdiZOxWrYK0qGaUr5HRbA4ZR+OTvOmnEBVHQCFIHpDqRXOto4eOkjXO7Mi5T/5iDwV0RYl9VCFDfEe6/tbwkdUgOxDOLBG730aodkDRjN5Ddo+qqcSHFX6QrA5SAV6fKQ4TikRL/iAqSlnmtNmquIrjRzV7JAasHb0p3FtRgH79doJpZOJEIlQ1TbFRWEUBJ2lxNDsXFcgEXwpEX1R0JeMTWV8AiP5iVTosiNlnPDOEoJ5yppWBSZqDYa9iFK9jxc7G0p0AByH0MQAS9ywXOFLWJDzNvoIk9lbvwfFzmBRCEhJlNnWQoihnybuFnA45xhW2IsZ7XkA/DxRBzT8DS3TGZLGusDkja8Y+fZz981+m//nT5X+ZbZ7Wi4dlZmBFqiUD8fDx7Xl1s5Ga3512u114I1OwZZ3O3DEj9esHQ4Uv50yeSK23xy92Jl5a5yElNt6BwqXt98qBsC2hFJUZ7txc7teXN8iQBd0t39zP3rjvyeX0cm1K1755tTxQ6uHQ7B4uDNV35EEjmAqMbrKWGAxPxqvgxat7C6MBletDy8pZ3FEm/ZyUiNJ7vqIVIKBPHitIQ62lca1kcefFUqLP1CNPkl71Bj6NBwFEq7QCgSAp1ND12fQhCzB1DJKwCkp3ulwddKdhhERg4zNsJj+Lc4AgB96wqvhfy1X1x49hP1WL693qfVy3Wj6FHnjXkyoi3EB+Na1xiybGADqlEM6grhACKbVpIGTGRKhAkZcJ0HV8UmUgTJlDUTnmltXgboQoR7NGsQFric8iJJ4bloE1lQTc/Q5twypmENU3NmCRvFm27AOarDU5AmnGEGMPqYQqQSB5VzrK7rojLJjvv7Ns3vUOTD+QTmQt6pvTzO66tTlKTExI1AU+br+9/PLr7l9/mf/LdvPFC0Nm691qZZ2PJ28ow9PGnq0Sfs82nX4jvWepDYd4tBBz/SALtpbW08aLb4fZp+fZL3Y3286/zVdZK60yfth7Qma4vBXdTNbl0QT2OH+zvn2/+P3N/Kd1EimRl7nLta3UEAMfPUt1OW+Pp0crcbp1XbKaqixCYU29qP5urjsxllvhYSNsnFB4jrzxifAifwotRifv6gQYzcurqXTnUzSHCJnKG9/IwBXU24pcjyJm0nSafXw+/O/b01/2x89rU4Gbt1bI1erAFvlFA31hPiOdJG1nVVUeKbRm8we7A9UsqbtbdCvOaWiqxqlRcU2LNWDmPUwoVFSTUaEY01KS7FOlFH53BymGtBaHe7xmjKB/UnHEtMCHVYHLKpNe0tlIORXivwU6ni8JegDE/NzpzbTr01VDHqzK2yrkaTwIwhMeiyhg6lVLw1EXERtVTyP+59TYKYzYAxezE+d7MdtUTQZh8ozHZxNw2/Pn3TlzgtiIsPi/mK7EwzhskohwIfYQhrhldAhumNArVgbAzUo+bl4ZQVU/hz0wzgR/Kxy8GoSpJCYnl/GCmR9+XPzwuH1nfs3wqGXOZv5C5czWKY9o/hTs/822Nal+ss/YarO2ZfwdOzuf+Gt4fpNcneZfrBJap6eOpQd+0eMG6QhZC3S3nm8t90InGHMr7Nf30232w8lWHJZNshesw6Bvx8VXq1CO56+X81e7kyVczu7N4Og5Se9iU8SQLYxMVBlPegYzQZtPwqb4bvyNJlTAFI4YKAMfw4G5pw3aH0eVWwKTBH2R7M2iUWLIRvNZ8K2Pips6rxbPPZ0XT4bVdue/LlZPWQASIIYmvuF4Xkbh8eyVjPbO2t30YtPTInhNg0BEsYpq51B6x6tuDj0ustEMdEkzWjKaGl0JHQlcSrZRJ/yZy7kTEjuEEiMpgeGMWtkjJ/eBotyhVDoe9QVTmCMCUBM2cxJbT+CSvBlUATD8jEtSA5xoa4C1etMh9Q3W4eEt90/57B/BBhJAaGYl0RqapB1Z2htTnMsPweqLKWh/J0bkY4bRtILbvqfLU3a81nM9f9Z/tWjZhEmmmWI2RTEio82GmPWa4mUwoJlPWGc8Hr3oR5dOp/l6YaSjzHq3WTduZ/hpaT4rD8iHJ+2RGY/xTpIf17+zbfBiv3qZ/XK4fPq2/SLaG80/rfa782zrZTqLR3m/1yrAxdSy5P1wWe/SScOKrJpZx70Tc9pHthSuMkqHs3ptYthg0GlvEqX5A0azBhb/7AUNGJctWeKmDCbCHyOe19bQLw+aap9db53PkCNGdyOQqH7e4zY74mA2M56MyfS59gg5sVWpmEWd7pC/4MAGvAaCBntY0ZAl9/51O/tlt//ri2df9l8lhKuz+LR4d/tePwdQV7xYxcoL+y/drF7SvY85AegJujrsZAUkzOhtt8gMGOoDpWfm1CjciDrgAoHVHPLTN9oLVSd0cGQjtL9+DthodHSxytuKKToqujXOayoFUKWPv8QKOsA7qBvAcAVkkK9RDaubkalmHQYE01SV3l0/UacWnatfdyeVgjYM4dZugB+kSyLKsu0wISqOWFqemVV1xlF1t0p1Mk/gglBqZFQgS+4IGtogZ21SxqPNXunpWYbQJIommWrzVGPaiilrSw9EyhAzjTFoK7rUdTGUD3TF+OXYgx48hPWPNUnZyMgaobluBi96eZO8qR224He8XS3++Obu3Wn9+bzcvcyePTX1zWpZI9/z3cfzl+3i5aSzID2T5V7A8XCitiygkINhC0xQbkUJGiW6dICOIQpug8XmAQwjjeXUntSfbzfr7Wb+xIwIwxx1yLP6nm1hz+Vxfn5kqXqdMYrjS+RA7WlRuMnSELW7mKk1mWsnwhiV6P1iSXxeMoHNrqgLVmTvD0bFl2XqMrfd9DScHYZ3T8d//nX3Pz/t/vR8EOkMCy/frN69v/15vvyP2RxzNhJZZiNYcypQ8HBEuoBsPs40vSGGRDAxeuv+q7UkbAAhxoA1VX1yasNxqNcPLKKa1UgibIePqIjNdR8FayDlYH/Gr8cxp1viTzjrN9YluEXV+IjEeo4G93E0+px2x0eNWkJ4DQxMGgFyO5iEvQUdsClI6RnwUGVX4k1qCarx99X7eCXX/bNoRrJB3pxB4kAADkKATdodtIsslOgQ1cdSqp+hvI517i/z53bedOrMMxC+VIpG6YVniihJBWMwXolXUTsG4AiZOv1YLZTCD9UrCzOVvDLyIWkaQZ/t1/nsl8XmcXE43Mz/sLB8LOoXpKInVr8JLIe3uLeevbU27O300/P+65vZYXP49OX4cTv7bP+5y9LEmKGTb1YGJAnn/BOp+Ei97HsCGwMYXVT/vD9/M9S79oIG+Zgh0DjmJBmelbfk0CIkbkbVw+ryxkKMZYZRqb0ZNQ+deZ54a+CpfVZvd5CG+cFOIJogoDN+fvyWR2VMqbmb3NVbIG5n8wc/s/gyoTseNOKN7wn3Q63cL1vEHA+H7Zfdr799+69/ff5vdob5tjeLYdnSdP92dfdOspXtfKWK6pBBxuzzCq8MG2NTN41KnkOmEa0WMmpxlUQ5/tr0dz14PQnA10+13w+t4CbVj+JWX0lWBaf5VaOikYojJDne6y3UoVO7VIzv98Ulw3zG+5zEY0KQE0mDVcIBsDBzCJwq8Gv3EmhCTrvt3lAz3lIhTUS4ITn5vgI00sdNZsklvRKlbr41FRNG9IF7GJwP2jGPAE+fQf/Xo7a6sHnLI6FEy5Ww41XWaRLe/VjKg/kS0TyLM3882PPUSGIahhLbAjyOSUOuvEo9pow07Vp0U9GoDjIDe7IUTtiyF0TC1flOu7HM4Bz/0lATcJbGzebvlqf7u9n5h9V/+Dr79O38leFb6GM7++3lk+36jvOtHeY88CSr9C5N+9cLjJgDVjetIgXmfe9hFUu1LQeDHtWUeuWVUNwFXqczKGW2YiOvoNLvYH5fYwCHZ2NKc8MAcy8A9ZRxXgCR4tgn+beNt7UhJnONUVm67fH9u8Xy/WX1xjqGQ0bb9XKiVepw6+iLiYJNWug8zXV0LOTwEMyXl92vxyeLfKbty3T7Znn7Znpz8/B2/WaZxRntqgp5+EN4/sR8KagGogC5EGn746aL0TNEJlWLWvg4KIM0XynE1Ym+Xm+RFFAFbuJ1enLuFqbq0c1oTPzxUKwAHOeq5bzDxI6G9tCYUK9rZOrqJBQgFjqMM1gAlP+p7RMFTdB29JsXUwivgjAdoDRptIiBEwy5rVEoKhrEglauD3ycp3xRSnnO2xUMUyp94m7fEPBEH2qi34XPr4Xq0SsQbsSQZPl5cDFBXyY5RGnN4vYw++i5QgtmjdyYijH+qNsRo2rCXbnUYaUDptVhHryjMoljDVCcadYmhkZuAukZlIlB8XWRUHt+akJPksCvLj3Ors+x/PH9/D0pC0gczHluNcPj9vzRQrKzPVA88isFCT4J4GzSC0lkNrv5E420iMNgIPeKzVb+6HRmU1IPtBib1StxllQn7MpTWGYHBDoQ5SthsXMyzbNodMPw7eX0bHDIYwZZg8SPMwHTyKedd1jNl+8fvQYlzM9WkXGKGfcBy4l1fzJX0xrnvSWejgCdn7/ZRmxzuQsPTi83p/nv7t/8ePNuczGPDQpVwF5ygh1BGw9OLFdW+eb97BPehoMViX4NDYAogqJ8EqbYYV4+h5PX5C1+Imr3eqQuoS0WAn7S67BwFIi+pjC34ugT5as6jwPvWuOJs6fr4VRF2zcGaZp+ilvA0fzvCIIQJ24DkIBNmzQtmLqur6jbZt99Kax3RVJH+I/ucqw64wcJAsNyglh1yy3JjGM6BkE942BgBi4jydiG1BMpfBHy886+8BF/8rSNmMPHR1i4Sfvf9nUQskeDURJI1fBHKm+B6ssNLz7j+Wy69lVan3wv6kvtqi0J+kIKVwIZYBHvwwAyy+l9u+vph8X0w2r+pnaolmGPQV19JWMJsWwBxhpOrkslHW8SLywrtC/C8o5eyO9n7/fT2/3sC6VqkIn/qpvD6Dy7Y6MkU2N5hCwSN4dg7TXdjzC8vXm5mXufwo0Ji7zI2fMHs7wCB4Ns8kixIZ/nNBiCUTJDBZCg06KfR1LTcz56XGlmVaWQEt9E/IfD8vnw7XnxICNyL4EoRJzNPe+O+xeTfUHrYsvl/dP2aXsUvHbPu/1ePLCux8ThxjzHzQ/r9w8GqDxAFmHrkCUHLVPiXNNLoUrxYdq11BnmUQKuNGPbtYOYcnQU02lelrsqpgtBy+bWC9SnELNalZzClRCes1NmSXK5FiCBCTgq4k3BadkeYm69CEi4l7ZqAwKdnFCCaWQ6MWHoQDopqVF7CtogZy6TYHySPcVNa4T+ZtTZ2LUpqr77NPfd9i9WWrR1ANI3aOYTe0Bswxedoz2KagYyZlrgr9kEw4C1+jJX1A1JoOWF9lmE+2TqNGJuHqbv1EF92tYeSHRR5BcKIPd2nV6HLvJhk/URiQYjeyzHaLwEl2sEKg+IWU/BfjqntjmZeD7/NF1+tGWgdcqYkIwR78jLQ1FGKL2aZLGrC0cDI6exSZdm7O5841UpiRHEzXvH+VlDtFl5ZGWxOM2eswBEpsC9phsm9hxMjln8ZgyqamHYap9RMHGLL/d8kXd93Mz81Z039hZPnlCatJtHs9KssYjMXXXqRrQckwnSqBAGR/urY+5CV7uGraxqe9IxOOtyWPonJUvafvDSz5dPT1+/Pj7vjK8ZZdtvzdlZvevhMmjmQQU4nB7uN7//+ecfH95aJOWFa3FV4GbFrCYgYQuMXXouyT+r5HFu8V/RUVFV9wNBfFiCvppRucHiZD7EVo5bi5KOXZKNa/8yRRNeRvqefmFUTuG4Zf/A9wGqdhBrdOIDB7USNKi+QFk9cx4rgqeRg8x3xiq0BVAtBT9BzFLW2ED6zZoHkWWryJpDjTuclSQ5M7VeIBy/7B+2l64kMWE9bXbZfxxKF7zmQdc1YX0KVmRIbmgnnKbz3cwjyx5XZ36JD1lub4/y/fG30+JLNqegfBneMUWY8ZNaVJaEAJVlIxgiXnmvcKprW7gA6s70In9fntD+EElD4VDDMHL9bYefQf/hdvZ+NfuH+fl9nrKyeIfMQ5GGjHYb4flynv92mj4lw06Ky968uOkhTzjaci7BP0qnn0zKca3ZWq5j9/E04UCEnIjGzqPLvK1sbT/96vxmeqefY72dLCMBa7XJYhiTo746lNUAeTzGefCSBDzCycT7IkALhjy53glhUqKu6XRzAtnSWoMoawRQevSfdoLAb8aF5jdWt27YD6ytMP3y8eWXj4/Px+f9aWuyjXfLwwYNMuvov9i0+PDuzU/v33rwh3efLlI3g3EIy6PQgDBekPQ3ElcjeFiTKoSg4aUSTu3gz2YIvv0bCqN29K9dhZQNW5Ks60llwpgBJBeqOtMe3rq5O9lrOP4VtPA0KpYWGfxouTWKQ5Q6I57R+9qA0ZW8JzfvzDMEYkIj+Q/8tSujTbCs3jNJ+HgsJHSgJJlkHEzWrcX0RiYiU16J/B7uI+uaQSxHIApjtJ//MUwV0UgLI3g4JsmJeYBFD5CmeZn3+/nldxmfiFCgI8tgfh44pjrmGW1JG2/N0TjvC6w+9gUOd2bl2oMyvMFt60qBGefShsxtgR9PgDVF6Za75PwgI5mzrNP6n0znnN8vLw/rxQ8LS+KKXgNeEEh8W75k9sns2/Svwj4DMBQiAbNisnM7LyfTUOKhbX8Wb3E4BgkIJsShPGerIRGMHepPc9pJGlBh6NLAq+tSBX0DOmbQmNZijKwqPlNORszRpLi5JDTkR1CUU6msy2R+WUCgALVJOHWXd5qv7m+WFtcRoF24SFruZZ/HpamU3eLwgkue4b0YuLUD6nH/+PX0pz/9+tW0sve5XY5rr0RM0psR69XqsiGa5dyjPQ8m6tCTFYKcOL3Jj7pXwSU+r26O0gxuRz8TsWP4PrRTB8NFtSU8VV2kRS54FFWJeeB6LoGGEkLktkN+nTS9T/+EHieGukjBSK4F6jKBUtdFx/EtjPj+8J1gEgcZQLp3mJPB0AxcCacZXIHHwJaTJJSkcTFmyghcUmVevOj4SzzZdMZwJP2II6cSif5mnxK+6CL+NJTpJqmYhWXPxu8lvpFjSIt2q1CMdUmNhGiwL+mjc8EkzFgtLcv9Wat0MPbXQbD59Rk0ZiAL0gfgKUyAWnLwZu6RbnbVUBXDau95JAk4U58CmFqotQbRu43fZ7LXIDuFNnWdxAQyWbyTl3DH9ixc9XTK5+P062H65Xn6lzzmlp5QHhA95miq6w3lszQ9aMx/mF/eC1NjvVays2yl8Wg8lKkPa8csc0fzPEr6ss76hpgqsWXxwGopc8tLTryD7WZ6z8RpcO5at5PpbX0vJgEqDnI6DIDCWRlBtzIok1E1no7pvF0fnndyG2wmEdJo7NYQRBfp5R4eZUH7/eXr48vHT/tvz6dnMQblnsVdHcgF+9LlSi7g2S6XVx4B0iDuNI3BtWiJvpktI3OEkK8rOWIwnBHFVoovkVMytuF3hBtdcie6FV1NawSEKkqXaqnrjlL++yhg1DJZUJmI1GgRBFUopMj01dMFCKCpmqbwPUEgo0BReuaaRNOGFkk3LduNDYChNOfRvj0eqhnQpSigferak+3EhToml0sD8kkGrqeWERcBJH2+vIJbZsxjJMYmslvrPnvaXV4yeGypwdyKOuai60lmLlkm/zTPtofiS0QIHW1YFWfrK6ugLWvPPmtBFAcGZ3DTmlBZvpIc/zADKwt1zflCMB11/hJ5sG9k7e0Ty9yi/Y4zz3KpazJHNBIBo6/47w/qTby+wNnTGrvpL3z/fvrLl2QsL8he5olKj6eLAAzGstAEZMdL7JDRSucYhgUK0jNDRI/N9AQF1oaDwW03GSD61UgRcvqo52n5dv6G56dqxn3uFx+87qor0ggaXzELjhI+qEUIGSUVLjZ4TLqiQLy9hwngYBWe6OSV5yez1Eeunn37kt8p+53mlSB58tnrzr98239+PDw+hTu3liJtOKdtrBBDOFVPOnp73I2D9xuu8lfo0/awWTqfkQn7A9Aq6lidIA3/qndBNb/YrcUkjs7peG8TmXvjRyzAJ3Gj+Ywb7c4GUFU43d+4/2RZ6UJRboBGsGA2Kdb/gQNk/qUMXRk34MYDUPR+2UPcP7vtiRW4ImuaVjdVo340jGnTXdOazCyqqMmQwv8kb+FsulodV5XQNRAP0l2Ul6ZDLNa/GJKOc/A64qNXdO2p/rTYe6Zjc3uzOHPYhvykULdUoRND1JehPpNUmXCbjlOQii+pKtOzaFWpS9JvXad4Yjm0V95nE4IoFtciZ75nTg1G0nSGlKuCG89FOAlZ+ZAjZZV6ZAAzRIY+RGV3GkXEP1TZ7G2+2M6yjSfcyP7ufvqwzRyznCKde1IBRLcYjuTXpRaSXUEF/rIag1SwEvotOtK0BIipwATyFnI+PucFpDCnmkz0sLyf33ml+W0s4GY1e+/VhlnkQ/lhFBtgxkQlxSD9dMTCHz8oh+X02X3suasPsKhO2kDqmvXptChgqbcQIu2J+RCl6P31r0+PVu95r/JBd31z88GD+U+P++3t/WJ9hw02KprfeYHuncEfz0KbA0MMbPNtGk2N9qcI15uS02RojE+OG+FAoqSZ/JMcJ4vKL5xXCoShcVGluNnCbEDAxtyrPl4vq1P1TQKTk9hfdDVkpGokip/IZ2N+uh4uFayfyuAeCYV7TaJIzQmjwskc2g1Ik2FLPhErgXiIT3zQSKxX2M66D0IsXdFaH4e0E/2J/dISrcQ6E1QMWxjS5mZsqzfzVu4kitLQxfKWf8s0eVSEY4rW0gn+jAqmuQCJnfdWMNdqJjJ7Qu2SF2Qlb0YbTM/k6ftQHg6g1i1/RkfEKFXgJTOjdhYguBMVlAFnQ6TZ3uYdWViqAeM5MiI5WAbirETbZCl+OmwE6jrPnbwEVkMGNTaYJOVAuiNGUK7aGC8EJJa4lfyTAndJNiqEL7xkQsMqOGxVFFP9aL7L/hleeC8MyP51VvDIeHDBhgwUxhJoVVQt6S9aWLv8h1oYvSwm0SGFWSwxJjSHCqRHAfUh6u7IUt9h/9hZaAo+e/vDh9VbM42LjU0VN0ehgJ7p/W5uDH4uDEmlzw0kRldpIckGDPXypjkm9SF3nj4KMP5FU3JWW6169d7Q64FkVA6uYWCOPVHJWe4jp+cIp5SZVw+baGibyN/IPeFaSYqCUe7wcWVUI0AQSB9XkAzrsjUw3RpTfhGl+rFG1Cj4Cqz6HA2mv0m04C438kkhnSN9qdrCVf8TX3JaOG1am5Q/BmBs2YTiTn5EHAxpsVovrDbTe5vJbaAbmFQ2gs43VlFluga6WlSNMKqWwp4PIfJmTeGOhJZku64BBrBAP+S4Xj4YNKGAUSWq1HIU0BZvYXaW6zXPJeYYkqIfb4U0T/bZ3chsUcaakr3olhJu+tzZajDbc2R8yqIJ68zCujiCiKouDT6JEg1okJGwYbtJ6CgrjTc10TBFVdJDAodNi5WSW3fBYU+3EXGy+TsbWeanCZGUHC7zeuzaB+lDNCcqkBeS9nxlbd6BrwmG/fKwjEmKRfczuKERMomuZjuVhw+r7VbgWN+9vXn384fH4yccXK0fzh5TNl7rEej1jPM3L0izotxwrUbGBGiMr/jfzN5vOPqfuMrX1P3DUJUYnvYGtlESSFeRxkloGBqdy7mWP40iquR3aKlXRpc5vyCfT4ZjYv8ZM4mF0ANtp3YUcTiLAbIGkIrBuatIagAlAMppPZgLpQNLNzKfkYyJEpOdElQjpBjgu+gR2d1MSBdkghuWpslSm6LpuJt7lPyICNyD2+lrt0jsJkNgsSofqhzPWmW904PsT+S5GSAVK/1zPrwsgkNGQwRszdNun5JIGB2Kx7XmzOAhpcSXdknXEmL8qg24Uv6EC7yFmTKbGvkahs+rkb1tcTV/v5w+ZOe12buFeQCMhkI1Ur6HQRItfd8p++YbvrTVnDd2sjQYYjfFxSPKSuNKXPWDq7YtdnS8iwcj+CQkcKD9vLw7IUfMlUdRtfs8KRxFfegIV2eF4tjgXHnFWziji9BL5cqOAMq1SIiTYOBJcOOGaL9yRl7DechIkSwVLF0s+qe7pbFXmagUx1De9mwueqlTlAeDJNx740gr60EqML49Dj1OiC7p1cn+Ba5G/0h/6AA2sUwLt9N4gg4tYWzqRbuSV+YEg17tATVxgS3UYojKJ2SC4AuXeHc0cuSsF11uB2L7oHRzFMBI7bUy8GolKQIFthn3bMgKwOi1KxkVraDqoIBKVdXSMehOJhkosodrsinY4igGSvSxg5vzquBwQkqJUSmAAzGUAHDIAnAM0iPDI8/yqQwGmm2A87yxPteKxngFh+Gnc4Qxqql+dQIHw7JwO5NWtIS8OXI2gBcyh93L5fG33Z8fs0H3i5DgAeybPKVgaFKUUJ066qqzBzDhGVMsdxAKmht6CIKOXqzWzbfSfl8GcOepSJ3vwb0+UC4OWEgv7JAOsAyJvmIv9Ia3HYzn1xmJW1rEJv0cqddw9Ilueqolj5VGPKYSBS5dZJYw3IQB/JuVTmrUQfNqVopxqDlN61qO3mMNZQpXk84arspyN0M3GYk3vEZeefNTAqayusRMBl4kkDEhS4qYgodxpJF37zLSs92/2KXw7j25rDJGIVDEWjTkDS6ZlYsdBYuBR9nY1mNKV+0P0uleSNCIliHwzekYROopFu3MeZEHIaXxDykJLLWV9mo0FROpH6W1oaVKht3aorX0yl3NtZl41qhwwlraUjsNRW8SGyl80vAknPQT/oBR8RouZxGNVk/SrIoPpiZAxsJjKcPOQzWQA0CGe0tGMcjGwDr4VA7bFbOgAzizh5CNm/KQISDmBqiLcmyDKh+8rFG0n9M5vIaj0mFwx0lSPcSn0aKfYZwx+JOyYTeLMiMwvXzZ//p4+GWbTaWEaxaUOTuvxjI+Y+VYHqqM9mNJCJfoazq+JrZBpWLHnCyA+qxGXpqPKO/DjzqGyjyEkihoMYCdOz4fLfacPnk1ddbYZJ5qPOENJY82WogRY5O6m8UtfGzI9gWCQ/2pRmMt9p/TBI2vMhAq8gWTrNuJ6hmQeuUIuB0pLk71N6hXGiP6DYtUF1ts3uylY5msNllozjlzPcYySgcKwt4sDwWcB8vwBTZkZIINLGRpUnxXNJssibunufHtkaixJ3citnDETbaDp1Ey32CWTyrjV3Q5DMc4LI8dETmLk8JCW5lqdrF3nl8hITfG/4aC7yUBE18UIyOMk/rDgQgdxyej3Wk2aDI0OCb+qALRNh904iBwhtdPx9dhqBBKYGBFgxBloNfKsVSPaNJtisY4YwFqgJE2AMaY+GVdntNikQHzQAhLMsJBMlrK2goKZAInQwZZPmKDj529Zb2PC8uZMyXJxvXWqzxpInlVaCAqeQLa4YESDl5aS60hzWv6mQAEFU3AjXpJXY7LL54g9ISBXWpkotClha3rYfngbWsPZhE9TitMQisJIEgVQ9pc/BzjXKQbEHVBKe/H/3bBlXOLq2mUYdA/Gwm1jb4XZ6HWiykYgK6FcEHdM/QZJZNwYL0WR4jQFGXWEXmxwjQijB8yXJk+veWfTYHEPX0hI1HJ4vTrcXr4bUjkcYJ4hfDMxQQ1IkcDFuQOPY5JeSz42TNfHo+0WbGNZjNFZVuuOuZyk1PObLHlpF3EsrHoOvqkgzT0ycvEIc+Z2QcvMgY6mUuEjm9ac46O6L+LdRIpgTb6ge+VIH7nblSuhauEUdeqkSyFMol4QyeVBD1VIqf8bZ3UTeOxgVLNCGmtf2mocTwcUj4Fk3lrMbfViXkgOUpZdXINarUEUbED/wVFy11OeYpLXoHkRB8DzQGuQAiqKIJGmkDHlbAsRx6mousTg28kwqX8LVlRMu9e2Wx+nuY/QGXh0ZDlvx0O/3o+f8kYnYUxENbJIHIBCOObBnS8nwfULsLc7dSvlTHNfxBD0oNXmoeOEHHIKx08P4uESCu5W9bT9DX2MRjZrSQb4jD2xx4e3Ly62gjLhRGoAmuGAccv2STLdjv2IngwseW9jNhgu3xLMPbzz8fpr5fMUYjAAOqg8puUwypOr+eQragi4ADjywCYhEZYjsYMkDMnzVmgFq6ygTpRBpmwQ6ubsLkH9xi9SgpAkS+pqKL6tFUzmSvURjTR3zABfl+m46ez59NM6FQ3zAKEGVQTpyM+AvdOtDu9RKO8uvkMNfMGntPcWllgtKfNXGNiYj3VCG/8daLOEHRUhWVnClrjRT0KassK60gx2cXrnSixH/W4ydR8oyLD3/kDpwALqdHRUfF1KCV+KLf9oVKqtWIknKsu+hMJhtjkKoWWW72trTC7naug0XJiePuiCtdODOeY5l4vV3cBL3nJpFj2LbMDGr+bPoAedRatQCAWoTH9KB2kjD6nqfA2sTK8wNX0r8IrO8UuP+RlLZs/rDb/3Wz6SfOL6ZN51q054MNOh0qLgMWKLA6zZj2WtpeEduSETw342Gg0OH1f6oKPTMJcIwrxn79Eh2jioivk0dXCphTkJPZfsjH9Q6UjBQ+2NKwwgdo5oaF6vVU+2AdI9xcyIpRpljpvGmkAhr7RsGce1v5ZXTrKZ5olzVwEPCHJAxpLxTIa3JznPq+QSShThsu27Vv8n+qnvGfoeZ0RJ6HgK5IhJu0Rr4oSpCjiTgQQFgk8gufw8qxt5Mq2kMTT+riOiUjSrue8vp33v2yf/+28fYaRN5Ot1tZmYZj+m6fa5OMZ77AIYn6TwYegKqmR1pBdtqrbkgGImRREA0EqEWUVo6JyCQBpMjqo7wCVuOxobL4p7+XeOgkZ5AuYFByKqFgK45Jve65gJR2KPvvEKlPev7jpFNaotC1ICuDOw98WoItMMQNYV5CxmkBuhzUnyhatck5DKlZr205FYJFSPWSMAmy6sn6Yrx4yQaFQXlhiD/Tny5E44zoMiYsvgYzI0rKkvNgGLs7oGzQs2i42GWX0LFE9u4Ctf5jNf5zm/zCb/mEykR+WvJ/O307Hf9bWJW+nvrLIHFsYI9RmO3uJMp0AJ5xEEnLCkzAmsvYzqhRo4UnYkhXCcgM6AyuL8rxEXqfCegppN9XnXI33QxenkKJqQ0Wgcc+6nowtvqaE8OvUKfqmb80Ta6B1VYlVSMDu+qLe4pmsqcmP6CxMUVEe3er5fTzr9G55ubMfRHxoKOEX0QXJDXoGzK6IdkXPzCM4sruQavAqE2HeQoW0ZkEKM/rHaGHsyVHukVyoHFGL6Wj72+H4y373q4e/dMXsmju77UI8AtWwEX2WSbGzbjcTsdEckotEw5Esq5rZzRBTNDe4H9aHxHDNB4saBxi0BDvjtgwDOpERWJGSdCGVQHA9Vws/N2oqSTxyEtXXUBLZfsfBMezEq6SsAemDxvGBJLC9qRRBQzutaj35NsVN1I9i9CNijBEIeATbXI46s5x+nYKV8Xwj8av72fIhK9jonPlOY94mQZOgng1y6sWtdC1Zh/3t0yGmptRFWx41KoKhkoVqxPWo4txel4bSlz/O5r8/X3x/trQzKAi/MYb/drz8K9bV4FwdSCe8cgzhnaHqRl8K3UQ/HEGq8z4liJD04VDusipiURie/0nuPWll2Xy/okw0uyLGGV423V9W7y4EMLGc2baMunqlkDIzhdfJT/qobtQDeeZReQRMWU7bTR7n1WEinpCtfJtQLPLouRkAt/SA0w2Ik7INdARPl7L0rfMJWJx+jgolJDmYKMSVQhtwShkxh/ZGQEc+p69quxVfBtKlXBJmLesXGwzt8/6Sc0bs36ywMZOCFBW7KI25XNs0L26yJoX2SC/RmJXTWQqfcQ4+KMagMOUlUrs/5P1+Y9jEKEC2cZb3Uyz27QA01LgGdZNa53VPMogrQ9wvd2PFMRS0x5NjAPWyY16Smjo5bZVMhOahHn/Suh5ITKBmQBHyF0P4v8Gx3KoChBDqn65tKMrHLWxKXz7aVD6Fy/Q/VNZENcXrGfqx5OOesk7zN51OclGdrIexaZe5wKxi0Jta2olsedzu9KqsoGNCzAcsjjJD7FHkzNfoODGgDAQl+nvg+u3s8uPF9/zBZA7E+Z7l/L9fzf71afe/LW9MPCWQYXncQ9KhDEollUI1BOyckF2a3UNqejnGKlidfQYM46WmW4YuQmhyDL+0gKUdLnBb/zI8queOb0hfOXsRUFOxhSkiTyIUmyk3pSu+Q6/IRtxgAJAKCi2gIoCeLVSFygHlGWLWkhjYkRxwQI5CWNYWpaXSIwnPbsfW/0muBBYdALEF+sadhisfQtqb6AWK2VATN9JwWuy3SOc3uPx95/PYxzB9Zm2j2a8HT2FakbFZ2ILF1qVRlkA2DuG1NPkUP6w0txX9TU4UhfTA9Us2/Y2CDHfqpQfuknJYQLC4nBF2LM0rzMyHCXGe5vQsQJRMjpVHJi0s824+aSTl0mxYH/mGAD5HgxkdpPcuZliqD7bFolMWi2lUauhLiD+RX1weQOFCVCTesI4gE2G5lsJ5Y1N9f458c4pikoZixtSSQtEfl8FMFI6wypcM2BhofjNfvrnkXXF3CarhFgHEi+d1DxLH47dMMVnQlmFlRp7BTZO5GWEWTuNZ2Kw9pDymgfAMuXnLlkAf3WUDlvVfBG1bu5nEjAdZzv/45vZ/3E//7WBnqPOXmPmVSFjJi4I8Dq9mb6uOgjWVCvk44pVdHGSeJokOxIvl53Xc0ABRNJvJAtGRIkvuyChhrSkDn8CBRWGwku525/Qoq0kAem/4FtpNUTJIcieVmu5N30mljGASnOiR2eIk7jmx/bopYcOOICSRJLYsihZ8JF16zxTxxfuBoq4ek8yjXmOtHquTdCnM0sZkn4yIqaLRrTjA7iGQAZZqe5QjYom7HfKJcrC/PNrc4SflmNTn3eXTcblbfZD53xPtPmEZ0PI32heytYSVjWtOMREMXGOp5g20zUY6aWBNW0wxcywsQqdHOaW84nJG72e7fVbJim7EaWt/z6RZQ4ZXSUTSxayoUcQtD2PgFRPLZc4JHcTMuIgehmV76KqUeXH4ajeZlIvVjah00Air6yUj35ZPX98qTu0mM/FFGqhReNo/vgESRuZWGJa+h2sGYOxldmuzpdni4WyRVWXPUiVxSUQynrVI/qN08kELw71K3BCz320zO8sknlgJoe+QhIvhxHtk8Ez2ZQMs/j7PBIoGYiYRJKoD/XYz/09v7/6HX7f/+/HySfAo292Clf62zjXt9x4QBsByaEmYU9kxqbiAsUu2fipFbN5MGXhaiJEUDWaTkTLb4GjNOrwqpYVxGZKHQzvTcQMgJy2J5nFLYojYgoyU4d2sv2SEngjrq1edGDGk/R+fpz8fpj/tjAgZdAmELHmg9wxAE138DHNAyJKB6Z3Ch+//usvqUT53lLc2LSOnU6aZ8YeIMTBiYn7+6gMMyiO80u9KROcnXJs8kVQ8pd7Cwcvb5k+zu/MyzwQIgqoMeMq3jmq5iGxOXS1HLopvyEWv0wvCUKDphtSVoHPYjdtmWxMZwlT2obm42jhdCRxfZ+AYFlHmZBdRwShCReAcVdyyKOGKa7XZjqLQF3lXmovNh8aiTEHhDRgKgo9fuZcBdQYAg0YJuOVqYCfvb16DiISQEDsGjJJwoIc9ITDohb0UCBwl2CI+Za/vqGYchA6/E20UU8O0IcPAum6irhR8rR3MCEciF1ULBmFkjdCW7yDE2jEvjNKg9pObRB2jCaG9J3GQH25m/3k1/4fj5S9zr8MN4pBSujV5i6xgoxzWxkkwtERe/sQQAWnYzwqCXsd9zhIjabBmYOtG2mvJmJ1bqvjChAEow/ty5xiBd8yJUMObWOraUKYCGQ2MYFDFl7/XnW2f09zym8O06duj/4KT7IEe1vw8G8naCcM2b9IDT5qDUNrDJj5RAUcWqwpzJQ3Ula4sWDAuFK9VYlXkIWtAQEDLJ1oR+efExXEFiqNbY+14n/wlhgw8dXehUUvpOsvUBSoAHDvIFc1AFZbHAOy7xACIr7ZDhhasUBerSvkzPXKsGrrBO0uC5aIJxXmVGj7QMsxlKZKo8BKPk+27lCZoHonQi2hZ0ZJ7XANFKNAhSFE14QG6S6OU38GuH1T4wZygH5jXyyVoGN6oF0C0Fa4pCgu1Ql94XTvJZbcDzQ3qSptV4sapTpaZ+EjLkBFr4rr69JpXvGTO3C6aOJyxFk9RR8v4N56Lv8qezsjTTIIVOrLOMDEb8PgYTYDZvmAE/2Z2+eN69o/b0z+fT7/mAehoN/MTR3JsIk40RKaFAihL+KyijU1UzbJk+mTwJNSVinCOkSSopFYadVTgikeGTZlKooSC0O/wiR+uMDnqbukEf+wngExrkIjWocppV6JiVsGm39y/fW1dYTwReJJ7i1otK+LV4eAhfamaPCXq0KXd+hv0RT8EHJAVCF8EVDw3Y0FPqBEMozamJCOoqgWyXOsxhJWVle6VQeYRzfaBHuLRBEjjGrKRoWQ+BZXTalBYE51IPAIz1Nq9KPcqqqTpSadbSKyHyMBEgcywyILz/CDMjX5pLWgzXpqjvpbC+/jxJBQZN4JDpakcveF1yI7v5d0YFqG7ln9qJ5vRbkHl6ByoqFTUseaRVgYdRThFUiLMjOaHPQGjsLohwu0oJZsAPBhkDIfqc38qK8KBsn6b+EGUMKIuaUIB2XY0MLhRyxW/dvvgOY9bewy8yDGT82VzJNs8Gnvk7o0x0GCuIVkl3aisUr3sD9yhebz7jw/r/+G0+JfnvGD0c2dlro/diTIhOdKRag9SR8WBiOtIZV5S6qxeRpJIXRyTSSRGJLanIZmCEUm5Kb/oiuGdhn0aGYdFcgl5ycxkgCN1wa+068uXZ/1eEhvF2MYdZHQ1LX94yfeR8ug8pMOX6EDjjbQavhRG1P1NB9/qmrYYgVB9qUJzbyon8c04VSfj6L3Rg1AUbusc2ziI3OtG4RKteGVeZFI9iThqvmggJYNK4UK781Wmso9Ow7j0hNjoaLmgZDUIgwAct8Jl7Ir2BLKxnYu9ebNamlnxNdilPh8ul4lrzw9Dr/HsbI24wR7YUVFq1iw4ii2DULo1lAirFKA4tpzgZrNRdtKiaG7KqRYTAipFo67BOZdwxPW2MYZ6ep4iLg+eRNcDAaxUzoYAY7ZjVGcRwaAEtpugEYYcI02fpGvG6G7aFvs8bvZ88aDz2Zz6S7aHGQja4DVpefYnyJtt2fHxtF57euI+m4mjIG949UQ4n4FOUTKDNjVysg9FSXa1kdzr/Wb6v7xd/N+kEPvpfz3bEY3iuh7dRYkR8W/1xB0xyBUeuqyJe5GYJr+PunRgnqlRZQASxKowftDs9hZkONk4jTbf610kp4cHT7yvXsUSwrimSZBkVHQG8JfLN5hbFrrJ+xfRIuNVkvo+2yfT6j/vAbBu5DapilZNG3t321udbIsaQGMeUOriePvG4bucjX6/aLRL694qw7TCIvLyVrjQIpo9H2aeY4EUqWjuleZwLecquOk6hvoh7jAcw1LQcjXt+CQlz5VoTy4HGz7v+ok+RWfDTW65VL3qUEqCP1QyoyBimvUUWf1qmLRtZMkjhLPGb4TI1I0Kjl4ATR0JBPsHJhacPH9AhVaULigpZkY29ZIlR/n5riRDuel/zCgpi/N8UJbWew8i0eae90oIC3n+h+SomdP86s+gFCcSIK6mPz5YlSGvIJdubBOh/ECrR1Vo/9fT+fF0fLT7sYpWjwjleQ7CovBF/tMoQ2QWLrqeeYMALS3aT6bQp3YpQPYL8mVCREY7qbEv3bBg5g830/84W9hhbL+d/VOe8Y8ECY5mI4+6RKFLDSUToFEdV95bySWoaXuuoa5ZPgIINAGkTjcS6GOHnhJUd4QktXLejm8k2JLbDmvifvoDjAobvVxdoBh+urPF9YLtP0jxGcYuHXTBRIhwYspZb8FaIFcEk3ADLRixn7FtPeA8AA3n9KLSKPPzZQ/aIkUDSl9rWqMXHhIYAIUBpVKMvJVDqg/BVufSjC/hjYFnLCP9XEy90hmR91tcAyF9xsD8Xkb18YEWLoMMmk1ZiDSvqydmQ5wGSfukqP0T+Dbvg6dIGfklogBTOKJ1KnXORSyuHuC6orEOVxSQYnQsXoUYh0+X5GUGiFJlDYFm6+8dS3GY0HKtzhgSwiLgV7QL3I/eF0lyB/YxuwEp0TGsy4gBH5sUCJOco0LHF2J4mEthrK2Qss+21xqcT19Pp+eMgIGZp0NMq9sSQIcYlrfZJMaoVhYy2/k+LcVv4n/036RjdgCP3vPC58yPhk1aKCLhlZ1z/Jn9w2L6Mjv/xeO/5+lT4pkuRTeHWiT/UQEvJRL6rOEjAwpjE/DdpV5O4goDKZoXrVAM6ejtt2slcm7RkZE+PofaSV3AhIzqEnpHJgfOr3EGHRqRwRuf6Yto31kp3/UOCR2+6+n9cfpD12LQZs8Bv6f6nmHIW3qvOOAJagUNxibz4QYwwvhpw38765zCZfpUPQwaniiwI4sOLSo6/CPu2Z46ZOQbyUZrHfsf8JygOcI0TOunxFRSqFqr0A8f7Ei2d3U8HeWpwcVOBjQaGC0eKU4aErwMCXfynJdSCrcXh+PCS+yyTzW3PVvmaXm7caXTOHQ4wDBd1wumJriI0SdI+UXjg0sEFyyTjOduekF1/aRKKT0Q6/eICLWeYhh5pjcbqumCf/kajYm6pZgWCj2dx9CsQi6kDTfjlJOytXLTNFDSqtJRLaTFLhHh0OE5CzSfDufPx/OXy/yLlSpZq2wkIDFNrmdloXx90wcFs0uGbbrHbpC6RdV+K3Ls9BbQBkpnokPahihl5WKT/EEl3zroPIS++LC4/HE6/nyZ/bN5TLqonczShJW8uUbEFnOu5EhBs1LA1fZ9wVTMBYahcOBiR1pJDIEyJQlHpOZEEyed6TlfikThjGDSewqaMNKwQ19Tx9h/H/al2V52/4d5doZ7Z0UTLWqfhjLT9Q/8gtdgA17z0J0VITUUpR040DR49hxuJt3edXWGzQESNxqm7C6BCq5h630zNUIoxorKuBpAqQIzQi16jmVqIh2y5YvJtyz0MzGc7YGu83yKIT4JJf/UIYVEUvyqmNEpjRtWlIvudPW2cxxU6857SzGRl6y65i2oeZdRJnufxfs8ECR/x2TjIUEMl7N1IwHTKbrkue/2Qj2OBnx0fXSE+X7frDSLKOm9sXgDV3kANUHD/yQtdd5xZfSFGrQDEZtJZIicawWvBhF9TzSID4yxU+9YgqL+YlWUrRoex9h03xSfjkcc5cLbT5L72PW4uy6bEfeOShsrnObSUOM8cZDKglaby6RbumhzK006pm5cyBxIGBBD8geHMroKU+hYkZBJAJObpsDcTIFwOn/Hbz8Rf7ecvbmcNpkBgdcirDPSzML9Xi5vGJx9PGIPEZ8vLsin9VDlP8PfAS0aYJ28nARN2lAMuuh6JrPG3om4QxgUjqM0elNVifazAeUSHZuZeQNK58VEgDd9YYw4YNgqXAhfg3rNaXpoCFJR8Iznk8awEIkNA9ZXtvUDJOuCY8ziADOoKo4sjqQ5hRgAS66dgECf2MZGR8I6agTACW6O4wt73np8GgzTsJCR8B1f2VzIgpXgGX4xEuYRA2AMUCROdomS8nHkXsQHpvKRI7dxTS3yvEwlL9smW7KI8CBqfzLADvGKvYYyH9AND5Y7o88crRuKAJkwLnl4RvOtldhtz1v7BPt4S6bXatNEnYphANHkcFsrlA55PdeS1rC+ZhBu5LTMScc8S3ii3IlkPQ8xJJp0yEWYR9sJwVgF/G0TItxY4WZB+G3H/gG0EpZRWo/p1R47iMpiYm1YmxBWu4QQ7tlj9bgzVzVf3UEVjhKhoDWGHKg+ftUA6m6NrliSdd93aOMnIsKlsDTUoMMFW415H+OtCcYgi1XiiMGbqBUuJs5qt9Lk7FVyrrfAAOwBQXtCq6OoHCZFWZ3J0SXihrdov56cXuwHfojqsyIKQ1zVmUopP8kocsUkS6DZjNymAKMUgKfZAIefVqKjHW1XEYMEAQJggVZGfJ3ykMAXKY1RUag2RCgQPWwc0IyAA5pPkG9KYvDUgCCFR4jCgoCGvFYpf3xdVYPWjk9wclYY1NAHL2GvvhjknAGQmY+L2Mf3RxFGeSco4EWKRyyKonAMaCuoMLENWKyjGyBvTFl5RNKTyDYThVAxXphfaWN0ICGrRLIb4rW4NFxL95A9xKz8VMLg6WE7vTyeHr9F6y0eXd0YVLUtXRYkuRInjTL6BqGOjelSgJNkCWIUCyOuWU1cpPM8yNVEj2/t9DQSq2goQfRYtqc6x88AbCM+e0MSRvfOtrD06j4veAUzaytMfuvvekBRkMoandifZ0xkLrHdOAK4NXuy+h9PjRsj1AXDPiGaA20ATBA1iq0fkIQ5u2pmNUQGmsJNhCgZfhf9qF1WttlwLHuiCDKxbO9FEVoS5THC+odIEEYcELZ6YOr5ZXra9R3pXQpRYYsToGZNJBdO+/HeWwYtZHgLDw/iAAS+9ZicLmhBwyRfEpKrrrCZ4furMyPahC21ZNAIEd58qCNloTmajIEB1Z0V6YWe7mcGYLaLPagbPkX7OQKmAoHiWCYQc/CNGaiIfdx/rAsOqggjpEqnFSHGakFKR7FaTQrhIjySS8Cp1hLL9rPn7sZmii7V9Ily+2rJuG/UMb4kABsZFaBCsWZ8ybqFlEVkyvCChv0teBhj522tQaHDNoSfGgmiAkNmx+IpozU4FatI4ySvf0d0T8dv387fvuGiEXSTijZ3zFOCWrWwgIqGr8EFr0JHtCS1Q2SuRlnd6u9I0GoDvVPGZCBAQtXNO7oeLYu/wwmCFGroKn56guLdbP6D9bxW5mTSMM6bOtK6Pkkng4h1xQ5pURaFDPsln7gCf4JMFNZjd16MZl+kvPlQlWwioo42zRMntBk90zP2KF72P7Xz1F0GKjpjmxnBkKJseioByTgslZv9YGGIPNaemIsbO5yZXzQvZUM0+bfreGD6kT16bkN24bFVa1N1Pq48yaBJOIaerNnUP5YL8T37bKQFppk8WmVBjughd6eOurZ8rQ/CkgZTcZaDvsBM9sKLD8XFaKwcsYg9sEPKk4zfWBCz0XCPLvL6T6LTPhsnpovCz/q5iiXwvDQwWQkd4yRKET2TZ2bzamPt0DYPLV/0iJnugUJAR9j4BVYtIXpfhYKT605dcdcJdc+dsiHG2m+sBYPVChEhY3zIAPzc8InkYt8upp+U60Y95zvj37qA+GnrRk/M6HzSh6wHytNimbfvGEgBML3CTof/dWMINlAPFoNFAvbIbLfbk3cL2CtezGbyVOKWwzWZyl6oBIyKU0imHjCKsoxPzmIGySOihu566+zKDo3pixqKFAoynUqSmVFkTFBMYaOc3jEqyHqv/buLdfmWvkUdRYqqdqYMPAK2ldoFPM9ruRKdM43Q3i0GhvhyVHZGANnixPNc5gJVzNbYwSBplhV0ujVZEioVoaKPi5Wdo0LUlZJQ538oiC+K+nPD8umfElvnpo+ebaXv5T1ZR4kULM7skmJUn6JYiuO72xuFtXNy0M09ph7PWKj1aE6Jkf6xf+k4ShEoE6YhmTlWcKRJijmv/rjlNF61YFCp5CNNjVZV/fyJa0uqwzwoJG3xGW1JtOSE75Fkey3Bp2P8+hiApT9DJuIYnGoDEQpB4Qs5gcDR8CgaisdKhyG01xPnUj4QFZiq7nHnSQsCOrRjdEuFG0kd/vYZ5wDkW80KsEFtfyoQzW0BDixogSGQJfBZHNrMOK9FsFdWlgt5Jj45RcZOKJ/cIwqaNKMCyKHNYHoE7usfomEWn1HVEb93/Bi83XfLFGhSn/h5NpooElxzIYK8gomjT1vhH7iA8ZXWLljZbbOumzz2IKql2wKII5jJ8pOpxcrUTN5vKMP+GnZd5mi6rhsSep7jm20E7P6SZrWV6slAIhwTmPzAYn4U3rkC98tFOsUZWBRivJxzSy8fBjZJJD6eNAZqeeyXxeXrdPk5WEc+4UiIizhyGnrS2MN89oczrObG8Wwd/nia876kQA/IPaseYk6dnR3nEROXBJ7WooFJEod64ZsTmLtT3nPYVBl6siOfqBk3zGcPZ+xSVYh7g5X8OXj6z9MbmC/3QFYr6t6UnY9/dNeDWY0khDm8p1p3bZdye0z5z3KhPjIPSMTbpt13klKkzSUyUTLCadzARU7fTIIykPGHgxqfv2lCeFYUgXC3iJaRLeiuLxMf6u5YS3Ut6jM43l6UVnEvwKpW4RhPM7I0tTLgJepn3/DnvlcvG5mZbaQIxbI6hiHVhRzhEe2PdriHtCivoSJuSwMqce9Sft23juHxCSTHZdG+AM7ot85f86RMDYeO2BPtQEJMIVNN4XMMSTqzWEgsvZTjZnO+Mb9p/ZUUvxO/GbXxxeJ0ovqV/IzUbmPhQonWMo3XTobAs82y7N/oIixCSNSK/USv/EzobcQ2rhdXhbRwWdqv02BVdFICM6baRHn2EDcMHKQp0+zyZXn+PLsYU6LKEI/u+1ScoBBgeEYDLIyZX94mcoVmXLHdPAekANGE6orXWdLaBH3Ys3DkZXQhnY5OQiuZ2Oeu7g5p1klnmCSWV/aNBLPaL4cRm9xSElSiig04oawJcvnphrGBneXQRhqLg2IWQn9hqLg67ySA3LIcphCVenogfM1b2Rrv0UEhKNO3tJIlJy1GkdpxjeOvxrIogddCOk+xeUXSC7xDKSTGoewoDiUGqerDfqihwgpAGurDoFuLkSmtJVINK8vOthhsCrvcqawj8ZZkeLuTjaIteTKwfdrHl7axbAQFCCl4y0FBY1m1t4KsyuoT0lahW8avV+rpQTLVTSRdCpO5+2hPaUgWjNNZd5coIr8ipUyHRQ+j+1QURiXVpVoGI5nlDbJ5t+p6cffON76a7xh93ii9aBtIyKEh1R7exBeucOrgCg1NIDGur+Mbv0uJoRnNhVvMNSE620NQf8lDIrOR/6THLFRCkT21+GXr/zOmtfIAIo2E4sjs04mykfL06XT+0/L887R4CAK6CrKqUlZkQlrQy/NfZtxpmMALkBL0JupY1QxGfK1xEp5VJ4HB2K/eI39ZcxRLY88DbHx/ate/6tFJS3SCq6m3CKlfiNCDdxxwT4PBsBl8i1SJiKcvG9H/NM+iDAk6ZiqXBKEjngxAf+LfDu1LyOJ0WChuYTrkMUvbZjEb/Tv9gUANbj5iMsuMYHyIMxINwjFI5YH1E/IMgLbUQaRkTtwLDimRk5o4qvwcVFWdGi5h3ybTUFvyMyEShQq3vCrOaYnrQ72Zkyu5qDtqwC/+N/NG65V/uM5XmkLhO6P9UYRwsl8WEQ0MWw1/myDKK53oy61dFPPwFx0/7Z4Mo+7CWs1DhUJq1mtETKikR9BRJx4ujwMyA2reoKgMpfRoW5P2UGG85M3N4na98NjD5sN5rkMPHD4MbODiNOyuDYQD7lwZEh9vnQ/UfYcTt1wHV/BEOY0hI1yXUFj/abV/ci96pmsL5FoE4et1U00MducNI/L2BDt6wcZOrznjZtHmKCQXzlA8aXCevdfr4IxDkkYqcBimTDYIcEn0kbbB7XA2xBwlG/i46asA1TfyCL30XUqsHCbjaETKVMaEAGupkoCZpEKI1MPqQyoWKlMsJhQ+8JK8cgMJkihA/Cyywa29DdblpyAGYPVQleG4lFXAdzhcs13fIHXMsAqtZcPRYzFBJ2o1/VhL4/V9MmWh7w6Bqp/IA1spUPBUpcsrhI4bgmCBXB9DedZ8xVkIQQULQE9kpm05RI/wKED9aBcHPUEOdE1GhVNMAfTQaIqi5CBS21H3YQCF5mdupSJxeTDDZnDZ6sWQH5B7BkBOBnryxIEW0qTykXfaIUWqTfdXFNQI/w0+6DOaGOMv94utRYmeEmFbGvAqCWsrPXFyWtlIIqvPoOiVrUZNWAM0xZo8OJ7OVFYb99lcDec5k/PN8nJ7c14bOeFyoKJ5+hnxwxwaiBrklwNaSwjOjXAO/n5Sc5ZoTEPmQ2OiW6EH/OgiODTYZTkJnU+0GN+FoR9P3Ol0Q/rOLj/7/dPzxfoJ713QOzJanK5R2MpbeLltE7P7heerLvHBVTtdcOhdpZBG22eIy8/WJkYPoUc/knOXxZBWkVvwDC5dITXGYKJKApN2mqvgaUZdqi3oStXkiNmUnPanulsVLt0KoyiMY5to6Rw0lAhf5VFGgMOf6JIsiAY7xyBBkKRbEqHxZqlavaqZsYEHS4OW07s8EJdz+SeljeKJHrUBaY+KjEpn+mWRNwPk5yaLL2IMdRHJmGEwsHQcH5adxqr3TsJmePc4fmKKn2kA3q6XQXAkY4ruVkxlqMWonkGSWhE5VPPdldTqmaHEnhF8j41z8WwvAcgabUlgBqzi819BFTu/XMnk/e389mG2vslComT/VsUaKtEtWizuv85vn706QudzkdeXcP/xmIKAmTDitS9ehsvHYGipJBB4ca1Ho/ZUnwz1M8MlykwSmtZAlCAKfv2Eaa+sC4NSKNQqw+WgIdfwpF06V3wSE/K3OlV6AiEDErAh8nTmaV7sYZYXhnjJp4End4zc33jYz7435go6bJRsL3MlBlHD9qfz9Mvs8pfFzHoHu7tSPVgDG1mkvYZNzXIreSqj/jgjtpFysc7Rd+AJ52EAPGUSCdqsHFBd0kNhKC5+jG/uVBPYhluKu5tGg3g021eLlC8xp9eH48h1UQXMAa1jmuM85ci9TfM7TgAMViUkumTos190gmZOjVq/IbDUy6pVGZRBT+ZkmoKBPTdJu7U6g6F6Slic5UA4ptEHCFqRRDDO5fyuKtdDpNvhMtVzsThl1IwGK1/tdC0ff6roudif6RXVJNIHKgS3okjIdoyI0hHkkTdS3vBo7BVltFJGp0uXyETKUIWeU+C7NYfc/+Z2trm3a6bhHYzJPy35dbe8//n+h9P5fmdFQexTkmCzwE1eGJt1wPqxsTb61p6qtDeG6Rz2zr1i3MC9jCTpwIL/xSPcBN9IxVClyljpiPlVoggOhkEjjGK+hBS/UNblajhSHg4XEHJaoZcV0H56plCpdGUy8JBROMnDi5YG7Wbrw/7RS9vhUp1QtQHJdIie85Kf+2wT2Wn2Bmur3ElI0m0abYAMDGcQjdEKtg7dxb/4laAfovxBaDApR6hLmnEYmLccq5PqJHUpsTy3ZlgbyPGAWBSZhWhaTtbU0RgRXR/SBypNOHacPuSAX4BXlir5qkXhM+1RJh2XgOViaP8Tek35cO0SG3uMVldNKQwVFbSpOHOCm8xajHrr5S/LhL5BI1BgxtlCEfYQChalJJateRcHPXEBQTcKjXJJmCd6FG6fiZKlSQUUqgkO1B3Di9YKf0szmIweWjgIAGee2cTOdBpj47a0aAuEQ9Z4Ne1UoR1JpcGwZKvzTasN35+e7FV/g2zo1+T65qf/cHf/fmf3Sq0cLAk6bm1CGn8wF14sODWtKrlKbxbwUNaHaYMNRDDNMH9CycacbsM61SeAkFnnARNl+79S13a045WiCiDEDm1wxwnYrRIWFVd/WSY4wQCfaXl/KCDU+CnJSSQhHEPB6StDbn7DkuMFMvtVBxF4VV85UBOAphDPWYihNxPJxn9HuKCKKnnTtcHQb93lQbsJEI1vBOQ0OJa6SKE4qx1lGIobPPN1JXKs5kS/qWMJ0UzgdSzD0TmaUl7Jhg5m4JyKR0PaooYUcvj+IRmIfb+ItXBTOJyp68m8oftIau6EvXpI8hnbTXNaggB1h7Zh2bQCDdZeYxYQ9VXesNhhz1oBVtJWNxkkcqX3YKM9MStTNmFfimoPT/kMJ3DCWWiJRPlZc89R+eS7aTvH/Ao2Pn6G2k58sELAgdKKyMWu+H5gXiwUy0i5fFuz6oWHbkS7XZASL/IypfVlscm8fm9DDhlxSKRp2mCzuNusbt+zJF0Fg57pTx9OT4/PvxxOXy4LqYK9FrTSDVcaWDJ7Cxc0ZQ9+Y51ZGplnF7Owkf/DPmwpGm3r7wQW0vysftUKXrkBXriW8qk4TuE5CvdK9IAaKRAYKYY/ANIYfT6zZmavzQNnCnhvxUqcejows7wlMksE8TpmE/qlSVZKvs1DgmmKnj2FKdlcpdvqYLMptQwu312mD10XQDaYmy5jaCiNRXJgAiufoFSvTEMivlGgtuFWVL/Xo2dDSV4LBGodnwtqRRNK3bArRCRWQLDsRQEIPlEqjbqOD8yA9b+qUNipjOvqMmXGM7DpRVPCf9ViNf7HPP8e0mg5KsD0iabBhwJ3QoC+qe1KPlKNGECpDfOKTW7VpTFuuMIvHrMWnZqVXwyLRwQ3mXLsTAEQID3iDpoDpjIunrlFtJnhI5DqvXCsAGHuzsn4+Wk98hdTRZnfxdWwoqhnyY7kZzNbvYlvnidVjwHUhRUNBikCWOHn9TaWHpgsjeIa8Tien+2BsH6wODTzAelew0K88b6sYCwnjjgMcWeA2GzuPCNoiDIgWMiULeoUavLBhnEePqhebiqSgFV6UYTjMHNR6RhPKzjm2zLuoFBuoMqQxLjOvTmJtlWBmCLGa6jdJZNh1j8fDbV4aOYaMjJVOLNBgam3t9Px4ZLFoZhm1FWsI34U0qo7/R6PXURYM28XNSacWXHODvIVU5gMt7q/XIAz3Oq56UDwRCwqlIm8rgodgZYEhfOtYqidgg0UisaE/s7Jplx5ONioGMc8+OkKLcoP9OIe/1sb+w5Wu6k10KjPdUsTcPvWJkz9v7HNaP1ypNNoYNiUdzBqRJpUQhVoqxerUNtVLEC5j4OTiKRyVYrw9Io82YCVGKR53MzdkuoKbLBVB9ytIIPgNjBsAHfCtQJPw40+T4NltQFKis7sgmLcME9IWUi4eLEWksdqhoAIcy+duLDV49z7lN5weNdYlK4rZNIyf5+8xWigLN6+aF0TFgrnuG9AxgPNkgZL7+B/OtpZMb1hLlY12g+gDwjx/ageEmqEyXBEMUescBcv1dQZvWl2aEx7EK6QX7xJ2QJIPv2Zwi0ZDvtWjfDZT4U5s1zUim98fxUuAuSzrWQOFb5imhm1XVzbjqHbZzSvE7J3krldgYsU0rs3Ee6fLbszKUYKOgyEKO35/TT7EG5eTG2gTL8h+0XrJmoHH4uAY5S1UXoYYfQBCUX7SuxAG6rfVf87aegKpKCbY6iqPjCzsKBXcE+LOBnptADV6rmfnOnVBoByfSxTrU6GveW/Y/AFBKpjtXb1ymvLrF+iUcli+/xxIl4DwgdHOsMA8FFbVWbNBSk2UWg9huf5UuIorSPZxAVlmdG+z7OlWumEn/pRi8o7NLc8hmbGBxP9JLxBsDKNPuSN7kzFmSaUaBcLuk4e1nk/yoKILRvfGsAoRFp5Wds08K19dcwU4kgbTYpZxkGCZnSAPcaQb18hkUiZHZrn28PyaXt52fGIGzuI25xnowtDJDIExSkMSoeEAwoRhdwUI9hCpYSkB1Zi4TxsgBjCLmV8rA+3FoBHTNqeAWacAQuLhk4oxpaiNLhXzchJvylYHUpRCGgu7XaIJz38LPr220IRvSPrc7a2BYOMPoqtyW4MmHrBiUpiBVSTKRUjbyWZPc5mHz0EeMweWlsb7U7H9I/bT7u/XHx/w5+qMhpVI27ab6m9Tj/cQqlohi3ahxV/rIyCLazJiA8HQn8aDRK5kJLE7eicrmOx68NXIk31wTTlU1FhF/vVULxM2ggT6B4gmueFqXVEX+kQnzKi5VNPQFAskNuoDJAbci5HoI1+cqw+fkKYXFQPnoIjTOL8ehvxxbcyIIaS4kiJ9WAAynx+OHHNF1/rvQrMDaxUspPSmGjsSRthH1A0nl2mdmaw0eGnbyVNLZKtitqqSNnlJB11gyA1z4obiQ3HfJvVxWVlFcsNP6K/mhmow6keK27YmKZRIIvtDvNvO2+iXxgfVT7L2cwdpNeRzhOqDZbRy/Cii8UjXT9bgFSAzpW2EEGWgzH7ctPP4IDdZuNxln53FpPr9RNS6sXTkyWg1R5/oRdMe9Ru+POqJc6xh4RCHOPnJjpQpvNrR2DvjKAGPEKeZtnP9W22XrhgDPn29nEl00vfCSVpjX2XCuL/9XD5KnhY1zEt/uNsLlnKImjBI9lldFpSGm+qfMcnoAT5DkBlnBRKvuEPzJvYjD6xc1UGuwjBeYn0p5SWLvCDBi7EOGM8YVetfQAMe31rA7iatSTlMFBwUB5Fgz8MoFEuWoRFYbhbnTjTtMJAse0hK6DUCnlu1QaCPAhdoax6eAS+Alk54yYMUOhIxj3PFYpZ1OGYRKg5GaCKayDFrlWvUdKNhEsqaByjcIYL8azdzeJiVilYtUdh5X7aDoVWDZzFa3YGcH15eYn0tBQTyUuc8sBH3L+pmYTIfhDbc8V4Cg5aVkuEeRoMAp60Oh2zhN6Dxk+nRXcdjIAhEFPsKGEGCkq7iaH4jBKFr1Ej58k9rnwEOdgWI8Wi/ZVouFxM1QDWOUmgJrMrPR9cikG2GIca9aoyDSrCzUoLqIi8YyCEHSbX52XM1gJUDV7OjwfbqdvTbeM1mfozsjNp0enl9Pxy/LJafF6vfjQ3dMkTAnlUwHTpRY/I0Of0bXv6f50u327m//fF4h+NrmYD/Qy6Zp3Psa+sy9/oU9wW/I0Bw6tKnLFUuKKuWGFOlKHOVeHYvG73WJdfkqLZCBn8LJDBZCSNW6HtOwfqI8LGshSqSaexq9oVRmFcOFRBuFjZaZQUct1AZzPGWG91AzKwBUEXjvJGg+QUDLuPxiNKf0YTTjBZsQtRQSulHB0gNHByXlQIG18CKNrYgFCE2EAJqWiLpTFdm8NIImEPyI3nj7J74/l+PX/w8l/dWDpZtyHFt25WWm55juG8WlmT+HYfswVUGFAmza1BmN9njXH8ItqSG4V65bXiLKxyYvrXLSRkNVjZl+wpwHFXWhzM3fY7DgmAuvMokSev4cx48F0TpQofM/TYWoFZj0g7lRnA3fINpLQZgEDGtbRwstUqvTtEGJAtj0+KhV6YqQ45o8DNl8Z4QArjXm8xgMwSquBjlezCoJC5jIvHWPOKhEwGWC1iqcTFm2d/Wdmkf/PDzF6fVlGcLRSB+81p+nBZvCzmHw/Tf318+dP+8peHu//navGPXaptfiNzhFlwkpRV2jMGXiAJMfqRIT4XG9mCUml0F3NkSpIC6EUrTLVCpbNgQl/8cVUIh1UPV8sKJz5hV2mnVwM4PsSb9OgEH7AOBEIJ48ancPAuzFdyRAl87KPqCsfdKO8zWNdXAMZNV2c0Cqt8m6BKZPIEApOD4TUCtPJgPSBIDSjttSU/E7+EG6KqCN2KJIds/B0U8qOa7EKL2/nRe1B/2Fze6YMvT/rg3HsR1Y2beQbc+jAWISEVgoUdcZ0lyE/WGRLPnA42UI/bZXdvJYOyODIISunM0U8/McufTgjUJILUSFWCvIdnM+LUvPalqSRUiRZ4FBMMzlk3zWixTzVV6HoUFPPJoHpM3q5jsea4Q0wUOtLMK/mqqJtWMLrCC68rYM1ElgMsLimJh2TctiRlzEyPIqFy4F2rJ7nwvJIeyJDe1q5Y6xsb5NhC3WY5CnofqhXuXkq+fTp9nG3znpY3N2b9fj87vb9kl1xBnA/63Wz+uLj8upz908vz/3Q4fHxz+/9Ybf6Lx8znZ2tI3p8v3/Yzz+9+xZDhCBBnuzkJU0J3sL2qgeuYWbUM62BYNWIDIpSP52nQxRh8olBVYiTj5LCBXrvyDSik+SIzY27DBmoG49bgmyYi5WR+KTY8d1whdqFvldUQBhCTotMQF91qYW4eAtAgCxglCLeHAx/WiyIhgkwzoqIN+MXnxaLSHnlEA0NIKgOjDDL4DArnhsP4jrpu+bpEZ2EpXXlYzG119MFj70lOwg2byxqCzBxUBipcyoNRWIc/mXgy3ek6VRBb80aZdIBk/AFVT0PDXhFCuMaCorogQIfTCzdLS0AOl5/3FXj2fPrkBSFP58/xaeFRFnhBCIVoroJGPA0ILvvEDZd9kZw8kKlVs9lJ3CQNbgFlNHotiZtj/UmZGakDRBhlLPhhUQsPJqsJE2j4XmXvdm2j9RTNLYJAVECR/dLbANbHhSWAYuTpRQfhfFwdnz37bLJj++38p8PTN6/Welj8x/XiP02Xd9PJozmC1s10+sPs/Nvs/Omy+LfH7f9bgHzn0YbZf2YDm/kH2RKDNE5wmn3NdGF4GikYyejul2hhbWFqkKo2owxWQwtLgpSJsHAmUmADMo0SnipOyt4ogZ+FE1j9fLfz8IHiDQ60JeJKXfBdrE67wnMrppYi2uKPnGk9HK4JuRhzKihylPwIbobXsRFFPBcdi4ZLhCCguspv4aelKOWrVAYlgBYDBEAkNLcYjUsy0P4QvCMhEAqNS7OE62F++bA6/yAFkokG1+FZdG5VhV8mKa1iLyFlWcb4PacWpw6O1hJJJP1d8A3RBKyqS8huggOlwOqn0kktOoxfUVZB2fton6fP2+njdvptNz1vZ7p6492T2a+m0MKBqjJIMSCAWj1/Sk6A+tbOQI/vH56jtEOSYFxP07T/aO/45Jq4QXmxJaYy4ADT64jCfdcJwLnqANA2ShMf6qTH2A9iej5QcEpS8kC37Ka+Ppo0pKB2E7vTlbfq4+mw3+/2H4+Px5fL57c3Xzer/962uOfj7ezEF35YTf+4P3ycnx9Xs4/n05/2h/82X36YezWvmdGzdxw9HI/zx9k/7+d/Nmwgm0SUtfIVBh0ir4EGLqEuiFXD6J9vDLjqSEY0eCOMtLw69Cp+t+oRtpQJ/hZECoUtoTlgnQ8tIkEfYN2RsjuCn7bqEYbsXEw9zKzG47amExleVQWfCYjDggOXzwYyxa6GE2wX3OiYpN2I6Tvt1YaiPWn6amGKxjAQEClHJAnc2ZPymiwqjVPxDQVKnJZIvJ1fHjZnsy0eQbcwPYvJrN8KA0fjpTk1AAfbPSQAT8WTyTjRhMSA2KBI9TN6pWopMX9Trx09wJpBMDSwPrgFZrrgezvAbKfPn8+/7udcWkb6lPCpbLK2uJEqHCzkpPs8X8XQS2EEAxssTs0BXKNdsXhtUbutBXuNmmrINPOQcZK62EBcWuUHBmhAISRawgYcK7+BxrgbPdAaPF+1p3WClBM2cM8Les+ugWNCPS93Fk0d1tvn51/28y/7/cvh5fPL4ev+7vPbhy9v7T0y+3nKekkLxn93c/N/nR226fjbdPj41/Xs03IpMrz3eur14v7d6sb+i3aru8x/zVqMpAf7VcYQv9mBEYGlawzvMmDUQf5NOYb8QcIQTQh0HcL8BVAoquzAJHUcyC0Xez06Vqk50ZY8GI2Ax4tbZR2yU8Vn8MdJmitzwKHlClsJxzzgw2aiKsAL7HGy+WGXFNmRUURXsptkCUlkIJo8E+xphoFN+Q4tn+phlFtj1FrEv8pDSefNpSgviPFzpCgRyYBdHrSR2stnrL0MvVlKSVQmei9PGDrzflWPcBuX7eNRJw8xZWgVcHoR7lTthhFLXkVV7h9VQSm2wgfrOscm1UgD/foBT5hHb0xse0PJzriHTWnmT2yJPKwsHbGvXAxDB1PLwUCvskYkJcdN2hk/7SgVKfzyNTjQDC4EH5MIVR5hF9Wvuwpb8LpZYlx7SEvVEAUgx4OuPvpEYMQGI9/g/8p/mj3SVgwBynX/Q2mYFM2QCeQawaGXTS7tD3dvS7bF9vDXpGqX89ftx0Ts29vbFf8vJnMl9hb9/Xz+aAPP2fQp21CYBJh9Fauny5sMUZxX9pImmqfT9mS7Lm9wuvaLkuIPDONHQoX+GBIgTfncKolXnXGOG/E2XAPcav+YptzAP0dVUVSwYWMJjJ1URwkRR/AcsSNUpqlyVSQJp175ib16KbGWajkanSg8jCp6gucNqlfuVdxpRbhmnFAFMMZaLgf112+5XkyHAFomeq8yDPSGfWsV/C6E4MGQjPHsN3nG1/MZMgGdzqxwT1o5f7zMv/ZpUSvUdlnPGK/ssZWn5dKLMKps+lFZGg0glYW3igMxiGpCu9LxzNHAocOsaYhraZ+GUaWP7joDyNZ8QQ8zhEseBRaYQqswe5hNTskhRXIr9Da4hyOlG8sUgFkkJMpVHophgnraVVDTyjv6+MlH4mY0vtKlKAO4ywTpy0F45O9tE9m7GjbZx31UIaDnOzSe6wrtEEBgMUwjlUUwKYYwURF6jvpWN8u7t16udPby5tmex5uOT6vjX7Lse7rz+heLnNQ3oLxYvDXXvljsTpdfT5e/Lua/y9sQrYDNC/d+uF/88Tj9ZlipEQCH6SWs8CHIVEHTH6gextTNjboLhzIk3HtVGPiyVQEcBEgC4gQtPpGvP696DBrgAepWoQGSdoeCjXjiZ79w0IjCYMKZL5CNR1gF6+QKqQqjirwfM2IMVZXBVdd5K+ahdB6IoT3Bu/hp4G+fXgw2Bo/ifRPRQkkXakbVWDkxrJOrYLRnCyicpfd8vlaxHGWqfNlePk3zr4IOVEzaZuOTwEmfks0yAMvfKWv2WrA0QwjBowQEXIAoMOEdBHT2xxcmhm6GPTAJt5DXES7YMqG0XOXgYrXgN+pcxGD+DO9ci97UPSjpZ2TQo+sBUoaq4iSqPETXn7jcIhXnqw1EPzpgAlano5qwNnPV3PBM0h7Pd7/NIHTfkKnda6tXs0FmOmr0rDKDXuTd5twaiME2RlikXXR3BL2Dcf/V/ZvzSpfXhqEhYc9hXz4eT//bab29m787X6w1fJnZ0+W8Pp4fvVboePnrcv5Nl7i7buH/3fLy43r28+7022XFCJMz1AJBY+fkAqV8GvrwITHZz/LT33EXnmERBDrcDkMxR13QyD2MHOUBKZkpn+LXo5+U52WwvYXjU8pnbEnTxMEqOkZM8aotKYAb1G9wiTJkYYH9Jtoxo3i6whmjV3A4pnLV4cQA4i/K66uzGVCKExSj7qSisp0WHF3x7dKa4WUNJ4U4qzRv1veryyZjPIXpvUK7y9eX45+/7f9k3475ijzMd/GF0DAY1Gem8mwv/RKxkRViigwQVAFUoFyBBuIVGkqf+CN722W3RyMVkm+hNvKo1oIvu6CO8d+2ZCohmoR2BNPr38GGoeBXoiGW+tZUFOCwKW54mtIABJv4ckenmnO9VYjEJRVHOLUuV6O3dV3jilrxWDKfjE/TfphGlp3Miqv77qiwNy5m4FyEldWOjzpO/IwO9SKKyMXD49mEMOsXsm2FkQMPV+hZz48Ha1+fFqd/OWw/n5Y/eexsqczCfILJAwCeLtOfj+d/m2ffLi5ezrlent/frv54mhk5EGktfknwbOuojkfrBBm2pA/jVzEUkCu08CSFy0MsGZxM6IazL1+J1agbPK9Mwwi1BlEtSRakMCgN13tXMdCG6mtFbMFS3k0egQMedrnvBkSJY2rSHL6VDdD7bmWrGCWPl6RgWneC54BrS36M+z5BJc3FU4Y9GlZ0+P5utUbbsi2jku3ZDKLhYSxWJ1Jwv1/N7kd1V83PcDM6o4/nXx+nj1jr4U09TUmCZ63SnEks2q87nuQnCzkrdlPE6XvUYYwmopdKQ6kxJ15EyfiTGKctmWKNjdGhB23GOq2dKI+oXTBE1zAPDaNr8BcOkUYyQmEhPCA5WUyPKiYoDQPoLUAyZl9baL1UDxPBKXBkRDNs8rrK234+MCFAD1b45UH4MrZPCdO+uHBrnLswlgOqkBKUS2Yw6UBtMCn+IxC5GxyGnKoNENBr1OEhZr06a+CMH5SEzItni5l0dy/7w+mvu+Onu5vNrZ2IPA7Br4cpNmgRlv80eXelIThZknxgdre+/Hwz+70VRM02mQHm+GhaJRxQjN+V22CFiz4wCublqrspOXjYi9hIHeO/MBs58OS/Kt8hVrcGkIjPeUsGSD0RsNHpV3ejZJSrQszF5hG2MKLcW4ZR6QxzApY3wVUy0vRASZVQAzEcK6p58ipElrlxY1UtIFKUAcCp2Hua1naDrCqkFkRECsVsXyWHicIRPzPN9jYIxb7t+fPT5eN28c0SLqtx4RDND+/76He3tkFOHOdCZhnW0Ix+iTYsK0fSYphXZW3SFYfdIBB+0VFIOylVSjk1WIESNhJ7KFFxYBouzWFo6gVgoLau365gLp2LwvnZ77ieo1sdbRgqSKikGObCk0dAMeUTXvhIif56+olP4vMWF4OVW13/0CI75ANwN9teYWZitFFzi7o6dj4wkXXo3tGbDGvgakdIo1jFE8JFv4GrabFagAcfVJMIBkY2tINwwk+jPo9eLds88wYStiDWT1BA65f5x2n262X+3lIr0y82BSjyvztmV3GvaYlZdiCBi4k1ttMIGYmDNkJ7leHqAq5yCHuvitslCfHcrZj41vM4VpAr8WTLKiCwteJ68L9q9l1SbkUidU/4AJrzSApP6s6NTODbwNCt8Rm8cjHoDYBtCJcGZHUvXp4mQARdzVdX4jsLFysVjRbKgiSUHG03zVOYmFMGN5fnvLNdGQkS98BNe+TUaz6Ps93L/PPL+ct+/mTPEwqSJc+ni03W7Myk4ei7bkPejRVf28RdcxhDn6CbjL85D8JoDV7jmuthuROY8Ny1FpAwAl8wNAgrb1W9/gQe00g0V/Ux4moAmOY8ZfPfSco4aYGwdVxx1CiwvY7e4DC4nJpX+cGBXFmCkhjFCz3weQLdlOc8Pbxza5tbO/Ckx8JfZ+tz3jq7xA3f781rDQX0gKnno8s45v6gXS+IDicDzxh/0XNE71B9lEaZlIG6AjCJuXr6Mw/TeO/CcWG/gNnL8fh0u/FSHiPOFJE0cOmb/Uguc+kQxBKHdVRWl9/PZ589ZNzd9FE3/Ej0uN1ZOb0PK4WDRvMBrX/1HK6mW0bxiUlXykMZCy5BeFCq54Z1yWarjoMoXoZ1jY9a0UlH95pxcU8Z+QE5Kd61lxUbqHko6QMmVK76rDrFLhzF3CLKAHNxKLzydiERAXy0Gwp9+blciKaleMdVuP/9U1YNYLRrYVWKZFmOPh9dNPFkC79nib0dML3f4uX4bJ/788pu9x5E8VRKerUWu2XxSpjUhx+RIWyjGp6RMdARHoDMqTs5ptcB415nAAqMc8hdYxHtVLG3/B2SiCqrUv5Gq9qAv1zLYG+qvApA1VAaDEp+6Aoa2ormuV6eUi0fuLvj4jC5oNpskpZoCH/9pAE2v/9p6QmUi+FCDpcXNxLjHXXb7PMMuJdTxLwd6YEZNFNObGdYGl7IMZwHWsM6xNACkTgNrVTFoaFFtkQdZTU+KgZrR/QyQkK2CQyNOmzP355fnmZWZRm6N2luFyWX+S0vf32cDIZaZ9E1KTwSJtjkeT39YT991L9qzKejg295XKFNBNUaZ1qEVdoPA3GG/mSct64HCmwATGhH7PFIiaV6F8wgydVgL8aGrfmGP0D1Z+RVExLkreznmp2AFl/W4eAh0OBwbT8nRABh/Mx5uVTUAio89G0ruQgHy0oYpbIReYMdAuo/Uj8cR7P3VKUbkEevG+89TJFHSXg7Sbx9i9LNrxkcD2dCzfvS9gYcBFRROCvgspctJ5Furl098CKP80pUiSsI+V2GDiPGUNFGn9v2QJoGECa5VdujeU7D6PwJQTHaQX8UNld8lBeUcBnXySD20DHQNFTVv5oHZrniG/RyEuipH5E4zddJkpk4syv3XWy0dDt6r0ALkzG0v0zTn73004p9z+Kny5vlaTBIO7a0ZcOZoQluT3TCm5MxtVZGs4NJf8YsexKfWnqDsG+dvRMqmFpswAlBjJwEKwSfkY4CZcewy+bu+embhwOiCypYPzHtb+/MDpgc3NhYjAFTR745BpypANUtOfppMf3nb8l7Oc5HmqSVwQ4GVuagPSQBCULPy7aEa9viKoyf8da1YWyvloVvFEB252OtHkKoH8BOVIHg0Gl2Ej8iDzT3R/vF1eY8ZBsxqUAWDoUDAcBJAQSRLd3idgD8DKpURXbaWZeMjrRKzAwQyA8DuPr1PCmYMGoARIhJTYyur8V3zbSdwYnqmX3OcHMbXRQERAXrtLZ7W+B3i3LcdIZFcf5pyxBQvIZxOJaWKBD2IToElEF+uQKzlo+mkkziu8r+18P566NuvsXWiQwKEESqG1bWZq5QtOCKFtNya6Go2ZQqynOfuaXhV/hBt4SDELE5r2tALAEQofEc3HeiaR9AUsyXM+4juV/OeRHQw9HDihGYmUF3uVwsUiOJwZBEcV5Dz4vRAaF8oa2YNGqlwzp44W5RosYRc/U1jHIObdCKEs9FfNoYIscQq8kX57cfvJJst/sqM/SmW6MEGYiee35sKC6c+XU2AA2CoHwixLtp+uNttJM+/bXoKZy7gAfBND1QCweK1biSc9KEImpLkSvclla0GvEhv/EB2oi6GnMlOPABXw5i0OSdDknfH3zXqBjfMSAUA3iG/7BiVM1C+YIRNmUlGSDCsfInTC/mEXGlrG7wdHnp3WnKvZKEOHMn1IXLF25QqxQNSDVggm+VKyDrxLJ3fXUuO3lj6vy0zSO3Z0kSmJ5IUTDPplrpliBgHJTwM/QDAa+vwKbcC94DpOIwi06Tirt5QXu0J/mPshSxqhApcXWhIPLwHeYO1YQIZWo23poSY4A4Fe+Di1oBDkD/UwVpYNKbtJEmHFzHkTHdholkeeRiuSuao7wRExUR26CcZ5nVapKQ2ILvuL+aHmfTl01GhLwrwHMJEEWaXibShT4mlK36z3mG9Z2xo+3019P0uQIjsyBTUP76gBmWQqDAh0vC2Pi8FoCBkhVJCajxYDIvhjWzB4/Rvzl/9M5VL2Xkgrq4R/Yp7vI+HUJhAFY6xg+WP9yBdaAfcI/C2Xj6lP6ADjGBYDUYQ2ruBkO61RPIIHRoPzm7p4AKpvMV8FG9Ag+B9CNw6vKjpqE4VZy4rDodAIMG0oSMB5RATIzultRhilpXneW0dnmiyut4nYsp63+AVjR0qkCG8WQU6Gp2QyE6SKFlPm+4xtBGMNaVeFx8T8Q1gzhVgLlEs1/etxMPlA8Obr2exQA3pwe17j2QJwEwsueWMKpIKY1Gw4pc/WIDI2UsH/FFi/hIw2IJmEJ/0lxZVv1ADvBXH0zG5VRY7yJCZCy1KPBRHsODC2TDjHKjwJ3FXzYyuIO5gVkfM/CFMubmS8vLwVTna5tNSUkxyjFMUdEt/4sYfd156adNKYpOAEsDo3FwUDYDArY4vj1nsfc72gbCLiQaFNIQOL6AjdaH8JxTVgYpw5Q+QTVKNtKMgXxoDe2uxztSsjIBwuu3t+8Xq+PXl9+O+2d+gyVZlGIXGMtGpumbrXXmTRsGm7G9i8ZNcQ422oT57pKtakdfpQJMQ8RylQxMSrumIRY+kJodPztCDQ1ahOx8qspR6xHuWg8QFpjEUF04hEs5wQqYkqG7KAKBMRRGzrWZMv0qZoxeFH3pEAJ/J18lmiylGTYDrJ5qPYhqRTYws0lUTArUuoZYcF0CobpIOWinsyio8X7bRhnuFjIGAFXd1jOmBL6KGW7rm63NUWFEElK0goUv/kEZ8ypjFOoaWtkT00eMtdHKl7jAIWxi2Ew3eU90toK6NtjwE10szqwUCqSV1pNpJO9PRbd7dDEKCnI1ccQZTeeur3Y7dskfY4piwbmMzrkmejGsL3A3g5scN4WyJIbkBmLxhXB2vciQk4kwgfvWG1xq6rlO68Fij2bDRzPWKJgIz151eTbXlBY48ZoAFQF+RmaSsphGLu06s64E7RpAJh8CKxRBL2ioyB/5gd/DPAZRN8vb2f37p4U3XuyMxoLlxbQvM3OuJpK+TNOX5fSDvBylKrYK0dmNN3Ggr6r+6N1EHcMxccECjZ3IvrACkpoLC4fbKvLBpCn+E9SgMdhSNg6sCAuXyC6EOKEjRZin9xODCA4amMFBYw7yAAnstnVV2mGBVXrTXtzHc62FWPHfWEIsrQZAcLRU5wS7tAhedccqnqwRCfSoGCy1UQWNGHxKW1g7apj/CLslPamSnJphVEsCAf1RUMq+mL3sL3IOOlJ2BC5cnLcf4Bd44u/gnbYG7wKz0CKAaufqHiNmK5O+u8SvsHVgiIYCGcaQitCiBLXn/GxaHzD+a6wdNbZBlXFn6D0E82xAiIgR+nAkUSA4jJKtmyokp2Svxwm1dTzglSlBHCGsCiH0GwZZT+9uph88rtGp3wgSjYGWv6G3eAuNhCpVvp8LBbMPVuBkODJf0AKvFf2VaNHYGECTUEf+Elk6P9EbrIUENFx07q6JBZ4Kae38DX4S/nqzubMrClSMS2hmPR3XGcH7PE0f59PP9KZxI9oMSfC7KB1iakgWDGXSM2MeRueeugkAxb2ageZJHjLDL0Cuzjt45d0ZQWxT9iYuFTJojA036AW9p+jMKV2aFgsO0MSN+M9UBySJkDHQ2gA4riug4ggUwcRPJYeWE2LLqOITOVJD3/xIXd/CKgZBCvYK0WMYIYMllIMRFqT9VEZtKuDEBwAuXq4ZSKmSPV2jDoqtk/EQozTCDYoGF07MGxIl1FyUpKKaF2qZDWMIXvmQVp7fpqbAi8JSQCVJVBoKVejBh2X2YhCBG7TTTL54FKYDMoJDCQlF1ZgcS+ZwDGmr1KQzUDNI9gUlF8FXEvfJqQMDYQ7GlY8DDVGeP86RcWJFK6JF+bddLXxr055oZLZ8LBv9qKlEDBLDTI34LTnyiDr9EBW1qCS2RQilEUo8jjExYjbKRC7ScbdIBD6h3M/XEIflyRnguc5LcDGe5+P2KEEyOrtDumhjIOAjKTuy2kQoEeDzKg+FGW1Myo7kQMWtaIgIeUfJMnwXGnGYnDWLdTChoPgFZ39HlevP6mWut9bQRbVGvgCI2c8wPyKM9LGRSSaklCKX+U9HYJE8MgVySZVamntxqqo0TmLktZgqgzh3lW4TwXHgh/+FmQjjIvKg69C/lU2ZNZiOy+BqdUDJ2UAhlhhcvH0RL8YgTG6OrMZgv9gML47CIBFLv32TaZntjveBXKaxNF6/Yvw0CgdjdZ17YYYZ/fn83l0dRljqewCgt2Aq2tQbLxdu+59FE2zaOZJytUBicH44JyRAaAaa/Wxwd11l33gFLCMe5yM+1HkEIM7SPOuI6s9wmVOP1b/iHPAKdxkSs6SXYTS+BSs8zbnxTu8lC/71P8BaCdtHI1LQYpysW/Z4gzdm53U2s4P3I2QSPchADHYjHBmNiGgN6SKhY9YYhZbIjx7UbsNJZHbVFvZwhHTOTyFuzwzW3bq5Vhp6ixOHFBbI0avEugG/Hqa/ep1aIwZqbuvoyB0PSdtKoXjZsk7TKPVJd3qejgH2jpwgjK26Q8DFfCHflSZaw0/ScQWJwI7opC0n8MBD8IcLj3AqI8eoKWR9NdmTVHGuii9uVI7xem091ysUXiAD9MXfRcXwUP7meoUfY45cR2P+OEkj2qA6381gwFXM7d5N4xyzQRhTZty/y8Om6CjNtn/xiEk6a0F/Nv3w5vbdzdr08M390ftoFX6NAKSFU9crGnKLXrACL0uKiEI8AJpbbUjx8vWQ1w2lSpGxijcYNZWKaJGAHeDA0A0f9JMBu4ILB9aYEJGI41UgyhDmBqMU886pKJZiDWvRBghga4GFP9iifKtwujAZJATJgbBbdOVkLY3F3vO33uidXi/c0iPGeooagEWCSXjH8cvOU7mXj176CYFyUnllkvBoYihuu79YozsOVY0qg2/5Ek3FjCcxgyHQ6lmK6VyppbAj4EIFTDrvYkYg72k1S7HP6suP0/RP6+weHkYZ7+qjrWVhzQmokjbapbJJnokHzGptPPTQPzZZ5dEixPIJ44Kqn04ho3Cmor/bQMlBybgLT1CHWkfrBArNja+wMDoS9U0MBo0KOBAcT6u8MAK+KhCITJujQgBYfQk/ASev3AU8o0ClIS1FYUJSJIY2DpgAQHdLmfGJSubMhTQ9mFsHkD0FuKsgbr1/53K5oB8eVv/d/QdDkJ5jPaxGmItj2HW9AIUrhbEB9oOnXgpm20KQqbJxm3ZRkiD5mbdleZ4mPiEPmmm+o08uQNI37rD+gC4myOi11xupHu4PIjTUcVtuaWi2QIHeQCNIeNp0rbKBhBPmncTGt8QiPHBGeRX9aAAML8qZ3F3kWYjP0/Sr12rA0UxwFDS2mJmwjAZr2u4tqRPIx/PLYfHtOGMAiSfacMcBLNBeScNUn1RWZfhA1hselIco5Y9qD+hCpevAIBwb/RxwwBQ4q4hpXW8cAlIjL8b7oqROJB+56VNKwTxJiAY5NGkS46RA0aGGgnicohR/qH9ZFrkYgOVSsPW/fAZE08oPHy9xAkdgabAMorABJ8VqzLBVPnoYLPOl9/RbFZod5fYFDsz+dD1dXr0vuOFhZToAUgl+B0AOxRiRwXrkh/iidDERxkpeuVWM297ASaG0UU8TXNSrVIKWZK0YcHhQ4WhZC0SRdJIXH0z6i9N2atwYSZB3JklVvYqYNwE4h/WmHtrF4pAgDjTv61YDOuDIQIPFzww1y3hpjkO2cA4Ow5FEV+DpWJnoYIRgz79lTU4JLNoqcmwpU6mgIAS5Uj5qOS+I0coo1uuDDzge0+ox2gO4woMWQMruq+Qa0+jKp6MpzLldOyVq9mDziJxThqnFAsg50xLQ0J4AhRZdJJQqgWZsUA6m8odEjcy1B8NSGuUoW0KOc3dVWkUJqKwoTwloJG5iacq0WHmT5qM9qQaHpDGAmuOP3y2fLUKhKKQAk5EI0VprIjwb+WXqSCi0cUO9NB7g0T9ntV5m4y4AkX9hhmZ3hxbKiylJHw4JEsZq2uu4EguxQCxRatSo8pOsS7KTXCy0wQQksA30MQ+5H6xQ5Rg/XAYWryu2MAzOSjee+HvKtijjC8u2NLgP42Div4ZHk/l9vaLBQZWqziMboJ1AJ0NDXmtyc1qt8946L2DW6QW8XjxLG9RQGHK6jzeRGXkMwpjQaEF8SG/PFH1EFfOQCh+zgE6zZUtr5RbcWiZKAGzzfjiP4QWNBuvEMQVxMdimtzquDxFWWhRriJNSUh2Q/Zfgxbzzo0rzyhMaCdMs1qAKdWIIBTu8as/fmPRvFf+92S7jnFn/VH+bAdArlJ70DVHZ+63+rLan3XBRbOyYDKW89QbcLtplJExLXsTDpblKYeg3JJO8NWh7lZAVptphUcgHIWwJr/JqHWclKAL04bxiAimeWLH1MgRXX6a7dQaR3jQJpNAs89GzTUKBYqVA+QJLRRBpsN4zNzE8dCji48tVwNNonaPScWd1xuFFuxYwHBlOInbwDD4+sfbiRsHCWKJpTNZu+Vkbq6dIuZKQiixNE3UlMMcJBqwuJWRF5EsY1+aUFgEiTF+NBWoBwb5+PabWz9UGxnk5l4KBXcahqqhzQj7n0yrpyma99HYHUvk8PdE5BEh7LJfjDMspXLbUxP41EqVkHRVSGAdEtR96zkGOllNZxazZBbnJkvJUJNpZnHOs4iqfC9QaqT264nVwebY7sFIlf1vez0HjINSqb46w2p0WjUFRPvX4GIiBe4UMW7lB8zd+TgGS84nk2EYF8A1vl9Mvefw3mGbEp5RJQGxEAj1iOHRVpnc/MjWdjftOFVo/JGYyAOZHYBAzlCCj/Grdv1Uu+2pPWgsE6hIOW13TJWiQhQkvszlMj5LQiigxBAd4RwaGjEEFZMIHOVlCt7CasdHyU4vs7aNfDQIQi+Z1Fkzewn/7GRFWUqgfMgqivQIxKNGzeMNYeaSQT9OY8KnFMmTZ5Gp4NW4k8hp3K8FkOC3pes6xt5gjUKOIQqz3890yvHFliCAFr0EP5ITTIhCEwW8TUafaQ6KESb40i1WOsAgi1Q9HVYd+VGlc98GlQcNQBfM0oARRV1HbknkVreWFe0vj7FkVzTEBAXsdshQe0Ort5CojOGhXMbky1cS3tK1plzhvKKXhDAqxk6DgRkNw5Z924wWLA6a4qV5acWSf9X+g5v4opoZ78CnjKLpf5XAYlKbt0WWFn+u8IO+r/20ghRZDoK2QLkLo94YL0HqbI2YaJp+WlcnR+ekvu+lPmtChnJnutYO5iURZQR6CywCWvfEMpXt1tk1rTZncZnuON+Rq9USXi4np8NGQOLPbZaLqsw2OltOzVSocG14p7Gv3BMmPZNN50ctTZ9vpGxuow9Y6DOPlvHOAGbRMmkf263m6AoQPW96xXKLrX7Guz/VCFqHtwYc9qYVjzgq51Ac+RzvuAoBFEQQmu+13b6VFldqKE1VoH6aZjcY9kgpRLaD632ysXl9VkkIJsBFf8TQ2pXv5Jqn00NxcVzFAqgC1wVxE39B+MLCUNoTiGMBjEfGjsgyY1G4dOA7lc1J1GQSUPyHKh3NTnKPyx9FFeTnZh+Va8FSYqWEvrMBabsaL8OL9MgnAo5gzPt/MVubkLdVa06doBUbQeM4jKAR0MYLuQGmE/l5PwlOq8qvoKTxY44ibwdNJbczzTsObQiqsqUGkvIYwqYqrdcLIEUADtrjjqYYO6aRT1VsjM4ELfLTuBBpStRCOHa4gDyeN6HENs+nftnnl+levs7XmJ3vz66cyZBps5/PMSNEATeg0ay48HL5cseYeroxU3mjUG8RKc8HHc7RDQJmNB/GyXpIG0Aaj/gMNC5bubfZmdQCtqolGz9oxAHCYRDlaPQj3wmyzEIm07UKY8HJiVMDMQPJJTGrFCH0wcLBXsXIMzFCAsf7gBughSKGcOEYFe8zPGjZFhEzE1J8COxvzm0DSxKvNRFjlcOohvNWBct3MiUHY9+MdlQI1aMyjbcI2EoQ29HqeUTW5nEYTe9tzQGn6AAPFoB/ctEBETl0e1pbQU8wGVSmgGDErwHPDT2G+lqr1G2v25lLPoNpn5rA77+bHuyVcz/cJ7izk8pJ3ZJgbkgtG4QzMxSTjb65Y+EMSSCGb6hn25ZYrTnoREtE2HGkaFlWmE9hXBjiPLAsudeHJr4snyndBZK40vVExjbsObRxUBT1eQuF6YYZYuLnbVJjGx2TwtIkm7YcJILQkQBxl6pI93Ddv+jJ9e5m+iNQ02MDiMst6eWtTeyaA6UqS1A6wqBjDA7nIMIDc9e3YqGISBixHu8xeSWimNI3vbBftlwykO+gGO8EidiLt88hBMw0QoBfuoQVYp5rulTBNZ4yuF4cUsCsWLel8qpLGstJemgyTk+GUSdoCAGJuhfDcDtPczQ/cyCEXU7suw0+miCgnrrROykdGpZGM0kRvhfO9dVVSv4Gqikccfr3Ed/yms+Rr3p1H4AXgVp1Ud1AaNKhZu0+yO/kI0aAu7+FK7llck1L5Glm/TVTFvkFesCzNOY7vq2KBHhHwEHAy5qif6skB5x3izNrf+/lmvzEOmLq30+a2ea0t4Ly5FJCP01fv/kS558LUgo3+wBCh81If1QyhzXTraYKPzytW/gJFUVJszIy61Cp6TnRFUo5+cK62BJedtcEGSWdeISmxET1SHBUmN2Q7w+S0SKfrUMMKBcgP4OFEh1ReU0x+4coZToh732Yd68AHpsfd9HWRd7l9lTWt41DtbMVnExWsgqxknU4Ua6DwUyYTHQJfw5isCrbQJ8DNPVFTaLQuVhvCl4wJlEig0AAG3ary6PtiLGQIKzrqW+5xK86ovvJpse+ZM5JDUXx5StkzVssDg0h1LmKEGDMreskG4UYRm80HcvkQErCraA8fPBrlEQLKf54YekE0mOajsLq1q/GzNytlN+sjIArOIC1a4Tr5+tr9shwzIcu/cC637Rsw2uEOQk77MDkiEGiVUTRMKAYweE/7Vb3zBqIwVBBARrp0jSBBMlqQL0SDn7TVAVPK9NwkpHFMzcbUzKfkfVY6dsvbLHDIMMUor2KeQ7VNbnJcTDmRJMJMLZeV16wmhFbzYMwfhz3hCJwdEROhujpwc46zdSGjWMTpTN3KBknK6pqL9c7SJ1GxGZdy1g4wiXANhrV/FGlfEXcxWiUAh1CxJZxtiBBFURyu+l9jM/xHF1lgEFBxkWRXRQok8uw8htrwQvOC+FjcVuDQS4uSFlTzVQxmk62EoqPNZPBQtvNGb3jQhXPd88MoGV/I+6IUc4bzor0Z4+j4/ehxCrnp9JUWLcE/VcQQ/RntqlvdQng4pWRjlCQNgfReASc+uVliEeBKRmnwkx6HCyEKCTkSB6Fgguu1yfx9bcUVLAWTarmuixVVUaC6kZP+zEnJjCHV3oBOc2oJnhpsYuNoEoNbEcoEhDfN6BKWGYnOBmLRjpzS5ZBuBiB8R6gJIokAQuHatCu5+umakzrRtK2Yhn3LZfUpimMGkkm6GgkiepLEu1vXi9fKp1bpAQdrNJegdpfBCitydwzz+XC5zfbG2BlraRgNfr5lRxDQFlA9QRXd8sGR+BL1MMlPcIt5mAslP13HqSIQ23PlALdQr0+CfrErOa5b+ESQYXbBBlx0JRIlpHLAkSzVThA3jIsVAMIq3Zu2DKuO92XxQlkXyvGkiqUtEDwxTB3xMyQgsOfBsyV5H2Ew1LQ/IEa5zN+XbfHZVJWfczH+Xlt4JecBto5soKp+9KOCjboXZ2xWhQYEB41WMwDKaH1bb/sNwiVZU+QYtW5DEB4FVNccsNpyxc8wzRHOQ15uEVYJclQyzTm2YhSp5dNoP7mQymVgeQvPSLZoK4ZPeJXqo2Qwi1Pwl9zddSRKaGiLaLAXZ3hS7l1bKkb1C7NYBvOEXzD5+xQHGDDF/eSn8agIhao0HuZyY5pMM2pqHlN6Fx9pVciTbipWq00zHCqEpEYU2jtvwR/YAMjfu6Uwu4Sh1wSUJZ4l2Hr7ewMFpUxxWjVaGcshR1xzXadZQyE09MMBv8CARuoNIykycOB00cW40DKKoZdI4JZwBxRkoAdnKRy9odyuKIx3LoLYYVyW7NR3CAMJKckFMSTXu30DbHK35jGcApG4mzjDv9AMeBonAF89N+pNws9KgDPOqE45zAySKFYhlJezqk5MjBko0RoqZBHE4Vn9iJ5VS8hTq8mYVGF1fpc/8UTVG8Ui0BqPsnIewsUrtYJkxxadwAHfrOFJayCwnyqL06FDWscEmVKsS1uqgw//Uu04zAA/IYl2X8jQRaIbnCHiqG/NNViNAZJKahAVxPuT1cXwoKJV+R6E+Yg2RO7xbtVbTOB69GGUjF6r0oox/vIKJhEiPJUg/sgVq2BfzYvXLwFKQSi+U/MkoYg6JS9Jf51QHuki8o5LyH2tfEv3q9y53HXccJOosrypsIGl+k3dWJShuhgMBB6MCC4u9/OlQaG6/2u2U0kgNqT0XOEEKJRjiuhhmbQAIomqrodN1ZgYIXSLc0wIX6IavVgqslVgScjIply/zCKGJDZ0V3MsoZ4joleRftDg0tULDg1lFBhRw0cO2dQqMh4wylW04ZuGfIsegGkI6MHDYQPgDPZiYP16Ug6k02yFfSHZMtGw9k/Y7ZU5VZGhHwMylAgYHfhGHGmo9uNKcp6qhU4awWV4t/grpRhWUCk8ua/9aEtSIdcNzp2Mi7cs8gQNQ+V92IkC4+s0luPYi/GkxXN4H5zJFjuyEULR70JsLRZp1HHwn7cOvVXTtDzI78WcF6DWYoFu12KjsU7H0cX2dP1FWnSYLji2rjIquoQKf5uaD9CAdRmMy0F6ME7V2opq2IaJuc5YVan7yW3l1a2GpZ4GMKncRyExxM2oWHaoFd/vWz2TLAkp2ahDP/gmHVBVFB42GiLbGyZvHE13RbZaX57QtszwucLjocTrnHGeSNZEllUGMaDqtiHmCjMgReeJSwKUFocLRJTCJXbwi+7EUFMtJKoLpQQ6GRrkXwuHFfUIQbiMjtXVGomwVVM4xiNH0ujAwbFKYC2+QBo9BhaqoalabphCGViVSzQbqPC8Qok9K+rjpxsMo7cGnnhPgTA5zq/KkR4FsJUX+GLa8GKxBHkCpdc7bzpEHYlAB92uFm/pt6lchQtH6ypmRbpw0fFE3SejriQz4GgicY+S1YxjVK9cVRGeqBhcTbHBGihBX5W6aifDOcIcG5Hw/RMCX6sorXxoh3/Z7ha6Bh9SRck+5q/YcP9hXa7l45hGBwOdsHX2Heggskg//86kYm3sAsb0Zh9wAKBc/YEQ0FigLp7OeHonrzLTpnN++mzMB5uQ12JwDRzaoGS5T2aIiSoDW72hMQNscEWnn+ryK9TIUUlARhna1oe7E1uwJruRShcMv4ZLpmET5oz5aKPP9dILi5Av9wk1NnMP2GpeiOg5GeAg1ceNq08CQVuv0oohp6FQrUyu15fEhCDf3ZO0sjAU5twVWSVKpT0GwVTuDkvs0DIQ0/D6IcJvZtDL6pgBx1yjEugi16H92lKgUd6VSBECQ62pZn2nIS/PDHgK8anaZi1gFBSQQlYXzsW6TZWftN9463edwHzU80r6xFIs2LoLB7Vici6a2ungb2yyFSMUVhTU4l8GhLKw1eop/JS/Ra+KuaLUJtyrWg9dCj9Hlttj/GPhA0sBQgH8WzE66QQblZQvNHdyMX7TnSE7Xq/7+4ZHLe8vVMmaxN3yjQqhV/3cq3Rd9XEMr/sZ/MIAF7zEPU+pF4rhuSio4/iqwie/nzY03iAgfkAOZsMXWl3oyquXCr/rzhlMuE9sbRR+AalYxQBRbYwuh+QhmupueQErPO3vPpDQJ5UMi+S6hMpi3y3l46yMy86ObNoamPVsb6i7Fe19k75+OyfRPHAxNI3nyCwT4nVpio8rrFS7SoVxiEIj8VSZMJQsSYicVDasRNFPT5kH8PTCSd8GMfulvrL62cUR4TrHbBWo2+ATCyk0KhUdKpdCu5JGtavEMdF+DV6FcB8Mr1/PKWybVVoB8WzezZtBujaTVRg8jYkypyo6WgacwAfBoXpAEUNaLQRimuBDcqVeP2WQ5gpQ3RJdGFQXNGSVsp4ogNOwKhy0YJEvNL6zF5B8XampJFuuqRO6tvgONoz5aV0BPCtPtBS5VHaqx0doHtTKIgALZ0BOgY726AOooyKsKHm0n/khweVaCyYgJ2+OBlphN5wlnA2D84uk2RN+cP/NHPBIGQfi0SrwYMVSKw+ui8wWd9P6Ltm5QKyMMKqAitGnOgDV49S1VTLgZxFv6A9RzZegVYTivaBe9JSPL28xd2EbNPzhgQzey5SkGe2QBBAOEUUkGTYpk+yllmmfCEoPWljTJt3XRnAZ6enwQLldT4yo8iR+tEqjFsB+RUj8UOyriJT1CZVfDofHk52RMpkMiichvNvONlTfjvs7r6cn5rMZD5skJdDBtInZULgwCtbwcQIyWdQHK5YQV+0JAlVNF0OcdouSioJJzGb4KeypJkWfgKqYwsbXvB8NEGCE0T9bd/mp7mv2D0YaDW/+HeEZRHKlF0teSNS0okFGZwnO8HRPT7evmckCvq7Ps6RU+hT/0qNz1EUTAqMkw0SjqldnwHQ+OlTRou/IlApyga04GQiOtIukQNYBGC6mIoMWTsIqymKAGJDqXpSWDi3vJosHY9xAVLFCiVbhRC91nEEsi/MTjFckVAmWNQA+clihu1E4ikvJhh4TZNtzETHRWsD7TZUBXA24Nr4PVsJBSfCRDZk4lbYLZjg1ZDC4DCA1ov0yCmD1wjOM0JU63p82WKCCtjgYZoBHnfRhroFD3QdJGESh+W9XkiYlCzLWhKeG3mOHQ0oYEtaEBPiHiRCrYUORKrtlfvvyrC9SJdWwd1Gs9EosSLX2w7sorAjNRjFpbgyfA+IcA/wvi6L3tTq189UGiZaT0WNNvA5ohMm+QxYKKOmprlZyHq6WPwJp5ItV3OEwAGWq8fFZALIQV5ovDUITlrtkn/0MMonPuesxv95VHsyrndQL+OkDSdBQg1fGJ+i9YOyRf8srMuXHq4agwFcuIUL56l4IB8eRH8HkEWCtS8BbtLymmhkro/2SWAY/6Bqmokq5NVAN/GJCdvwjSsFASzSq2ugk4zMPrTOIDAHlaXoq0CMh5tFQgEc0BsUhu87ez6H3wxWp674vXDlaw5QDj7BVe8QDMkGqzmE7V7RNGORG8ygzeBcZQ4AuYkFpizjBUSyVrvoHPorDQNfpbkWOWntu4Xv0naZB3mNXoG8W3otiR4Tjm7kpQ85jIBwINB4khirlELssUzWy1JErLUBY/zve1LdTHxmAck6r2oOiMbjng2l8zzzbsHWkE3f4HXtBnLM5amRurwB7MVgNN18tddtpA9o5izQTmK5ECSoeNTB2pB+AIzZIKmj1VJGHTDiAP1WgSEe4GFdAqnS4gqDWFBySQ/tlni5iSeA7U0at8Xlt5XseyMUWcMo4QWA62SqNiqUdKHIJqkEhXGKWklBOQL6X/as9Y8AS/KQG9USEg16Fhxgi9xISVnS0NAxXBkA8H1qL/tIl3Q7PfelSb7kebayAQKB7wXPwqyqEY5Q+ataGtDUIP8sfBEGVQQz2bZVCIBLqkaPxCp0598iJSzUI41vBRyFQW2nFK9A5pgkPzBgi7BRpOBIEQ9ggO4sX0PaS/XTTl+WMm0ZDHePCi9F9LGJwi5+r4Zm5lFOhHIthHB71HKfiCFXksy1jBtyq6b3HK+ka0HVBd3crxnF7MScN//9PU3ey5DiTbAcYJDOZc9b/93h1d9rq/V9Fa8msTQu19VBVOScnfec4s3RZKCYIRHi4Hx/CIxAAfAK1/3wVTfQ1hz6vm1Qe9jIcBRo+RdBU0ZD83gC3/ATrsY/w0THAu6fjbda3Xme932+vLjbzMoC052a3sAUmx/QHvQNYIwxCdxTyiOBBrOIDRXJMCiBR/TDQhnhazB1cDQqKgTeKyN/YRMjWIOwk6PBwZw14WIDYidVpS/liGG/5L/tqhbhTjcHwSXMl7iBMzAXZCeblmhKt9Yra64GCjjLuMnv1rqq3LAd88wCiZiYJ/x2sEyGt+Kim9aCf/XTjkSEaSY4+bDvguBaLTOYSWI5ilKXuBD5llJ84K0JRYqsw/di6U1W61sK5b/TtZF6FeH6UAd6med6vSmJwb0yh9fwW9Zm+9TO6HjiSXH0c+K5RqotKSNW9cByimPgV7zGtfNEJcxUj9ifuVgHQ0E7KV4URjOYa7ULcKXDUH2KIYfErWOKhFjB8arlLSy/yaEb3JGwv1x8f3o++uV1v71f45wA6sVgUZsgig0K2IvvzaHXxYfkXPTVlom39lduFqcQy6b0sS0wyhNWNNLJiBKIBif8wqO1pc3d3nUXbMv88fMqzyb2w3mPyvJwCaoc8G683wWj6i3PB6WzHAOFy7eUVT29QcAhFRqj+0ncchgPUVWINijkCOvGv64v8YiIcQCSGc4bUtDO6dqSKY0BlP8hpi49kr98aShN1v9BveYjG6GvNLuO4BEahdKSjSEbe669Bw/bqjWPn2xiMAbIVJadUYTyK+UphckUZ4TZjOW1qjjPYH9hros6Hi1pOClCQXqWqNIBh/SFHoXrvXsZRMu6tALMEb5uIQPVbjSKXadD4ViFGlO2i4xQDFfvlbcGuUyXefuGZqa5DuQtBMbV425RUJ7pBBIJVGPcIu2g5VR1jLrHNz9KM5FUz5uheXUHdwWz2kSp/AaPB7Bxoy1gKQUpJZyuY6hjg0/XLr+NXm6z2CfHNdnezv19t75I4cmPmFcrqEsF+vT8e60MEx9+Xu59hidp871/jAHDYPh/e5C8362SfXz2DM4CgwuOty96b6283d3NEOKSP1+XDDJWxgBXZ9Vu+hwFYjZhhBjV8tlYWkjiLKILVC76io4ITBlMuP4OQ/z79phQ/z8drguZ+MZ9iDdsTx+hEV50a1Qvt2IlVjQhFWP8mJCGINbE8GmmZxPVWp/pMOn3ktpuEdiXh1lcAyjGS4tLyy/LKB4Q8Sq/gCc9frKJJQN01BiIdtirXNFepMsGN8yhHRXzSC/bqcuFHkmOr8RBc7fh/+czZwgLJoG1rXM4xJxoCksFCDN9j8upgKSpRWR78c3n9kaXqch5F17fL7X1WnNK6KBIpJpC3Sgyx8iSMlZUcQMofObEm7VclGY/zfnyLTDYBg1qYQrlRMGMPf7SIjfErTRTByG/jJ2VVg2EVEfwory7cv86GiAIdq6C2uVtZi2oZZiKKg0LCcI4x5dCXnlC54zQhMN8st1Kdl+XH2+lD4KpPntyo4mWMGceuM8IxU65KJQ1ZBNlZR2xRwwhCx4y7sgzOKSbBMyUqrJRJX54uk269LLHvhBKU7ZS3HPc/HKcJDDpLwOjSMbLXl2gh2mxbyupPgKl0RiyRKXHaxYGx5hAptfPPL8qOT1uRq6PVaVdzmk4Cw/QbF9zN9/60PL0sz2/Hjwuv2Et6HevHBkW8nz5fj96DmDdzmA7G8a3HHYS43aiyvppOr0iOfARXNzyMvbJ1yqUvp9kb36shZX6Byqo1FFmR+xaUUT0NwA19Ha8CVVCUheAXnjEYBKe7wzHFR2acOKxxPcvr8pN4sBMyrejEwcRO4mmnEEMEHFw/PEWsAGQDXMnnK4oc3TjFIIRSPLWRKiTKQIdzp+UyEWa0K0aNhEpPaFSGt9ivhDp0P7UVsiU4UOpbjV5iJWXJ1Qnva+G9V7ddUVze0AdlWtQQi9FWoRmAGGvOWcfh5bLSdWx8HD7d3UkQPcDvF9Yz6+jHY0Wj0PHfBlbtKg9rUY2fO1V7jQPvTzvPTPVofkcdN7LqwHoAP4gvOKnm9ACMA81hj0MiGMwH57Jd0iFO/Nh9vQX/mAz+yjAdYjIa4bmjOCaSjA7nt8s9PX5pLaQctKGmrfJMIwG+EmGGvGBP1y0VbELl20hp78nKz6f3J3JlbY8wJKBGTYzv/Xj4+eYFHTERqRLqD7f7RNAzvOnx2qiWonG2EdM3WxG9IiUYpdsHu3zGiQbcenRBBjh+SKtRF+2ug0bsgZ2Q10UYyWqAiCDmMPCf4Ahhv+Hpg6nwXIdWDemUdVTmo1V5gjZMkrY7Hnaj6SEEBX0fUHRwORZzxC5NwCL20SbAiiltT/Pox++haWLRksxRrSM4a5RKJeUJ1n7TcWRjAQ6WTmCCj/0BqGcBl3FFPTm6pEgFNE3axzxanvwyt0E+1PRvpa+jTx9Vr04eAj8hvvhEAXqMPy2/v60+bi5fr1foWMtg3TwoBH6toJMMWGwCupinXWLD0MNM8yaEUsYGF1Vx7VZmz4XJCxXKWkfMdMwNqm/8xQON2IdzTVTloVmW0mJI5jP7KM+MCp/PB+uEHR8gZnVK68lGygahPAxc0kyQmQSjp7LZ6kNWLeUz/j+TwhW1Ju5VXm2ZYAkDDK43Nnjb0gsqmKMuB+3QuEcPHdefZkB1+nSmwFOex5uHINykE2ZXsV4dL7sXTKH05ho9PboYkYkWBMV+BpP5644f4u3aFRpa19gsiwxQ/jIeEdkvL0P+/HHySumA5bK64ZBRn5kj14apj7rhXE/QXHocWkQ0UdwHN6ZMZroAo3TjVPkHZdbbkFDJLgC0Cm3/kqhArgwyOi4klXY1E1WFnTRGVj9DLV6ZKo7Hx0wS1gRBQDbmiH4MxMc+Uvjhkw0cjsWDtcWgmbiz/vfhZAkG2pIydv5YyMRShuz354up+ImGsGoHiB3g4gUBzSR0dWyTYi1ARiWlf8n3rlZ6nngROUYQlOiYFnmddjFZH44W5TYvh7ebvIRFgdxwowBmPCTxYptnuRRMgERwYLkmfdd5hbDST22LRjAQWPDbCIL9cNfqDjrl49QYEOOgON+JDnamwLTVQBMi3LUdghvbFUh8RcJ/pqZRQa19IzC1BYFsIOIAfEaFFlAGkSiLzzt7ubq+vuBgwz4/4TrpstxvdHnpZiDIRE63SqmTam6TWrnHOiPm8qCAhQXQ8P7QRGF1w1Zwi8VHXTnCD/OTrdvBcuFowR6cGEpSjT2fDj9R6qUNGen7yiIUS05kMcCJbRSKdAgI58FYCg8lLYVAwud5piyNp0LKgji/InYM7nV5/7kcv1uHYBoiQdcFfxc4lRSnxex0IK2YkO9n67JLxDWap1bgoHacM00bApFaiZeRVoj1KGM01u4Y2x3325U5nHmMCkmSq+AXXuKBVEQUGcU4xXS0aDLHDea9gySG5yBbbZeV8q8VXLvCDJ2JeA0SzKKEg7i9fBVMl6sdYRPpW5RAEJ9aAWDtiTdmP7CueMJWzuNq2O3ag3L1GNSZV4Kr0vGPsMirwRLBzSEaWWGvYRvthO2GujQFkx6xH6Ov/hxKt/lVPvvg4oe4avITaOyXjt04s8TA/Dr1FjpBNL2i38rABSlrNDp3ZJ8smfio+OboQtzPEmT3yUlqQ1lk5RUyXng2schTB7g6RkMPsCvvDv20LEufIqndXq/oTAjjM73/RkHE89147EVCwpdXCiHo+S3iI1LOUhz3IwIoPH08z1kgKSg0YYRJXhkXWCgxT00z7XY6ZZmxRnmwiLXNi2G5K0Xc5RmbcEi8JrJtUl7slu3IoSVq1mqAd4LbUYaiUBBvplpTiBifWzMYPbTabSVHxzReu4XH0kAWPbHEKVrhx4iz76Qu6DvYvnvCf9IPLGqOTbB9FRN31xfbk9dAu2pRWqEcZTR0+WYEqV7Z8JBR+7fl8Tpr68mI8yCmacr7sbw+LW8c2E8pyf3K4kcAxXaxQd9A0GqjALniF2UbGA5qS/KG51iT4/lKP++P46z5+LiBymXfOZdJXjxbG0d2oDE+dTGiCRfayOWbJzjLzRpccwWGps8ZWwJH7KvMEzBGX6/wh1BRQW1oDMKppAFfGwuOcTMGFobz3oCfGMQZLvOoFVMaWQeKlCPY860tiFFo9RW2tY0gXfSUdhP7n08v1lkB05zj19M20qUAkG3VVE7fLu63m72H+b3vP0373nk9YjjBUZFrzAJIx0I6zDzz8tVbyyIxKnl4gH/Qrz2AAOdumcJGBAQdwNmPflzwet1lhyR5B9WY7hhEwSIVll7yKtXaUrtfoUdfF+f7MvcRNTjV9bNDeKoCEJnbAwoGfiY+0dDdsr4xy54AZr1A5gFsxVq9oUZUdLKvTOmBDwQ8ypIVNwcmAbNQwHSBOVbYYREFOySnWnMIv6SVPQvzbQVZRELb2bGJ8uAyllxI8Nj2Lm89SWxLIChSUZirvP/YPT1xhAt1UTyuN8ajaRE5051ykhn/CNIOgkmkqQsFEDiwqrYb8+pxyBAnaClfi2cHwYQlYdTBAnjt/l1Ghpm6VtZyS9Ku8xCUiTjx3t4jYfKNshOMygP0Yvq/REat1hw7qnRpV/DUrdEOKSBMXiy1znxnSlFxIUMTTUnWr1FKjmqX6RMqakvQhBuLdJLb4LaHUyzax4nvF1btQZdZdu5qu8CfheWd8QsCjWt42N+sLlx42W8ztzH3hCDDGhUAK+0YgmKyKOkZNlkQn0flyTFO3jZ0vTbnLl+CD8FUSVu6qYEaTVJjwOmPt3fRi3tFSPhmLOUlCPEm/DusLrK037hjra7BKtV4T2nAzWfkLND2HctxhXoWzQSAFkvhsT51mY7YD6zOASvPYlRSC5ox5SncnRB0XC0/myJ7KpECrFx/lYXB2oXAtKuM0OggI0OkSrDP5nwyOWMrt/EuG3UJHDhhjkEqmxYTGmkR4hbDmZZ+XnZvZjD6pEJlVIZLrxqKONwi+YysFxu1sxAWbJo8pOUmAHQm1mgudqYJBz1G5XolqZBQzQ3myZtt6iuojEQLHYsCSIpa+2eNB5/5KFlPSDwil3hW5Y1RajrC2hSrB47UUe3EFzLyGaZpoyktVkfZ50WaIZHCNZrxW8d+FcaPyJKYy/SFGM7puyxoLrKGg3Td5pSSRnqkINI8R6fXpbUcPheDBzT4V1PRHawElKi5Y/Fa0TCAJT0NVrUkAF1dbjafm+j3c3N8+nwrD2G4uojsOGQSjc5UrLqz/NOfvH2QN6b38XiMzLemweNlHs0tqyoCQmpiCoLoUDGgIBAvr3iBw4Ey5G/I+pEi1ccYGKmi7Cg+qECAA/D4jpPiS6NRQrY+muFDe46XFJKD5rSFUaacud69hcMFVHlqIMi07idStTPf9gGkvE4vfRlQ7LRR9FURaSSOMiuWmjwV+/WTRGiOwe/ZOuO3Lsjbcz9P3l/vAfn0yqDNne2MR93X9tpnNt7lFS+QwheUaBrVqJztdkkzms46QsfOMm6wCENMJ7l++Q+SlOEPTtg0c1Hd7OHb4f1iI2omHNZVYu1KGrcgaCn36All4bxgEgQZpyJLu5cgA7rRUg0rcSoyN+C1ZMpUUyk2R4YONPDEZxz3H6UCCL0opTNdsQ1NdourqyLbDvO59S/vf5PeOM7rLchFTLKuTh1Vu8jSUZZ/W/PCxHXp5SVaKSZgJDtdayUISSLEIK14V8JFRgdMX7viS8KluorZ0Yq+BQWsNl9FZHW3PYprWYBr+LXO8IaYp6y3ZegJWFWl8o4zobUFDRXn45wfl+lIWrAiwwiPrbBWv8FC9qK/ZJYtiaHwRB/OwjFwfn37O1rpzhgBeWJqBoJwmUsNjAZN3R9ea/pE59Y6x3gZnakCZXZgDQLV1hlEltXtmoGyeo6HuOMoYwpvsLDqkClkpRN+kGLitfJ47J+2D3S8W3ubd4jzioy20T/u39aQSnan2MNyJ0WpNWgCXolbyOJkFhq010pea/rLe0ezDC5YK4PhAO3dRxPUaw2x2j4INhx6VjbbrVxiahaoqtWoydwTyPkGh+mHIBUimMQgKkistpuz4KqWEhESFOiilo1OHKAamb9489PxHCRIe28RJ+Wxym/NkNYQGQafpBpVGBWeZY9SVr1o7rPAi6Hq8/7TE9Y/vCjx+trrszg93UVtHVPpb/MEmtOHKWARR/8MK8bqfAMimvFqPKg1qebYjhX1j3nDynkBL/NFs0k40NKXliVwRdIa9HIfPeRWELdgKN++F9vyOvvJMIngPg2tGGBf5UnA1ME5O0D0A538ry0CnQ7CZndGCQMxU0PORagp7OdNpJoQEmEakFSdj1L/1QcSrkgOvgKaWrX4JGdmkjpZm9hD3021E7Gmz1WegQo8qhBGQ3jzAB6O3o4Mq9GTg4xSYQe9XvL759vt5XXelRvIZl6Ymo1KRZor/WaGTcunR5fmLQ+nj7cDl8g8tI8Zrffl2UNiGss5p9UmgSmeFxVmX4wAKKy7DkwPK/4Jc8mjDA2Zu6FIA0SCXNvlSK5DbW+WG3czK8kaIEB8ecUgjBoReF0H5S70pK9v2NNcFAJADLT14cH3L/yrsWgNY6mFPijIrq4jxT+odic9c4kn9HTwmsVCvUSQvB/ZL6jhFAfg9i6hFGpsePeZWbbV82H38rb/cfFzd+la+/2HFtOZe/LS57/ef76fPB7ztLUmV46SOd90dBaYgRE+2G1HTTWmDbCdyUpcjUV1lgyeK4NXcLEEzk/westZLvuOkNH31RpBWtUOAzjfLosN9gAKMrwcd9t1YqjCpCACBgSqXEbpoVAhtibJ37jyS9NnlHEJRmKwtnIpZicsjRe2YtBvxqxkqNZc7MRqbBUvVOpIucSoAP30VPo56dqUhBHWJSTsvrrXz8T0kY3ZZV1NBv5MCk0HcQ4InmP4BAZp4fvaMpVM7JAZt3W2RJpG4jQizLPsh7Se980cLmguOShcbHp52RTADZtqDZPDsFS6VCrfAHEfArv/1Up00HxJo1ydFK2rTDKc2TwiqXafoWHFT99VZLgTwz07G30XZziEQxyPEbdfshuRi7IzWGXujDsxyNHCnpPK+QUHO5E5P6MUm7akEMI2JWKvDqMY0QNCSIeUaOW6YRyAuTo7PDSrzmVb9/qsvYv4ItVroy7Bmk9zjUjA2pllJKrGyMIWhTm+ja6fwbwZPNk7LS6XDhukbBLrLLkjSO9owVI4IsiM0/xo7uRYjhcf5RULJ9gu8mkLPx+xDUMQvY1FiDFdxMedTMmfpYUdSpoZoxxFnhErXkwHOUV6dS3KqzCihS4UUlGw7Kr6jl4LPRXaCfKlrDoj0GnomGgLfzluq3JZapIZBZDiVC6eNDlRgFYisG8xw6n4QAKnHIOFKR/fqAPkMcd4iyibC+8oKhBYZPqpzm3Uqr3SAXXmsrRhjHzglWNDbpXbKXFJH6Yb8MZYbUKyXqjiRJ6yFBkV0F10Tp0nMxem7JqgHtxgEduUmsjUGVJ8ktHBpLBVMKvCQy6ohVIIU3/wKbaJLOwj45YYKxNXgoIjS1MmyAzgseZiMjiHwfJGYsdxiNTYXNqoXzmorZJsuymaU4GpAMZMmYdNh8a4iaNdp7oBOSBg4PVjd7O5cIUZnoTSg73vdrrT5w/z1qudCyLH5Y6f9Hlk6Peih8ibZfbUDToCarm5SvhpiAkXeEYQYTYN/7ZLCqcCO3XTezmM5yNVhnnI2sodQ4I5SMaZG4Rv5o8ixdyfLULt8KGNVLbTCogOEzHiKkMdwmqWvtPj4IYZqYWVhlUKUwA0lFFRqk6FHW+wDE3l25a+j5LShEgGvjKNhzShjK9+4ydTYZbXm6vvZUQdGeEziKwmGDH6WgrnsHNwrBNlcQJY+kRe42zVplHOo6HPp9hrrmqTqE4VU+HE18kg06sgy3iFrnLSqe6Kphiyzve4vQxLBBh5SzqMtBUleQvRt829QZwmdDJ4q0tDaZKxCDgATo5OCCXZekAsCBXKLoJx+PqMWkGtrg7DdErtA3kOfmTGvBTOeYIBoymp+Ab7UAwC4HXwqwm/sk985iUYlXJko8BKJ5Uf6z9nPsZsgjoVN98IbqpoN/MVm+Xfr08avd3ePF7lnSCGoh/7g44D73EUi+GkVitfYrA0EfOM78KIokIpgRlSmI3FauNijmRVKWaUKWMoZXimND3CmVy9lJQesi7NBhycswaBZHc5RS04KN8VLC3AJJqjJupRSSrjoGLn22ncaMhRkaNKgR/7Dp/9tpOfCtQrcOUT31C6YSDYIVu7j7mAWAn/u88g5oIuGqk1iuSOpR8vstExiz/uPO8uhDLCdzgo4TBGcZCzxIj1vFBTxGkWo2oOEvvrW9yNG3APDKrbnjpjqfZd8XNcKWxmwGVGl83dtPXinSknM9O81PwGufgYmnFLHBTTBEgVbaMMZ7TNHoBiOUo7Fj2+37kGKVJgT2HscXtvUssUXR14MiUgYF50py2UcYs9XLGYjpqAEyP+kiImrlfpfPZMOsWGNaF53FblEECNkSXYN+5gP6ag4QHHKTvGJyQapWMPG00hYgncr3DxooyveCnxdZBRQUyFgXsV4On5zfsLLXp7Y+PpnjLwujy9f0o++CXgr8zx932HQIaMQIZD4YMhagVXWI14YS+cVNNkDLy2CZpin6I1uRQASywm0iV8EAsELUDAVKkgEpY5zj3iTkKSJmrYHksTrWg3YKKLaHiolRemtN20L7EWi8UIrH6NJ7RUKX7RiQ3UIM6sywTglaMpNuwGIvSGWk/piDwvOqBosVKk17tZbW8urnarg4vobihphoPPGMcHV+dqKeoru+UqOmNq/ME3XWi0bREeXs5iG2OFuqLWalkw9uaiLN2kV3nYAhd22KCw4V8FcRGsGIgjIV49Oc68EE1df/X2pKhW9AuuahGJT5I6oPk20PeE4DFNMxUy1OflxVKzd7fL7w6P17duqylL4QpKnelSkTh+kshHdT45PYzLpecyX7rDZJ4kxyDkG4Z5cAJRO8kMQMunJoKfn5E4BMMeztlNN+bOygV+yY/9UGjFtK9DwLbU5eO49ubPGcJbAfqy/7zeuhvJq5IvH+72n59H16QMgiWX15uL+8xAePKfKRuUBJfDz+WZDxSfHKqjsh+2Mfwwv/CpyTqqdabpocunMrE0DDehCM8BJj0MUrGfJk6CY7p65+jRGY7RtIXMkTqKq9khakM0ykNrSDsozGhP85Oa252SwSr/oRRhar7U4Ej404wOqCnsCBBPQxxPo1TCTnPaUvLNauEMhkHMUFgwjrXogaG3rt8JSMKGrpMmQJ9BtjtvI/khYTOJWlpWZe8ddJn9xQL1xwfKpNOu/2esiT0ilD4jTm5QBIlcMeo8BHQ8E9GxY0QoEXaaQmesX4rEBXGbcOtcy7i2netEL8ngc+nNBQZXx/RjblwCiVsxFSufwn8C48xAvHmpmu4gF3NkZqyqLFZPRXUiOgeOpspYpko6BoAn+uwJhsHWlbjSZzeOB0A23F5FCOcSrF9FCDgOrnzw366MEDCIQhUgOHhBixmoKpN0pn2FMvQkKUXLDVNP71b9x46MEt5eTj/fdn98TNdtTY95YYsCL9eHS0tgDy4uuEQomty6SI8m3SHpTd29mpuFYRjW7YN6DINQmmo/w1SCfN01Sb8TlcK8bUbeGXC7+5XSMl7KtYlbZ2KHGRXEGNNX6PMtnM4co+NGfa4Xe6xgI1daqummbfsxLDLPMKslkI7dQx9z3fedYv0OjvUERIb7jCDZMQrojJPUzpLhNWNOsdFu2/LqpFfXhqT729X1xvu2VzEgfS5zr9iYSWPo2zTzsFzmgu5we2Q7FjzlrODDT1IohWk9RpMz4RC1zChjqVKQVDEwJUFiGTjs0JMmcsWEJmCNiIrcgIZ0PkBQqfc659IpEWI16SvkY5pgK6t/78x/my3/1KP9dnN92jyC29NRvQmmsYoxxVqQ5dh0YBXk7SppMXS+WVsZJzRDH4fJwUz/GS/Kj83Ecy0WY/yT+Y2GRmCI8YRirBKQW2Rdc+3AAyTpGCvaOEzximWX6VAASH7KUQ0hgkikdlx5h/k/JmNJUAKI0EMpMHEWZP5I9E2O6oxy22+mLI7rw+uDZfSn483V+s83XhD4frE/PVxm8nCG7504NpaLKgjrCX/GA2y0foQZxJzCQ4aaNvYN6toP/Lmk0xqPW1YXRFBMCEgt7GLpyitJe8XA0jHHGYNOkjiNCLHwLnlmJx6SGVOJ4LUSkBEqJmLjWwUI1o4ziABULHzbDUBwb/WYH6R4SB2OjfLmfNDpJFcuMKnbagmZaDbMEJ52vQAv6tcKLbqgQQfgzYXbzGlSAzUvPz/f2PmlKbfwk2ROzBBqPGYHQCnBNzLSOqcK8ldTeDmc6lhKWHDQ1Gqa6vGKE1wACtZeaccjyhzJRX4YJbHRXEXDOKk1wUapED4DQvJjYb6xc/3yvvvnGx84cOOX4+fhfvX7+n6zvLuEpDrmgcPEhbSCtXlYWbUaZYRWCKb/rGVExxZN6algaDocLE18/Y3s5HJZ1INyLZhhoDULzAMyMZjM2KZQjGW0F4Yd45UxMs14QVunm7iTJ3JPrpxY6yxhy0mCFNDEFGuJETGzSQRhBeAwY7z4Nt5kHHocKkHWG9GNhB+2l5698SD843Aj80Ek1yX7aOtc+tBE+XSLtjL8ypxbrhkTnywDOJVpi31jCTZkc9IpYrD4zrNlZBhq9QyImFC73grwiGsiCQ/NUpMYhAhS6GDJcUrX7gyC0UU91qmBosMEs9KV7q+qM+SwMqZAheOO/eZyPji24ZK5KGUfByqxy5hO+3ol0xtgolEK8YxLXA+2MPMlL1OJv4HRDVxjWPjDZ0MvouubS1evUMNh2rRTe3VG35qridqtepzCScIzSwlynTtylxDsHCcp+OqNvlGOPX0RpMoooKt6krWzmzpJZFexQPmT6koK4eg3iLIq/uaXm+/XH1lkp/31frP6fvCUoPfvpx9uBzA8wPPVciO6J3GLLoVG+uC0TBNB+MQh/SySaRKhiJ+skuXFBMuYBmQUlu75vuk1ZqYglxABhZWk5Z0XCkqQ6dW6mD6toQnDPksPZH6aLbEY0bVI+R4kwyS7gVs1pT5/s2hFdRUDV+yPcVt+88BduUJKSHlNipHq/np1tT4+uCMgnaczkEyQZrKjEOL8kot0pcljz+w1utsPHkqi0AJsN6rnh+17nI0bowiR2HUUl57xPqsKZsTlO30FTcl/QCocQpj1t/fGw4kvIno2/dqBfW0zEXDnoxBMtQQOCu4Agj4Iwy/TXahFH1ri0JCqJzRvqlVVTl8IuoMsblaC6Q0UJozA9vfjz3/sX912QrBeqohBjCkU8TCtGS+2QId2rTFH5TLdV6y81q9dNAVmsYQNsUun5O44lKwmmTE6MHHkh2uD1pTjyDVLiaPqtbwwmSVZ9ZCQT7+MYTrgFeMGKVO7dDDwSAkaehIp+jPd5sfu8PGWp54YHX5ebU6369eT5QIvHpLy54d73dulQePlg3Yb2OTB+KQjHzyfO048k6XGEX1LWNkYZvDNGpomqYMxCyizCg3syqPTlFpYSb//5ULxapEyDTTVRkHTLFYrZJRJqoWa8zznfrl1S3SVO7ahDwEjwfNKxTzysXq8WUnlD9eb9dXd/sPzVrXIfUyCeuSdGYvcFwfey52H3u/fzYH+4cKjRTUqunHXdK3slkbDVniQH0bkYhJm2vcGf74n+HY4jk+f9NUsp7aRWKYmnVIpNTjIUFWpPYxVwC3XHMiodXxWanABDT8BJV9MM2B0v0acQUN/IgoCkxUuRyuDKPU7qF2+IVq47wGXyVzR8V8Asw0xZZD0X8nacWxIGQektrKRn8vL00HGcBAgCc/ZjAA8t1mj7bCiSAK3J0GHKtmA+6w9Y6TCHj6uT9sHq26jY5FsqzN92u8+D8zvdGeJSlqL3Xj2ulNSgs3GSgTXF7hAoLhc68nDFTcWb+xoECnf9VUBjMG5r4CkhlAopDNFEHzuqrGCGp/qoldn2/12b5bzitpfXy2UOe42LmVYK2p817TKEyViKcprnkLpXuwIpELdOFvywIhPoZPYxDgg2e8ZFwE8TjydQ0+hprxisXIEqwDfCGcfz4rxkI5njDG8oEQ0YRYIElbakPU0CkrnpN11AFU0nU7b+1dkpE95yIW+JViNw+i+fr+8s+6yxDNhYKzyvlid/MZgnsxqrXa6JPZ4f2GAaxhq7OTdm2fD4zHmxCkVsC95gpBeBPEJ2P9fFg6QsWDOkrETemPIlkcTtm8kvnNLWbIajy9JPwC9qgMUcaoOOcAgF4N2Qi0RHI+fVeVwihEAywkcKIRLeAyUjqNYounI1PwqmSkIuLcZ+gsd3yUFvnxq98OHhtO1VR9YFKhYgOC6Pex2+1w4NJYVw6y36xWllKRp/KB8jsHW1l6stk9WgB92h7UbbY/7z+e7q93jpVT45mP34Z4h+nw/ehwbSl5ULf6xXRP8cL465TZo68Kj9f2GkeWibIcN4gGWsBcxP8XuPMAQOiwm0ULyCpOO4Ok+CFUTLOPt58FrCj5vN4yc+Bvx/OF+c3N0S9Th4/XzXjZ8dXG3scDr+tvqvg/XkNZzQCYbqAQ/1qYf0GWhCzCGAiU5MeiKXrwLaMUt+BjDtZMUA4CTIVAfZJLKhBBEYFtmplYsGGt4ExqJQJDCjiCEwWQixfpThf0MS8K84y5LSVDxyTF4qdtf468xxKTR8iW2wQ1wAhwdWuN6Lma9pTGNZkmi2G+y3f0tMlvzP5CsDUTvdfhM+9iI74inaHWqauwkrDAtrWPXqjOq94wm07Lt8RI+LEsztjZ1ZvrE1d9OB2PDKTYZi6VoRKBaUqRz02IQQJO8GWjVfAPT12eCB56oOceDR2ROPC7rcSbs10mENKqKiQOFtNpuYfWyMx+nhoijlIcJ9BRuL5YJlm+Xd6fHrNqGWukgpYXxH3UDB7cEZCMc3jxsc+/uoT3fN+t5d/W5Wj/lsTxSbPe8ufFnw+QIqVPSmOr4xHCtWQyQdoNVJuTGyLxiAxY1aCykUUr6zAOtgntU2XjMZPkPmjPOcbDRNGnZXZ7/FjOqUEmoLi8O29PF/W/3y/3+8fLqapWBzaNFo7lLMzd5tEM3NlWFvaaXUysMhn6GbmVp7tvMpCqUHCEXyzMsluvDvJPxubpPiayHmGG3/QCkaw0Ckw9lE20Gf9LLeHKlUFiVaARZEaE8pAY3aEcHBA/2iQ01BYJ8qrTbz5QidnW5uutbax1yT0zG68+pkglZHsKCjH2/WXTep2E32UucnnYhbb+uqNFLM3tuD8JGuyDvPx13U2B6SCkJBxbd0eyKlSSyyWCzAM7VZ4SiOzgk4/WTUC+Bl+xhpSx5spsBmE6CpdUk2qv+CtWxg4JYEGIlsd2Sti/3ymno1ExD1FUCB9lKL+toG1iMlRbDHLgw1PjtBxXiRo5OeYRMfJbSKCy7/XZx19z90ypOFwTaxNF+oGdppemSLBnGCQ+n9X6XeOBmmourrPnhD/84/sv1F0uzDicdyOU2mcaFjvt4cgfM+j5DYWYh1uaSAn5wyRNwqB8Q+2tJcIG7foMjZY6SMqSPJlWI5hF/ncmOqxcgBzNSMlvwWfBfT29vu4/LSyvE5L5eRHl43Loz080iYlWs33XQ0ToGSNbH7ROWgZJLxwVLYRV10SupeX8mEkkt6vx8MsBijAvx4DMamVeNyrGHf6qFGHNBvzsc3nK9SKpAh8vRpkJBNkoZ7dB1dhU76zlWeyufEc7YCXsitUDQPA2GaGKMXJ4Z9XsvcTB0VGUyh1c98O51m4tiJojzND6XgzWIDqG0XgwH83Oqo5hU02QxH8CDG+gOy2vDbsLx9HtlwBcq8cZBAyDU3ShMFhr0iV2BtHNlWox7UKvZgvbh3EAcZLfvjCDAOdf4oQ4UAp//OVofmF37RUyr4Sa8J05AMH2N/sirC91rV840L2PJ3FwBVVNnnYBqVMpipODs0jofz0lWQNcmP0FkJ7ZJG5JE6pRd2ghrdVGmYVj16cL7BI/NxfFyY1AbOWU9bCULwU/HXDZe5yYbDL6bkjB9nhdyux65kqrerDYPjUxiFdLCT65Lhbck/c/7d2sFuR8BO+LMAAvbGOuS6cmU9LnuWaEhzOVOwidPEDt9PO92G2Hf1G3e0bH65hJ2ZgA98MeLMJisnJsdED2Gno4w+oum0GfN7h/oDJgFFF4cTzcgXTxZzS0KBL5a5fKNS0jEgWRv9r+SYddz0iH3+gAVaIUs0vr4CUV0tIq+2DnPp0jkKgOxe63Atg4v9suxMxOPMXR0OKQGS73IwJEBjUmgH3Oksk5DC/NmSG+u8lwjJo7Z1X3sxPJn8SfvJ0e2EScO0wIaTlcp6DS8KiEpEuOVRCFPY2DQkhM3rb5GL+9CSUwxFikgTrDAqCVXRy3ol/lhuzsmRyK9lh41c1bK6IVU7sRATE7vZNJM4AC8bJCj6lJiZP3OTnk6W3bhTvfqRIBJMfpz1m7dLDtktuU4a5AC0RD4RIt6pyrKxFbqKn7kJwntmDDgEi3hbBIyvSq6FA9iy4xxTLvof7kcxaQuNryF+3i998CSz/3x2XVkk8/yJwm+hdJrHiUQrj/2u93BYNeLKtxit/zY/7i7vvhttf/mAdF5Rho+IR7RyioRaCWw5hXeaRdX2qIwRYQW/pRxiOEHSImsP2ElxvFSLm9+19FsTXhv14dDJgwQdlaKRSWiL08jzm3uRs+kTeM0k41ujKRZP0CmvxICoccsEkSMIC0F1Go4sZw46DnelzDwQ2oQ+3fyq2GyOUZyNd0Xgl5Ea2bdpaqqQ2uZ9NPTVjRypYuzBMMJtsIhHcdzGdZidKwtscmRjhOsINS9R2PoaFEKALqaWuraxx4mH5c/XC33N5v75o1hkwO3YuBkJ1a+NLRrKyD7jrAxRyXFAqpxZWK/P2z0JC9GIuAjT1EQQ5lBZXefMS8VpLgQg8l8KwyzcCxc8W1Hksp2EolmdzJb2YdUFiZOkZoDiAT5QKGf6QHsQmA+s1OUUkp7iU/k8YMrc6PIXT92qsCxeFKl3/SNCtsqTMpzSPvkZH3xijY0OylGRgEDOkJsm9dIOrtEXPNrX50a+S32pJktkaFzQR/73VGXQF3uL2PZF9cXl++bT9b85kExr5+5I323/3H4ebd9+etFLlaKWwhSOZao7f4CLpkVKWQsnix+RiJnbXTjJzt2RC1PTcRUc1YX/hNvCHptTinWnnGtMnQjjOmmVGnSPNln/Jxvs6r0bPUunJjM4N6mqqpIfmLN4MVVVhZh0Zocf404BRceTtB0sMYDGChubOi8UT80gMwxX03ILK8FM/qGAVthuE3xea/nlr64ImbAXbKsMNclOsAdo2R1RIM8/2RSuKV9UusxFBChwpLx7thnXDXK0j+Y66QfMQKSaqWH4edYpXpHClG6r2pZtdiMMUAXd/g2hnvMywyPqxcLIoneykmjo464U3htfk/MwRMpDsDba3jwGh/IWVLLpevnKfBlXaCoATpde64Ov6J1eQp7WlcqJKL45KaYKEvxlkh89gcsxZrmm63UB9LtKlZrSEahgI/qCJays0BJlw0dxRR2EsTp+bKvbnypO2c6GiSDHpZR3m8YTRTjMlmm9nNqBj3b7Yr9PdeI3WaqhAIe+3i4vd1rkmXAi2VjoF1N5otyLUnsOR50JtigQvxoBasiyjBsua804+3zeLXdfp7275+5LnG12Vr96EHQ2rjmlobRHkvg4TiGyBXK6A2FqlyCLhePbJH3lKcmCMZMTSyXXdAs42YK2nUfVqeJqNzYLmAKEPoQMVh1fb2uTFLB8VWxH7yCFU5hpU82iY5z/hDw26YArC7RMoAxjftyJO/q4eKaZimCq3rrOjr1q/h/8/74Q+eX0i2jBihzX9a93ixvvyWCWMRhLijX5vBFX822qZVqdHHRbPSZ48k7EGcebcUJBBXwiwVjFYmHh+XRUxy3q3s91D9f/v55eaRaJ+KRETzN+IssQcq2uQEkkoA0hZu0DYzwSRN8Hnscp3ySEZiSqFAh5Fm1+K79BaABkagpcWZRmpgEzhH/7bCPrpZjyiwKH4xPAItuRirluV1/qkEHqVjfmN1SDx2nkguiCdbOciRakG1iVanlbiAFAmXvCWa+yY8vPczZJQV5C+szToh7ts+VAmrZM8qPqzuj0qNlZ0neJRMn6UTuUZJo3S93rBlf1MLg+INVqHIsEHfQzKTUyIcZQVPu6O7SGOlRlpX1wPv3/fXl+tuVRV8obHiON3FYo8HZPrwuRk+3ObgG/Hb6/Pfq+SHP6poh6VyQN4IHwkvtg2imyQ0EXd+NMZnc3LW/buS2WCAkfT8mrc/lLfwUW8mD8SjdR3F1LV/pT7AJjp/LU5Mi1eFMWbxaJqAql8P7moXe5eWQIWiQwz+ZrGKEhnVDaeBqImQyNLZFNQITVR6X7/93+RfBTQcZXP5x+auZFqs+DbRsVbjCsXi9a5QftPGJfblD+pNYWE7FMGZ8ZTCwXf6Q+eTVH/94/5f/tf+ff9v97zcT2640I0kqW/QVu53+GWj2BQIaJqNmmn3gP0EzLXRs0xE5FaSDyhigfhDUCgdys6M0mHAWyLCOBLHb3XPWtN242L+pEhO3oVYOopXW1XIqzr7zX+4U4q2RWnbQp1oH7XRQmKVmFQMD+fhGKkXxI4877i7XkxOHGXZsfYEc/bmpyLgiTNVqQPVguU+Lcm8vLq1NQEyOZGxabVChpUEJSzhHX3nU9OxN389MMn0FWBj7ANzl6tYgwYp3Nk0V5lzd9P0bq13fMlypgtSLG3u8xw9XuPPsFTxqztNTrHuDVXxNo8YqqJHJafPcOj3MKSx22nhjGxXsr2DCyUkkAXs7PL2sX29XuWcfz+rDrfM83ACHRoTMlyrNtrEnBNExgeM6piAV9/DN/miQ82+Wb7kOExaR0nQiYAFUNdOajd/paanGT01QhJEPbmhTZmP7bm2fxjwq97D86fpff17/9pflP+6WBxfXSlCvHgWSrl1H7KqtwGR0yh6cHL8yMtGc3uynJT3b5ZuQ8d8v/ofraH97/9s/96/ChvlXIOsM0G8fLo7L0FyHCXTCGUNl3HqqBtOIQOj2QqtvVbR2bY6oCQvb2GPBPHtkuK386Z46b51ZgvhpHSAqPe9EMICO2Q3EDd7Qj3+LahPLI2sEZhD++Mp/QIDOAcW4SssnM56T1InRmmEmYQqT+jEhzRGATXRHWxY8GZgaX5I2auZCKnZ/4+UA6FCeaKxRdNTSd7Fj7Q5LbASw7JKynbWAlyxw9F07A3fyDXX1oy69314YELOA/dGkaUbw8ZyqhBqQkuecPjeSIgjEAMp1bH2aq4Bp8TrcQliuEsExiZOBEadEUKWWnZxQ/rPfWBafB4o9R1jsRVJ2gDdmkR5M5pDxPY348KvE6QZeXgEx4mTKoYuIxEITRFkg8BVflBE4bHCImsBVrPxSkizIGuX/FBQoiVgN27EhA3wDrcPxbbd2deXVo4V/l8xg5gAAH3RJREFUy/Qoi8WDrhvPvqchbNjy0RY4AaSBZvhU6XWXBhWM+Ikbb5dHs1t/Xv7DEw5uT//nuBL4sJQFYPrSdqcWZWAzmnW8GZqKJhJXPz17xIsJqbopk4O6tcY74T/8cGsM/XKAWhqWwha+YhzdRGXhPyA6bsNrrXacB0aa9n92xqDJBywUWHYicbeYcj/Rqw2y9Q2Fea0mxJX0GIiVPq9lSyHluyZkWINIAhvbbS2lXVqK2hxkB3RGNyi0L4oSZd7fVuaVZVZcETV8ZjynvHRCYm1iIUvxF/cxinl4S6LEnlCBEVPoMoGwgR9kVUTBdp/gJ7s4ehy+tTHiYnHWSbNmt4xYIsPl5EI7ry6m5Nu1qUmGa97IuzRjW8RvtJMwGGEnymr6F5L2R3w+ue0jXhiLu2wFepODkj1d2cvy8bx/ZlkXF943vjYTYPXF5nh5v9lebDzZV78kocojyyUwXLQ5Ol50C/L1XJolVHEGbIwBzhpgKHDuqekWxBfelef5GftSnRXQBlHY4+d+zyCX+74G2dPz6cfz5vU/l3d5kRanH2isie5IpaG2hYBYk4P0Unso6uH2O4cyJXi1ZN0Ufkjxl9WfXC12fQOHlOUCXDsuHWk6zNpUxnoIIkX3z/BIlv4WA4pOTQ8a+717/L0CulOu6ZKbEK6w/+n+bEoTfvoR2sUo8eKnbaHch54+q5cbUtcYvS7IXpXSiiPIpAYdk80PR4aPfgcCobEOEKOX39MQC+g0S8oLVLD+tUCgdBKS6xuKyQcAzs5edeWkh7JvMU9oLwMjC/YEY7EzBk1YjFQiXHmkT0I439DWz8SMd6WZvjjKoszWkZFPduVwZsflabLbBi1vI/aQufe554uZm7EGYdf8JeDw53Sbhzw60wLvowfpnAS018+8wM8ub3wQ1+tOLE+VzO4VtMDTI+fuAtdkd0qBa2t41tvPTI96FKwZW89fWP08fbCIPInBw/jNyHDEt8y6i713l8sf7jZ/2f6RiXJmgyK5tSlGk54zl0KblMga8Fxd5zEcgqgWDeTh0PQpfvjlKnoGU0boWLnAhrI6CHQgomDdELETopbl3xHz7w/L1X3GBnjJtSqSsU5+pQCiPZK/DZQJT2zGb0bIdFigJ9a8Lv/2HPbO5OI5yx9Ma6ZqDMa9+JTCDGg+V7hbVx5L4QZRp79e/G6e1yUFsqvTFjH4bA2OfR2pExBLe/AVKbXPGfCPfKN+8gl204Qvbao2n9JiaEqSJ8YHxLm4Uwp0kVE7RnWR1SuIbfH1HI0Y+odEcUfs1Cx0F2nFl28VaxNRj1ZaMmXR8e1gySaZ6zSckJZY1XRl8pwxdxVtMMrlG/vlnHtnnGQk0Ou4YZIHrpY3Z+VR2qVv/JsQ5JB4qU6pja8KgUphSffoxkBrHi0HiO+hr3wxYT0mbTY+YAwgJkw9sEIOkDsckmXtlx/6K0MXDJO3svhO4kF2G56prZCP+CyDBay+rYWx7W9r12h3z8szWB4vr73/8ufHyYMXNSbcgR5219bHWJCZVCh9mqiJb1rXoTkE874LwjWjXA9pgZiuSwcsj5myuS8fiFVMXBNfsFvwIy9w2KgpWsykr2TajLG0sP4SixdhBRFTq5NeJt7XoIJhjcFOACVIBc/xZoB+2U9hIVw0aWGGAcbkcp0fE5mZAexHX3iTp+kEkhqxZ5f/u7DyWnVb1QoHBkOnwVzNs0FgAuKxvX5rti4YDcyO73D69eFiGIIXXlGBFFwmh9NAT2IUc9Q7ESE5g+M1x7iBWI4PPyHyZdyBADWfEb3fWlbXkTTou44e7Bz0aflpMSKNV2jLWe0hSB2wGOnqUROEki5r3Twda7HjamKJq8RQuIS5RWehyZyMQAh4drm267JrkmCDCselB8TvtaSEMXRcBnaWznUgVW2fj3C+n4EVJqQ0H1WYhSYEFh8MJ5RgvEfIh584gDjXtMSKV6c1kktUur4f6YUwt/6+cuW4+hJsdfbb5ffr1X9bHv+QXVIk+ugn6KhLMJAwTIzDF8KEAyzRhd54lgw0IIoU4T/98+nT4Lr3msD23DnoxDBfjbviwnmiALaRvKqsI6o/aZn0w7KM6kQVHwNWyAfV/swXyvi0sbsaumN+Shopa/adihV1opzTsc9c3XO2KmD6F9+WPxgTdzIXcYBRrvFh8mT7vhsx4dynQrTV0K7fpuUWKguaqrdGXTmejwK19fmlARaQYXi3KTAWH1wU/vVdcBNrqbYCiPpYscUi1RwgIGTzmR5JWygweoeLjnjgkyKlDAgi0qO2pveMwH42o1Ms+lMYe7AquArrCuJ7OqIG4LnhASLSpPT+7dDMUTiumJ9i/yiAdvXzodhg55nP7mdPf+oxcuSibMe7kUt3oaDHkbkanS5Emi5P0Ydo2iDbvnxDeuAaWccnfFJqK1XAfywTJzBpjxcp2l2LuBnCkqXRJw+zYAp+XxxX7kOwEg27D/eZjQKZPEe8l/o3RwU+DPOAaDP6YqTm2s9wyBg62avKjKGtvNCF8P8GDvR3TycvzspLkHHGnqoRPNq3GG6uqe2f9ppI56O9uEH1RLmFGjiJifgXMmoY6cxJIV7Yoe6qLNAOAkSGABoqArOgUBlquhTdl7QZjPF5m7P96J+zBKbr83T7ud7SU+ki0BofQJkUoMiQaBorH6HAJrSK40LcLLiE/bZFLZUKuNeZvBOHpHc0xxNCEelJGL7IRvPjviPPwGEfsv1OgQhdqyr5837Lj1uGOMsjbW/sGiw4dNzAKV5UIf0GvuPQpP4Yd605TSg58g9Zx9sus1ae+r3VUAokbwnENOeCqAihE9AzkI68jaNm33Jhq3xqPZ2A8aV2GaUW+zxQNiAo6D0sUJKv5s4YNXDgNcHBIujrKPhJ1OAKxi7TkSwVZY3GfzQ3NRKyon5YWRKQDJ8BsTlya47FyHTvklDt/nJ7+jdXcIeRCRejUx6ZTFtQliUzZZ7JvvEWwGru5wSayJ5uZDKAarw4/TGr9i1dNkEUH1AeICYGHtZ//LF8f1n++bl8pwU4YIAIdXI/PY5q5T5o3dGgo+2xS6NkZjc+MPqt/0Ai0ZNdtgapk77WQ6IsXPYragJitRYtoyNYiB2yn4y8W9n3fKhERQvpegmI4Mwg1wf6wWrsUwGQatpBk3f3PZ3AoCWH+jPlYGrMcZlvuoxbzVn74AfM/XJ5m6dc6GuSfNekxF0fDcdGbWKM9iAyhqWJ6Q0dVLI2qvMNjiRP1ezHiNXWtZG2M9x6cK6cSED9Ii57VaBVcK4V1hD4VGcrytiAgg1NFBOF01w7xIzTsOFAmWQZKYtJ4wHfDlYKmQCzTqbUzJ6rG1dNfotbBIVPrbvsr7wsSDQJn9NdCOTWXVqq7vmYwiGR0kEl+08TIBHAIm2BdSEMmPqBdi+xCVsVDy49iWt8XtXq3lHZNpcT2D7Yn/JlTHpGjze/r/Z/uTPGWP7xEuF1r3IOX5ZzVvAqvPhD0sajRuOYwaDhkCDDHu7c0tj1bW6x720GMU0KlPLJK74t98/Lw8vyb/2YrBrCsiMs6W84wGn1zuE47XwgOeGZV7jzeDThlPxQ/9AVbARMBjG6qz0kIk9wxNiXe1RRsQdipTeA3VCuaaVF3NswSh0q4s0IioUoQDpfWne2ds/UUY7JUdi94s7NZ8K/03WURDcrBoz6HVFguNDMTZ7L4DKKZYDGcBlCwUiJKVBO4rhtMeNOoaUGl3SiDoBYYmoZklFwHlZIK6HkP7dhdr3gLy5aJRvDQtZ0jeGU+2LfMrRiBz7MJRZAATUa9FEhW1yahOVNU3HvOkxYLSKMzA5TyfVdyrBgs14aomoVSkMoNmEAxzTHAQwZiZZrTKCkAx+RmwpF5QZFDkC5cXsTncbHFBYm6KTTXPJ4DjxvKoDv2Ip52BTOPJ2IjjHVg1u9JRLNPWJ1A/MtGNhbgGCtm5y8rWsLXDf/eXm4+f1oFcHTUwIGyERft6p3YMwUOHwiMRVogvgEjWkEpRxpsmTGBpjpzYoPiBTznanGDoR8G13fPS//3C0/CIJmSgQBi23lY9Sdi1CU9ZqcMI7OAdglfUFi9O6bUrQieDmubjEPSzag2WpQv8yKBplULNOhORoaLTSGN8TbChcS5l55WttXyuEIjlv0K7WWPN40qz4cDQQ9Guejlykaw4nDCSXmknqibd9GDBHXZIIpXvr2QQHdUK8dj5iAk9Em7JnQ7FXuYV6xmOOI29blUVQSHB1vOoGCupm71ZaJczbhlv91EM/QB58MfWzFlHBzMEaA7DTBSkjILf3NbvMlsmDR/vAc+XArN9ClyByQU1kBJ0DWVuwmoUVZt9tAYCfRRRXBzzfGMM9PijJAZhWAVhx/gB416yv0AaLmzot1s0b652H5nolXtmxOxzLs4oxhMxgQGBeiBRUFvGZW8hwT7xlosuwmAN4EpZ/RA0eDEn3Zy966B4e2p7u1s3jiuhkEA7+kYJ58j2hCTI2bxGoAn6TpGZypFkgNzzkSoLDEBwJMLrxYTZjb6sUF7GulJcQpMuLBeg1jDDNU1vQLK/EBBdJSWMpGEX5iu03H6KcfYIf0UCT9mcSJooEZJapOWd1irrP1YPZLMG11vJtMyRFT/tUyuZRRKxVJqiEHotr8SgMKR8EaKV0ctsGaKfepY6WqT9NiQSIxe8qr29AYKpEmp/g8yNTzrdUPCSj6nAQolY1e45f0h0fBD/o1fTiqC5q0iQ41MDKJoGJyGJMtfbhSRFaFBypZzvHAMBzXuSdVKOwACI8zWaaVesgoEtYK+8/lzKpnntJ6jL6ZT7cCSade5YG8Cw+nvBid9cvFqTZXIbDTdsULNu2ZH9pCUI8kexYps1ShPAQoXHm37PtiucQPk0PTCeAmJ0IWM/rbuRrgWLjqhin0c7wwKhai2uqm40I8ZguE32Lr97+vj0ePMelFAz1YBzPqSg7hE5MafCq1Dg1imshAvymffpVLEy2GVMsrfFFsmCKvU6yHjq6XR0s/kO2gN5aADjeTfpD0JTMKpyePJY8sITffmPfBvPLkuspMA0lDF8/oV0y2wfMTs50NHG26Hjsml0TIUWTJrrpvxVhMDwYlcxjSeOGM0umXLOhDoELBIX1Oci+VYcHCGI3dr5AZCo3ocQl0pT3zIYD5ZdOrfBe7+ppSUDnV7TdU+47Vihllmv78xKS2hnLIEq98J0bax2g7lgTgulZwiSD9qRoOlVdmJO0+H1YcMX7F6XWdbBhLCerjolQFTRAY8RvYlT0Oo4tURaxSLOo/brzrYf3uZss+htH9NVmaExA8AW3sUltwh53AnUFRzT3o23HBBeWaI1SlbQaRZmKSz2AvlKJsq8TES76k93iTWz4v++8uElSR7oR+zhj3XUAlmlilLV2N5vBpZMtAH2Lu/N8sh5wbNcE4kxCaILJOgA9gjHRkb5KN54l5AcejgVwqaBaRiZTqNxrHQIJN8ffzkOnR5LQNMYohgqYmmL6fUQvE3FuYRXSxpAyIHXc22orZuep8Y92EWdpchNZSAw/dQNBifBHOMPI1gnsxD0CSCGmklsAY0Ge40wlrLlsjLMeLjxlRyIRp3LAQn8pPLCZEpYsD4IdF7pYX8QvsUNJfEYRouMCOKhpVclhPbOYfhJzZZEpi3LWAsw8oLQuU6TYtiZJqdmmLm6rVbiXMBKEwrWJ3Y8Q2mogkGha5narlJghW4MDneM+6cIPXkMVPCOUen5ENSz4VsIbVgIHtad38QKZKyMl6wIqy/VJjKAaLrhnHBwjbKykMTqaYbMEDqmIT6+Pb2j1WHnOW6yYYZnAuYAlmyI5Uug+cU6HPIOgbt+KZZu34yROaGCTEKEZGYAK9WbvHA94/NEOVyrthIXTjUR8vVQFtcRVHMMmf/TW7Qy5QCJwkMmCV9JvowAkrD+JhVe7uWyqvIhVgIzijAywfXooNvLAbYPY7+sV0A230XrSNr1g/8wJUupnpPBFkN1iy1WERJB0Pz8xV+dI6uyQjmihvfk/A8lrOpx+uUaTW8rQsP7BQAyRYjC9fNoNsk625eiXdVZKOEPVd/9TuGIMOSs/AcMVKps+bcpymiIYwhfBwF3qjiW7Uh7ooBhxniwnYEhQcz9R1pXIOrUAwW+X0EyHfSiYq14eEnKz8rkmBCRzBJSWKtb81OxYWfqYuLoXbZsxKKpCQA6BOBaqeKoEHn+HHEa1Nx8JuYIkNMyGgSQBr6AL0KJ7WJc1Jr7UyF0cUONNqQwwd58aEvRf+5iLrH0HAYVxeSTLTzN/9r66w+uwfQ+1a3BLGmpoHAfRlKdwA55hjcBqtpPapyoam3l8V3juJGR8WJuKDammUdjXAYoyYwagT4JNMWRhjDejrBIxgKcmgX/wTa7RLtYYfcGNTVhx0RgUmwjllsc6EDGSBU0OMm/VBIQzRFtDKKgpclL1SCnwwTy7WI/uKRBVKR+f2sWDO3+wbTeCT5ptkpm61Q00aHcpZcjEOgAnU8pUokPHbbRzgcL88/tVTPHIX2Ovb6vCvzduPDgyMjxW1kaiwhBktlG08Byti1dJwG8PQLlk4GHMCHb1UnEkcVEGMies3LOjgzGLWmSHQgVcIQKcRFv9OHbNMDw94RatdbaI+H+hBJjg8RX+jZhcZbU27IRbqLAbfxYUOkM2G4CBRD8FuxotSQ2QbbKYqmMJG41xA52yyAud03+180sGRQbbtm+7ZhLbqtDNmUJ+tJNGqxyofscPU18cPR1DYLq9u364Py8rcQ6gWWIaBNp65OeoUvh11ZUpD2pVH6itseZ59OQzQbZTTGpkwOKToQEVVqPmnh4JulnsAtWcIUGMczEjqyXWLHGwZqMhXd2y4khIAvyDqf5ZvmYiMwnAyiWz7FuyJO6jwYXAJ0lhykH1DPgHYN5EK/gDhvPJOjREIq1FuZQwKX5DRlLyPtye7qKHo7QmSqQ7fAl/JsYeITH3KNBJhObDw1dqSAsYzHPiOXoR2nNzGAFym+3hcnv65PL1kKiyOqKcjqfrDBQ4rMugCnlbaIobxj+eJj4lZMFGlEsUNyk9h7kwavRBwRBvtakUvdJtmGAmgVMqVYD9+OYBAGwcYY3L8iyfykDM6thG73Y3GbLImWGsoEPc7MRLpelE8gb0iy08g1Sw/kbL6g5edGLcYD3TNsW+tzgcdh5ydTRtd6pKTVZhwFeyc772kgGOOORVLbK22ct5XFzPDvDr1MbVhpEuRXTBxc/k4TKZEwTVTUljXKa3CpGu08WSmL0KLi7W2OGr5Z3N0TxOElT79MNiY2NkWk0MH7zDABzTB7LVO/HTxGGbFCQ8RJx/ltYI9iJGrUSP3m9/Vak0a2jq6JR0NMoggQeU2NlH1UysSIgsXPWuwLbDU6Kg9AN5Ts5mt2KmhjFyNN8DF8+1vlu+U7jqD9RFdlJZ53vZscSd0NOJ7tuE/rPT+BzDWZyQaiWvteK0qvfx92T6kK9OJETDIYADgBTZsqD7M4JwrVijFElUJy50aB2N7IxFn6DUi5yVIzIkxoIIxR0Lf5oOOs1pBxL66OMsecs7arzUP0dRswwHUfuNB5OwnAWbAZdy175wRA2oWOUn4HKiJ8924c6wqLeKtjqHpcxMzCYiCmgy9xNPOeLAdAkzT8x2G+rFT9uJLlAfNiX9RbIifP1MdDz4OkmX4xwaR6/aTu9MBuPX1pE6Eaz4a068+2HpOmS83kOhQlQXrAF2bM5gW+3XmqiP4dMyiUfEyllcmiRxzscmX8MxVoucoHizn5J686nAOrErYXByoA0h+kiYpj20Id4AhHqEWwFBu0qgdqiR63LLGEekKHj5HHC1qOo26oVq81yJweD4By1iMpn0sn89N/RiGqtmwU6Y9/HTxQb8kneMGiIRfpJTyE2J4DB9nASGmBYrGj+cgufGNu5oh5Qarh95wM5GqZqMh/maRVYxFhKq6oEcoUpAroZbtioR+jxtUoaw/R/sZo5p96EXdgELL5qeNpA0ZUYeWFIgPdAtZ8tcfIsOZZurGoJsIqhye6kMUo7sUJ86tIteWhJzEPFu7EWSgTzZExI/0YrJhU4Gcu6Xw4aAtdNQadr/4GwhyHH++fb5MJ2aqcDtokJlgEWpgnfEVgIJZJfRND+U2q3xZQMngijhisK6D4Aog4i8ukla2NYX1e0g54lQKcGPTAKI4tTVlMsUkD/aed3ddGa1KkCzT/y6BRpy3fAnUNs8C0o1nJht14CdTfswCej6Od7lypiz4GAdQfToBTTQk58o0PMdFqcNBGSZ5OSdTa5drhxi+mLW5L0MFdj9VWGpO1hqYTjDvhXZ27ETctYNg7froEKIauPomeK1Fpkp8faMxj6ECJmdMmASyRhK08TPUuC4O2ahEtJ2trA9X7GEGD2PfEAAFuQK4FLTdReIUSlgSN/kSS4MY+8RVJ45z2ln6bov59hPiPkUj8HU/OyYMKnViQQ97MWIgU8eXtmIEmB4zw4qd/lBBjVidHYWnV8Lx8FS2iDFQQhnEbE95JEq+39oc8dBIYzEsrSeS2TJZlvQXDxSZtns8+iNz+cuQQFtl3VlgKawAqSSp6JAOfHSmuowTwSDio7rrr+6lsIK813HRxmfGi6rXkmCdHr8zOUnGhOBKndp2fNq/4W1CXSBs3bg60+x1a2Oq3M3kQgwSvUSVVWX8JL/SkLI2xHU4NirPQsWmfylBc6Y4rbhk/Y5PYqAY9dtXkVK1RdgBtiEj65d0QZ7vUPXHXo2X6LGMIesC7b3rdCIr0OCJB4ZMakG9U7r6ZzJmq50FNDvoCNX2NeoA8K2qEFzEcnQOfc8VWKhSOKAIEYHqXYgATG2UK5r5cFPWK+RJ4fqJh4uhZr4BdA2XwWTMCUeAqnQFK2NZ7TL6cAUieVTH/XiLD4ySMKCQfTkWVmfTK0kpfaqjAEffjAOwhBdTHKn4eW4mvEhOf3H9HJ//tbkph6eypQcYFSoYA8YEVloLE+GyYzJ8T1QWJ0KgZaaVeF41F9OxdSCivza1yohBzG5k5Eg6K5vKGoQGJ+3K7WYBYGZ7uESDDQlFC+aS9UgNxmAFGSGtMGPx8cnxGBh5E9Hj8mI0jH5xRyRdv01dxTDc8r4IaIjJu3QR9p0kgrNRLU2IkRQzkzykUIGdTXLMFini0xXZXCQinTlNTw6UOVCBAOZ+QvOelu5n8TLFSAa03jtJghdmMN9VFVSBQ6ZsC87Voi+uPpEID/GNhiEvPLaer4x2BZyKKRqdwuHnt+X6MdcNZNhaoVBnMZxYa/CjiUKadcW2sQEFck05TJGI1JlipiyF+3AerhhL6tzAd1qujem+XASMHVOTcIasTuZpeeLqZBR00AeLU2yaV1RAIujHzplYc3QcYl4x61/c4cOFXFTOmCHM1ejtxLz6k1Cq//ppX3UFHAeC434y/W4xTuxV12taz9CwLoitM9atqzrMVaaeX9+h5ejkPzmdzwSP7HQwgKAGGEoCuR3Ka+anALXBNKg5TnJqKEEGlIPY7XwlAga4ybjmKk8B1eFyCdBnRUDhTiAsHW6c/ebBBCZyDFrM06vgYUIFojLI9+WHh22UOMZmFBWhOJiS7RPCfgMMf9aQYhHQroPti7QvkX12VmrRmHqjCkOkBcqTn4BCTJXyvqSi52F54Pg33iLqs/vX5cf35e+fueE1EwNKK4//9ukYZm2sQcDDD7kwQLQk+rXpKNT8VWOHAtREPrFGHlUuGwvV1fB8yAUu4xM3Rl3Gdc3nRLmlaYJYxpiudd7HLEvhVPUTLE2yNGTy0A06VdNACLc1EhCh6YMflm1zFk3YeNqzu+c4GIchmgFSDEOfr2lTogJ2CpV2ZXDN2LKFtz5YbtYvxfDaCq/LzcYT41sjX6WWnei7pGoYZ3VXmzmLODqDBqX09tc0C0zoSYHocuxemUrXeKNODXTqpgkm4ruWaieOqGJaSDXFEiBrIk6ZPxZpkFViIPMtGIODZQyp1K0jKpPI2rA0fp+JCBXByiddbBdueU75CwOVyB8HtQv/MIaH/rTvo1gSVoNFO1gdFJzosC/TJtUlljJYLALzrWRi0leNIFPpVBWlkEkMI6B97tSVeQL2ozhK1l4rkB6k7/JdrFnzizRAxdoTBlxXfnbfd6/ckTGZm0EIfjRKhXBDikVqDFYQ0HUAitTYhhWXaGcSblo9IZkub8v0W+GoU8URbfIB6zS9X0M+0wwzYIBR0BVQxQi/uxGQ10WP6DoyZIsGviDpA5A0Z4cp10IoSLYmldIdkSKyq187gQB1JLB+Sx4rzpoNDxn/UQwf3bfjpw1Mfd/SdNExCSBDXphI7/lVOM2feQ6FoTMi+zlHFPhFXItDXElVy/+Almgasv73G74hrmbLhUSTljG1fM8GBYgXzRaNtoZufmKJlbDC7J0FRikhFtl8fbWCWknloH1233bxE/6ajrOqcJg7qxqAa6+oRWr/8TAm/0V2UBo6CeH2ooSeDhPlvBxgOJ4AWE7im0TNcEJTDOv8D2uLGHVsR+Iw2tXt1LvYpbGHcAj86RwUYEPKGBiQl9rMo+fCc40YIzA0B+oRaI4wbvEeVhFhcGjSr+vLEebFgdu5YU+xTPA57oMl5StFcCt9oT1nGcoI62yJpDxOakP4wRX9qkIKzEgBEtfxgKsOTINY8T0buv1uWHIm+71+ktZw2JGMb+KkC9JQ+/zER2MYxUHX2M9C+FugQUVb9DiqQtOOz0NTFPzXbRzQlE9crmAW5R5F4deWElPu62A0FE7ymR18zE9c2doLqRXe/h+/CV5MfD60RQAAAABJRU5ErkJggg==", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 0024:\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Display sample frames\n", + "from IPython.display import display\n", + "import PIL.Image\n", + "\n", + "sample_indices = [0, len(frames) // 4, len(frames) // 2, 3 * len(frames) // 4, len(frames) - 1]\n", + "for idx in sample_indices:\n", + " print(f\"Frame {idx:04d}:\")\n", + " display(frames[idx].resize((256, 192))) # Thumbnail for display" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:40:29.429550Z", + "iopub.status.busy": "2026-03-06T00:40:29.429413Z", + "iopub.status.idle": "2026-03-06T00:40:29.433997Z", + "shell.execute_reply": "2026-03-06T00:40:29.433065Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "First generation time (with warmup): 63.9s\n", + "Output: /home/ubuntu/ltx2_output/\n" + ] + } + ], + "source": [ + "# Save metadata\n", + "metadata = {\n", + " \"model\": \"Lightricks/LTX-2\",\n", + " \"prompt\": PROMPT,\n", + " \"resolution\": f\"{WIDTH}x{HEIGHT}\",\n", + " \"num_frames\": NUM_FRAMES,\n", + " \"num_steps\": NUM_STEPS,\n", + " \"guidance_scale\": 4.0,\n", + " \"max_sequence_length\": 1024,\n", + " \"seed\": SEED,\n", + " \"first_generation_time_s\": first_gen_time,\n", + " \"text_encoder\": f\"Neuron Gemma3-12B (TP={TP_DEGREE})\",\n", + " \"dit\": f\"Neuron LTX2 DiT 48 blocks (TP={TP_DEGREE})\",\n", + "}\n", + "\n", + "with open(os.path.join(OUTPUT_DIR, \"metadata.json\"), \"w\") as f:\n", + " json.dump(metadata, f, indent=2)\n", + "\n", + "print(f\"\\nFirst generation time (with warmup): {first_gen_time:.1f}s\")\n", + "print(f\"Output: {OUTPUT_DIR}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Try Your Own Prompt (Warm Generation)\n", + "\n", + "With models already loaded, this generation reflects steady-state performance without warmup overhead. Change the prompt below and re-run to generate a different video." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "execution": { + "iopub.execute_input": "2026-03-06T00:40:29.436475Z", + "iopub.status.busy": "2026-03-06T00:40:29.436332Z", + "iopub.status.idle": "2026-03-06T00:40:50.937829Z", + "shell.execute_reply": "2026-03-06T00:40:50.937016Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4fb0a3dd8d4049c795147b367d42d498", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/8 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Frame 24:\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Change this prompt to generate different content\n", + "my_prompt = \"A cat sitting on a windowsill watches rain falling outside, with soft piano music playing.\"\n", + "\n", + "generator = torch.Generator(device=\"cpu\").manual_seed(123)\n", + "\n", + "t0 = time.time()\n", + "output2 = pipe(\n", + " prompt=my_prompt,\n", + " height=HEIGHT,\n", + " width=WIDTH,\n", + " num_frames=NUM_FRAMES,\n", + " num_inference_steps=NUM_STEPS,\n", + " generator=generator,\n", + " output_type=\"pil\",\n", + ")\n", + "warm_gen_time = time.time() - t0\n", + "print(f\"Warm generation time: {warm_gen_time:.1f}s\")\n", + "\n", + "# Display first and last frame\n", + "from IPython.display import display\n", + "frames2 = output2.frames[0]\n", + "print(f\"Frame 0:\")\n", + "display(frames2[0].resize((256, 192)))\n", + "print(f\"Frame {len(frames2)-1}:\")\n", + "display(frames2[-1].resize((256, 192)))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "01b86c5511924c4b967f584a8a16a646": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3a590911c73e44f3a2c20b1a6b80c624", + "placeholder": "​", + "style": "IPY_MODEL_de9ecdcd6b654176b68f55c481f7edef", + "tabbable": null, + "tooltip": null, + "value": "config.json: 100%" + } + }, + "02fbdb8ae06a4617b349918c9f9b79ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0427388f2b0f48318df4e0f82a17159b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0455002fae1e48ba85e5e4fbd24b26df": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_065ddeb0b2a24b4183dc48c23457e550", + "placeholder": "​", + "style": "IPY_MODEL_98a76de7f43148d7898e725ca1bb15d7", + "tabbable": null, + "tooltip": null, + "value": " 8/8 [00:03<00:00,  2.37it/s]" + } + }, + "0488b9081e0b47c8a6e00af407b779d5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4cefb9376e214862ba68677d33bb88fb", + "max": 11.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_3b862268eea94942a239138297cb6842", + "tabbable": null, + "tooltip": null, + "value": 11.0 + } + }, + "04f9b51c3c6945f88fe19a93845ad678": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "06374e368630466db3dd8df4d2b1197a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_91b4705c1b5e4e79831a63b8387fd22f", + "IPY_MODEL_7e6e6e0417d94df28bca8f53f498cd5e", + "IPY_MODEL_da2a955513f142498862634d8dbaf225" + ], + "layout": "IPY_MODEL_fd361ece51ac4935b9ffaa7e68db953d", + "tabbable": null, + "tooltip": null + } + }, + "065ddeb0b2a24b4183dc48c23457e550": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0669dd35c5824c0897ea167a02c84db4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "07e7eba7da74421e9ad2e744902182c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "09c9559aa0514eeea4e79a138a6d274d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "0aa3fbaf3f934179b2c64b9c0b3f0eaf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_487a2a4a730244c0b3e8e084a3756179", + "placeholder": "​", + "style": "IPY_MODEL_a7386b00f241468bb3a8612af129e26c", + "tabbable": null, + "tooltip": null, + "value": "Loading checkpoint shards: 100%" + } + }, + "0ae5149f1062454196aec5741e6bba06": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0cc0cb98d0e94368890fabb971383a47": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_aeb6133df8064e07913e6708b8499d34", + "IPY_MODEL_5daf1433f05b44549d6e33f905d6460c", + "IPY_MODEL_b726f5ca92d34242862b42a2a4b46759" + ], + "layout": "IPY_MODEL_2ee2f716374a430185ba4938d89b6e9c", + "tabbable": null, + "tooltip": null + } + }, + "0d0c9c536e0842438b319379f1411e21": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0fb9db3a4cbb4f65a7545512cd1e0e1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "118a5b4ade6e46bf9fb943bcfe2f0cc5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "11aabf54d4604cb38aabe4242fe8d035": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1285d5acbe9b4814acc11a8f46d9ebbe": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_dadf6f0341004bf6bf3c4f98eff5708c", + "max": 2931020072.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ef9b0a1ece54475ca026674bc25a27a1", + "tabbable": null, + "tooltip": null, + "value": 2930935698.0 + } + }, + "13e8cf6414864c38aa38ca3a92b4e6e0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "174910e6eeca45d098d66d7acc688aa5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "17770dfd00a745b0a85d43675a4ab1d6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1a3fe16797e147bcbaf2058c3f4d377c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_04f9b51c3c6945f88fe19a93845ad678", + "placeholder": "​", + "style": "IPY_MODEL_c28b525e5f3a4c209adfa56f902399ee", + "tabbable": null, + "tooltip": null, + "value": "vocoder/diffusion_pytorch_model.safetens(…): 100%" + } + }, + "1d938359bbe346ef93205b104af7779f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "20709fdc45dd46c9a9afe2fc1f9e4edc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "264a199c5cc9484d8d7ed48afec46ef6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "26ec67f43a184ba790c149c7d49dea1d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8b8ba5f9da9e49f3a7a32231c5721b35", + "IPY_MODEL_f1a5e539ce3049ffbc13fcb58720d467", + "IPY_MODEL_f9c45c57f92c4f63922dbed2a5d563c1" + ], + "layout": "IPY_MODEL_6c23052c0c3e4c5ab171cd7d7d87b1bf", + "tabbable": null, + "tooltip": null + } + }, + "2880c0657934424b8fc7cc01909659ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "29a229eea2fa4f149f31b6ba3de06ead": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_2c82ba75e9034985befbf95309101e76", + "max": 544.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b262972299694b3b980de546b3c38f60", + "tabbable": null, + "tooltip": null, + "value": 544.0 + } + }, + "2a7714ba5b5a487f9d48089173f3f45e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_13e8cf6414864c38aa38ca3a92b4e6e0", + "placeholder": "​", + "style": "IPY_MODEL_a8fda30e8f4b4f27bdd241212ec183ed", + "tabbable": null, + "tooltip": null, + "value": " 111M/111M [00:01<00:00, 405MB/s]" + } + }, + "2c2d1791828e435eb76f0dbf4c47a4ab": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a030c128b2674e2e975db0881a5e118e", + "IPY_MODEL_834c90b5e4f4492f9e2746efb20846d0", + "IPY_MODEL_c53d41e9e6fd4b8780b72100b844fdcb" + ], + "layout": "IPY_MODEL_63ddce0c99244ea3b479655b3f80f1c2", + "tabbable": null, + "tooltip": null + } + }, + "2c82ba75e9034985befbf95309101e76": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2ee2f716374a430185ba4938d89b6e9c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "328f1921f207445db51f272f4bed8672": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "329713961c8f41a48341f006b777a0f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5f15e93809174077b2d2687a99f30240", + "IPY_MODEL_f50d5b69d6fa4367bb47134af2545c57", + "IPY_MODEL_da7ea885dbb0484fbaef3c9a869c777f" + ], + "layout": "IPY_MODEL_ba2c7d643fe7400c932e50d5f090f3b1", + "tabbable": null, + "tooltip": null + } + }, + "34d1595dfae8479b899790ea7014f9a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "354027e14a634b3db9e4e32aeea4f571": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3796625b699445bd9493de4662418266": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "37bad1397e9e42a192fef2ede934c478": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9c8170d86fbe4490bf12015bbc091f9e", + "placeholder": "​", + "style": "IPY_MODEL_354027e14a634b3db9e4e32aeea4f571", + "tabbable": null, + "tooltip": null, + "value": " 2.93G/2.93G [00:19<00:00, 122MB/s]" + } + }, + "38f067cd5ebc466a85e97bf9e8eb6487": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_118a5b4ade6e46bf9fb943bcfe2f0cc5", + "max": 8.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6ee664a8871f46e3a1d27e3ff679b14d", + "tabbable": null, + "tooltip": null, + "value": 8.0 + } + }, + "3a590911c73e44f3a2c20b1a6b80c624": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b760b3edcba42f49a0b9763522f6413": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3b862268eea94942a239138297cb6842": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "3d8afc5fd08f462ab37e364a9f72fef3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "3f14b0c7c3a642669bb8a36ffb99c5ef": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "41368cc24bd040ab8e9607eeac77d7ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "487a2a4a730244c0b3e8e084a3756179": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "48a9ce37d3f2456bb51d6603f105a49e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4a8a0c8725ed4f008e3c376d96a5e244": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4c48f0ddffb14dcca978d639ad824467": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4cefb9376e214862ba68677d33bb88fb": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "4d926f07296e421687680fe5ea5a3bec": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_01b86c5511924c4b967f584a8a16a646", + "IPY_MODEL_29a229eea2fa4f149f31b6ba3de06ead", + "IPY_MODEL_fd8095c855634516ad60879d32a9cd46" + ], + "layout": "IPY_MODEL_5d03cabf618c45b19a1f7f553f492dd9", + "tabbable": null, + "tooltip": null + } + }, + "4df01cedd4244b15814560b4e5efd1cc": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a4a2dee4cd7c4e568c2b7d585be1beee", + "IPY_MODEL_5569f4f871e24c819eaf692955a866d8", + "IPY_MODEL_e688b3776fb044ecb96ae45fadce6501" + ], + "layout": "IPY_MODEL_a7a50d31e3b84e6b871db42f02dda979", + "tabbable": null, + "tooltip": null + } + }, + "4e4cb26de8ea451090dc284eb9d97ccf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "4e645f18993b473cbebb8596b82641f8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "4ef85306c56b4a35b25130de7e56f6e8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_0aa3fbaf3f934179b2c64b9c0b3f0eaf", + "IPY_MODEL_b8dbfdd968774be38a664b7d2e0f6e30", + "IPY_MODEL_cc0374adcffc47dca859148c85e7250b" + ], + "layout": "IPY_MODEL_eda38bdc565c474aa8ab1f9288cb07ec", + "tabbable": null, + "tooltip": null + } + }, + "4fb0a3dd8d4049c795147b367d42d498": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c3086b1f42cb4f0fb3f550e1f2f04d3e", + "IPY_MODEL_96622057c24249bebe10774e7df0aead", + "IPY_MODEL_0455002fae1e48ba85e5e4fbd24b26df" + ], + "layout": "IPY_MODEL_bb07d15ee78c4f5d87e8990017452f08", + "tabbable": null, + "tooltip": null + } + }, + "54dbd22916164ddf916d089b73f7925c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_fefcc43a2feb478cbc29f313d3329b4a", + "placeholder": "​", + "style": "IPY_MODEL_09c9559aa0514eeea4e79a138a6d274d", + "tabbable": null, + "tooltip": null, + "value": "Loading checkpoint shards: 100%" + } + }, + "5569f4f871e24c819eaf692955a866d8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_96e723b96f224057b93b1e3e59c90ae0", + "max": 4977771856.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_82026b8472154512956496e84be0094b", + "tabbable": null, + "tooltip": null, + "value": 3256514538.0 + } + }, + "5644dac03fe54d019b565ca0383f0f49": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_5e1abff8c5644daca8753c8672118678", + "placeholder": "​", + "style": "IPY_MODEL_7fc67acc3f9441b684d00fca5ae9a319", + "tabbable": null, + "tooltip": null, + "value": "transformer/diffusion_pytorch_model-0000(…):  73%" + } + }, + "57a20634adb3447587135cf04843ea46": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5a4be0bc11bf442fbbaf9ebc3fac867c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5c8b895e15ee4942a69f5cbc1d2567f6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "5d03cabf618c45b19a1f7f553f492dd9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5daf1433f05b44549d6e33f905d6460c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7803c998f976496d985199e258d0e545", + "max": 4969712888.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5a4be0bc11bf442fbbaf9ebc3fac867c", + "tabbable": null, + "tooltip": null, + "value": 2304331085.0 + } + }, + "5e1abff8c5644daca8753c8672118678": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "5f15e93809174077b2d2687a99f30240": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_1d938359bbe346ef93205b104af7779f", + "placeholder": "​", + "style": "IPY_MODEL_c6ee561499ae48ddb6a5bef62c209647", + "tabbable": null, + "tooltip": null, + "value": "Fetching 10 files: 100%" + } + }, + "6331231a0b774b5a8bd277f1a8fe91c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "63ddce0c99244ea3b479655b3f80f1c2": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6460c6e552314011b2bd04389e527852": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "64f7aa6576b642488f089f531b354938": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_a6e77118ca0e448696aa6a7d37cd62cd", + "IPY_MODEL_b8bb0aa15b9e4bc484c38d4ed38f2431", + "IPY_MODEL_bb8254dcda604f4283098ffc98c932f4" + ], + "layout": "IPY_MODEL_85f9174d9939451fa9640f17b66aedee", + "tabbable": null, + "tooltip": null + } + }, + "664cb666615249a3b5a179fd1675bfe0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6c23052c0c3e4c5ab171cd7d7d87b1bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6c3ca261e92841f39698118ccf12f946": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0ae5149f1062454196aec5741e6bba06", + "placeholder": "​", + "style": "IPY_MODEL_d8004bbcb1e5407db10b9f52cbb06739", + "tabbable": null, + "tooltip": null, + "value": "Fetching 55 files: 100%" + } + }, + "6c9866e6341a4b5cacfb91a2e0adbcaf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "6d1e25341dc54d27b5788383c4029523": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_02fbdb8ae06a4617b349918c9f9b79ad", + "placeholder": "​", + "style": "IPY_MODEL_ea91a3fd6f4549f7991d239a8ed17fd4", + "tabbable": null, + "tooltip": null, + "value": "transformer/diffusion_pytorch_model-0000(…): 100%" + } + }, + "6e20524468c34c05a633a794ba241c7e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_4a8a0c8725ed4f008e3c376d96a5e244", + "max": 4994621704.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c5c89d7cb9af4504b7bc2c24a85899e5", + "tabbable": null, + "tooltip": null, + "value": 3711476760.0 + } + }, + "6ee664a8871f46e3a1d27e3ff679b14d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "71d9555514be40e8834fd5bd1292c8f8": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "72dba564050840ddb10a554da49c7b66": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "76064d1f94d044ffac85c29e99c689de": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "77e6f2b651fe46209b1726c46f655839": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_1a3fe16797e147bcbaf2058c3f4d377c", + "IPY_MODEL_98fe5630a3ab4bca97fb9d20370d2549", + "IPY_MODEL_2a7714ba5b5a487f9d48089173f3f45e" + ], + "layout": "IPY_MODEL_4c48f0ddffb14dcca978d639ad824467", + "tabbable": null, + "tooltip": null + } + }, + "7803c998f976496d985199e258d0e545": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7b6619f7bfec4c5a95d8cb7f5cbd68c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "7b75ba65281f462eae25beb45b639d8a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ea29425c3d8046138c6b7c0398d101cd", + "max": 2444982370.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_b03a7a832a834cebac980b3eccabdc58", + "tabbable": null, + "tooltip": null, + "value": 2444982370.0 + } + }, + "7b852fed5aff4f76a0349e2f8432edee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7cb2e55790054ea38043a8ffdade3210": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "7cbf36086de549a280dd524de4914453": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7dafb5f4f3b4408d8e073852fa5407c5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_c4391acdae0c4160b2f386dd4b29a939", + "IPY_MODEL_38f067cd5ebc466a85e97bf9e8eb6487", + "IPY_MODEL_fdf004d8ade4441f9099d53279d222a8" + ], + "layout": "IPY_MODEL_d25a78476e9c44128bc483309f2075ad", + "tabbable": null, + "tooltip": null + } + }, + "7e516904ea444588a0296e5fe2a8a944": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6c3ca261e92841f39698118ccf12f946", + "IPY_MODEL_b3154b8f2dc14fcbb8c3b141f392ff59", + "IPY_MODEL_de5a44ae22d2455381e68b1d0c0c185e" + ], + "layout": "IPY_MODEL_0d0c9c536e0842438b319379f1411e21", + "tabbable": null, + "tooltip": null + } + }, + "7e6e6e0417d94df28bca8f53f498cd5e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c9b65a04e16d4decba0c5c81adaf4191", + "max": 8.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_91ce98e3943e4bd49c64c8de2197849c", + "tabbable": null, + "tooltip": null, + "value": 8.0 + } + }, + "7f5cf11367214f5088f09282f1296ae0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7fc67acc3f9441b684d00fca5ae9a319": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "82026b8472154512956496e84be0094b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "823d3dd282bb400a8ac51a3830e8dd23": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "834c90b5e4f4492f9e2746efb20846d0": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_89a5276d154549408eacd8b6dc8ccde4", + "max": 4994840928.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_17770dfd00a745b0a85d43675a4ab1d6", + "tabbable": null, + "tooltip": null, + "value": 3734742168.0 + } + }, + "83fa1bf8cf4c48a08878a53f9ea20166": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "85f9174d9939451fa9640f17b66aedee": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "86cbb827a523499686b59223719cd1ba": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "87d5b3592e774556a81fcfc5313929f1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_11aabf54d4604cb38aabe4242fe8d035", + "placeholder": "​", + "style": "IPY_MODEL_a176c27848484cc0a11ee630fe0d383c", + "tabbable": null, + "tooltip": null, + "value": " 3.71G/4.99G [02:13<00:19, 67.1MB/s]" + } + }, + "88e151872454473a9400c1eb254b20f9": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "89a5276d154549408eacd8b6dc8ccde4": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "8b8ba5f9da9e49f3a7a32231c5721b35": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a32c88cac29c4a43a97040c84bd953bf", + "placeholder": "​", + "style": "IPY_MODEL_e3d36ff256074df792d9602f5cb1eaaa", + "tabbable": null, + "tooltip": null, + "value": "(…)ion_pytorch_model.safetensors.index.json: " + } + }, + "8cc315921a9540f685a4dc7040ad43ce": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "8deb0e592c1c4743bc506d24abd1ea57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_a0d69549f5784965b1da02c82d88dcfd", + "placeholder": "​", + "style": "IPY_MODEL_b2fda5ba983a4224abf929bb1a59c33d", + "tabbable": null, + "tooltip": null, + "value": "vae/diffusion_pytorch_model.safetensors: 100%" + } + }, + "90f26847269e4b2da5bb4b7107f2fe75": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_8deb0e592c1c4743bc506d24abd1ea57", + "IPY_MODEL_7b75ba65281f462eae25beb45b639d8a", + "IPY_MODEL_dab1ba7d89f64279a9bfb91ecf01f55f" + ], + "layout": "IPY_MODEL_7cbf36086de549a280dd524de4914453", + "tabbable": null, + "tooltip": null + } + }, + "91b4705c1b5e4e79831a63b8387fd22f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_71d9555514be40e8834fd5bd1292c8f8", + "placeholder": "​", + "style": "IPY_MODEL_3796625b699445bd9493de4662418266", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "91ce98e3943e4bd49c64c8de2197849c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "96622057c24249bebe10774e7df0aead": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_f7115f2b812648f392c46b0e8c0b9893", + "max": 8.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_6460c6e552314011b2bd04389e527852", + "tabbable": null, + "tooltip": null, + "value": 8.0 + } + }, + "96e723b96f224057b93b1e3e59c90ae0": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "98a76de7f43148d7898e725ca1bb15d7": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "98fe5630a3ab4bca97fb9d20370d2549": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_07e7eba7da74421e9ad2e744902182c2", + "max": 111204124.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_cad799306b8d487aaf61c35c48037adf", + "tabbable": null, + "tooltip": null, + "value": 111204124.0 + } + }, + "9a16451f68274249a94fb003e8121266": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9bc0f3a804564e1eb3e2861331718552": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c02072535c44f329a315501f4121a1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c6f4a9daee248dab77063fc298e8c7d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9c8170d86fbe4490bf12015bbc091f9e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "9e4cf5cc365a4b778d4d2213c26246e3": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_e5860f76106c488888d21db83828c2bb", + "IPY_MODEL_6e20524468c34c05a633a794ba241c7e", + "IPY_MODEL_87d5b3592e774556a81fcfc5313929f1" + ], + "layout": "IPY_MODEL_174910e6eeca45d098d66d7acc688aa5", + "tabbable": null, + "tooltip": null + } + }, + "9e9aee6a5d6649a9883901c64fbcf276": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a030c128b2674e2e975db0881a5e118e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_72dba564050840ddb10a554da49c7b66", + "placeholder": "​", + "style": "IPY_MODEL_0427388f2b0f48318df4e0f82a17159b", + "tabbable": null, + "tooltip": null, + "value": "transformer/diffusion_pytorch_model-0000(…):  75%" + } + }, + "a0d69549f5784965b1da02c82d88dcfd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a176c27848484cc0a11ee630fe0d383c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a32c88cac29c4a43a97040c84bd953bf": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a4a2dee4cd7c4e568c2b7d585be1beee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_6331231a0b774b5a8bd277f1a8fe91c7", + "placeholder": "​", + "style": "IPY_MODEL_48a9ce37d3f2456bb51d6603f105a49e", + "tabbable": null, + "tooltip": null, + "value": "transformer/diffusion_pytorch_model-0000(…):  65%" + } + }, + "a55d28d0742a47af9465729eae022d65": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9a16451f68274249a94fb003e8121266", + "placeholder": "​", + "style": "IPY_MODEL_0fb9db3a4cbb4f65a7545512cd1e0e1d", + "tabbable": null, + "tooltip": null, + "value": " 11/11 [04:31<00:00, 27.31s/it]" + } + }, + "a6e77118ca0e448696aa6a7d37cd62cd": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_acfa8422ed1c4803ac79668c7d8d1205", + "placeholder": "​", + "style": "IPY_MODEL_d5e9ace5fb834c528c3d876ed9d59a12", + "tabbable": null, + "tooltip": null, + "value": "config.json: " + } + }, + "a7386b00f241468bb3a8612af129e26c": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "a7a50d31e3b84e6b871db42f02dda979": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "a8fda30e8f4b4f27bdd241212ec183ed": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "aaf180822af44a1994f089261dff41a6": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9c6f4a9daee248dab77063fc298e8c7d", + "placeholder": "​", + "style": "IPY_MODEL_20709fdc45dd46c9a9afe2fc1f9e4edc", + "tabbable": null, + "tooltip": null, + "value": " 3.61G/4.94G [02:13<00:03, 354MB/s]" + } + }, + "ac699035797f4eb6b64eb717a3ce9c03": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "acb33c09a5c4445588fa6a9e192d580a": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_5644dac03fe54d019b565ca0383f0f49", + "IPY_MODEL_e798f28ca8ad46e0a44da9fee2b7a303", + "IPY_MODEL_aaf180822af44a1994f089261dff41a6" + ], + "layout": "IPY_MODEL_f12f50464a734722a4e9dc280432382d", + "tabbable": null, + "tooltip": null + } + }, + "acfa8422ed1c4803ac79668c7d8d1205": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "aeb6133df8064e07913e6708b8499d34": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3b760b3edcba42f49a0b9763522f6413", + "placeholder": "​", + "style": "IPY_MODEL_34d1595dfae8479b899790ea7014f9a8", + "tabbable": null, + "tooltip": null, + "value": "transformer/diffusion_pytorch_model-0000(…):  46%" + } + }, + "b03a7a832a834cebac980b3eccabdc58": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b262972299694b3b980de546b3c38f60": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "b2fda5ba983a4224abf929bb1a59c33d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "b3154b8f2dc14fcbb8c3b141f392ff59": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_3f14b0c7c3a642669bb8a36ffb99c5ef", + "max": 55.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_5c8b895e15ee4942a69f5cbc1d2567f6", + "tabbable": null, + "tooltip": null, + "value": 55.0 + } + }, + "b726f5ca92d34242862b42a2a4b46759": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_823d3dd282bb400a8ac51a3830e8dd23", + "placeholder": "​", + "style": "IPY_MODEL_328f1921f207445db51f272f4bed8672", + "tabbable": null, + "tooltip": null, + "value": " 2.30G/4.97G [02:13<01:13, 36.4MB/s]" + } + }, + "b7731d66242040f3a2d0616c5f50bf9a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "b7c9edd2576144908b355b8b2ed2c439": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_54dbd22916164ddf916d089b73f7925c", + "IPY_MODEL_0488b9081e0b47c8a6e00af407b779d5", + "IPY_MODEL_a55d28d0742a47af9465729eae022d65" + ], + "layout": "IPY_MODEL_ede39f68c5574538a98408864f069827", + "tabbable": null, + "tooltip": null + } + }, + "b820dbf9ec614b35a418aad61c8fb3c7": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": "20px" + } + }, + "b8bb0aa15b9e4bc484c38d4ed38f2431": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7cb2e55790054ea38043a8ffdade3210", + "max": 1.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_ac699035797f4eb6b64eb717a3ce9c03", + "tabbable": null, + "tooltip": null, + "value": 1.0 + } + }, + "b8dbfdd968774be38a664b7d2e0f6e30": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e417ccd322e649b19f8281d45698fc1e", + "max": 8.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_4e4cb26de8ea451090dc284eb9d97ccf", + "tabbable": null, + "tooltip": null, + "value": 8.0 + } + }, + "ba2c7d643fe7400c932e50d5f090f3b1": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb07d15ee78c4f5d87e8990017452f08": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "bb8254dcda604f4283098ffc98c932f4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_41368cc24bd040ab8e9607eeac77d7ad", + "placeholder": "​", + "style": "IPY_MODEL_2880c0657934424b8fc7cc01909659ce", + "tabbable": null, + "tooltip": null, + "value": " 1.32k/? [00:00<00:00, 176kB/s]" + } + }, + "c02efb047ad4449d819872110f7e3e98": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c28b525e5f3a4c209adfa56f902399ee": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c3086b1f42cb4f0fb3f550e1f2f04d3e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_86cbb827a523499686b59223719cd1ba", + "placeholder": "​", + "style": "IPY_MODEL_9e9aee6a5d6649a9883901c64fbcf276", + "tabbable": null, + "tooltip": null, + "value": "100%" + } + }, + "c4391acdae0c4160b2f386dd4b29a939": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_0669dd35c5824c0897ea167a02c84db4", + "placeholder": "​", + "style": "IPY_MODEL_3d8afc5fd08f462ab37e364a9f72fef3", + "tabbable": null, + "tooltip": null, + "value": "Loading pipeline components...: 100%" + } + }, + "c531cf3111cf41119500173e7f4e73f5": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c53d41e9e6fd4b8780b72100b844fdcb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9c02072535c44f329a315501f4121a1e", + "placeholder": "​", + "style": "IPY_MODEL_8cc315921a9540f685a4dc7040ad43ce", + "tabbable": null, + "tooltip": null, + "value": " 3.73G/4.99G [02:14<00:01, 649MB/s]" + } + }, + "c5c89d7cb9af4504b7bc2c24a85899e5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c6ee561499ae48ddb6a5bef62c209647": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "c7701cf0ce73410c82556a9baf63015b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "c9b65a04e16d4decba0c5c81adaf4191": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cad799306b8d487aaf61c35c48037adf": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "cc0374adcffc47dca859148c85e7250b": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_ed26e9f779e641ad9e781aa37c4f40f9", + "placeholder": "​", + "style": "IPY_MODEL_264a199c5cc9484d8d7ed48afec46ef6", + "tabbable": null, + "tooltip": null, + "value": " 8/8 [02:08<00:00, 20.56s/it]" + } + }, + "cfd39c6f164c4b7590d412a17b45dcff": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d14be2208a844928a70199220d1a1006": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d25a78476e9c44128bc483309f2075ad": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d5e9ace5fb834c528c3d876ed9d59a12": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "d8004bbcb1e5407db10b9f52cbb06739": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "da2a955513f142498862634d8dbaf225": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_eba51e913d6e44fdaa5b46f1a673072d", + "placeholder": "​", + "style": "IPY_MODEL_4e645f18993b473cbebb8596b82641f8", + "tabbable": null, + "tooltip": null, + "value": " 8/8 [00:03<00:00,  2.30it/s]" + } + }, + "da7ea885dbb0484fbaef3c9a869c777f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b7731d66242040f3a2d0616c5f50bf9a", + "placeholder": "​", + "style": "IPY_MODEL_7b6619f7bfec4c5a95d8cb7f5cbd68c1", + "tabbable": null, + "tooltip": null, + "value": " 10/10 [02:14<00:00, 33.61s/it]" + } + }, + "dab1ba7d89f64279a9bfb91ecf01f55f": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_9bc0f3a804564e1eb3e2861331718552", + "placeholder": "​", + "style": "IPY_MODEL_88e151872454473a9400c1eb254b20f9", + "tabbable": null, + "tooltip": null, + "value": " 2.44G/2.44G [00:09<00:00, 426MB/s]" + } + }, + "dadf6f0341004bf6bf3c4f98eff5708c": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "de5a44ae22d2455381e68b1d0c0c185e": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_efdfd8bf191a4fccad1c5eeac50bbd88", + "placeholder": "​", + "style": "IPY_MODEL_f75fdb560bd446e7964cd79d19a6d11d", + "tabbable": null, + "tooltip": null, + "value": " 55/55 [00:10<00:00, 198.06it/s]" + } + }, + "de9ecdcd6b654176b68f55c481f7edef": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e350dc7a9b254adfa82f9b20baadb776": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e3d36ff256074df792d9602f5cb1eaaa": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "e417ccd322e649b19f8281d45698fc1e": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "e55a5bcd0f8741f3829bad28d22dd037": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e5860f76106c488888d21db83828c2bb": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_c531cf3111cf41119500173e7f4e73f5", + "placeholder": "​", + "style": "IPY_MODEL_76064d1f94d044ffac85c29e99c689de", + "tabbable": null, + "tooltip": null, + "value": "transformer/diffusion_pytorch_model-0000(…):  74%" + } + }, + "e688b3776fb044ecb96ae45fadce6501": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_57a20634adb3447587135cf04843ea46", + "placeholder": "​", + "style": "IPY_MODEL_f3404bee511748279409160f5ea1e7f2", + "tabbable": null, + "tooltip": null, + "value": " 3.26G/4.98G [02:13<00:08, 193MB/s]" + } + }, + "e798f28ca8ad46e0a44da9fee2b7a303": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "danger", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7f5cf11367214f5088f09282f1296ae0", + "max": 4935871736.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_83fa1bf8cf4c48a08878a53f9ea20166", + "tabbable": null, + "tooltip": null, + "value": 3605773560.0 + } + }, + "e8904cf303b243e1928b26b7d88cfc4f": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea29425c3d8046138c6b7c0398d101cd": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ea91a3fd6f4549f7991d239a8ed17fd4": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "eba51e913d6e44fdaa5b46f1a673072d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ed26e9f779e641ad9e781aa37c4f40f9": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "eda38bdc565c474aa8ab1f9288cb07ec": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ede39f68c5574538a98408864f069827": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "ede9381e55504e28a2241a0a93e506f5": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HBoxModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6d1e25341dc54d27b5788383c4029523", + "IPY_MODEL_1285d5acbe9b4814acc11a8f46d9ebbe", + "IPY_MODEL_37bad1397e9e42a192fef2ede934c478" + ], + "layout": "IPY_MODEL_cfd39c6f164c4b7590d412a17b45dcff", + "tabbable": null, + "tooltip": null + } + }, + "ef9b0a1ece54475ca026674bc25a27a1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "ProgressStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "efdfd8bf191a4fccad1c5eeac50bbd88": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f12f50464a734722a4e9dc280432382d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f1a5e539ce3049ffbc13fcb58720d467": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_b820dbf9ec614b35a418aad61c8fb3c7", + "max": 1.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7701cf0ce73410c82556a9baf63015b", + "tabbable": null, + "tooltip": null, + "value": 1.0 + } + }, + "f3404bee511748279409160f5ea1e7f2": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f50d5b69d6fa4367bb47134af2545c57": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "FloatProgressModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e8904cf303b243e1928b26b7d88cfc4f", + "max": 10.0, + "min": 0.0, + "orientation": "horizontal", + "style": "IPY_MODEL_e55a5bcd0f8741f3829bad28d22dd037", + "tabbable": null, + "tooltip": null, + "value": 10.0 + } + }, + "f7115f2b812648f392c46b0e8c0b9893": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f75fdb560bd446e7964cd79d19a6d11d": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLStyleModel", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "StyleView", + "background": null, + "description_width": "", + "font_size": null, + "text_color": null + } + }, + "f9c45c57f92c4f63922dbed2a5d563c1": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_d14be2208a844928a70199220d1a1006", + "placeholder": "​", + "style": "IPY_MODEL_6c9866e6341a4b5cacfb91a2e0adbcaf", + "tabbable": null, + "tooltip": null, + "value": " 378k/? [00:00<00:00, 24.0MB/s]" + } + }, + "fd361ece51ac4935b9ffaa7e68db953d": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "fd8095c855634516ad60879d32a9cd46": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_e350dc7a9b254adfa82f9b20baadb776", + "placeholder": "​", + "style": "IPY_MODEL_c02efb047ad4449d819872110f7e3e98", + "tabbable": null, + "tooltip": null, + "value": " 544/544 [00:00<00:00, 48.3kB/s]" + } + }, + "fdf004d8ade4441f9099d53279d222a8": { + "model_module": "@jupyter-widgets/controls", + "model_module_version": "2.0.0", + "model_name": "HTMLModel", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "2.0.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "2.0.0", + "_view_name": "HTMLView", + "description": "", + "description_allow_html": false, + "layout": "IPY_MODEL_7b852fed5aff4f76a0349e2f8432edee", + "placeholder": "​", + "style": "IPY_MODEL_664cb666615249a3b5a179fd1675bfe0", + "tabbable": null, + "tooltip": null, + "value": " 8/8 [06:42<00:00, 29.39s/it]" + } + }, + "fefcc43a2feb478cbc29f313d3329b4a": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/contrib/models/ltx2-video-audio/samples/gpu/frame_0000.png b/contrib/models/ltx2-video-audio/samples/gpu/frame_0000.png new file mode 100644 index 00000000..076ea6cb Binary files /dev/null and b/contrib/models/ltx2-video-audio/samples/gpu/frame_0000.png differ diff --git a/contrib/models/ltx2-video-audio/samples/gpu/frame_0012.png b/contrib/models/ltx2-video-audio/samples/gpu/frame_0012.png new file mode 100644 index 00000000..311d9f8f Binary files /dev/null and b/contrib/models/ltx2-video-audio/samples/gpu/frame_0012.png differ diff --git a/contrib/models/ltx2-video-audio/samples/gpu/frame_0024.png b/contrib/models/ltx2-video-audio/samples/gpu/frame_0024.png new file mode 100644 index 00000000..6c8337b5 Binary files /dev/null and b/contrib/models/ltx2-video-audio/samples/gpu/frame_0024.png differ diff --git a/contrib/models/ltx2-video-audio/samples/neuron/frame_0000.png b/contrib/models/ltx2-video-audio/samples/neuron/frame_0000.png new file mode 100644 index 00000000..55600bb1 Binary files /dev/null and b/contrib/models/ltx2-video-audio/samples/neuron/frame_0000.png differ diff --git a/contrib/models/ltx2-video-audio/samples/neuron/frame_0012.png b/contrib/models/ltx2-video-audio/samples/neuron/frame_0012.png new file mode 100644 index 00000000..c16ae7ad Binary files /dev/null and b/contrib/models/ltx2-video-audio/samples/neuron/frame_0012.png differ diff --git a/contrib/models/ltx2-video-audio/samples/neuron/frame_0024.png b/contrib/models/ltx2-video-audio/samples/neuron/frame_0024.png new file mode 100644 index 00000000..44c3af96 Binary files /dev/null and b/contrib/models/ltx2-video-audio/samples/neuron/frame_0024.png differ diff --git a/contrib/models/ltx2-video-audio/src/__init__.py b/contrib/models/ltx2-video-audio/src/__init__.py new file mode 100644 index 00000000..59dae707 --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/__init__.py @@ -0,0 +1,2 @@ +# NxDI LTX-2 Video+Audio Diffusion Model +# Neuron-optimized implementation of the LTX-2 DiT transformer diff --git a/contrib/models/ltx2-video-audio/src/application.py b/contrib/models/ltx2-video-audio/src/application.py new file mode 100644 index 00000000..4b51ac0d --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/application.py @@ -0,0 +1,154 @@ +""" +NxDI LTX-2 Application +====================== +Top-level orchestrator for the LTX-2 video+audio diffusion model on Neuron. + +Architecture: + - Transformer backbone → Neuron (TP=4, compiled with NxDI) + - Text encoder (Gemma 3-12B) → CPU (too large for Neuron NC) + - Video VAE decoder → CPU + - Audio VAE decoder + vocoder → CPU + +Unlike Flux which compiles ALL components (CLIP, T5, transformer, VAE) onto Neuron, +LTX-2 only compiles the DiT transformer. The text encoder (Gemma 3-12B) and VAEs +remain on CPU because: + 1. Gemma 3-12B exceeds single NC memory even with TP + 2. VAE decoding is sequential and runs once per generation + 3. The transformer is the bottleneck (48 blocks × 8 denoising steps) + +Usage: + from nxdi.application import NeuronLTX2Application + + app = NeuronLTX2Application( + model_path="Lightricks/LTX-2", + backbone_config=backbone_config, + height=384, width=512, num_frames=25, + ) + app.compile(compiled_model_path) + app.load(compiled_model_path) + output = app(prompt="A golden retriever runs across a meadow") +""" + +import logging +import os +from typing import Optional + +import torch +import torch.nn as nn + +try: + from .modeling_ltx2 import ( + NeuronLTX2BackboneApplication, + LTX2BackboneInferenceConfig, + ) + from .pipeline import NeuronLTX2Pipeline +except ImportError: + from modeling_ltx2 import NeuronLTX2BackboneApplication, LTX2BackboneInferenceConfig + from pipeline import NeuronLTX2Pipeline + +logger = logging.getLogger(__name__) +logger.setLevel(logging.INFO) + + +class NeuronLTX2Application(nn.Module): + """Top-level application class for LTX-2 on Neuron. + + Orchestrates: + 1. Loading the Diffusers LTX2Pipeline from HuggingFace + 2. Compiling/loading the DiT transformer backbone on Neuron + 3. Swapping the pipeline's transformer with the Neuron version + 4. Running end-to-end inference (text → video+audio) + + The compile/load/call pattern follows NeuronFluxApplication: + - compile(path) → traces and saves the Neuron model + - load(path) → loads compiled model onto Neuron devices + - __call__(...) → runs the full pipeline + """ + + def __init__( + self, + model_path: str, + backbone_config: LTX2BackboneInferenceConfig, + transformer_path: Optional[str] = None, + height: int = 384, + width: int = 512, + num_frames: int = 25, + num_inference_steps: int = 8, + instance_type: str = "trn2", + ): + super().__init__() + self.model_path = model_path + self.transformer_path = transformer_path or os.path.join( + model_path, "transformer" + ) + self.height = height + self.width = width + self.num_frames = num_frames + self.num_inference_steps = num_inference_steps + self.instance_type = instance_type + + self.backbone_config = backbone_config + + # Load the stock Diffusers pipeline (CPU) + # This gives us text encoder, VAEs, vocoder, scheduler, etc. + logger.info("Loading Diffusers LTX2Pipeline from %s", model_path) + self.pipe = NeuronLTX2Pipeline.from_pretrained( + model_path, + torch_dtype=torch.bfloat16, + ) + + # Wrap the transformer with NxDI + self.pipe.neuron_backbone = NeuronLTX2BackboneApplication( + model_path=self.transformer_path, + config=self.backbone_config, + ) + + def compile(self, compiled_model_path, debug=False, pre_shard_weights_hook=None): + """Compile the transformer backbone for Neuron. + + Only compiles the transformer — text encoder and VAEs stay on CPU. + """ + logger.info("Compiling LTX-2 transformer backbone to %s", compiled_model_path) + self.pipe.neuron_backbone.compile( + os.path.join(compiled_model_path, "transformer/"), + debug, + pre_shard_weights_hook, + ) + + def load( + self, + compiled_model_path, + start_rank_id=None, + local_ranks_size=None, + skip_warmup=False, + ): + """Load the compiled transformer backbone onto Neuron devices. + + After loading, swaps the pipeline's CPU transformer with the Neuron version. + """ + logger.info("Loading compiled LTX-2 transformer from %s", compiled_model_path) + self.pipe.neuron_backbone.load( + os.path.join(compiled_model_path, "transformer/"), + start_rank_id, + local_ranks_size, + skip_warmup, + ) + + # Swap the pipeline's transformer with the Neuron wrapper + self.pipe._swap_transformer_to_neuron() + + def __call__(self, *args, **kwargs): + """Run the full LTX-2 pipeline. + + Supports all arguments that LTX2Pipeline.__call__ accepts: + - prompt, width, height, num_frames, num_inference_steps + - guidance_scale, generator, max_sequence_length, etc. + """ + # Set defaults for common parameters + kwargs.setdefault("height", self.height) + kwargs.setdefault("width", self.width) + kwargs.setdefault("num_frames", self.num_frames) + kwargs.setdefault("num_inference_steps", self.num_inference_steps) + kwargs.setdefault("guidance_scale", 4.0) # CFG (pipeline default) + + return self.pipe(*args, **kwargs) diff --git a/contrib/models/ltx2-video-audio/src/compile_gemma3.py b/contrib/models/ltx2-video-audio/src/compile_gemma3.py new file mode 100644 index 00000000..15ba3182 --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/compile_gemma3.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python3 +""" +Full 48-layer Gemma3 text encoder: compile, load, forward test. +""" + +import gc +import os +import sys +import time + +import torch + +os.environ["NEURON_FUSE_SOFTMAX"] = "1" +os.environ["NEURON_RT_STOCHASTIC_ROUNDING_EN"] = "0" + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +TP_DEGREE = 4 +SEQ_LEN = 1024 +BATCH = 1 +NUM_LAYERS = 48 +COMPILE_DIR = "/home/ubuntu/gemma3_encoder_compiled_1024" + + +def get_model_fn(tp_degree=TP_DEGREE): + from modeling_gemma3_encoder import Gemma3TextEncoderModel + + model = Gemma3TextEncoderModel( + vocab_size=262208, + hidden_size=3840, + num_hidden_layers=NUM_LAYERS, + num_attention_heads=16, + num_key_value_heads=8, + head_dim=256, + intermediate_size=15360, + rms_norm_eps=1e-6, + rope_theta=1_000_000.0, + max_position_embeddings=131072, + query_pre_attn_scalar=256, + pad_token_id=0, + dtype=torch.bfloat16, + ) + model = model.to(dtype=torch.bfloat16) + model.eval() + return model, None + + +def main(): + print("=" * 60) + print( + "Compiling full 48-layer Gemma3 encoder (TP=%d, seq=%d)" % (TP_DEGREE, SEQ_LEN) + ) + print("=" * 60) + + import torch_neuronx + from neuronx_distributed.trace import parallel_model_trace, parallel_model_save + + os.makedirs(COMPILE_DIR, exist_ok=True) + + input_ids = torch.zeros(BATCH, SEQ_LEN, dtype=torch.int64) + attention_mask = torch.ones(BATCH, SEQ_LEN, dtype=torch.int64) + + compiler_args = "--model-type=transformer -O1 --auto-cast=none --enable-saturate-infinity --enable-mixed-precision-accumulation --lnc=2" + os.environ["NEURON_CC_FLAGS"] = compiler_args + print(" Compiler flags: %s" % compiler_args) + + t0 = time.time() + traced = parallel_model_trace( + get_model_fn, + (input_ids, attention_mask), + tp_degree=TP_DEGREE, + compiler_workdir=os.path.join(COMPILE_DIR, "compiler_workdir"), + compiler_args=compiler_args, + inline_weights_to_neff=False, + ) + elapsed = time.time() - t0 + print(" Compile: %.1fs (%.1f min)" % (elapsed, elapsed / 60)) + + parallel_model_save(traced, COMPILE_DIR) + tp0_size = os.path.getsize(os.path.join(COMPILE_DIR, "tp_0.pt")) / 1e9 + print(" Saved tp_0.pt: %.2f GB" % tp0_size) + + # Quick forward test with random weights + print("\nLoading for forward test...") + from neuronx_distributed.trace.trace import ( + _mock_parallel_state, + init_on_device, + get_sharded_checkpoint, + replace_weights, + TensorParallelNeuronModel, + ) + + _mock_parallel_state(1, 0) + with init_on_device(torch.device("cpu")): + ref_model, _ = get_model_fn() + checkpoint = ref_model.state_dict() + total_params = sum(v.numel() for v in checkpoint.values()) + print( + " Checkpoint: %d keys, %.2f B params" % (len(checkpoint), total_params / 1e9) + ) + del ref_model + gc.collect() + + models = [] + for rank in range(TP_DEGREE): + t0r = time.time() + ckpt = {k: v.clone() for k, v in checkpoint.items()} + _mock_parallel_state(TP_DEGREE, rank) + with init_on_device(torch.device("meta")): + model, _ = get_model_fn() + get_sharded_checkpoint(ckpt, model, rank, TP_DEGREE) + with torch_neuronx.contexts.disable_nrt_load(): + traced_model = torch.jit.load(os.path.join(COMPILE_DIR, "tp_0.pt")) + replace_weights(traced_model, ckpt) + models.append(traced_model) + print(" [rank %d] %.1fs" % (rank, time.time() - t0r)) + gc.collect() + del checkpoint + gc.collect() + + compiled = TensorParallelNeuronModel(models) + print(" All %d ranks loaded" % TP_DEGREE) + + print("\nForward pass...") + _ = compiled(input_ids, attention_mask) # warmup + t0 = time.time() + output = compiled(input_ids, attention_mask) + elapsed = time.time() - t0 + + expected = (BATCH, SEQ_LEN, 3840, NUM_LAYERS + 1) + print(" Time: %.3fs" % elapsed) + print(" Output shape: %s (expected %s)" % (tuple(output.shape), expected)) + print(" Output dtype: %s" % output.dtype) + print(" NaN: %s" % ("FAIL" if torch.isnan(output).any() else "PASS")) + print(" Inf: %s" % ("FAIL" if torch.isinf(output).any() else "PASS")) + if tuple(output.shape) == expected: + print("\n *** 48-LAYER COMPILE + LOAD + FORWARD: PASSED ***") + else: + print("\n *** SHAPE MISMATCH -- FAILED ***") + + +if __name__ == "__main__": + main() diff --git a/contrib/models/ltx2-video-audio/src/compile_vae.py b/contrib/models/ltx2-video-audio/src/compile_vae.py new file mode 100644 index 00000000..55abd85a --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/compile_vae.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python3 +""" +LTX-2 VAE Decoder — Standalone Compilation Script +================================================== +Compiles the tensor-parallel VAE decoder for Neuron. + +Default tile: 4x16 latent (128x512 pixels) — optimal for 1024x1536 output. + +Usage: + source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate + pip install diffusers + + # Compile 4x16 tile (recommended for 1024x1536 output) + NEURON_RT_VISIBLE_CORES=0-3 python compile_vae.py \\ + --tp-degree 4 --height 128 --width 512 + + # Compile 8x8 tile (for 512x768 output) + NEURON_RT_VISIBLE_CORES=0-3 python compile_vae.py \\ + --tp-degree 4 --height 256 --width 256 + +Notes: + - Tile area must satisfy H_latent * W_latent <= 64 (SRAM limit) + - 4x16 tiles are 12.5% faster per-tile than 8x8 tiles + - Compilation requires ~150GB RAM (use trn2.48xlarge or larger) + - Compilation takes ~30 minutes on trn2.48xlarge +""" + +import argparse +import os +import sys + +# Add src directory to path for imports +sys.path.insert(0, os.path.join(os.path.dirname(__file__))) + +from modeling_vae import compile_vae_decoder + + +def main(): + parser = argparse.ArgumentParser(description="Compile LTX-2 VAE decoder with TP") + parser.add_argument( + "--height", + type=int, + default=128, + help="Tile pixel height (default 128 for 4-latent)", + ) + parser.add_argument( + "--width", + type=int, + default=512, + help="Tile pixel width (default 512 for 16-latent)", + ) + parser.add_argument( + "--num-frames", type=int, default=121, help="Number of video frames" + ) + parser.add_argument( + "--tp-degree", type=int, default=4, help="Tensor parallel degree" + ) + parser.add_argument("--output-dir", type=str, default="/home/ubuntu/ltx2_vae_tp4") + parser.add_argument( + "--compiler-workdir", type=str, default="/home/ubuntu/compiler_workdir_vae" + ) + parser.add_argument("--vae-path", type=str, default="Lightricks/LTX-2") + args = parser.parse_args() + + # Verify tile area constraint + latent_h = args.height // 32 + latent_w = args.width // 32 + area = latent_h * latent_w + if area > 64: + print( + f"ERROR: Tile area {latent_h}x{latent_w} = {area} exceeds 64-element SRAM limit" + ) + print("Reduce tile dimensions. Maximum compilable tiles:") + print(" 8x8 (256x256 px), 4x16 (128x512 px), 4x14 (128x448 px)") + sys.exit(1) + + compile_vae_decoder( + tp_degree=args.tp_degree, + tile_height=args.height, + tile_width=args.width, + num_frames=args.num_frames, + output_dir=args.output_dir, + compiler_workdir=args.compiler_workdir, + vae_path=args.vae_path, + ) + + +if __name__ == "__main__": + main() diff --git a/contrib/models/ltx2-video-audio/src/generate_ltx2.py b/contrib/models/ltx2-video-audio/src/generate_ltx2.py new file mode 100644 index 00000000..6707e76a --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/generate_ltx2.py @@ -0,0 +1,267 @@ +#!/usr/bin/env python3 +""" +LTX-2 Video+Audio Generation on AWS Neuron +============================================ +Example script demonstrating end-to-end LTX-2 inference on Neuron. + +Compiles (or loads) the DiT transformer backbone with TP=4 on trn2.3xlarge, +then generates video+audio from a text prompt. + +Hardware: trn2.3xlarge (1 NeuronDevice, 4 logical cores with LNC=2) +Memory: ~9.4 GB HBM per TP rank (fits in 24 GB per core) + +Usage: + source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate + python generate_ltx2.py --prompt "A golden retriever runs across a sunny meadow" + python generate_ltx2.py --compile-only # Compile without generating + python generate_ltx2.py --load-only # Skip compilation, load existing + +Requirements: + - neuronx-distributed-inference (NxDI) + - diffusers >= 0.37.0.dev0 (from git main, with LTX-2 support) + - Neuron SDK 2.27+ +""" + +import argparse +import json +import os +import time + +import torch + +from nxdi.application import NeuronLTX2Application +from nxdi.modeling_ltx2 import LTX2BackboneInferenceConfig, replace_sdpa_with_bmm + +try: + from neuronx_distributed_inference.models.config import NeuronConfig + from neuronx_distributed_inference.utils.hf_adapter import load_pretrained_config +except ImportError: + raise ImportError( + "neuronx_distributed_inference is required. " + "Activate the Neuron venv: source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate" + ) + + +# Default configuration for trn2.3xlarge +DEFAULT_CONFIG = { + "model_path": "Lightricks/LTX-2", + "height": 384, + "width": 512, + "num_frames": 25, + "num_inference_steps": 8, + "tp_degree": 4, + "world_size": 4, + "compile_dir": "/tmp/ltx2_nxdi/compiler_workdir/", + "output_dir": "/tmp/ltx2_nxdi/output/", + "prompt": "A golden retriever puppy runs across a sunny green meadow, " + "its ears flapping in the wind. The camera follows from a low angle. " + "Birds chirp in the background.", + "seed": 42, + "max_sequence_length": 1024, + "frame_rate": 24.0, +} + + +def create_ltx2_config(args): + """Create NxDI configuration for the LTX-2 transformer backbone.""" + + # Latent dimensions (derived from video dims and VAE compression) + latent_num_frames = (args.num_frames - 1) // 8 + 1 # temporal compression + latent_height = args.height // 32 # spatial compression + latent_width = args.width // 32 + + video_seq = latent_num_frames * latent_height * latent_width + audio_num_frames = round( + (args.num_frames / args.frame_rate) * 24.97 # audio tokens + ) + + # Load transformer config from HuggingFace + from huggingface_hub import hf_hub_download + + config_path = hf_hub_download(args.model_path, "transformer/config.json") + with open(config_path) as f: + hf_config = json.load(f) + + num_heads = hf_config["num_attention_heads"] + head_dim = hf_config["attention_head_dim"] + inner_dim = num_heads * head_dim + audio_num_heads = hf_config["audio_num_attention_heads"] + audio_head_dim = hf_config["audio_attention_head_dim"] + audio_inner_dim = audio_num_heads * audio_head_dim + audio_ca_dim = hf_config.get("audio_cross_attention_dim", audio_inner_dim) + caption_channels = hf_config.get("caption_channels", 3840) + + # NeuronConfig for the backbone + backbone_neuron_config = NeuronConfig( + tp_degree=args.tp_degree, + world_size=args.world_size, + torch_dtype=torch.bfloat16, + ) + + # LTX2 backbone inference config + backbone_config = LTX2BackboneInferenceConfig( + neuron_config=backbone_neuron_config, + num_layers=hf_config["num_layers"], + num_attention_heads=num_heads, + attention_head_dim=head_dim, + inner_dim=inner_dim, + audio_num_attention_heads=audio_num_heads, + audio_attention_head_dim=audio_head_dim, + audio_inner_dim=audio_inner_dim, + audio_cross_attention_dim=audio_ca_dim, + caption_channels=caption_channels, + video_seq=video_seq, + audio_seq=audio_num_frames, + text_seq=args.max_sequence_length, + height=args.height, + width=args.width, + num_frames=args.num_frames, + ) + # Store HF config dict so the backbone model can auto-build from diffusers + backbone_config.hf_config_dict = hf_config + + print( + f" Config: {hf_config['num_layers']} layers, {num_heads} heads, " + f"head_dim={head_dim}, inner_dim={inner_dim}" + ) + print( + f" Audio: {audio_num_heads} heads, audio_head_dim={audio_head_dim}, " + f"audio_inner_dim={audio_inner_dim}" + ) + print( + f" Video: {args.height}x{args.width}, {args.num_frames} frames → " + f"latent {latent_height}x{latent_width}x{latent_num_frames} = {video_seq} tokens" + ) + print(f" Audio: {audio_num_frames} tokens") + print(f" TP={args.tp_degree}, world_size={args.world_size}") + + return backbone_config, hf_config + + +def run_generate(args): + """Run the full LTX-2 generation pipeline.""" + print("=" * 60) + print("LTX-2 Video+Audio Generation on Neuron") + print("=" * 60) + + t_total = time.time() + + # Replace SDPA before any model loading + replace_sdpa_with_bmm() + + # Create configuration + print("\n[1/4] Creating configuration...") + backbone_config, hf_config = create_ltx2_config(args) + + # Create application + print("\n[2/4] Creating NeuronLTX2Application...") + app = NeuronLTX2Application( + model_path=args.model_path, + backbone_config=backbone_config, + height=args.height, + width=args.width, + num_frames=args.num_frames, + num_inference_steps=args.num_inference_steps, + ) + + # Compile or load + if args.compile_only or not os.path.exists( + os.path.join(args.compile_dir, "transformer/model.pt") + ): + print("\n[3/4] Compiling transformer backbone...") + t0 = time.time() + app.compile(args.compile_dir) + print(f" Compiled in {time.time() - t0:.1f}s") + if args.compile_only: + print( + "\nCompilation complete. Use --load-only to skip compilation next time." + ) + return + + print("\n[3/4] Loading compiled transformer...") + t0 = time.time() + app.load(args.compile_dir) + print(f" Loaded in {time.time() - t0:.1f}s") + + # Generate + print("\n[4/4] Generating video+audio...") + print(f" Prompt: {args.prompt[:80]}...") + print( + f" Resolution: {args.width}x{args.height}, {args.num_frames} frames, " + f"{args.num_inference_steps} steps" + ) + + generator = torch.Generator(device="cpu").manual_seed(args.seed) + + t0 = time.time() + output = app( + prompt=args.prompt, + generator=generator, + output_type="pil", + max_sequence_length=args.max_sequence_length, + ) + gen_time = time.time() - t0 + print(f" Generated in {gen_time:.1f}s") + + # Save outputs + os.makedirs(args.output_dir, exist_ok=True) + + frames = output.frames[0] + frames_dir = os.path.join(args.output_dir, "frames") + os.makedirs(frames_dir, exist_ok=True) + for i, frame in enumerate(frames): + frame.save(os.path.join(frames_dir, f"frame_{i:04d}.png")) + print(f" Saved {len(frames)} frames to {frames_dir}/") + + try: + from diffusers.utils import export_to_video + + video_path = os.path.join(args.output_dir, "output.mp4") + export_to_video(frames, video_path, fps=int(args.frame_rate)) + print(f" Video: {video_path}") + except Exception as e: + print(f" Video export failed: {e}") + + # Summary + total_time = time.time() - t_total + print(f"\nSummary:") + print(f" Total time: {total_time:.1f}s") + print(f" Generation time: {gen_time:.1f}s") + print(f" Output frames: {len(frames)}") + print(f" Output dir: {args.output_dir}/") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="LTX-2 Video Generation on Neuron") + parser.add_argument("-p", "--prompt", type=str, default=DEFAULT_CONFIG["prompt"]) + parser.add_argument("--height", type=int, default=DEFAULT_CONFIG["height"]) + parser.add_argument("--width", type=int, default=DEFAULT_CONFIG["width"]) + parser.add_argument("--num-frames", type=int, default=DEFAULT_CONFIG["num_frames"]) + parser.add_argument( + "--num-inference-steps", type=int, default=DEFAULT_CONFIG["num_inference_steps"] + ) + parser.add_argument("--tp-degree", type=int, default=DEFAULT_CONFIG["tp_degree"]) + parser.add_argument("--world-size", type=int, default=DEFAULT_CONFIG["world_size"]) + parser.add_argument("--model-path", type=str, default=DEFAULT_CONFIG["model_path"]) + parser.add_argument( + "--compile-dir", type=str, default=DEFAULT_CONFIG["compile_dir"] + ) + parser.add_argument("--output-dir", type=str, default=DEFAULT_CONFIG["output_dir"]) + parser.add_argument("--seed", type=int, default=DEFAULT_CONFIG["seed"]) + parser.add_argument( + "--max-sequence-length", type=int, default=DEFAULT_CONFIG["max_sequence_length"] + ) + parser.add_argument( + "--frame-rate", type=float, default=DEFAULT_CONFIG["frame_rate"] + ) + parser.add_argument( + "--compile-only", action="store_true", help="Only compile, don't generate" + ) + parser.add_argument( + "--load-only", + action="store_true", + help="Skip compilation, load existing compiled model", + ) + + args = parser.parse_args() + run_generate(args) diff --git a/contrib/models/ltx2-video-audio/src/modeling_gemma3_encoder.py b/contrib/models/ltx2-video-audio/src/modeling_gemma3_encoder.py new file mode 100644 index 00000000..f0e689ae --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/modeling_gemma3_encoder.py @@ -0,0 +1,645 @@ +""" +NeuronGemma3TextEncoder — Gemma 3 as an encoder-only model for LTX-2 text conditioning +======================================================================================== + +LTX-2 uses Gemma 3-12B as a text encoder, NOT as a causal language model. The pipeline +calls the text encoder with `output_hidden_states=True` and collects ALL 49 hidden states +(embedding + 48 decoder layers), stacks them, normalizes, and flattens to produce +conditioning embeddings of shape (B, seq_len, 188160) = (B, seq_len, 3840 * 49). + +NxDI's built-in NeuronGemma3ForCausalLM cannot provide this because: + - It only returns logits/tokens, not intermediate hidden states + - It has KV cache machinery baked into the compiled graph + - Its forward slices to the last token position + +This module builds a CUSTOM encoder-only model that: + 1. Reuses NxDI's Gemma3 layer implementations (TP-sharded attention, MLP, norms) + 2. Runs all 48 decoder layers in a single forward pass + 3. Accumulates all hidden states and returns torch.stack(all_hidden_states, dim=-1) + 4. Has NO KV cache, NO lm_head, NO sampling + 5. Takes (input_ids, attention_mask) -> (B, seq_len, hidden_size, num_layers+1) + +Architecture: + Gemma3ScaledEmbedding -> 48 x SimplifiedGemma3DecoderLayer -> Gemma3RMSNorm + Output: torch.stack([embed_out, layer_0_out, ..., layer_47_out], dim=-1) + +The SimplifiedGemma3DecoderLayer strips away KV cache handling from NeuronGemma3DecoderLayer +since we don't need it for single-pass encoding. We keep the same weight structure so +that HF Gemma 3 weights can be loaded directly. + +TP strategy: + - Q, K, V projections: ColumnParallelLinear (shard output dim) + - O projection: RowParallelLinear (shard input dim, all-reduce) + - gate_proj, up_proj: ColumnParallelLinear + - down_proj: RowParallelLinear + - Norms: replicated (not sharded) — they operate on the full hidden_size + - Embedding: ParallelEmbedding (sharded across vocab) +""" + +import logging +import math +from typing import List, Optional, Tuple + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from neuronx_distributed.parallel_layers.layers import ( + ColumnParallelLinear, + ParallelEmbedding, + RowParallelLinear, +) +from neuronx_distributed.parallel_layers.parallel_state import ( + get_tensor_model_parallel_rank, + get_tensor_model_parallel_size, +) + +logger = logging.getLogger(__name__) + + +# ── RMSNorm (Gemma3 variant: 1 + weight) ──────────────────────────────────── + + +class Gemma3RMSNorm(nn.Module): + """Gemma3-specific RMSNorm: uses (1.0 + weight) instead of just weight.""" + + def __init__(self, dim: int, eps: float = 1e-6): + super().__init__() + self.eps = eps + self.weight = nn.Parameter(torch.zeros(dim)) + + def _norm(self, x): + return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) + + def forward(self, x): + output = self._norm(x.float()) + output = output * (1.0 + self.weight.float()) + return output.type_as(x) + + +# ── Scaled Embedding ──────────────────────────────────────────────────────── + + +class Gemma3ScaledEmbedding(nn.Module): + """Gemma3 embeddings scaled by sqrt(hidden_size).""" + + def __init__(self, num_embeddings, embedding_dim, padding_idx, dtype): + super().__init__() + self.embed_scale = embedding_dim**0.5 + self.embedding = ParallelEmbedding( + num_embeddings, + embedding_dim, + padding_idx, + dtype=dtype, + shard_across_embedding=True, + pad=True, + ) + + def forward(self, input_ids): + return self.embedding(input_ids) * self.embed_scale + + +# ── Rotary Position Embedding ─────────────────────────────────────────────── + + +class RotaryEmbedding(nn.Module): + """Standard RoPE for Gemma3 (no sliding window variant needed for encoder).""" + + def __init__(self, dim, max_position_embeddings=131072, base=1_000_000.0): + super().__init__() + self.dim = dim + self.max_position_embeddings = max_position_embeddings + self.base = base + inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2, dtype=torch.float32) / dim)) + self.register_buffer("inv_freq", inv_freq, persistent=False) + + def forward(self, position_ids): + """ + Args: + position_ids: (batch_size, seq_len) + Returns: + cos, sin: (batch_size, seq_len, dim) + """ + # (seq_len, dim/2) + inv_freq = self.inv_freq.to(position_ids.device) + # position_ids: (B, seq_len) -> (B, seq_len, 1) + pos = position_ids.unsqueeze(-1).float() + # (B, seq_len, dim/2) + freqs = pos * inv_freq.unsqueeze(0).unsqueeze(0) + # (B, seq_len, dim) + emb = torch.cat([freqs, freqs], dim=-1) + return emb.cos(), emb.sin() + + +def apply_rotary_pos_emb(q, k, cos, sin): + """Apply rotary embedding to query and key tensors. + + Args: + q: (B, num_heads, seq_len, head_dim) + k: (B, num_kv_heads, seq_len, head_dim) + cos: (B, seq_len, head_dim) + sin: (B, seq_len, head_dim) + """ + cos = cos.unsqueeze(1) # (B, 1, seq_len, head_dim) + sin = sin.unsqueeze(1) + + def rotate_half(x): + x1, x2 = x.chunk(2, dim=-1) + return torch.cat([-x2, x1], dim=-1) + + q_embed = (q * cos) + (rotate_half(q) * sin) + k_embed = (k * cos) + (rotate_half(k) * sin) + return q_embed, k_embed + + +# ── Attention ─────────────────────────────────────────────────────────────── + + +class Gemma3EncoderAttention(nn.Module): + """Gemma3 attention for encoder-only use (no KV cache). + + Uses GQA with Q-K normalization. For encoder use, we compute full + bidirectional attention over the entire sequence (no causal mask needed + since we just want hidden states, not autoregressive generation). + + Actually, for correctness with the original Gemma3 model weights, we + should use causal attention to match training. The hidden states were + trained with causal attention, so we keep it here. + """ + + def __init__( + self, + hidden_size: int, + num_attention_heads: int, + num_key_value_heads: int, + head_dim: int, + rms_norm_eps: float, + rope_theta: float, + max_position_embeddings: int, + query_pre_attn_scalar: int, + dtype: torch.dtype, + ): + super().__init__() + self.hidden_size = hidden_size + self.num_heads = num_attention_heads + self.num_kv_heads = num_key_value_heads + self.head_dim = head_dim + self.num_kv_groups = num_attention_heads // num_key_value_heads + + # Scaling uses query_pre_attn_scalar, not head_dim + self.scale = query_pre_attn_scalar**-0.5 + + tp_size = get_tensor_model_parallel_size() + + # Q/K/V projections (column parallel) + self.q_proj = ColumnParallelLinear( + hidden_size, + num_attention_heads * head_dim, + bias=False, + gather_output=False, + dtype=dtype, + pad=True, + ) + self.k_proj = ColumnParallelLinear( + hidden_size, + num_key_value_heads * head_dim, + bias=False, + gather_output=False, + dtype=dtype, + pad=True, + ) + self.v_proj = ColumnParallelLinear( + hidden_size, + num_key_value_heads * head_dim, + bias=False, + gather_output=False, + dtype=dtype, + pad=True, + ) + + # Output projection (row parallel) + self.o_proj = RowParallelLinear( + num_attention_heads * head_dim, + hidden_size, + bias=False, + input_is_parallel=True, + dtype=dtype, + ) + + # Q-K normalization (Gemma3-specific) + self.q_layernorm = Gemma3RMSNorm(head_dim, eps=rms_norm_eps) + self.k_layernorm = Gemma3RMSNorm(head_dim, eps=rms_norm_eps) + + # RoPE + self.rotary_emb = RotaryEmbedding( + dim=head_dim, + max_position_embeddings=max_position_embeddings, + base=rope_theta, + ) + + # Local TP-adjusted head counts + self.num_heads_per_rank = num_attention_heads // tp_size + self.num_kv_heads_per_rank = num_key_value_heads // tp_size + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor], + position_ids: torch.Tensor, + ) -> torch.Tensor: + batch_size, seq_len, _ = hidden_states.shape + + # Project Q, K, V + q = self.q_proj(hidden_states) + k = self.k_proj(hidden_states) + v = self.v_proj(hidden_states) + + # Reshape to (B, num_heads, seq_len, head_dim) + q = q.view( + batch_size, seq_len, self.num_heads_per_rank, self.head_dim + ).transpose(1, 2) + k = k.view( + batch_size, seq_len, self.num_kv_heads_per_rank, self.head_dim + ).transpose(1, 2) + v = v.view( + batch_size, seq_len, self.num_kv_heads_per_rank, self.head_dim + ).transpose(1, 2) + + # Q-K normalization (before RoPE) + q = self.q_layernorm(q) + k = self.k_layernorm(k) + + # Apply RoPE + cos, sin = self.rotary_emb(position_ids) + q, k = apply_rotary_pos_emb(q, k, cos, sin) + + # GQA: repeat K, V for each query head group + if self.num_kv_groups > 1: + k = k.repeat_interleave(self.num_kv_groups, dim=1) + v = v.repeat_interleave(self.num_kv_groups, dim=1) + + # Compute attention using BMM (Neuron-friendly, no SDPA) + # (B, H, S, D) @ (B, H, D, S) -> (B, H, S, S) + attn_weights = ( + torch.bmm( + q.reshape(batch_size * self.num_heads_per_rank, seq_len, self.head_dim), + k.reshape( + batch_size * self.num_heads_per_rank, seq_len, self.head_dim + ).transpose(-1, -2), + ) + * self.scale + ) + + # Reshape for mask application + attn_weights = attn_weights.view( + batch_size, self.num_heads_per_rank, seq_len, seq_len + ) + + # Apply causal mask (for training consistency) + if attention_mask is not None: + attn_weights = attn_weights + attention_mask + + attn_weights = F.softmax(attn_weights, dim=-1, dtype=torch.float32).to( + hidden_states.dtype + ) + + # (B*H, S, S) @ (B*H, S, D) -> (B*H, S, D) + attn_output = torch.bmm( + attn_weights.reshape( + batch_size * self.num_heads_per_rank, seq_len, seq_len + ), + v.reshape(batch_size * self.num_heads_per_rank, seq_len, self.head_dim), + ) + + # Reshape back: (B, H, S, D) -> (B, S, H*D) + attn_output = attn_output.view( + batch_size, self.num_heads_per_rank, seq_len, self.head_dim + ) + attn_output = attn_output.transpose(1, 2).contiguous() + attn_output = attn_output.reshape(batch_size, seq_len, -1) + + # Output projection (row parallel with all-reduce) + return self.o_proj(attn_output) + + +# ── MLP ───────────────────────────────────────────────────────────────────── + + +class Gemma3EncoderMLP(nn.Module): + """Gemma3 MLP: gate_proj * act(up_proj) -> down_proj, with GELU(tanh).""" + + def __init__(self, hidden_size: int, intermediate_size: int, dtype: torch.dtype): + super().__init__() + self.gate_proj = ColumnParallelLinear( + hidden_size, + intermediate_size, + bias=False, + gather_output=False, + dtype=dtype, + pad=True, + ) + self.up_proj = ColumnParallelLinear( + hidden_size, + intermediate_size, + bias=False, + gather_output=False, + dtype=dtype, + pad=True, + ) + self.down_proj = RowParallelLinear( + intermediate_size, + hidden_size, + bias=False, + input_is_parallel=True, + dtype=dtype, + ) + self.act_fn = nn.GELU(approximate="tanh") + + def forward(self, x): + return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x)) + + +# ── Decoder Layer (simplified for encoder use) ───────────────────────────── + + +class Gemma3EncoderLayer(nn.Module): + """Single Gemma3 decoder layer adapted for encoder-only use. + + Same weight structure as NeuronGemma3DecoderLayer but without KV cache. + Four norms per layer (Gemma3-specific). + """ + + def __init__( + self, + hidden_size: int, + num_attention_heads: int, + num_key_value_heads: int, + head_dim: int, + intermediate_size: int, + rms_norm_eps: float, + rope_theta: float, + max_position_embeddings: int, + query_pre_attn_scalar: int, + dtype: torch.dtype, + ): + super().__init__() + self.self_attn = Gemma3EncoderAttention( + hidden_size=hidden_size, + num_attention_heads=num_attention_heads, + num_key_value_heads=num_key_value_heads, + head_dim=head_dim, + rms_norm_eps=rms_norm_eps, + rope_theta=rope_theta, + max_position_embeddings=max_position_embeddings, + query_pre_attn_scalar=query_pre_attn_scalar, + dtype=dtype, + ) + self.mlp = Gemma3EncoderMLP(hidden_size, intermediate_size, dtype) + + # Four norms (Gemma3-specific) + self.input_layernorm = Gemma3RMSNorm(hidden_size, eps=rms_norm_eps) + self.post_attention_layernorm = Gemma3RMSNorm(hidden_size, eps=rms_norm_eps) + self.pre_feedforward_layernorm = Gemma3RMSNorm(hidden_size, eps=rms_norm_eps) + self.post_feedforward_layernorm = Gemma3RMSNorm(hidden_size, eps=rms_norm_eps) + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor], + position_ids: torch.Tensor, + ) -> torch.Tensor: + # Attention block + residual = hidden_states + hidden_states = self.input_layernorm(hidden_states) + hidden_states = self.self_attn(hidden_states, attention_mask, position_ids) + hidden_states = self.post_attention_layernorm(hidden_states) + hidden_states = residual + hidden_states + + # MLP block + residual = hidden_states + hidden_states = self.pre_feedforward_layernorm(hidden_states) + hidden_states = self.mlp(hidden_states) + hidden_states = self.post_feedforward_layernorm(hidden_states) + hidden_states = residual + hidden_states + + return hidden_states + + +# ── Full Encoder Model ────────────────────────────────────────────────────── + + +class Gemma3TextEncoderModel(nn.Module): + """Gemma3 used as a text encoder: returns all hidden states stacked. + + This is the model that gets compiled to a Neuron graph. It takes + (input_ids, attention_mask) and returns a single tensor of shape + (B, seq_len, hidden_size, num_layers+1). + + For Gemma 3-12B: + hidden_size = 3840, num_hidden_layers = 48 + Output: (B, seq_len, 3840, 49) + + Note on causal attention: Gemma3 was trained with causal (left-to-right) + attention. Even though we use it as an encoder, we keep causal masking + to produce hidden states consistent with the original model. + """ + + def __init__( + self, + vocab_size: int = 262208, + hidden_size: int = 3840, + num_hidden_layers: int = 48, + num_attention_heads: int = 16, + num_key_value_heads: int = 8, + head_dim: int = 256, + intermediate_size: int = 15360, + rms_norm_eps: float = 1e-6, + rope_theta: float = 1_000_000.0, + max_position_embeddings: int = 131072, + query_pre_attn_scalar: int = 256, + pad_token_id: int = 0, + dtype: torch.dtype = torch.bfloat16, + ): + super().__init__() + self.hidden_size = hidden_size + self.num_hidden_layers = num_hidden_layers + self.dtype = dtype + + # Embedding (scaled by sqrt(hidden_size)) + self.embed_tokens = Gemma3ScaledEmbedding( + vocab_size, + hidden_size, + pad_token_id, + dtype=dtype, + ) + + # 48 decoder layers + self.layers = nn.ModuleList( + [ + Gemma3EncoderLayer( + hidden_size=hidden_size, + num_attention_heads=num_attention_heads, + num_key_value_heads=num_key_value_heads, + head_dim=head_dim, + intermediate_size=intermediate_size, + rms_norm_eps=rms_norm_eps, + rope_theta=rope_theta, + max_position_embeddings=max_position_embeddings, + query_pre_attn_scalar=query_pre_attn_scalar, + dtype=dtype, + ) + for _ in range(num_hidden_layers) + ] + ) + + # Final norm + self.norm = Gemma3RMSNorm(hidden_size, eps=rms_norm_eps) + + def forward( + self, + input_ids: torch.Tensor, # (B, seq_len), int64 + attention_mask: torch.Tensor, # (B, seq_len), int64 — 1=real, 0=pad + ) -> torch.Tensor: + """ + Returns: + stacked_hidden_states: (B, seq_len, hidden_size, num_layers+1) + """ + batch_size, seq_len = input_ids.shape + + # Position IDs (0, 1, 2, ..., seq_len-1) — same for all batch items + position_ids = ( + torch.arange(seq_len, device=input_ids.device) + .unsqueeze(0) + .expand(batch_size, -1) + ) + + # Create causal attention mask + # (B, 1, seq_len, seq_len) with -inf for future positions and padding + causal_mask = torch.triu( + torch.full( + (seq_len, seq_len), + float("-inf"), + device=input_ids.device, + dtype=self.dtype, + ), + diagonal=1, + ) + causal_mask = causal_mask.unsqueeze(0).unsqueeze(0) # (1, 1, S, S) + + # Combine with padding mask: mask out padded key positions + # attention_mask: (B, seq_len) -> (B, 1, 1, seq_len) + pad_mask = (1.0 - attention_mask.to(self.dtype)).unsqueeze(1).unsqueeze( + 2 + ) * float("-inf") + # Replace NaN (from 0 * -inf) with 0 + pad_mask = torch.nan_to_num(pad_mask, nan=0.0) + combined_mask = causal_mask + pad_mask # broadcast: (B, 1, S, S) + + # Embedding + hidden_states = self.embed_tokens(input_ids) # (B, seq_len, hidden_size) + + # Accumulate all hidden states + all_hidden_states = [hidden_states] + + # Run through all decoder layers + for layer in self.layers: + hidden_states = layer(hidden_states, combined_mask, position_ids) + all_hidden_states.append(hidden_states) + + # Apply final norm to the last hidden state + # Note: HuggingFace Gemma3TextModel applies norm to the final output, + # and this IS included in hidden_states[-1] when output_hidden_states=True + # Actually, checking HF code: the norm is applied to the LAST hidden state + # but hidden_states tuple contains pre-norm outputs. Let me verify... + # + # From HF modeling_gemma3.py: + # hidden_states = self.norm(hidden_states) + # all_hidden_states += (hidden_states,) <-- post-norm + # So the last element in hidden_states IS the post-norm output. + # We need to replace the last element with the normed version. + hidden_states = self.norm(hidden_states) + all_hidden_states[-1] = hidden_states + + # Stack all hidden states: (B, seq_len, hidden_size, num_layers+1) + return torch.stack(all_hidden_states, dim=-1) + + +# ── State Dict Conversion ─────────────────────────────────────────────────── + + +def convert_hf_gemma3_to_encoder_state_dict( + hf_state_dict: dict, dtype: torch.dtype = torch.bfloat16 +) -> dict: + """Convert HuggingFace Gemma3ForConditionalGeneration state dict to encoder format. + + The HF model has keys like: + language_model.model.embed_tokens.weight + language_model.model.layers.0.self_attn.q_proj.weight + language_model.model.layers.0.self_attn.q_norm.weight + language_model.model.layers.0.mlp.gate_proj.weight + language_model.model.norm.weight + language_model.lm_head.weight (skip) + + Our encoder model expects: + embed_tokens.embedding.weight (ParallelEmbedding wraps in .embedding) + layers.0.self_attn.q_proj.weight + layers.0.self_attn.q_layernorm.weight (q_norm -> q_layernorm) + layers.0.self_attn.k_layernorm.weight (k_norm -> k_layernorm) + layers.0.mlp.gate_proj.weight + norm.weight + + Note: HF stores norm weights as float32 but our compiled model uses bfloat16. + All values are cast to `dtype` (default bfloat16) to match the compiled graph. + """ + encoder_state_dict = {} + + # Possible prefixes for the language model weights, in priority order. + # LONGER prefixes must come first to avoid partial matches (e.g., "model." + # would match "model.language_model." keys but strip too little). + # 1. "base_text_encoder.language_model.model." — diffusers safetensors + # 2. "model.language_model." — pipeline .state_dict() (Gemma3ForConditionalGeneration) + # 3. "language_model.model." — HF safetensors (model-*.safetensors) + # 4. "model." — bare Gemma3ForCausalLM + prefixes = [ + "base_text_encoder.language_model.model.", + "model.language_model.", + "language_model.model.", + "model.", + ] + + for key, value in hf_state_dict.items(): + new_key = None + for prefix in prefixes: + if key.startswith(prefix): + new_key = key[len(prefix) :] + break + if new_key is None: + continue + + # Skip lm_head — encoder doesn't need it + if "lm_head" in new_key: + continue + + # Skip keys that don't belong to the text model (vision tower, projector, etc.) + # Valid keys start with: embed_tokens, layers, norm + if not ( + new_key.startswith("embed_tokens") + or new_key.startswith("layers.") + or new_key.startswith("norm.") + ): + continue + + # Rename embed_tokens for ParallelEmbedding wrapper + if new_key == "embed_tokens.weight": + encoder_state_dict["embed_tokens.embedding.weight"] = ( + value.detach().clone().to(dtype) + ) + continue + + # Rename Q-K norm: q_norm -> q_layernorm, k_norm -> k_layernorm + new_key = new_key.replace(".self_attn.q_norm.", ".self_attn.q_layernorm.") + new_key = new_key.replace(".self_attn.k_norm.", ".self_attn.k_layernorm.") + + encoder_state_dict[new_key] = value.detach().clone().to(dtype) + + return encoder_state_dict diff --git a/contrib/models/ltx2-video-audio/src/modeling_ltx2.py b/contrib/models/ltx2-video-audio/src/modeling_ltx2.py new file mode 100644 index 00000000..018649b7 --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/modeling_ltx2.py @@ -0,0 +1,973 @@ +""" +NxDI LTX-2 Transformer Model +============================= +Neuron-optimized implementation of the LTX-2 19B DiT audio-video +diffusion transformer. Follows the NxDI Flux pattern for diffusion models. + +Architecture: + - 48 LTX-2 joint transformer blocks (video + audio dual-stream) + - TP-sharded attention (ColumnParallelLinear/RowParallelLinear) + - DistributedRMSNorm for QK-norm (all-reduce across TP ranks) + - SPMDRank-based RoPE slicing (critical fix for TP>1) + - NKI flash attention for video self-attn (seq >= 512), BMM fallback otherwise + - Batched CFG (BS=2): unconditional + conditional passes in a single forward call + +The model takes 22 preprocessed tensor inputs (proj_in, time_embed, +RoPE, caption_projection, attention masks all computed on CPU) and +returns (video_output, audio_output). All inputs have batch_size=2 +when CFG is active. + +Usage: + See application.py for the high-level NeuronLTX2Application class. +""" + +import logging +import math +import os +from typing import List, Optional, Tuple + +import torch +import torch.nn as nn + +logger = logging.getLogger(__name__) + +# These imports are only available on Neuron instances +try: + from neuronx_distributed.parallel_layers.layers import ( + ColumnParallelLinear, + RowParallelLinear, + SPMDRank, + ) + from neuronx_distributed.parallel_layers.parallel_state import ( + get_tensor_model_parallel_size, + ) + from neuronx_distributed.parallel_layers.utils import ( + set_tensor_model_parallel_attributes, + ) + import neuronx_distributed.trace.trace as _nxd_trace + + from neuronx_distributed_inference.models.application_base import ( + NeuronApplicationBase, + ) + from neuronx_distributed_inference.models.config import ( + InferenceConfig, + NeuronConfig, + ) + from neuronx_distributed_inference.models.model_wrapper import ( + BaseModelInstance, + ModelWrapper, + ) + + NEURON_AVAILABLE = True +except ImportError: + NEURON_AVAILABLE = False + + +# ── NKI Flash Attention + BMM-based SDPA replacement ──────────────────────── +_sdpa_replaced = False +_sdpa_original = None + +# Minimum sequence length for NKI flash attention kernel eligibility +_NKI_FLASH_MIN_SEQ = 512 + + +def _try_load_nki_cte(): + """Try to load the nkilib attention_cte kernel and build a 4D wrapper. + + The attention_cte kernel is a pure-NKI flash attention implementation with + 3-deep software pipelining and LNC2-aware sharding. It operates on 3D + tensors (B*H, seq, d) but we wrap it to accept 4D (B, H, S, D) for + drop-in compatibility with the ISA kernel interface. + + Integration uses the nki 0.2.0 public API: + 1. peel_decorations() strips the @nki.jit(mode='auto') decorator + 2. nki.jit(mode='torchxla') redecorates for PyTorch XLA tensor support + 3. Integer grid (2,) for LNC=2 sharding (nki 0.2.0 uses int grids) + + Returns a callable matching scaled_dot_product_attention_kernel's 4D interface, + or None if nkilib is not available. + """ + try: + import nki + from nkilib.core.attention.attention_cte import attention_cte + from neuronx_distributed_inference.utils.decorator_peeling import ( + peel_decorations, + ) + + # Peel @nki.jit(mode='auto') and redecorate with mode='torchxla' + # for PyTorch tensor compatibility during torch_neuronx.trace(). + raw_func = peel_decorations(attention_cte) + decorated_cte = nki.jit( + raw_func, + mode="torchxla", + platform_target="trn2", + ) + + logger.info("nkilib attention_cte kernel loaded (nki 0.2.0 torchxla)") + + def attention_cte_4d(Q, K, V, is_causal=False, scale=None): + """4D wrapper for attention_cte: (B, H, S, D) -> (B, H, S, D). + + Reshapes 4D tensors to 3D (B*H, seq, d) with tp_q=True layout, + calls the nkilib CTE kernel, and reshapes back. + """ + bsz, num_heads, q_len, head_dim = Q.shape + k_len = K.shape[2] + + if scale is None: + scale = 1.0 / math.sqrt(head_dim) + + # Reshape to 3D: (B*H, seq, d) — tp_q=True, tp_k=True layout + Q_3d = Q.reshape(bsz * num_heads, q_len, head_dim).contiguous() + K_3d = K.reshape(bsz * num_heads, k_len, head_dim).contiguous() + V_3d = V.reshape(bsz * num_heads, k_len, head_dim).contiguous() + + # Integer grid (2,) for LNC=2 sharding (nki 0.2.0 API) + out = decorated_cte[(2,)]( + q=Q_3d, + k=K_3d, + v=V_3d, + scale=scale, + causal_mask=is_causal, + tp_q=True, + tp_k=True, + tp_out=False, + ) + + return out.reshape(bsz, num_heads, q_len, head_dim) + + return attention_cte_4d + + except ImportError: + logger.info("nkilib not available, will try ISA kernel fallback") + return None + except Exception as e: + logger.info(f"nkilib attention_cte load failed: {e}") + return None + + +def _try_load_nki_flash(): + """Try to load the NKI flash attention kernel from the SDK. + + Returns the kernel function or None if unavailable. + """ + try: + from neuronx_distributed_inference.experimental.functional.attention.causal_attention_functions import ( + scaled_dot_product_attention_kernel, + ) + + return scaled_dot_product_attention_kernel + except ImportError: + logger.warning("NKI flash attention kernel not available, using BMM fallback") + return None + + +def replace_sdpa_with_bmm(): + """Replace F.scaled_dot_product_attention with NKI flash + BMM hybrid. + + Kernel priority (auto mode): + 1. NxDI ISA kernel (AttentionMMSoftmaxMMWithoutSwap) — fastest compile + 2. nkilib attention_cte (pure NKI, 3-deep pipelined, LNC2-aware) + 3. BMM fallback (explicit batched matmul + softmax) + + For attention with no mask, Q.seq >= 512, and 4D input on Neuron: + Uses the best available NKI flash attention kernel. + This covers: + - Video self-attention (attn1): Q.seq == K.seq == 6144 + - Audio-to-video cross-modal attention (a2v): Q.seq=6144, K.seq=121 + The kernel supports Q.seq != K.seq for non-causal attention. + + For attention with masks or Q.seq < 512: + Falls back to explicit BMM + softmax. + + Falls back to original SDPA on CPU. + """ + global _sdpa_replaced, _sdpa_original + if _sdpa_replaced: + return _sdpa_original + _sdpa_original = torch.nn.functional.scaled_dot_product_attention + + # Try ISA kernel first (fastest compile), then nkilib CTE. + # Set LTX2_FLASH_KERNEL=isa to force ISA, or LTX2_FLASH_KERNEL=cte to force nkilib CTE. + kernel_pref = os.environ.get("LTX2_FLASH_KERNEL", "auto").lower() + + _nki_flash_kernel = None + if kernel_pref in ("auto", "isa"): + _nki_flash_kernel = _try_load_nki_flash() + if _nki_flash_kernel is not None: + logger.info("Using NxDI ISA kernel for flash attention") + if _nki_flash_kernel is None and kernel_pref in ("auto", "cte"): + _nki_flash_kernel = _try_load_nki_cte() + if _nki_flash_kernel is not None: + logger.info("Using nkilib attention_cte for flash attention") + if _nki_flash_kernel is None: + logger.warning("No NKI flash kernel available, all attention uses BMM") + + def neuron_sdpa( + query, + key, + value, + attn_mask=None, + dropout_p=0.0, + is_causal=False, + scale=None, + enable_gqa=False, + ): + # CPU fallback (for text encoder, preprocessing) + if query.device.type == "cpu": + return _sdpa_original( + query, + key, + value, + attn_mask=attn_mask, + dropout_p=dropout_p, + is_causal=is_causal, + scale=scale, + ) + + # ── NKI Flash Attention path ──────────────────────────────────── + # Eligible when: 4D input, no mask, Q.seq >= 512 + # The kernel supports Q.seq != K.seq for non-causal attention. + # This covers: + # - Video self-attention (attn1): Q=6144, K=6144 — majority of attn compute + # - Audio-to-video cross-modal (a2v): Q=6144, K=121 + # Cross-attention with masks (attn2, audio_attn2) uses BMM fallback. + # Audio attention with Q.seq < 512 (audio_attn1, v2a) uses BMM fallback. + if ( + _nki_flash_kernel is not None + and attn_mask is None + and len(query.shape) == 4 + and query.shape[2] >= _NKI_FLASH_MIN_SEQ + ): + if scale is None: + scale = 1.0 / math.sqrt(query.shape[-1]) + return _nki_flash_kernel( + query, key, value, is_causal=False, scale=float(scale) + ) + + # ── BMM fallback path ─────────────────────────────────────────── + d = query.shape[-1] + if scale is None: + scale = 1.0 / math.sqrt(d) + orig_shape = None + if len(query.shape) == 4: + orig_shape = query.shape + b, h, sq, d_head = query.shape + query = query.reshape(b * h, sq, d_head) + key = key.reshape(b * h, -1, d_head) + value = value.reshape(b * h, -1, d_head) + if attn_mask is not None and attn_mask.ndim == 4: + attn_mask = attn_mask.reshape( + b * h, attn_mask.shape[-2], attn_mask.shape[-1] + ) + elif attn_mask is not None and attn_mask.ndim == 2: + attn_mask = attn_mask.unsqueeze(0) + elif attn_mask is not None and attn_mask.ndim == 3: + if attn_mask.shape[0] == orig_shape[0]: + attn_mask = ( + attn_mask.unsqueeze(1) + .expand(orig_shape[0], orig_shape[1], -1, -1) + .reshape( + orig_shape[0] * orig_shape[1], + attn_mask.shape[-2], + attn_mask.shape[-1], + ) + ) + scores = torch.bmm(query, key.transpose(-1, -2)) * scale + if attn_mask is not None: + scores = scores + attn_mask + probs = scores.softmax(dim=-1) + out = torch.bmm(probs, value) + if orig_shape is not None: + out = out.reshape(orig_shape[0], orig_shape[1], -1, orig_shape[3]) + return out + + torch.nn.functional.scaled_dot_product_attention = neuron_sdpa + _sdpa_replaced = True + return _sdpa_original + + +# ── DistributedRMSNorm ────────────────────────────────────────────────────── +class DistributedRMSNorm(nn.Module): + """RMSNorm with all-reduce for global variance computation across TP ranks. + + Standard RMSNorm on a TP-sharded hidden dimension only sees the local shard. + This version computes sum-of-squares locally, all-reduces across ranks, then + normalizes with the global RMS. Essential for QK-norm accuracy in TP>1. + + The all-reduce in this norm is NOT redundant — removing it (LocalRMSNorm + experiment) made quality significantly worse. + """ + + def __init__(self, normalized_shape, eps=1e-5, tp_size=4, dtype=torch.bfloat16): + super().__init__() + self.weight = nn.Parameter(torch.ones(normalized_shape, dtype=dtype)) + self.eps = eps + self.tp_size = tp_size + self.local_dim = normalized_shape + + if NEURON_AVAILABLE: + set_tensor_model_parallel_attributes( + self.weight, is_parallel=True, dim=0, stride=1, num_partitions=tp_size + ) + + def forward(self, hidden_states): + hidden_states_f32 = hidden_states.to(torch.float32) + local_sum_sq = hidden_states_f32.pow(2).sum(dim=-1, keepdim=True) + import torch_xla.core.xla_model as xm + + global_sum_sq = xm.all_reduce(xm.REDUCE_SUM, local_sum_sq) + global_dim = self.local_dim * self.tp_size + rms = torch.rsqrt(global_sum_sq / global_dim + self.eps) + hidden_states = hidden_states_f32 * rms + if self.weight.dtype in [torch.float16, torch.bfloat16]: + hidden_states = hidden_states.to(self.weight.dtype) + return hidden_states * self.weight + + +# Register DistributedRMSNorm as a supported sharded module for NxD tracing +if NEURON_AVAILABLE: + _nxd_trace.__SUPPORTED_SHARDED_MODULES = ( + *_nxd_trace.__SUPPORTED_SHARDED_MODULES, + DistributedRMSNorm, + ) + + +# ── NeuronLTX2TransformerBackbone ─────────────────────────────────────────── +class NeuronLTX2TransformerBackbone(nn.Module): + """The core LTX-2 DiT transformer backbone for Neuron. + + Contains the 48 transformer blocks, output normalization, and projection layers. + Takes 22 preprocessed tensor inputs (all preprocessing done on CPU) and returns + (video_output, audio_output). + + This corresponds to the FullTransformerWrapper from the standalone scripts, + wrapped in NxDI conventions. + + Key features: + - SPMDRank for correct per-rank RoPE slicing in TP>1 + - DistributedRMSNorm for QK-norm (all-reduce across ranks) + - BMM-based SDPA with NKI flash attention for video self-attn (replaces torch SDPA for Neuron) + """ + + def __init__(self, config): + """Initialize from InferenceConfig. + + If config has an `hf_config_dict` attribute (set during config creation), + the transformer is automatically built from the diffusers model with TP sharding. + Otherwise creates an empty backbone (for use with from_diffusers()). + """ + super().__init__() + self.config = config + self.tp_degree = config.neuron_config.tp_degree + + # Check if we have the HF config dict to auto-build + hf_config_dict = getattr(config, "hf_config_dict", None) + if hf_config_dict is not None: + self._build_from_diffusers(hf_config_dict) + else: + # Empty backbone — will be populated by from_diffusers() + self.transformer_blocks = None + self.norm_out = None + self.proj_out = None + self.scale_shift_table = None + self.audio_norm_out = None + self.audio_proj_out = None + self.audio_scale_shift_table = None + self.spmd_rank = None + + def _build_from_diffusers(self, hf_config_dict): + """Build the TP-sharded transformer from a HuggingFace config dict.""" + replace_sdpa_with_bmm() + + from diffusers.models.transformers.transformer_ltx2 import ( + LTX2VideoTransformer3DModel, + ) + + hf_model = LTX2VideoTransformer3DModel.from_config(hf_config_dict) + hf_model = hf_model.to(dtype=self.config.neuron_config.torch_dtype) + hf_model.eval() + + if self.tp_degree > 1: + _shard_ltx2_transformer(hf_model, self.tp_degree) + + self.transformer_blocks = hf_model.transformer_blocks + self.norm_out = hf_model.norm_out + self.proj_out = hf_model.proj_out + self.scale_shift_table = hf_model.scale_shift_table + self.audio_norm_out = hf_model.audio_norm_out + self.audio_proj_out = hf_model.audio_proj_out + self.audio_scale_shift_table = hf_model.audio_scale_shift_table + + if self.tp_degree > 1 and NEURON_AVAILABLE: + self.spmd_rank = SPMDRank(self.tp_degree) + else: + self.spmd_rank = None + + @classmethod + def from_diffusers(cls, config, hf_config_dict): + """Build the Neuron transformer from a HuggingFace config dict. + + Args: + config: NxDI InferenceConfig + hf_config_dict: Dict from transformer/config.json (HuggingFace) + + Returns: + NeuronLTX2TransformerBackbone instance with TP-sharded layers + """ + # Store hf_config_dict on config so __init__ auto-builds + config.hf_config_dict = hf_config_dict + return cls(config) + + def _slice_rope(self, cos, sin): + """Slice RoPE embeddings to the heads owned by this TP rank. + + Uses SPMDRank (a learnable parameter sharded per-rank) instead of a + Python int to avoid baking rank=0 as a constant during XLA tracing. + """ + if self.tp_degree <= 1 or self.spmd_rank is None: + return (cos, sin) + h_per_rank = cos.shape[1] // self.tp_degree + rank = self.spmd_rank.get_rank() # shape (1,), int32 — auto-sharded per-rank + start = (rank[0] * h_per_rank).to(torch.long) + indices = start + torch.arange(h_per_rank, device=cos.device, dtype=torch.long) + cos_sliced = torch.index_select(cos, 1, indices) + sin_sliced = torch.index_select(sin, 1, indices) + return (cos_sliced, sin_sliced) + + def forward( + self, + hidden_states, # (B, video_seq, inner_dim) — after proj_in + audio_hidden_states, # (B, audio_seq, audio_inner_dim) — after audio_proj_in + encoder_hidden_states, # (B, text_seq, inner_dim) — after caption_projection + audio_encoder_hidden_states, # (B, text_seq, audio_inner_dim) + temb, # (B, 1, 6*inner_dim) — packed time embedding (6 mod params) + temb_audio, # (B, 1, 6*audio_inner_dim) — packed audio time embedding + embedded_timestep, # (B, 1, inner_dim) — for output scaling + audio_embedded_timestep, # (B, 1, audio_inner_dim) + temb_ca_ss, # (B, 1, 4*inner_dim) — cross-attn video scale/shift (4 mod params) + temb_ca_audio_ss, # (B, 1, 4*audio_inner_dim) — cross-attn audio scale/shift + temb_ca_gate, # (B, 1, inner_dim) — cross-attn video gate (1 mod param) + temb_ca_audio_gate, # (B, 1, audio_inner_dim) — cross-attn audio gate + video_rot_cos, # (B, num_heads, video_seq, rope_dim) rope_dim=inner_dim/heads/2 + video_rot_sin, # (B, num_heads, video_seq, rope_dim) + audio_rot_cos, # (B, audio_num_heads, audio_seq, audio_rope_dim) + audio_rot_sin, # (B, audio_num_heads, audio_seq, audio_rope_dim) + ca_video_rot_cos, # (B, num_heads, video_seq, ca_rope_dim) ca uses audio_ca_dim + ca_video_rot_sin, + ca_audio_rot_cos, # (B, audio_num_heads, audio_seq, ca_rope_dim) + ca_audio_rot_sin, + encoder_attention_mask, # (B, 1, text_seq) — additive bias + audio_encoder_attention_mask, # (B, 1, text_seq) — additive bias + ): + # Slice RoPE to local TP shard + video_rotary_emb = self._slice_rope(video_rot_cos, video_rot_sin) + audio_rotary_emb = self._slice_rope(audio_rot_cos, audio_rot_sin) + ca_video_rotary_emb = self._slice_rope(ca_video_rot_cos, ca_video_rot_sin) + ca_audio_rotary_emb = self._slice_rope(ca_audio_rot_cos, ca_audio_rot_sin) + + # Run 48 transformer blocks + for block in self.transformer_blocks: + hidden_states, audio_hidden_states = block( + hidden_states=hidden_states, + audio_hidden_states=audio_hidden_states, + encoder_hidden_states=encoder_hidden_states, + audio_encoder_hidden_states=audio_encoder_hidden_states, + temb=temb, + temb_audio=temb_audio, + temb_ca_scale_shift=temb_ca_ss, + temb_ca_audio_scale_shift=temb_ca_audio_ss, + temb_ca_gate=temb_ca_gate, + temb_ca_audio_gate=temb_ca_audio_gate, + video_rotary_emb=video_rotary_emb, + audio_rotary_emb=audio_rotary_emb, + ca_video_rotary_emb=ca_video_rotary_emb, + ca_audio_rotary_emb=ca_audio_rotary_emb, + encoder_attention_mask=encoder_attention_mask, + audio_encoder_attention_mask=audio_encoder_attention_mask, + ) + + # Video output projection + scale_shift_values = ( + self.scale_shift_table[None, None] + embedded_timestep[:, :, None] + ) + shift, scale = scale_shift_values[:, :, 0], scale_shift_values[:, :, 1] + hidden_states = self.norm_out(hidden_states) + hidden_states = hidden_states * (1 + scale) + shift + output = self.proj_out(hidden_states) + + # Audio output projection + audio_ssv = ( + self.audio_scale_shift_table[None, None] + + audio_embedded_timestep[:, :, None] + ) + audio_shift, audio_scale = audio_ssv[:, :, 0], audio_ssv[:, :, 1] + audio_hidden_states = self.audio_norm_out(audio_hidden_states) + audio_hidden_states = audio_hidden_states * (1 + audio_scale) + audio_shift + audio_output = self.audio_proj_out(audio_hidden_states) + + return output, audio_output + + +# ── TP Sharding ───────────────────────────────────────────────────────────── +def _shard_ltx2_transformer(transformer, tp_degree): + """Apply tensor parallelism sharding to the LTX-2 transformer. + + Shards: + - Attention Q/K/V projections → ColumnParallelLinear (shard output dim) + - Attention output projections → RowParallelLinear (shard input dim) + - FFN gate/up projections → ColumnParallelLinear + - FFN down projections → RowParallelLinear + - QK-norm → DistributedRMSNorm (all-reduce for global variance) + - Attention heads count divided by tp_degree + + Each of the 48 blocks has 7 attention modules and 2 FFNs: + - attn1, attn2 (video self-attn, video cross-attn) + - audio_attn1, audio_attn2 (audio self-attn, audio cross-attn) + - audio_to_video_attn, video_to_audio_attn (cross-modal) + - ff, audio_ff (feed-forward) + """ + from neuronx_distributed.parallel_layers import parallel_state + + tp_rank = parallel_state.get_tensor_model_parallel_rank() + tp_size = parallel_state.get_tensor_model_parallel_size() + + def get_shard(data, dim): + s = data.shape[dim] // tp_size + if dim == 0: + return data[s * tp_rank : s * (tp_rank + 1)].clone() + return data[:, s * tp_rank : s * (tp_rank + 1)].clone() + + def shard_attention(attn): + for proj_name in ["to_q", "to_k", "to_v"]: + proj = getattr(attn, proj_name) + col = ColumnParallelLinear( + proj.in_features, + proj.out_features, + bias=proj.bias is not None, + gather_output=False, + dtype=proj.weight.dtype, + ) + col.weight.data = get_shard(proj.weight.data, 0) + if proj.bias is not None: + col.bias.data = get_shard(proj.bias.data, 0) + setattr(attn, proj_name, col) + + out_linear = attn.to_out[0] + row = RowParallelLinear( + out_linear.in_features, + out_linear.out_features, + bias=out_linear.bias is not None, + input_is_parallel=True, + dtype=out_linear.weight.dtype, + ) + row.weight.data = get_shard(out_linear.weight.data, 1) + if out_linear.bias is not None: + row.bias.data = out_linear.bias.data.clone() + attn.to_out[0] = row + + for norm_name in ["norm_q", "norm_k"]: + norm = getattr(attn, norm_name, None) + if norm is not None and hasattr(norm, "weight") and norm.weight is not None: + full_dim = norm.weight.shape[0] + local_dim = full_dim // tp_size + dist_norm = DistributedRMSNorm( + local_dim, + eps=norm.eps, + tp_size=tp_size, + dtype=norm.weight.dtype, + ) + dist_norm.weight.data = get_shard(norm.weight.data, 0) + setattr(attn, norm_name, dist_norm) + + attn.heads = attn.heads // tp_size + attn.inner_dim = attn.inner_dim // tp_size + if hasattr(attn, "inner_kv_dim"): + attn.inner_kv_dim = attn.inner_kv_dim // tp_size + + def shard_ffn(ff): + net = ff.net + gate = net[0] + if hasattr(gate, "proj"): + proj = gate.proj + col = ColumnParallelLinear( + proj.in_features, + proj.out_features, + bias=proj.bias is not None, + gather_output=False, + dtype=proj.weight.dtype, + ) + col.weight.data = get_shard(proj.weight.data, 0) + if proj.bias is not None: + col.bias.data = get_shard(proj.bias.data, 0) + gate.proj = col + elif isinstance(gate, nn.Linear): + col = ColumnParallelLinear( + gate.in_features, + gate.out_features, + bias=gate.bias is not None, + gather_output=False, + dtype=gate.weight.dtype, + ) + col.weight.data = get_shard(gate.weight.data, 0) + if gate.bias is not None: + col.bias.data = get_shard(gate.bias.data, 0) + net[0] = col + + down = net[-1] + if isinstance(down, nn.Linear): + row = RowParallelLinear( + down.in_features, + down.out_features, + bias=down.bias is not None, + input_is_parallel=True, + dtype=down.weight.dtype, + ) + row.weight.data = get_shard(down.weight.data, 1) + if down.bias is not None: + row.bias.data = down.bias.data.clone() + net[len(net) - 1] = row + + for block in transformer.transformer_blocks: + shard_attention(block.attn1) + shard_attention(block.attn2) + shard_attention(block.audio_to_video_attn) + shard_ffn(block.ff) + shard_attention(block.audio_attn1) + shard_attention(block.audio_attn2) + shard_attention(block.video_to_audio_attn) + shard_ffn(block.audio_ff) + + +# ── NxDI Config ───────────────────────────────────────────────────────────── +class LTX2BackboneInferenceConfig(InferenceConfig if NEURON_AVAILABLE else object): + """InferenceConfig for the LTX-2 transformer backbone.""" + + def __init__(self, *args, **kwargs): + if NEURON_AVAILABLE: + super().__init__(*args, **kwargs) + + def get_required_attributes(self): + return [ + "num_layers", + "num_attention_heads", + "attention_head_dim", + "inner_dim", + "audio_num_attention_heads", + "audio_attention_head_dim", + "audio_inner_dim", + "audio_cross_attention_dim", + "caption_channels", + "video_seq", + "audio_seq", + "text_seq", + "height", + "width", + "num_frames", + ] + + +# ── NxDI ModelWrapper ─────────────────────────────────────────────────────── +class ModelWrapperLTX2Backbone(ModelWrapper if NEURON_AVAILABLE else object): + """ModelWrapper for the LTX-2 DiT transformer backbone.""" + + def __init__( + self, + config, + model_cls, + tag="", + compiler_args=None, + priority_model_idx=None, + model_init_kwargs={}, + ): + if NEURON_AVAILABLE: + super().__init__( + config, + model_cls, + tag, + compiler_args, + priority_model_idx, + model_init_kwargs, + ) + self.bucket_config = None + + def input_generator(self): + """Generate example inputs for Neuron compilation. + + Returns list of (tuple_of_tensors,) matching the 22-input forward() signature. + + Compiled with batch_size=2 to support CFG (classifier-free guidance) natively. + With CFG, the Diffusers pipeline doubles the batch (uncond + cond) and the + Neuron backbone processes both in a single forward pass, avoiding the overhead + of two sequential BS=1 calls. + + Shapes are derived from the actual LTX-2 preprocessing pipeline: + - time_embed produces (B, 6*inner_dim) for video, (B, 6*audio_inner_dim) for audio + - cross-attn scale/shift has num_mod_params=4, gate has num_mod_params=1 + - Audio streams use audio_inner_dim (32*64=2048), not inner_dim (32*128=4096) + - RoPE: video uses num_heads/head_dim, audio uses audio_num_heads/audio_head_dim + See compile_full_tp4.py:precompute_inputs() for the authoritative reference. + """ + dtype = self.config.neuron_config.torch_dtype + inner_dim = self.config.inner_dim + audio_inner_dim = self.config.audio_inner_dim + audio_ca_dim = self.config.audio_cross_attention_dim + video_seq = self.config.video_seq + audio_seq = self.config.audio_seq + text_seq = self.config.text_seq + num_heads = self.config.num_attention_heads + head_dim = self.config.attention_head_dim + audio_num_heads = self.config.audio_num_attention_heads + audio_head_dim = self.config.audio_attention_head_dim + + # Batch size = 2 for CFG (unconditional + conditional in one pass) + bs = 2 + + # RoPE rotation dim per head: + # self-attn video: rope.dim=inner_dim → inner_dim / num_heads / 2 + # self-attn audio: audio_rope.dim=audio_inner_dim → audio_inner_dim / audio_num_heads / 2 + # cross-attn video: cross_attn_rope.dim=audio_cross_attention_dim → audio_ca_dim / num_heads / 2 + # cross-attn audio: cross_attn_audio_rope.dim=audio_cross_attention_dim → audio_ca_dim / audio_num_heads / 2 + video_rope_dim = inner_dim // num_heads // 2 # 4096/32/2 = 64 + audio_rope_dim = audio_inner_dim // audio_num_heads // 2 # 2048/32/2 = 32 + ca_video_rope_dim = audio_ca_dim // num_heads // 2 # 2048/32/2 = 32 + ca_audio_rope_dim = audio_ca_dim // audio_num_heads // 2 # 2048/32/2 = 32 + + model_inputs = ( + # Projected hidden states (after proj_in / audio_proj_in on CPU) + torch.randn(bs, video_seq, inner_dim, dtype=dtype), # hidden_states + torch.randn( + bs, audio_seq, audio_inner_dim, dtype=dtype + ), # audio_hidden_states + # Projected encoder hidden states (after caption_projection on CPU) + torch.randn(bs, text_seq, inner_dim, dtype=dtype), # encoder_hidden_states + torch.randn( + bs, text_seq, audio_inner_dim, dtype=dtype + ), # audio_encoder_hidden_states + # Time embeddings: LTX2AdaLayerNormSingle with num_mod_params=6 + # time_embed.linear: (embedding_dim) → (6 * embedding_dim) + torch.randn(bs, 1, 6 * inner_dim, dtype=dtype), # temb + torch.randn(bs, 1, 6 * audio_inner_dim, dtype=dtype), # temb_audio + # Embedded timestep (second return from time_embed, shape=embedding_dim) + torch.randn(bs, 1, inner_dim, dtype=dtype), # embedded_timestep + torch.randn(bs, 1, audio_inner_dim, dtype=dtype), # audio_embedded_timestep + # Cross-attn scale/shift: num_mod_params=4 + torch.randn(bs, 1, 4 * inner_dim, dtype=dtype), # temb_ca_ss + torch.randn(bs, 1, 4 * audio_inner_dim, dtype=dtype), # temb_ca_audio_ss + # Cross-attn gate: num_mod_params=1 + torch.randn(bs, 1, 1 * inner_dim, dtype=dtype), # temb_ca_gate + torch.randn(bs, 1, 1 * audio_inner_dim, dtype=dtype), # temb_ca_audio_gate + # Video RoPE cos/sin: (B, num_heads, video_seq, video_rope_dim) + torch.randn( + bs, num_heads, video_seq, video_rope_dim, dtype=dtype + ), # video_rot_cos + torch.randn( + bs, num_heads, video_seq, video_rope_dim, dtype=dtype + ), # video_rot_sin + # Audio RoPE cos/sin: (B, audio_num_heads, audio_seq, audio_rope_dim) + torch.randn( + bs, audio_num_heads, audio_seq, audio_rope_dim, dtype=dtype + ), # audio_rot_cos + torch.randn( + bs, audio_num_heads, audio_seq, audio_rope_dim, dtype=dtype + ), # audio_rot_sin + # Cross-attn RoPE: same seq_len, but rope dim = audio_ca_dim / heads / 2 + # cross_attn_rope has dim=audio_cross_attention_dim, not inner_dim + torch.randn( + bs, num_heads, video_seq, ca_video_rope_dim, dtype=dtype + ), # ca_video_rot_cos + torch.randn( + bs, num_heads, video_seq, ca_video_rope_dim, dtype=dtype + ), # ca_video_rot_sin + torch.randn( + bs, audio_num_heads, audio_seq, ca_audio_rope_dim, dtype=dtype + ), # ca_audio_rot_cos + torch.randn( + bs, audio_num_heads, audio_seq, ca_audio_rope_dim, dtype=dtype + ), # ca_audio_rot_sin + # Attention masks: additive bias (B, 1, text_seq) + torch.zeros(bs, 1, text_seq, dtype=dtype), # encoder_attention_mask + torch.zeros(bs, 1, text_seq, dtype=dtype), # audio_encoder_attention_mask + ) + + return [model_inputs] + + def get_model_instance(self): + def _create_model(): + model = self.model_cls(self.config) + model = model.to(dtype=self.config.neuron_config.torch_dtype) + model.eval() + return model + + return BaseModelInstance(module_cls=_create_model, input_output_aliases={}) + + def forward(self, *args, **kwargs): + if self.model is None: + raise RuntimeError( + "Forward called before load. Run load() or load_state_dict() first." + ) + output = self._forward(*args) + return output + + +# ── NxDI Application ──────────────────────────────────────────────────────── +class NeuronLTX2BackboneApplication( + NeuronApplicationBase if NEURON_AVAILABLE else object +): + """NxDI Application wrapping the LTX-2 DiT transformer backbone. + + Handles compilation, weight sharding, loading, and inference. + Follows the same pattern as NeuronFluxBackboneApplication. + """ + + _model_cls = NeuronLTX2TransformerBackbone + + def __init__(self, *args, **kwargs): + if NEURON_AVAILABLE: + super().__init__(*args, **kwargs) + self.model_wrapper = self.get_model_wrapper_cls() + + self.model = self.model_wrapper( + config=self.config, + model_cls=self._model_cls, + tag=self._model_cls.__name__, + compiler_args=self.get_compiler_args(), + priority_model_idx=0, + ) + self.models.append(self.model) + self.dtype = self.config.neuron_config.torch_dtype + + def get_model_wrapper_cls(self): + return ModelWrapperLTX2Backbone + + def forward(self, *model_inputs, **kwargs): + return self.models[0](*model_inputs, **kwargs) + + def get_compiler_args(self): + """Compiler args for the LTX-2 transformer. + + Uses --auto-cast matmult (the spelling with two t's) and --lnc 2 for trn2. + """ + compiler_args = "--model-type=transformer -O1" + compiler_args += " --auto-cast matmult --lnc 2" + compiler_args += " --tensorizer-options='--enable-ccop-compute-overlap'" + + os.environ["LOCAL_WORLD_SIZE"] = str(self.config.neuron_config.world_size) + os.environ["NEURON_RT_VIRTUAL_CORE_SIZE"] = "2" + os.environ["NEURON_FUSE_SOFTMAX"] = "1" + os.environ["NEURON_CUSTOM_SILU"] = "1" + os.environ["NEURON_RT_STOCHASTIC_ROUNDING_EN"] = "0" + + return compiler_args + + @staticmethod + def update_state_dict_for_tied_weights(state_dict): + pass + + def checkpoint_loader_fn(self, mmap: bool = False): + """Load the LTX-2 transformer weights from HuggingFace or local path. + + Handles HuggingFace hub IDs (e.g., "Lightricks/LTX-2/transformer") by + downloading the transformer via diffusers. Also handles local directories + containing safetensors files. + + The state dict returned contains ALL HuggingFace transformer weights. + Keys that don't match the backbone model (proj_in, time_embed, etc.) are + ignored during load_state_dict(strict=False). + """ + model_path = self.model_path + logger.info("Loading LTX-2 transformer weights from %s", model_path) + + # Try local path first + if os.path.isdir(model_path): + from safetensors.torch import load_file + import glob as _glob + + safetensors_files = sorted( + _glob.glob(os.path.join(model_path, "*.safetensors")) + ) + if safetensors_files: + model_sd = {} + for sf in safetensors_files: + model_sd.update(load_file(sf)) + logger.info( + "Loaded %d tensors from %d safetensors files", + len(model_sd), + len(safetensors_files), + ) + else: + # Fallback to loading from torch checkpoint + import glob as _glob + + pt_files = _glob.glob(os.path.join(model_path, "*.bin")) + _glob.glob( + os.path.join(model_path, "*.pt") + ) + if pt_files: + model_sd = {} + for pf in pt_files: + model_sd.update(torch.load(pf, map_location="cpu")) + else: + raise FileNotFoundError( + f"No safetensors or pt files in {model_path}" + ) + else: + # HuggingFace hub ID — download via diffusers + from diffusers.models.transformers.transformer_ltx2 import ( + LTX2VideoTransformer3DModel, + ) + + logger.info("Downloading transformer from HuggingFace: %s", model_path) + hf_model = LTX2VideoTransformer3DModel.from_pretrained( + model_path, torch_dtype=torch.bfloat16 + ) + model_sd = hf_model.state_dict() + del hf_model + import gc + + gc.collect() + logger.info("Loaded %d tensors from HuggingFace", len(model_sd)) + + model_sd = self.convert_hf_to_neuron_state_dict(model_sd, self.config) + return model_sd + + @staticmethod + def convert_hf_to_neuron_state_dict(state_dict, config): + """Convert HuggingFace state dict to Neuron format. + + Key transformations: + 1. Adds the SPMDRank arange tensor for per-rank RoPE slicing (critical for TP>1) + 2. Filters to only keep keys matching the backbone model structure + (transformer_blocks.*, norm_out.*, proj_out.*, scale_shift_table, audio_*) + 3. Removes CPU preprocessing layers (proj_in, time_embed, rope, caption_projection, etc.) + """ + # Add SPMDRank tensor for per-rank sharding + state_dict["spmd_rank.rank"] = torch.arange( + 0, config.neuron_config.world_size, dtype=torch.int32 + ) + + # Filter to keys the backbone model expects + backbone_prefixes = ( + "transformer_blocks.", + "norm_out.", + "proj_out.", + "scale_shift_table", + "audio_norm_out.", + "audio_proj_out.", + "audio_scale_shift_table", + "spmd_rank.", + ) + filtered_sd = {} + skipped_keys = [] + for k, v in state_dict.items(): + if k.startswith(backbone_prefixes): + filtered_sd[k] = v.clone().detach().contiguous() + else: + skipped_keys.append(k) + + if skipped_keys: + logger.info( + "Filtered out %d CPU-only keys (proj_in, time_embed, rope, etc.)", + len(skipped_keys), + ) + + return filtered_sd diff --git a/contrib/models/ltx2-video-audio/src/modeling_vae.py b/contrib/models/ltx2-video-audio/src/modeling_vae.py new file mode 100644 index 00000000..edb70e7f --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/modeling_vae.py @@ -0,0 +1,545 @@ +""" +NxDI LTX-2 VAE Decoder — Tensor Parallel Model +================================================ +Tensor-parallel VAE decoder for the LTX-2 video diffusion model. + +Compiles the LTX-2 VAE decoder with tensor parallelism to overcome the +single-core compilation limit (max 64 latent spatial elements at 128 channels). + +The optimal tile shape is 4×16 latent (128×512 pixels), which maximizes the +spatial area within the 64-element SRAM budget. Rectangular tiles reduce the +tile count by 43-69% compared to 8×8 tiles at 1024×1536 resolution while +being 12.5% faster per-tile (1257ms vs 1440ms). + +Architecture (verified from diffusers source): + conv_in (128 -> 1024): ColumnParallel (full in, sharded out) + mid_block (5 resnets @ 1024ch): ColumnRowParallel (sharded throughout) + up_block_0: upsampler (1024->512) + 5 resnets @ 512ch — all sharded + up_block_1: upsampler (512->256) + 5 resnets @ 256ch — all sharded + up_block_2: upsampler (256->128) + 5 resnets @ 128ch — all sharded + norm_out + conv_out (128 -> 48): RowParallel on conv_out (sharded in, gathered out) + +CRITICAL: Up-block order is UPSAMPLER FIRST, then resnets (verified from source). + +The sub-pixel shuffle in the upsampler rearranges channels into spatial dims. +Channel counts are all divisible by stride_t*stride_h*stride_w=8 at every +TP degree (1024/8=128, 512/8=64, 256/8=32), so shuffle works per-rank. + +Compilation boundary: + - H_latent × W_latent ≤ 64 elements (SRAM limit, NCC_IGCA030 above this) + - 8×8 = 64 ✓ (1440ms/tile) + - 4×16 = 64 ✓ (1257ms/tile — 12.5% faster, optimal for wide outputs) + - 4×20 = 80 ✗ (NCC_IGCA030) + - 9×9 = 81 ✗ (NCC_IGCA030) + +Usage: + See compile_vae.py for the standalone compilation script, or + tiled_vae_decode.py for the tiled runtime decoder. +""" + +import os +from functools import partial + +import torch +import torch.nn as nn + +os.environ.setdefault("NEURON_FUSE_SOFTMAX", "1") +os.environ.setdefault("NEURON_CUSTOM_SILU", "1") + +COMPILER_FLAGS = ( + "--model-type=unet-inference -O1 --auto-cast none " + "--enable-fast-loading-neuron-binaries" +) + + +def get_sharded_data(data, dim): + """Get shard for current TP rank along given dimension.""" + from neuronx_distributed.parallel_layers import parallel_state + + tp_rank = parallel_state.get_tensor_model_parallel_rank() + tp_size = parallel_state.get_tensor_model_parallel_size() + shard_size = data.shape[dim] // tp_size + if dim == 0: + return data[shard_size * tp_rank : shard_size * (tp_rank + 1)].clone() + elif dim == 1: + return data[:, shard_size * tp_rank : shard_size * (tp_rank + 1)].clone() + else: + raise ValueError(f"Unsupported dim: {dim}") + + +# ── Temporal padding helper ───────────────────────────────────────── + + +def make_noncausal_pad_fn(kernel_size_t): + """Create non-causal temporal padding function for LTX2VideoCausalConv3d. + + Replicates the non-causal branch of LTX2VideoCausalConv3d.forward(): + pad_left = first frame repeated (kernel_t - 1) // 2 times + pad_right = last frame repeated (kernel_t - 1) // 2 times + """ + pad_t = (kernel_size_t - 1) // 2 # 1 for kernel=3 + + def pad_fn(x): + if pad_t > 0: + pad_left = x[:, :, :1].repeat(1, 1, pad_t, 1, 1) + pad_right = x[:, :, -1:].repeat(1, 1, pad_t, 1, 1) + x = torch.cat([pad_left, x, pad_right], dim=2) + return x + + return pad_fn + + +# ── Parallel Conv3d layers ─────────────────────────────────────────── + + +class ColumnParallelConv3d(nn.Module): + """Conv3d with output channels sharded across TP ranks. + Input: full channels. Output: sharded channels.""" + + def __init__(self, original_conv, tp_degree): + super().__init__() + self.sharded_out = original_conv.out_channels // tp_degree + self.conv = nn.Conv3d( + original_conv.in_channels, + self.sharded_out, + kernel_size=original_conv.kernel_size, + stride=original_conv.stride, + padding=original_conv.padding, + padding_mode=original_conv.padding_mode, + bias=original_conv.bias is not None, + ) + self.conv.weight.data = get_sharded_data(original_conv.weight.data, 0) + if original_conv.bias is not None: + self.conv.bias.data = get_sharded_data(original_conv.bias.data, 0) + + def forward(self, x): + return self.conv(x) + + +class RowParallelConv3d(nn.Module): + """Conv3d with input channels sharded. Output is all-reduced (full channels). + Input: sharded channels. Output: full channels.""" + + def __init__(self, original_conv, tp_degree): + super().__init__() + from neuronx_distributed.parallel_layers.mappings import ( + reduce_from_tensor_model_parallel_region, + ) + + self.reduce = reduce_from_tensor_model_parallel_region + self.sharded_in = original_conv.in_channels // tp_degree + self.conv = nn.Conv3d( + self.sharded_in, + original_conv.out_channels, + kernel_size=original_conv.kernel_size, + stride=original_conv.stride, + padding=original_conv.padding, + padding_mode=original_conv.padding_mode, + bias=original_conv.bias is not None, + ) + self.conv.weight.data = get_sharded_data(original_conv.weight.data, 1) + if original_conv.bias is not None: + # Bias is added after reduce (sum), so divide by tp_degree to compensate + self.conv.bias.data = original_conv.bias.data.clone() / tp_degree + + def forward(self, x): + return self.reduce(self.conv(x)) + + +class ColumnRowParallelConv3d(nn.Module): + """Conv3d with sharded input -> sharded output via all-gather + column parallel. + + Correct implementation: all-gather input along channel dim (dim=1) across + TP ranks to reconstruct full input channels, then apply ColumnParallel conv + (full in -> sharded out). + + This replaces the previous incorrect "diagonal-only" implementation that + skipped cross-rank channel interactions. + + Communication: 1 all-gather per forward pass. + """ + + def __init__(self, original_conv, tp_degree): + super().__init__() + from neuronx_distributed.parallel_layers.mappings import ( + gather_from_tensor_model_parallel_region_with_dim, + ) + + self.gather_channels = gather_from_tensor_model_parallel_region_with_dim + self.sharded_out = original_conv.out_channels // tp_degree + # Conv takes FULL input channels, produces SHARDED output channels + self.conv = nn.Conv3d( + original_conv.in_channels, # full input + self.sharded_out, # sharded output + kernel_size=original_conv.kernel_size, + stride=original_conv.stride, + padding=original_conv.padding, + padding_mode=original_conv.padding_mode, + bias=original_conv.bias is not None, + ) + # Shard weights along output dim only (input stays full) + self.conv.weight.data = get_sharded_data(original_conv.weight.data, 0) + if original_conv.bias is not None: + self.conv.bias.data = get_sharded_data(original_conv.bias.data, 0) + + def forward(self, x): + # x: [B, C_shard, F, H, W] -> all-gather along dim=1 -> [B, C_full, F, H, W] + x_full = self.gather_channels(x, gather_dim=1) + return self.conv(x_full) + + +# ── Sharded RMSNorm ───────────────────────────────────────────────── + + +class ShardedPerChannelRMSNorm(nn.Module): + """PerChannelRMSNorm that works with sharded channel dimension. + + When channels are sharded across TP ranks, each rank only has C/tp channels. + The local mean(x^2) over local channels is wrong — we need the global mean. + + Strategy: + 1. Compute local sum of x^2 over local channels: [B, 1, F, H, W] + 2. All-reduce (sum) across ranks to get global sum of x^2 + 3. Divide by total channel count for global mean + 4. x / sqrt(global_mean + eps) + """ + + def __init__(self, original_norm, tp_degree): + super().__init__() + from neuronx_distributed.parallel_layers.mappings import ( + reduce_from_tensor_model_parallel_region, + ) + + self.reduce = reduce_from_tensor_model_parallel_region + self.tp_degree = tp_degree + self.eps = getattr(original_norm, "eps", 1e-8) + + def forward(self, x): + # x shape: [B, C_shard, F, H, W] + local_sq_sum = (x**2).sum(dim=1, keepdim=True) # [B, 1, F, H, W] + global_sq_sum = self.reduce(local_sq_sum) # sum across TP ranks + n_channels = x.shape[1] * self.tp_degree # total channels + rms = torch.sqrt(global_sq_sum / n_channels + self.eps) + return x / rms + + +# ── Sharded ResNet Block ──────────────────────────────────────────── + + +class ShardedLTX2ResnetBlock(nn.Module): + """LTX-2 ResNet block with sharded channels. + + Verified forward order (from diffusers source): + residual = inputs + x = norm1(x) -> SiLU -> conv1 -> norm2 -> SiLU -> conv2 + return x + residual + """ + + def __init__(self, original_block, tp_degree): + super().__init__() + self.nonlinearity = nn.SiLU() + + # Norms — sharded + self.norm1 = ShardedPerChannelRMSNorm(original_block.norm1, tp_degree) + self.norm2 = ShardedPerChannelRMSNorm(original_block.norm2, tp_degree) + + # Extract inner Conv3d from LTX2VideoCausalConv3d wrappers + conv1_inner = original_block.conv1.conv + conv2_inner = original_block.conv2.conv + + # Both convs are ColumnRowParallel (sharded in, sharded out) + self.conv1 = ColumnRowParallelConv3d(conv1_inner, tp_degree) + self.conv2 = ColumnRowParallelConv3d(conv2_inner, tp_degree) + + # Temporal padding functions (non-causal mode) + self._pad1 = make_noncausal_pad_fn(original_block.conv1.kernel_size[0]) + self._pad2 = make_noncausal_pad_fn(original_block.conv2.kernel_size[0]) + + def forward(self, x): + residual = x + + x = self.norm1(x) + x = self.nonlinearity(x) + x = self._pad1(x) + x = self.conv1(x) + + x = self.norm2(x) + x = self.nonlinearity(x) + x = self._pad2(x) + x = self.conv2(x) + + return x + residual + + +# ── Sharded Upsampler ─────────────────────────────────────────────── + + +class ShardedLTX2Upsampler(nn.Module): + """LTX-2 sub-pixel shuffle upsampler with TP support. + + The sub-pixel shuffle is a local reshape+permute operation. At any TP + degree, the per-rank channel counts are divisible by stride_prod=8, so + the shuffle works independently per rank. + """ + + def __init__(self, original_upsampler, tp_degree): + super().__init__() + self.tp_degree = tp_degree + self.stride = original_upsampler.stride + self.upscale_factor = original_upsampler.upscale_factor + self.residual = original_upsampler.residual + + conv_inner = original_upsampler.conv.conv + self.conv = ColumnRowParallelConv3d(conv_inner, tp_degree) + self._pad = make_noncausal_pad_fn(original_upsampler.conv.kernel_size[0]) + + def forward(self, x): + batch_size, num_channels, num_frames, height, width = x.shape + + residual = None + if self.residual: + residual = x.reshape( + batch_size, + -1, + self.stride[0], + self.stride[1], + self.stride[2], + num_frames, + height, + width, + ) + residual = residual.permute(0, 1, 5, 2, 6, 3, 7, 4) + residual = residual.flatten(6, 7).flatten(4, 5).flatten(2, 3) + repeats = ( + self.stride[0] * self.stride[1] * self.stride[2] + ) // self.upscale_factor + residual = residual.repeat(1, repeats, 1, 1, 1) + residual = residual[:, :, self.stride[0] - 1 :] + + x = self._pad(x) + x = self.conv(x) + + batch_size2, num_channels2, num_frames2, height2, width2 = x.shape + x = x.reshape( + batch_size2, + -1, + self.stride[0], + self.stride[1], + self.stride[2], + num_frames2, + height2, + width2, + ) + x = x.permute(0, 1, 5, 2, 6, 3, 7, 4) + x = x.flatten(6, 7).flatten(4, 5).flatten(2, 3) + x = x[:, :, self.stride[0] - 1 :] + + if residual is not None: + x = x + residual + + return x + + +# ── Full Sharded Decoder ──────────────────────────────────────────── + + +class ShardedLTX2Decoder(nn.Module): + """Tensor Parallel LTX-2 VAE Decoder. + + All layers stay sharded until the very end. Channel flow: + + conv_in: 128 full -> 1024 sharded (ColumnParallel) + mid_block: 1024 sharded (5 resnets, ColumnRowParallel) + up_block_0: 1024 sharded -> upsampler -> 512 sharded -> 5 resnets @ 512 + up_block_1: 512 sharded -> upsampler -> 256 sharded -> 5 resnets @ 256 + up_block_2: 256 sharded -> upsampler -> 128 sharded -> 5 resnets @ 128 + norm_out: 128 sharded -> ShardedRMSNorm -> 128 sharded + conv_act: SiLU (element-wise, sharded OK) + conv_out: 128 sharded -> 48 full (RowParallel, gathers via all-reduce) + unpatchify: reshape 48 channels -> 3 RGB channels via patch_size=4 + + CRITICAL order: upsampler runs FIRST in each up_block, then resnets. + """ + + def __init__(self, vae, tp_degree): + super().__init__() + decoder = vae.decoder + self.tp_degree = tp_degree + + # conv_in: 128 full -> 1024 sharded (ColumnParallel) + self._conv_in_pad = make_noncausal_pad_fn(decoder.conv_in.kernel_size[0]) + self.conv_in = ColumnParallelConv3d(decoder.conv_in.conv, tp_degree) + + # mid_block: 5 resnets at 1024 channels (all sharded) + self.mid_resnets = nn.ModuleList() + for resnet in decoder.mid_block.resnets: + self.mid_resnets.append(ShardedLTX2ResnetBlock(resnet, tp_degree)) + + # up_blocks: upsampler FIRST, then resnets (verified from source) + self.up_upsamplers = nn.ModuleList() + self.up_resnets = nn.ModuleList() + + for up_block in decoder.up_blocks: + self.up_upsamplers.append( + ShardedLTX2Upsampler(up_block.upsamplers[0], tp_degree) + ) + block_resnets = nn.ModuleList() + for resnet in up_block.resnets: + block_resnets.append(ShardedLTX2ResnetBlock(resnet, tp_degree)) + self.up_resnets.append(block_resnets) + + # norm_out: sharded PerChannelRMSNorm + self.norm_out = ShardedPerChannelRMSNorm(decoder.norm_out, tp_degree) + + # conv_act: SiLU (element-wise, works on sharded data) + self.conv_act = nn.SiLU() + + # conv_out: 128 sharded -> 48 full (RowParallel gathers) + self._conv_out_pad = make_noncausal_pad_fn(decoder.conv_out.kernel_size[0]) + self.conv_out = RowParallelConv3d(decoder.conv_out.conv, tp_degree) + + # Unpatchify config (from VAE config) + self.patch_size = decoder.patch_size # 4 + self.patch_size_t = decoder.patch_size_t # 1 + + def forward(self, latent): + # conv_in + x = self._conv_in_pad(latent) + x = self.conv_in(x) + + # mid_block + for resnet in self.mid_resnets: + x = resnet(x) + + # up_blocks: upsampler FIRST, then resnets + for upsampler, resnets in zip(self.up_upsamplers, self.up_resnets): + x = upsampler(x) + for resnet in resnets: + x = resnet(x) + + # Output path (norm -> act -> conv_out gathers channels) + x = self.norm_out(x) + x = self.conv_act(x) + x = self._conv_out_pad(x) + x = self.conv_out(x) # [B, 48, F, H, W] — gathered (full channels) + + # Unpatchify: 48 channels -> 3 RGB channels + p = self.patch_size # 4 + p_t = self.patch_size_t # 1 + + batch_size, num_channels, num_frames, height, width = x.shape + x = x.reshape(batch_size, -1, p_t, p, p, num_frames, height, width) + x = x.permute(0, 1, 5, 2, 6, 4, 7, 3).flatten(6, 7).flatten(4, 5).flatten(2, 3) + + return x + + +class DecoderWrapperTP(nn.Module): + """Wrapper for parallel_model_trace.""" + + def __init__(self, vae, tp_degree): + super().__init__() + self.decoder = ShardedLTX2Decoder(vae, tp_degree) + + def forward(self, latent): + return self.decoder(latent) + + +def get_decoder_model(tp_degree, vae_path="Lightricks/LTX-2"): + """Factory function for parallel_model_trace. + + Returns: + (model, empty_dict): The DecoderWrapperTP model and empty state dict + """ + from diffusers import AutoencoderKLLTX2Video + + vae = AutoencoderKLLTX2Video.from_pretrained( + vae_path, + subfolder="vae", + torch_dtype=torch.float32, + ) + vae.eval() + + wrapper = DecoderWrapperTP(vae, tp_degree) + wrapper.eval() + return wrapper, {} + + +def compile_vae_decoder( + tp_degree=4, + tile_height=128, + tile_width=512, + num_frames=121, + output_dir="/home/ubuntu/ltx2_vae_tp4", + compiler_workdir="/home/ubuntu/compiler_workdir_vae", + vae_path="Lightricks/LTX-2", +): + """Compile the TP VAE decoder for Neuron. + + Args: + tp_degree: Tensor parallel degree (default 4) + tile_height: Tile height in pixels (default 128 for 4-latent) + tile_width: Tile width in pixels (default 512 for 16-latent) + num_frames: Number of video frames (default 121) + output_dir: Directory to save compiled model + compiler_workdir: Directory for compiler intermediate files + vae_path: HuggingFace model ID for the VAE + + Returns: + compiled: The compiled parallel model + """ + import time + + import neuronx_distributed + + latent_f = (num_frames - 1) // 8 + 1 + latent_h = tile_height // 32 + latent_w = tile_width // 32 + + os.environ["LOCAL_WORLD_SIZE"] = str(tp_degree) + os.environ["NEURON_CC_FLAGS"] = ( + os.environ.get("NEURON_CC_FLAGS", "") + f" {COMPILER_FLAGS}" + ) + + print("=" * 70) + print("LTX-2 VAE Decoder — Tensor Parallel Compilation") + print("=" * 70) + print(f" Tile size: {tile_height}x{tile_width} pixels") + print(f" Latent tile: [1, 128, {latent_f}, {latent_h}, {latent_w}]") + print(f" TP degree: {tp_degree}") + print(f" Output dir: {output_dir}") + + latent_input = torch.randn( + 1, 128, latent_f, latent_h, latent_w, dtype=torch.float32 + ) + + print("\n Compiling (this may take 10-30 minutes)...") + t0 = time.time() + + get_model_fn = partial(get_decoder_model, tp_degree, vae_path) + + compiled = neuronx_distributed.trace.parallel_model_trace( + get_model_fn, + (latent_input,), + compiler_workdir=compiler_workdir, + compiler_args=COMPILER_FLAGS, + tp_degree=tp_degree, + inline_weights_to_neff=False, + ) + + compile_time = time.time() - t0 + print(f" Compiled in {compile_time:.1f}s") + + os.makedirs(output_dir, exist_ok=True) + neuronx_distributed.trace.parallel_model_save(compiled, output_dir) + print(f" Saved to {output_dir}") + + # Quick validation + print("\n Running validation...") + with torch.no_grad(): + neuron_out = compiled(latent_input) + print(f" Output shape: {list(neuron_out.shape)}") + print(f" Output range: [{neuron_out.min():.3f}, {neuron_out.max():.3f}]") + print(f" Expected: [1, 3, {num_frames}, {tile_height}, {tile_width}]") + + return compiled diff --git a/contrib/models/ltx2-video-audio/src/pipeline.py b/contrib/models/ltx2-video-audio/src/pipeline.py new file mode 100644 index 00000000..6fb923fb --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/pipeline.py @@ -0,0 +1,615 @@ +""" +NxDI LTX-2 Pipeline +==================== +Neuron-aware pipeline that wraps the Diffusers LTX2Pipeline with +Neuron-compiled transformer backbone. + +The pipeline works by: +1. Using the stock Diffusers LTX2Pipeline for text encoding, VAE, vocoder +2. Intercepting transformer calls and routing them through: + a. CPU preprocessing (proj_in, time_embed, RoPE, caption_projection) + b. Neuron compiled backbone (48 blocks + output layers) +3. Returning the pipeline output (frames + audio) + +This approach avoids reimplementing the complex LTX2Pipeline scheduling, +CFG handling, VAE decoding, etc. We only replace the transformer forward(). +""" + +import gc +import logging +import os +import time +from typing import Optional + +import torch +import torch.nn as nn + +try: + from .modeling_ltx2 import replace_sdpa_with_bmm + from .tiled_vae_decode import load_compiled_vae, tiled_decode +except ImportError: + from modeling_ltx2 import replace_sdpa_with_bmm + from tiled_vae_decode import load_compiled_vae, tiled_decode + +logger = logging.getLogger(__name__) + + +class NeuronTransformerWrapper(nn.Module): + """Drop-in replacement for LTX2VideoTransformer3DModel in the Diffusers pipeline. + + The pipeline calls: + self.transformer( + hidden_states=..., audio_hidden_states=..., + encoder_hidden_states=..., audio_encoder_hidden_states=..., + timestep=..., encoder_attention_mask=..., + audio_encoder_attention_mask=..., + num_frames=..., height=..., width=..., fps=..., + audio_num_frames=..., video_coords=..., audio_coords=..., + return_dict=False, + ) + + This wrapper: + 1. Keeps a CPU copy of the transformer's preprocessing layers + (proj_in, time_embed, caption_projection, rope, etc.) + 2. Replicates the preprocessing from LTX2VideoTransformer3DModel.forward() + 3. Converts encoder_attention_mask to additive bias format + 4. Calls the compiled Neuron model with 22 positional tensor args + 5. Returns (video_output, audio_output) as the pipeline expects + """ + + def __init__(self, compiled_backbone, cpu_transformer, text_seq=1024): + """ + Args: + compiled_backbone: The NeuronLTX2BackboneApplication or + TensorParallelNeuronModel (loaded Neuron model) + cpu_transformer: The original LTX2VideoTransformer3DModel (for preprocessing layers) + text_seq: Maximum text sequence length (must match compile-time) + """ + super().__init__() + self.compiled_backbone = compiled_backbone + self.text_seq = text_seq + + # Copy config and attributes the pipeline expects + self.config = cpu_transformer.config + self.dtype = cpu_transformer.dtype + self.device = cpu_transformer.device + if hasattr(cpu_transformer, "cache_context"): + self.cache_context = cpu_transformer.cache_context + + # Keep CPU preprocessing layers (NOT compiled, NOT in the Neuron model) + self.proj_in = cpu_transformer.proj_in + self.audio_proj_in = cpu_transformer.audio_proj_in + self.time_embed = cpu_transformer.time_embed + self.audio_time_embed = cpu_transformer.audio_time_embed + self.av_cross_attn_video_scale_shift = ( + cpu_transformer.av_cross_attn_video_scale_shift + ) + self.av_cross_attn_video_a2v_gate = cpu_transformer.av_cross_attn_video_a2v_gate + self.av_cross_attn_audio_scale_shift = ( + cpu_transformer.av_cross_attn_audio_scale_shift + ) + self.av_cross_attn_audio_v2a_gate = cpu_transformer.av_cross_attn_audio_v2a_gate + self.caption_projection = cpu_transformer.caption_projection + self.audio_caption_projection = cpu_transformer.audio_caption_projection + self.rope = cpu_transformer.rope + self.audio_rope = cpu_transformer.audio_rope + self.cross_attn_rope = cpu_transformer.cross_attn_rope + self.cross_attn_audio_rope = cpu_transformer.cross_attn_audio_rope + + def _compute_step_invariant( + self, + encoder_hidden_states, + audio_encoder_hidden_states, + encoder_attention_mask, + audio_encoder_attention_mask, + video_coords, + audio_coords, + batch_size, + inner_dim, + audio_inner_dim, + dtype, + ): + """Compute and cache step-invariant preprocessing (caption proj, RoPE, masks). + + These values depend only on the prompt and spatial layout, not the timestep + or noisy latents, so they are identical across all denoising steps. + Computing them once saves ~0.2-0.4s of CPU time per step. + """ + with torch.no_grad(): + # Caption projection (CPU) + enc_hs = self.caption_projection(encoder_hidden_states) + enc_hs = enc_hs.view(batch_size, -1, inner_dim) + audio_enc_hs = self.audio_caption_projection(audio_encoder_hidden_states) + audio_enc_hs = audio_enc_hs.view(batch_size, -1, audio_inner_dim) + + # RoPE (CPU) — compute from coords + video_rotary_emb = self.rope(video_coords, device="cpu") + audio_rotary_emb = self.audio_rope(audio_coords, device="cpu") + video_cross_rotary_emb = self.cross_attn_rope( + video_coords[:, 0:1, :], device="cpu" + ) + audio_cross_rotary_emb = self.cross_attn_audio_rope( + audio_coords[:, 0:1, :], device="cpu" + ) + + # RoPE modules return float32 for precision; cast to bfloat16 for Neuron + video_rotary_emb = ( + video_rotary_emb[0].to(dtype), + video_rotary_emb[1].to(dtype), + ) + audio_rotary_emb = ( + audio_rotary_emb[0].to(dtype), + audio_rotary_emb[1].to(dtype), + ) + video_cross_rotary_emb = ( + video_cross_rotary_emb[0].to(dtype), + video_cross_rotary_emb[1].to(dtype), + ) + audio_cross_rotary_emb = ( + audio_cross_rotary_emb[0].to(dtype), + audio_cross_rotary_emb[1].to(dtype), + ) + + # Attention masks — convert from binary (B, text_seq) to additive bias + with torch.no_grad(): + if encoder_attention_mask is not None and encoder_attention_mask.ndim == 2: + enc_mask = (1 - encoder_attention_mask.to(dtype)) * -10000.0 + enc_mask = enc_mask.unsqueeze(1) # (B, 1, text_seq) + else: + enc_mask = encoder_attention_mask + + if ( + audio_encoder_attention_mask is not None + and audio_encoder_attention_mask.ndim == 2 + ): + audio_enc_mask = (1 - audio_encoder_attention_mask.to(dtype)) * -10000.0 + audio_enc_mask = audio_enc_mask.unsqueeze(1) + else: + audio_enc_mask = audio_encoder_attention_mask + + if enc_mask is None: + enc_mask = torch.zeros(batch_size, 1, self.text_seq, dtype=dtype) + if audio_enc_mask is None: + audio_enc_mask = torch.zeros(batch_size, 1, self.text_seq, dtype=dtype) + + return ( + enc_hs, + audio_enc_hs, + video_rotary_emb, + audio_rotary_emb, + video_cross_rotary_emb, + audio_cross_rotary_emb, + enc_mask, + audio_enc_mask, + ) + + def forward( + self, + hidden_states, + audio_hidden_states=None, + encoder_hidden_states=None, + audio_encoder_hidden_states=None, + timestep=None, + encoder_attention_mask=None, + audio_encoder_attention_mask=None, + num_frames=None, + height=None, + width=None, + fps=None, + audio_num_frames=None, + video_coords=None, + audio_coords=None, + return_dict=False, + **kwargs, + ): + """Preprocess on CPU, run 48 blocks on Neuron, return results. + + Step-invariant computations (caption projection, RoPE, attention masks) are + cached after the first call and reused for subsequent denoising steps. The + cache is invalidated when encoder_hidden_states changes (new prompt). + """ + batch_size = hidden_states.shape[0] + dtype = torch.bfloat16 + + with torch.no_grad(): + # 1. Project inputs (CPU) — step-varying (latents change each step) + hs = self.proj_in(hidden_states) + ahs = self.audio_proj_in(audio_hidden_states) + + # 2. Time embeddings (CPU) — step-varying (timestep changes each step) + temb, embedded_ts = self.time_embed( + timestep.flatten(), batch_size=batch_size, hidden_dtype=dtype + ) + temb = temb.view(batch_size, -1, temb.size(-1)) + embedded_ts = embedded_ts.view(batch_size, -1, embedded_ts.size(-1)) + + temb_audio, audio_embedded_ts = self.audio_time_embed( + timestep.flatten(), batch_size=batch_size, hidden_dtype=dtype + ) + temb_audio = temb_audio.view(batch_size, -1, temb_audio.size(-1)) + audio_embedded_ts = audio_embedded_ts.view( + batch_size, -1, audio_embedded_ts.size(-1) + ) + + # 3. Cross-attention conditioning (CPU) — step-varying (timestep-dependent) + ts_scale = ( + self.config.cross_attn_timestep_scale_multiplier + / self.config.timestep_scale_multiplier + ) + + video_ca_ss, _ = self.av_cross_attn_video_scale_shift( + timestep.flatten(), batch_size=batch_size, hidden_dtype=dtype + ) + video_ca_gate, _ = self.av_cross_attn_video_a2v_gate( + timestep.flatten() * ts_scale, batch_size=batch_size, hidden_dtype=dtype + ) + video_ca_ss = video_ca_ss.view(batch_size, -1, video_ca_ss.shape[-1]) + video_ca_gate = video_ca_gate.view(batch_size, -1, video_ca_gate.shape[-1]) + + audio_ca_ss, _ = self.av_cross_attn_audio_scale_shift( + timestep.flatten(), batch_size=batch_size, hidden_dtype=dtype + ) + audio_ca_v2a_gate, _ = self.av_cross_attn_audio_v2a_gate( + timestep.flatten() * ts_scale, batch_size=batch_size, hidden_dtype=dtype + ) + audio_ca_ss = audio_ca_ss.view(batch_size, -1, audio_ca_ss.shape[-1]) + audio_ca_v2a_gate = audio_ca_v2a_gate.view( + batch_size, -1, audio_ca_v2a_gate.shape[-1] + ) + + # 4-6. Step-invariant: caption projection, RoPE, attention masks (cached) + # Use data_ptr() of encoder_hidden_states as cache key — changes per prompt, + # constant across denoising steps within a single generation. + cache_key = encoder_hidden_states.data_ptr() + if not hasattr(self, "_step_cache") or self._step_cache_key != cache_key: + ( + enc_hs, + audio_enc_hs, + video_rotary_emb, + audio_rotary_emb, + video_cross_rotary_emb, + audio_cross_rotary_emb, + enc_mask, + audio_enc_mask, + ) = self._compute_step_invariant( + encoder_hidden_states, + audio_encoder_hidden_states, + encoder_attention_mask, + audio_encoder_attention_mask, + video_coords, + audio_coords, + batch_size, + hs.size(-1), + ahs.size(-1), + dtype, + ) + self._step_cache = ( + enc_hs, + audio_enc_hs, + video_rotary_emb, + audio_rotary_emb, + video_cross_rotary_emb, + audio_cross_rotary_emb, + enc_mask, + audio_enc_mask, + ) + self._step_cache_key = cache_key + else: + ( + enc_hs, + audio_enc_hs, + video_rotary_emb, + audio_rotary_emb, + video_cross_rotary_emb, + audio_cross_rotary_emb, + enc_mask, + audio_enc_mask, + ) = self._step_cache + + # 7. Call compiled Neuron model (22 positional args) + # The Neuron backbone is compiled for batch_size=2 (CFG mode). + # When CFG is active (guidance_scale > 1), the pipeline doubles the batch + # to 2 (uncond + cond) and the backbone processes both in a single pass. + backbone_args = ( + hs, + ahs, + enc_hs, + audio_enc_hs, + temb, + temb_audio, + embedded_ts, + audio_embedded_ts, + video_ca_ss, + audio_ca_ss, + video_ca_gate, + audio_ca_v2a_gate, + video_rotary_emb[0], # cos + video_rotary_emb[1], # sin + audio_rotary_emb[0], + audio_rotary_emb[1], + video_cross_rotary_emb[0], + video_cross_rotary_emb[1], + audio_cross_rotary_emb[0], + audio_cross_rotary_emb[1], + enc_mask, + audio_enc_mask, + ) + + video_output, audio_output = self.compiled_backbone(*backbone_args) + + return video_output, audio_output + + +class NeuronTiledVAEDecoder(nn.Module): + """Drop-in replacement for the Diffusers LTX2VideoDecoder3d. + + This is swapped into pipe.vae.decoder so that the stock Diffusers + AutoencoderKLLTX2Video.decode() calls our Neuron-tiled decode path + transparently. + + The outer VAE calls: + self.decoder(hidden_states, temb=None, causal=False) + + For LTX-2: timestep_conditioning=False, so temb is always None. + causal=False for non-causal inference. + + This wrapper: + 1. Loads the compiled TP VAE decoder from disk + 2. On forward(), calls tiled_decode() to spatially tile the latent + 3. Returns the full-resolution decoded tensor + + Attributes copied from original decoder: + patch_size, patch_size_t — needed by the outer VAE's unpatchify logic + (Actually, unpatchify is handled inside our compiled model, but we + expose these for compatibility in case the outer VAE checks them.) + """ + + def __init__( + self, + compiled_dir, + tile_latent_h=4, + tile_latent_w=16, + overlap_latent_h=1, + overlap_latent_w=0, + original_decoder=None, + ): + """ + Args: + compiled_dir: Path to directory with compiled TP model (tp_0.pt, etc.) + tile_latent_h: Tile height in latent pixels (default 4) + tile_latent_w: Tile width in latent pixels (default 16) + overlap_latent_h: Overlap in latent H (default 1) + overlap_latent_w: Overlap in latent W (default 0) + original_decoder: The original LTX2VideoDecoder3d (for attribute copying) + """ + super().__init__() + self.tile_latent_h = tile_latent_h + self.tile_latent_w = tile_latent_w + self.overlap_latent_h = overlap_latent_h + self.overlap_latent_w = overlap_latent_w + + # Load compiled model + logger.info("Loading compiled VAE from %s", compiled_dir) + t0 = time.time() + self.compiled_model = load_compiled_vae(compiled_dir) + logger.info("VAE loaded in %.1fs", time.time() - t0) + + # Copy attributes the outer VAE might access + if original_decoder is not None: + self.patch_size = getattr(original_decoder, "patch_size", 4) + self.patch_size_t = getattr(original_decoder, "patch_size_t", 1) + self.is_causal = getattr(original_decoder, "is_causal", False) + else: + self.patch_size = 4 + self.patch_size_t = 1 + self.is_causal = False + + self._warmed_up = False + + def warmup(self, num_frames=121): + """Run 2 warmup iterations to prime the Neuron model.""" + if self._warmed_up: + return + logger.info("Warming up VAE decoder...") + latent_t = (num_frames - 1) // 8 + 1 + dummy = torch.randn( + 1, + 128, + latent_t, + self.tile_latent_h, + self.tile_latent_w, + dtype=torch.float32, + ) + for _ in range(2): + with torch.no_grad(): + self.compiled_model(dummy) + self._warmed_up = True + logger.info("VAE warmup done") + + def forward(self, hidden_states, temb=None, causal=None): + """Decode latent tensor using Neuron tiled decode. + + Args: + hidden_states: [B, C, T, H, W] latent tensor (from VAE encoder/denormalize) + temb: Time embedding (always None for LTX-2, timestep_conditioning=False) + causal: Causal mode flag (always False for inference) + + Returns: + Decoded tensor [B, 3, T_out, H_out, W_out] + + Note: The compiled Neuron model includes unpatchify (48 -> 3 channels), + but the outer AutoencoderKLLTX2Video.decode() does NOT call unpatchify + separately — it's part of the decoder. So our output is the final RGB. + """ + if not self._warmed_up: + num_frames_approx = (hidden_states.shape[2] - 1) * 8 + 1 + self.warmup(num_frames=num_frames_approx) + + # tiled_decode expects float32 input (Neuron compiles in fp32) + latent_fp32 = hidden_states.float() + + output = tiled_decode( + latent_fp32, + self.compiled_model, + tile_latent_h=self.tile_latent_h, + tile_latent_w=self.tile_latent_w, + overlap_latent_h=self.overlap_latent_h, + overlap_latent_w=self.overlap_latent_w, + spatial_scale=32, + verbose=True, + ) + + return output + + +class NeuronLTX2Pipeline: + """Wrapper around the Diffusers LTX2Pipeline that supports Neuron acceleration. + + This class manages: + 1. Loading the stock Diffusers pipeline (text encoder, VAEs, vocoder on CPU) + 2. Holding a reference to the NeuronLTX2BackboneApplication + 3. Swapping the transformer with NeuronTransformerWrapper after loading + 4. Optionally swapping the VAE decoder with NeuronTiledVAEDecoder + + Usage: + pipe = NeuronLTX2Pipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16) + pipe.neuron_backbone = NeuronLTX2BackboneApplication(...) + pipe.neuron_backbone.compile(path) + pipe.neuron_backbone.load(path) + pipe._swap_transformer_to_neuron() + pipe._swap_vae_to_neuron("/home/ubuntu/ltx2_vae_tp4_128x512") + output = pipe(prompt="...", height=384, width=512, num_frames=25) + """ + + def __init__(self, diffusers_pipe, text_seq=1024): + """ + Args: + diffusers_pipe: A loaded Diffusers LTX2Pipeline + text_seq: Maximum text sequence length (must match compile-time) + """ + self.pipe = diffusers_pipe + self.text_seq = text_seq + self.neuron_backbone = None + self._original_transformer = None + self._original_vae_decoder = None + + @classmethod + def from_pretrained( + cls, model_path, torch_dtype=torch.bfloat16, text_seq=1024, **kwargs + ): + """Load the Diffusers LTX2Pipeline from HuggingFace. + + Args: + model_path: HuggingFace model ID or local path (e.g., "Lightricks/LTX-2") + torch_dtype: Dtype for CPU components (default bfloat16) + text_seq: Maximum text sequence length + **kwargs: Additional args passed to LTX2Pipeline.from_pretrained() + """ + from diffusers import LTX2Pipeline + + logger.info("Loading Diffusers LTX2Pipeline from %s", model_path) + diffusers_pipe = LTX2Pipeline.from_pretrained( + model_path, torch_dtype=torch_dtype, **kwargs + ) + logger.info( + "Pipeline components: %s", + ", ".join(k for k, v in diffusers_pipe.components.items() if v is not None), + ) + + return cls(diffusers_pipe, text_seq=text_seq) + + def _swap_transformer_to_neuron(self): + """Replace the pipeline's CPU transformer with the Neuron-compiled version. + + Must be called after neuron_backbone.load() succeeds. + Preserves the CPU preprocessing layers (proj_in, time_embed, etc.) + and frees the heavy transformer blocks (~38 GB). + """ + if self.neuron_backbone is None: + raise RuntimeError("neuron_backbone must be set and loaded before swapping") + + cpu_transformer = self.pipe.transformer + cpu_transformer.eval() + + # Create the wrapper that adapts pipeline calls to 22 positional args + wrapper = NeuronTransformerWrapper( + compiled_backbone=self.neuron_backbone, + cpu_transformer=cpu_transformer, + text_seq=self.text_seq, + ) + + # Free the heavy transformer blocks (keep preprocessing layers via wrapper refs) + self._original_transformer = cpu_transformer + del cpu_transformer.transformer_blocks + del cpu_transformer.norm_out, cpu_transformer.proj_out + del cpu_transformer.audio_norm_out, cpu_transformer.audio_proj_out + gc.collect() + + # Hot-swap + self.pipe.transformer = wrapper + logger.info("Transformer swapped to Neuron backbone") + + def _swap_vae_to_neuron( + self, + compiled_dir, + tile_latent_h=4, + tile_latent_w=16, + overlap_latent_h=1, + overlap_latent_w=0, + warmup_frames=None, + ): + """Replace the pipeline's CPU VAE decoder with Neuron tiled decoder. + + Swaps pipe.vae.decoder with a NeuronTiledVAEDecoder that loads the + compiled TP model and uses spatial tiling with overlap blending. + + The outer AutoencoderKLLTX2Video.decode() calls: + self.decoder(hidden_states, temb=None, causal=False) + Our NeuronTiledVAEDecoder matches this interface. + + Args: + compiled_dir: Path to compiled TP VAE model (contains tp_0.pt, etc.) + tile_latent_h: Tile height in latent pixels (default 4) + tile_latent_w: Tile width in latent pixels (default 16) + overlap_latent_h: Overlap in latent H (default 1) + overlap_latent_w: Overlap in latent W (default 0) + warmup_frames: If set, run warmup immediately with this frame count + """ + original_decoder = self.pipe.vae.decoder + self._original_vae_decoder = original_decoder + + neuron_decoder = NeuronTiledVAEDecoder( + compiled_dir=compiled_dir, + tile_latent_h=tile_latent_h, + tile_latent_w=tile_latent_w, + overlap_latent_h=overlap_latent_h, + overlap_latent_w=overlap_latent_w, + original_decoder=original_decoder, + ) + + # Free the original decoder's heavy layers + del original_decoder + gc.collect() + + # Hot-swap + self.pipe.vae.decoder = neuron_decoder + logger.info("VAE decoder swapped to Neuron tiled decoder") + + if warmup_frames is not None: + neuron_decoder.warmup(num_frames=warmup_frames) + + def __call__(self, *args, **kwargs): + """Run the full LTX-2 pipeline (text encoding + denoising + VAE decode).""" + return self.pipe(*args, **kwargs) + + def __getattr__(self, name): + """Proxy attribute access to the underlying Diffusers pipeline.""" + if name in ( + "pipe", + "text_seq", + "neuron_backbone", + "_original_transformer", + "_original_vae_decoder", + ): + raise AttributeError(name) + return getattr(self.pipe, name) diff --git a/contrib/models/ltx2-video-audio/src/shard_gemma3_weights.py b/contrib/models/ltx2-video-audio/src/shard_gemma3_weights.py new file mode 100644 index 00000000..2fbe2914 --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/shard_gemma3_weights.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python3 +""" +Pre-shard Gemma 3-12B encoder weights for Neuron TP=4. + +Produces per-rank checkpoint files that can be loaded directly with +replace_weights() — no cloning or sharding at load time. + +Output structure (ready for HuggingFace upload): + gemma3_encoder_sharded/ + rank_0.pt (~5.9 GB) + rank_1.pt + rank_2.pt + rank_3.pt + +Usage: + source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate + python shard_gemma3_weights.py +""" + +import gc +import glob +import os +import sys +import time + +import torch + +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +TP_DEGREE = 4 +OUTPUT_DIR = "/home/ubuntu/gemma3_encoder_sharded" + + +def get_model_fn(): + """Create Gemma3 encoder model with TP layers (for sharding metadata).""" + from modeling_gemma3_encoder import Gemma3TextEncoderModel + + model = Gemma3TextEncoderModel( + vocab_size=262208, + hidden_size=3840, + num_hidden_layers=48, + num_attention_heads=16, + num_key_value_heads=8, + head_dim=256, + intermediate_size=15360, + rms_norm_eps=1e-6, + rope_theta=1_000_000.0, + max_position_embeddings=131072, + query_pre_attn_scalar=256, + pad_token_id=0, + dtype=torch.bfloat16, + ) + model = model.to(dtype=torch.bfloat16) + model.eval() + return model, None + + +def main(): + print("=" * 60) + print("Pre-shard Gemma 3-12B encoder weights (TP=%d)" % TP_DEGREE) + print("=" * 60) + + # 1. Load HF weights from safetensors + print("\n[1/3] Loading HF weights from safetensors...") + t0 = time.time() + + from modeling_gemma3_encoder import convert_hf_gemma3_to_encoder_state_dict + from safetensors.torch import load_file + + cache_base = os.path.expanduser( + "~/.cache/huggingface/hub/models--Lightricks--LTX-2" + ) + te_dirs = glob.glob(os.path.join(cache_base, "snapshots/*/text_encoder")) + if not te_dirs: + print("ERROR: text_encoder not found in HF cache") + sys.exit(1) + te_path = te_dirs[0] + + # Prefer model-*.safetensors (HF format) + st_files = sorted(glob.glob(os.path.join(te_path, "model-*.safetensors"))) + if not st_files: + st_files = sorted( + glob.glob(os.path.join(te_path, "diffusion_pytorch_model-*.safetensors")) + ) + + print(" Loading %d safetensors files..." % len(st_files)) + hf_state_dict = {} + for f in st_files: + shard = load_file(f) + hf_state_dict.update(shard) + print(" Total HF keys: %d" % len(hf_state_dict)) + + encoder_state_dict = convert_hf_gemma3_to_encoder_state_dict(hf_state_dict) + del hf_state_dict + gc.collect() + + total_bytes = sum(v.numel() * v.element_size() for v in encoder_state_dict.values()) + print(" Encoder keys: %d (%.2f GB)" % (len(encoder_state_dict), total_bytes / 1e9)) + print(" Done in %.1fs" % (time.time() - t0)) + + # 2. Shard per rank and save + print("\n[2/3] Sharding and saving per-rank checkpoints...") + os.makedirs(OUTPUT_DIR, exist_ok=True) + + from neuronx_distributed.trace.trace import ( + _mock_parallel_state, + init_on_device, + get_sharded_checkpoint, + ) + + for rank in range(TP_DEGREE): + t0 = time.time() + # Clone the full dict for this rank (get_sharded_checkpoint modifies in-place) + ckpt = {k: v.clone() for k, v in encoder_state_dict.items()} + + _mock_parallel_state(TP_DEGREE, rank) + with init_on_device(torch.device("meta")): + model, _ = get_model_fn() + get_sharded_checkpoint(ckpt, model, rank, TP_DEGREE) + + # CRITICAL: Force contiguous clones so torch.save doesn't serialize + # the full unsharded storage backing sliced/narrowed tensors. + ckpt = {k: v.contiguous().clone() for k, v in ckpt.items()} + + rank_path = os.path.join(OUTPUT_DIR, "rank_%d.pt" % rank) + torch.save(ckpt, rank_path) + size_gb = os.path.getsize(rank_path) / 1e9 + num_keys = len(ckpt) + elapsed = time.time() - t0 + print( + " rank_%d.pt: %d keys, %.2f GB, %.1fs" % (rank, num_keys, size_gb, elapsed) + ) + del ckpt, model + gc.collect() + + del encoder_state_dict + gc.collect() + + # 3. Verify + print("\n[3/3] Verification...") + total_size = 0 + for rank in range(TP_DEGREE): + rank_path = os.path.join(OUTPUT_DIR, "rank_%d.pt" % rank) + size = os.path.getsize(rank_path) + total_size += size + ckpt = torch.load(rank_path, weights_only=True) + print(" rank_%d.pt: %d keys, %.2f GB" % (rank, len(ckpt), size / 1e9)) + # Spot-check a few key shapes + if rank == 0: + for k in sorted(ckpt.keys())[:3]: + print(" %s: %s %s" % (k, tuple(ckpt[k].shape), ckpt[k].dtype)) + del ckpt + + print("\n Total sharded size: %.2f GB" % (total_size / 1e9)) + print(" Output dir: %s" % OUTPUT_DIR) + print("\nDone!") + + +if __name__ == "__main__": + main() diff --git a/contrib/models/ltx2-video-audio/src/tiled_vae_decode.py b/contrib/models/ltx2-video-audio/src/tiled_vae_decode.py new file mode 100644 index 00000000..08805199 --- /dev/null +++ b/contrib/models/ltx2-video-audio/src/tiled_vae_decode.py @@ -0,0 +1,350 @@ +""" +NxDI LTX-2 Tiled VAE Decode — Spatial Tiling with Overlap + Blending +===================================================================== +Tiles the latent space into overlapping patches, decodes each on Neuron, +then blends in output pixel space. + +Optimal tile shape: 4x16 latent (128x512 pixels) with overlap_h=1, overlap_w=0. + +Tile count examples (1024x1536, latent 32x48): + 8x8 tiles, overlap=4: 77 tiles, ~111s (CPU wins) + 4x16 tiles, oh=1, ow=4: 44 tiles, ~56s (1.78x vs CPU) + 4x16 tiles, oh=1, ow=0: 33 tiles, ~42s (2.32x vs CPU) + 4x16 tiles, oh=0, ow=0: 24 tiles, ~31s (3.16x vs CPU) + +Usage (standalone): + source /opt/aws_neuronx_venv_pytorch_inference_vllm_0_13/bin/activate + NEURON_RT_VISIBLE_CORES=0-3 python tiled_vae_decode.py \\ + --compiled-dir /home/ubuntu/ltx2_vae_tp4_128x512 \\ + --tp-degree 4 --height 1024 --width 1536 \\ + --tile-latent-h 4 --tile-latent-w 16 \\ + --overlap-h 1 --overlap-w 0 + +Usage (as library): + from tiled_vae_decode import tiled_decode + output = tiled_decode(latent, compiled_model, tile_latent_h=4, tile_latent_w=16, + overlap_latent_h=1, overlap_latent_w=0) +""" + +import os +import time + +import torch + +os.environ.setdefault("NEURON_FUSE_SOFTMAX", "1") +os.environ.setdefault("NEURON_CUSTOM_SILU", "1") + +COMPILER_FLAGS = ( + "--model-type=unet-inference -O1 --auto-cast none " + "--enable-fast-loading-neuron-binaries" +) + + +def create_blend_mask_1d(length, blend_size, device="cpu"): + """Create a 1D linear blending mask. + + Returns a tensor of shape [length] where: + - First blend_size pixels ramp from 0 to 1 + - Middle pixels are 1 + - Last blend_size pixels ramp from 1 to 0 + """ + mask = torch.ones(length, device=device) + if blend_size > 0: + ramp = torch.linspace(0, 1, blend_size + 2, device=device)[1:-1] + mask[:blend_size] = ramp + mask[-blend_size:] = ramp.flip(0) + return mask + + +def tiled_decode( + latent, + compiled_model, + tile_latent_h=4, + tile_latent_w=16, + overlap_latent_h=1, + overlap_latent_w=0, + spatial_scale=32, + verbose=True, +): + """Decode latent tensor using spatial tiling with overlap blending. + + Args: + latent: [1, 128, T, H_lat, W_lat] latent tensor + compiled_model: Neuron-compiled VAE decoder + tile_latent_h: tile height in latent space (default 4) + tile_latent_w: tile width in latent space (default 16) + overlap_latent_h: overlap in latent H pixels (default 1) + overlap_latent_w: overlap in latent W pixels (default 0) + spatial_scale: latent-to-pixel spatial scale (32 for LTX-2) + verbose: print progress information + + Returns: + [1, 3, T_out, H_out, W_out] decoded video tensor + """ + B, C, T, H_lat, W_lat = latent.shape + assert B == 1, "Batch size must be 1" + + H_out = H_lat * spatial_scale + W_out = W_lat * spatial_scale + + stride_h = tile_latent_h - overlap_latent_h + stride_w = tile_latent_w - overlap_latent_w + assert stride_h > 0, ( + f"stride_h={stride_h} must be > 0 " + f"(tile_h={tile_latent_h}, overlap_h={overlap_latent_h})" + ) + assert stride_w > 0, ( + f"stride_w={stride_w} must be > 0 " + f"(tile_w={tile_latent_w}, overlap_w={overlap_latent_w})" + ) + + overlap_h_pixels = overlap_latent_h * spatial_scale + overlap_w_pixels = overlap_latent_w * spatial_scale + tile_h_pixels = tile_latent_h * spatial_scale + tile_w_pixels = tile_latent_w * spatial_scale + + # Determine tile start positions + n_tiles_h = max(1, (H_lat - tile_latent_h + stride_h - 1) // stride_h + 1) + n_tiles_w = max(1, (W_lat - tile_latent_w + stride_w - 1) // stride_w + 1) + + tile_starts_h = [] + for i in range(n_tiles_h): + start = min(i * stride_h, H_lat - tile_latent_h) + tile_starts_h.append(start) + tile_starts_h = sorted(set(tile_starts_h)) + + tile_starts_w = [] + for i in range(n_tiles_w): + start = min(i * stride_w, W_lat - tile_latent_w) + tile_starts_w.append(start) + tile_starts_w = sorted(set(tile_starts_w)) + + n_tiles_h = len(tile_starts_h) + n_tiles_w = len(tile_starts_w) + total_tiles = n_tiles_h * n_tiles_w + + if verbose: + print(f" Tiling: {n_tiles_h}x{n_tiles_w} = {total_tiles} tiles") + print( + f" Tile latent: {tile_latent_h}x{tile_latent_w}, " + f"overlap: h={overlap_latent_h}, w={overlap_latent_w}" + ) + + # Output temporal dimension: T_out = (T-1)*8 + 1 + T_out = (T - 1) * 8 + 1 + + output_accum = torch.zeros(1, 3, T_out, H_out, W_out, dtype=torch.float32) + weight_accum = torch.zeros(1, 1, 1, H_out, W_out, dtype=torch.float32) + + decode_times = [] + + for ti, h_start_lat in enumerate(tile_starts_h): + for tj, w_start_lat in enumerate(tile_starts_w): + tile_idx = ti * n_tiles_w + tj + 1 + + h_end_lat = h_start_lat + tile_latent_h + w_end_lat = w_start_lat + tile_latent_w + tile_latent = latent[:, :, :, h_start_lat:h_end_lat, w_start_lat:w_end_lat] + + t0 = time.time() + with torch.no_grad(): + tile_output = compiled_model(tile_latent) + dt = time.time() - t0 + decode_times.append(dt) + + h_start_px = h_start_lat * spatial_scale + w_start_px = w_start_lat * spatial_scale + h_end_px = h_start_px + tile_h_pixels + w_end_px = w_start_px + tile_w_pixels + + # Create spatial blend mask + blend_h = create_blend_mask_1d( + tile_h_pixels, overlap_h_pixels if h_start_lat > 0 else 0 + ) + blend_w = create_blend_mask_1d( + tile_w_pixels, overlap_w_pixels if w_start_lat > 0 else 0 + ) + + # Handle end tiles + if h_end_lat < H_lat and overlap_h_pixels > 0: + blend_h[-overlap_h_pixels:] = torch.linspace( + 1, 0, overlap_h_pixels + 2 + )[1:-1] + if w_end_lat < W_lat and overlap_w_pixels > 0: + blend_w[-overlap_w_pixels:] = torch.linspace( + 1, 0, overlap_w_pixels + 2 + )[1:-1] + + # 2D blend mask: [1, 1, 1, H, W] + blend_mask = blend_h.unsqueeze(1) * blend_w.unsqueeze(0) + blend_mask = blend_mask.unsqueeze(0).unsqueeze(0).unsqueeze(0) + + output_accum[:, :, :, h_start_px:h_end_px, w_start_px:w_end_px] += ( + tile_output.float() * blend_mask + ) + weight_accum[:, :, :, h_start_px:h_end_px, w_start_px:w_end_px] += ( + blend_mask + ) + + if verbose: + print( + f" Tile {tile_idx}/{total_tiles}: " + f"lat[{h_start_lat}:{h_end_lat}, {w_start_lat}:{w_end_lat}] " + f"-> px[{h_start_px}:{h_end_px}, {w_start_px}:{w_end_px}], " + f"{dt * 1000:.0f}ms" + ) + + output = output_accum / weight_accum.clamp(min=1e-6) + + total_decode = sum(decode_times) + if verbose: + print(f"\n Total decode time: {total_decode:.2f}s ({total_tiles} tiles)") + print(f" Avg per tile: {total_decode / total_tiles * 1000:.0f}ms") + + return output + + +def load_compiled_vae(compiled_dir): + """Load a compiled TP VAE decoder from disk. + + Args: + compiled_dir: Directory containing tp_0.pt, tp_1.pt, etc. + + Returns: + compiled: The loaded TensorParallelNeuronModel + """ + import neuronx_distributed + + return neuronx_distributed.trace.parallel_model_load(compiled_dir) + + +def main(): + """Standalone CLI for tiled VAE decode.""" + import argparse + + import torch.nn.functional as F + + parser = argparse.ArgumentParser(description="LTX-2 Tiled VAE Decode") + parser.add_argument( + "--compiled-dir", + type=str, + required=True, + help="Directory with compiled TP model (tp_0.pt, etc.)", + ) + parser.add_argument("--tp-degree", type=int, default=4) + parser.add_argument("--height", type=int, default=512, help="Target pixel height") + parser.add_argument("--width", type=int, default=768, help="Target pixel width") + parser.add_argument("--num-frames", type=int, default=121) + parser.add_argument( + "--overlap", + type=int, + default=4, + help="Default overlap in latent pixels (used for both H and W unless overridden)", + ) + parser.add_argument( + "--overlap-h", type=int, default=None, help="Override overlap for H dimension" + ) + parser.add_argument( + "--overlap-w", type=int, default=None, help="Override overlap for W dimension" + ) + parser.add_argument( + "--tile-latent-h", type=int, default=4, help="Tile height in latent space" + ) + parser.add_argument( + "--tile-latent-w", type=int, default=16, help="Tile width in latent space" + ) + parser.add_argument( + "--validate-cpu", action="store_true", help="Also run CPU decode and compare" + ) + parser.add_argument("--seed", type=int, default=42) + args = parser.parse_args() + + os.environ["NEURON_CC_FLAGS"] = COMPILER_FLAGS + + latent_t = (args.num_frames - 1) // 8 + 1 + latent_h = args.height // 32 + latent_w = args.width // 32 + + print("=" * 60) + print("LTX-2 VAE Tiled Decode") + print("=" * 60) + print(f" Target: {args.height}x{args.width}, {args.num_frames} frames") + print(f" Latent: [1, 128, {latent_t}, {latent_h}, {latent_w}]") + print(f" Tile latent: {args.tile_latent_h}x{args.tile_latent_w}") + + torch.manual_seed(args.seed) + latent = torch.randn(1, 128, latent_t, latent_h, latent_w, dtype=torch.float32) + + print("\n Loading compiled model...") + compiled = load_compiled_vae(args.compiled_dir) + print(" Model loaded.") + + # Warmup + print(" Warmup (2 iterations)...") + dummy = torch.randn( + 1, 128, latent_t, args.tile_latent_h, args.tile_latent_w, dtype=torch.float32 + ) + for _ in range(2): + with torch.no_grad(): + compiled(dummy) + print(" Warmup done.") + + # Compute effective overlap + overlap_h = args.overlap_h if args.overlap_h is not None else args.overlap + overlap_w = args.overlap_w if args.overlap_w is not None else args.overlap + overlap_h = min(overlap_h, args.tile_latent_h - 1) + overlap_w = min(overlap_w, args.tile_latent_w - 1) + + print("\n Running tiled decode...") + t0 = time.time() + output_neuron = tiled_decode( + latent, + compiled, + tile_latent_h=args.tile_latent_h, + tile_latent_w=args.tile_latent_w, + overlap_latent_h=overlap_h, + overlap_latent_w=overlap_w, + spatial_scale=32, + ) + total_time = time.time() - t0 + print(f"\n RESULT: Tiled decode {args.height}x{args.width} in {total_time:.2f}s") + print(f" Output shape: {list(output_neuron.shape)}") + print(f" Output range: [{output_neuron.min():.3f}, {output_neuron.max():.3f}]") + + if args.validate_cpu: + print("\n Running CPU decode for validation...") + from diffusers import AutoencoderKLLTX2Video + + vae = AutoencoderKLLTX2Video.from_pretrained( + "Lightricks/LTX-2", subfolder="vae", torch_dtype=torch.float32 + ) + vae.eval() + + t0_cpu = time.time() + with torch.no_grad(): + cpu_output = vae.decoder(latent, temb=None, causal=False) + cpu_time = time.time() - t0_cpu + + print(f" CPU decode time: {cpu_time:.2f}s") + + if cpu_output.shape == output_neuron.shape: + cos_sims = [] + for f in range(output_neuron.shape[2]): + a = output_neuron[0, :, f].flatten() + b = cpu_output[0, :, f].flatten() + cos = F.cosine_similarity(a.unsqueeze(0), b.unsqueeze(0)) + cos_sims.append(cos.item()) + avg_cos = sum(cos_sims) / len(cos_sims) + min_cos = min(cos_sims) + print(f" Cosine similarity: avg={avg_cos:.6f}, min={min_cos:.6f}") + print(f" MSE: {F.mse_loss(output_neuron, cpu_output).item():.6f}") + + print("\n" + "=" * 60) + print("SUMMARY") + print("=" * 60) + print(f" Resolution: {args.height}x{args.width}, {args.num_frames} frames") + print(f" Tiled Neuron decode: {total_time:.2f}s") + + +if __name__ == "__main__": + main() diff --git a/contrib/models/ltx2-video-audio/test/__init__.py b/contrib/models/ltx2-video-audio/test/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/contrib/models/ltx2-video-audio/test/integration/__init__.py b/contrib/models/ltx2-video-audio/test/integration/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/contrib/models/ltx2-video-audio/test/integration/test_model.py b/contrib/models/ltx2-video-audio/test/integration/test_model.py new file mode 100644 index 00000000..dfd27282 --- /dev/null +++ b/contrib/models/ltx2-video-audio/test/integration/test_model.py @@ -0,0 +1,558 @@ +#!/usr/bin/env python3 +""" +Integration tests for LTX-2 video+audio diffusion model on Neuron. + +Validates that the Neuron-compiled pipeline (DiT backbone + Gemma3 text encoder) +produces output frames that are visually consistent with GPU reference frames. + +Since this is a diffusion model (not a CausalLM), accuracy is measured via +structural similarity (SSIM) between Neuron and GPU output frames generated +with identical settings (same seed, guidance_scale, etc.), rather than logit +or token matching. + +Prerequisites: + - Compiled DiT backbone at $LTX2_DIT_COMPILE_DIR (default: /home/ubuntu/ltx2_nxdi_compiled_1024/) + - Compiled Gemma3 encoder at $LTX2_GEMMA3_COMPILE_DIR (default: /home/ubuntu/gemma3_encoder_compiled_1024/) + - Pre-sharded Gemma3 weights at $LTX2_GEMMA3_SHARDED_DIR (default: /home/ubuntu/gemma3_encoder_sharded/) + + To compile these, run from the src/ directory: + NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python compile_gemma3.py + python shard_gemma3_weights.py + The DiT backbone is compiled automatically on first use. + +Usage: + # With pytest: + NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + pytest test/integration/test_model.py -v --capture=tee-sys + + # Standalone: + NEURON_FUSE_SOFTMAX=1 NEURON_CUSTOM_SILU=1 NEURON_RT_STOCHASTIC_ROUNDING_EN=0 \ + python test/integration/test_model.py +""" + +import gc +import json +import os +import sys +import time +from pathlib import Path + +import numpy as np +import pytest +import torch + +# Environment variables for Neuron +os.environ.setdefault("NEURON_FUSE_SOFTMAX", "1") +os.environ.setdefault("NEURON_CUSTOM_SILU", "1") +os.environ.setdefault("NEURON_RT_STOCHASTIC_ROUNDING_EN", "0") +os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") + +# Add src directory to path +CONTRIB_ROOT = Path(__file__).parent.parent.parent +sys.path.insert(0, str(CONTRIB_ROOT / "src")) + +# Model directories (override with environment variables) +DIT_COMPILE_DIR = os.environ.get( + "LTX2_DIT_COMPILE_DIR", "/home/ubuntu/ltx2_nxdi_compiled_1024/" +) +GEMMA3_COMPILE_DIR = os.environ.get( + "LTX2_GEMMA3_COMPILE_DIR", "/home/ubuntu/gemma3_encoder_compiled_1024/" +) +GEMMA3_SHARDED_DIR = os.environ.get( + "LTX2_GEMMA3_SHARDED_DIR", "/home/ubuntu/gemma3_encoder_sharded/" +) +OUTPUT_DIR = os.environ.get("LTX2_TEST_OUTPUT_DIR", "/tmp/ltx2_test_output/") +GPU_SAMPLES_DIR = CONTRIB_ROOT / "samples" / "gpu" + +# Generation settings (must match GPU reference) +TP_DEGREE = 4 +HEIGHT, WIDTH, NUM_FRAMES = 384, 512, 25 +NUM_STEPS = 8 +SEED = 42 +PROMPT = ( + "A golden retriever puppy runs across a sunny green meadow, " + "its ears flapping in the wind. The camera follows from a low angle. " + "Birds chirp in the background." +) + + +def compute_ssim(img1, img2): + """Compute structural similarity index between two PIL images. + + Uses a simplified SSIM that does not require scikit-image. + Returns a value between 0 and 1 (1 = identical). + """ + a = np.array(img1, dtype=np.float64) + b = np.array(img2, dtype=np.float64) + + if a.shape != b.shape: + raise ValueError(f"Shape mismatch: {a.shape} vs {b.shape}") + + c1 = (0.01 * 255) ** 2 + c2 = (0.03 * 255) ** 2 + + mu_a = a.mean() + mu_b = b.mean() + sigma_a_sq = a.var() + sigma_b_sq = b.var() + sigma_ab = ((a - mu_a) * (b - mu_b)).mean() + + ssim = ((2 * mu_a * mu_b + c1) * (2 * sigma_ab + c2)) / ( + (mu_a**2 + mu_b**2 + c1) * (sigma_a_sq + sigma_b_sq + c2) + ) + return float(ssim) + + +# --------------------------------------------------------------------------- +# Pipeline fixture (shared across all tests) +# --------------------------------------------------------------------------- + + +@pytest.fixture(scope="module") +def neuron_pipeline(): + """Load the full Neuron LTX-2 pipeline (DiT + Gemma3 on Neuron, VAE on CPU).""" + from modeling_ltx2 import ( + LTX2BackboneInferenceConfig, + NeuronLTX2BackboneApplication, + replace_sdpa_with_bmm, + ) + from pipeline import NeuronTransformerWrapper + from neuronx_distributed_inference.models.config import NeuronConfig + + replace_sdpa_with_bmm() + + # Load transformer config + from huggingface_hub import hf_hub_download, snapshot_download + + config_path = hf_hub_download("Lightricks/LTX-2", "transformer/config.json") + with open(config_path) as f: + hf_config = json.load(f) + + num_heads = hf_config["num_attention_heads"] + head_dim = hf_config["attention_head_dim"] + inner_dim = num_heads * head_dim + audio_num_heads = hf_config["audio_num_attention_heads"] + audio_head_dim = hf_config["audio_attention_head_dim"] + audio_inner_dim = audio_num_heads * audio_head_dim + audio_ca_dim = hf_config.get("audio_cross_attention_dim", audio_inner_dim) + + latent_num_frames = (NUM_FRAMES - 1) // 8 + 1 + latent_height = HEIGHT // 32 + latent_width = WIDTH // 32 + video_seq = latent_num_frames * latent_height * latent_width + audio_num_frames = round((NUM_FRAMES / 24.0) * 24.97) + + backbone_neuron_config = NeuronConfig( + tp_degree=TP_DEGREE, + world_size=TP_DEGREE, + torch_dtype=torch.bfloat16, + ) + + config = LTX2BackboneInferenceConfig( + neuron_config=backbone_neuron_config, + num_layers=hf_config["num_layers"], + num_attention_heads=num_heads, + attention_head_dim=head_dim, + inner_dim=inner_dim, + audio_num_attention_heads=audio_num_heads, + audio_attention_head_dim=audio_head_dim, + audio_inner_dim=audio_inner_dim, + audio_cross_attention_dim=audio_ca_dim, + caption_channels=hf_config.get("caption_channels", 3840), + video_seq=video_seq, + audio_seq=audio_num_frames, + text_seq=1024, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + ) + config.hf_config_dict = hf_config + + # Load Diffusers pipeline + from diffusers import LTX2Pipeline + + pipe = LTX2Pipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16) + + # Load DiT backbone onto Neuron + local_transformer_path = snapshot_download( + "Lightricks/LTX-2", allow_patterns=["transformer/*"] + ) + local_transformer_path = os.path.join(local_transformer_path, "transformer") + + cpu_transformer = pipe.transformer + backbone_app = NeuronLTX2BackboneApplication( + model_path=local_transformer_path, config=config + ) + + compiled_model_file = os.path.join(DIT_COMPILE_DIR, "model.pt") + if not os.path.exists(compiled_model_file): + os.makedirs(DIT_COMPILE_DIR, exist_ok=True) + backbone_app.compile(DIT_COMPILE_DIR) + + backbone_app.load(DIT_COMPILE_DIR) + + wrapper = NeuronTransformerWrapper( + compiled_backbone=backbone_app, cpu_transformer=cpu_transformer, text_seq=1024 + ) + del cpu_transformer.transformer_blocks + del cpu_transformer.norm_out, cpu_transformer.proj_out + del cpu_transformer.audio_norm_out, cpu_transformer.audio_proj_out + gc.collect() + pipe.transformer = wrapper + + # Load Gemma3 text encoder onto Neuron + import torch_neuronx + from neuronx_distributed.trace.trace import ( + replace_weights, + TensorParallelNeuronModel, + ) + + del pipe.text_encoder + gc.collect() + + models = [] + for rank in range(TP_DEGREE): + rank_ckpt_path = os.path.join(GEMMA3_SHARDED_DIR, f"rank_{rank}.pt") + ckpt = torch.load(rank_ckpt_path, weights_only=True) + neff_path = os.path.join(GEMMA3_COMPILE_DIR, f"tp_{rank}.pt") + with torch_neuronx.contexts.disable_nrt_load(): + traced_model = torch.jit.load(neff_path) + replace_weights(traced_model, ckpt) + models.append(traced_model) + del ckpt + gc.collect() + + compiled_gemma3 = TensorParallelNeuronModel(models) + + class NeuronTextEncoderOutput: + def __init__(self, hidden_states): + self.hidden_states = hidden_states + + class NeuronTextEncoderWrapper: + def __init__(self, compiled_gemma3, dtype=torch.bfloat16): + self.compiled_model = compiled_gemma3 + self.dtype = dtype + self._device = torch.device("cpu") + self.config = type("Config", (), {"output_hidden_states": True})() + + def __call__( + self, + input_ids=None, + attention_mask=None, + output_hidden_states=True, + **kwargs, + ): + with torch.no_grad(): + stacked = self.compiled_model(input_ids, attention_mask) + num_states = stacked.shape[-1] + hidden_states = tuple(stacked[:, :, :, i] for i in range(num_states)) + return NeuronTextEncoderOutput(hidden_states=hidden_states) + + def eval(self): + return self + + def to(self, *args, **kwargs): + return self + + @property + def device(self): + return self._device + + pipe.text_encoder = NeuronTextEncoderWrapper(compiled_gemma3) + return pipe + + +# --------------------------------------------------------------------------- +# Tests +# --------------------------------------------------------------------------- + + +def test_smoke_pipeline_loads(neuron_pipeline): + """Test that the Neuron pipeline loads without errors.""" + assert neuron_pipeline is not None + assert hasattr(neuron_pipeline, "transformer") + assert hasattr(neuron_pipeline, "text_encoder") + print("PASS: Pipeline loaded successfully") + + +def test_generation_produces_frames(neuron_pipeline): + """Test that generation produces the expected number of output frames.""" + generator = torch.Generator(device="cpu").manual_seed(SEED) + + output = neuron_pipeline( + prompt=PROMPT, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + num_inference_steps=NUM_STEPS, + generator=generator, + output_type="pil", + ) + + frames = output.frames[0] + assert len(frames) == NUM_FRAMES, f"Expected {NUM_FRAMES} frames, got {len(frames)}" + assert frames[0].size == (WIDTH, HEIGHT), ( + f"Expected ({WIDTH}, {HEIGHT}), got {frames[0].size}" + ) + + # Save frames for inspection + os.makedirs(OUTPUT_DIR, exist_ok=True) + for i, frame in enumerate(frames): + frame.save(os.path.join(OUTPUT_DIR, f"frame_{i:04d}.png")) + + print(f"PASS: Generated {len(frames)} frames at {frames[0].size}") + + +def test_accuracy_vs_gpu_reference(neuron_pipeline): + """Test that Neuron output is visually similar to GPU reference frames. + + Compares SSIM between Neuron-generated frames and GPU reference frames + (both generated with identical seed=42, guidance_scale=4.0, etc.). + SSIM > 0.7 indicates strong structural similarity. + """ + from PIL import Image + + generator = torch.Generator(device="cpu").manual_seed(SEED) + + output = neuron_pipeline( + prompt=PROMPT, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + num_inference_steps=NUM_STEPS, + generator=generator, + output_type="pil", + ) + + frames = output.frames[0] + + # Compare against GPU reference samples (frame_0000, frame_0012, frame_0024) + reference_indices = [0, 12, 24] + ssim_scores = [] + + for idx in reference_indices: + gpu_path = GPU_SAMPLES_DIR / f"frame_{idx:04d}.png" + if not gpu_path.exists(): + pytest.skip(f"GPU reference frame not found: {gpu_path}") + + gpu_frame = Image.open(gpu_path).convert("RGB") + neuron_frame = frames[idx] + + ssim = compute_ssim(neuron_frame, gpu_frame) + ssim_scores.append(ssim) + print(f" Frame {idx:04d}: SSIM = {ssim:.4f}") + + avg_ssim = sum(ssim_scores) / len(ssim_scores) + min_ssim = min(ssim_scores) + + print(f" Average SSIM: {avg_ssim:.4f}") + print(f" Min SSIM: {min_ssim:.4f}") + + # SSIM > 0.7 indicates strong structural similarity. + # Neuron BF16 vs GPU FP16 produces minor numerical differences, but + # the visual output should remain structurally very similar. + assert min_ssim > 0.7, ( + f"SSIM too low: min={min_ssim:.4f}. Neuron output may not match GPU reference." + ) + print(f"PASS: Accuracy validated (avg SSIM={avg_ssim:.4f}, min={min_ssim:.4f})") + + +def test_warm_generation_time(neuron_pipeline): + """Test that warm generation completes within a reasonable time. + + The first generation includes warmup overhead. This test measures + a second generation to capture steady-state performance. + """ + # First generation (warmup) + generator = torch.Generator(device="cpu").manual_seed(SEED) + _ = neuron_pipeline( + prompt=PROMPT, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + num_inference_steps=NUM_STEPS, + generator=generator, + output_type="pil", + ) + + # Second generation (warm) + generator = torch.Generator(device="cpu").manual_seed(123) + t0 = time.time() + _ = neuron_pipeline( + prompt="A cat sitting on a windowsill watches rain falling outside.", + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + num_inference_steps=NUM_STEPS, + generator=generator, + output_type="pil", + ) + warm_time = time.time() - t0 + + # Warm generation should complete in under 120s (generous threshold) + assert warm_time < 120, f"Warm generation took {warm_time:.1f}s, expected < 120s" + print(f"PASS: Warm generation time = {warm_time:.1f}s") + + +# --------------------------------------------------------------------------- +# Standalone runner +# --------------------------------------------------------------------------- + +if __name__ == "__main__": + print("=" * 70) + print("LTX-2 Integration Tests (Neuron)") + print("=" * 70) + + print("\nLoading pipeline...") + t0 = time.time() + + # Inline the fixture for standalone mode + from modeling_ltx2 import ( + LTX2BackboneInferenceConfig, + NeuronLTX2BackboneApplication, + replace_sdpa_with_bmm, + ) + from pipeline import NeuronTransformerWrapper + from neuronx_distributed_inference.models.config import NeuronConfig + + replace_sdpa_with_bmm() + + from huggingface_hub import hf_hub_download, snapshot_download + + config_path = hf_hub_download("Lightricks/LTX-2", "transformer/config.json") + with open(config_path) as f: + hf_config = json.load(f) + + num_heads = hf_config["num_attention_heads"] + head_dim = hf_config["attention_head_dim"] + inner_dim = num_heads * head_dim + audio_num_heads = hf_config["audio_num_attention_heads"] + audio_head_dim = hf_config["audio_attention_head_dim"] + audio_inner_dim = audio_num_heads * audio_head_dim + audio_ca_dim = hf_config.get("audio_cross_attention_dim", audio_inner_dim) + + latent_num_frames = (NUM_FRAMES - 1) // 8 + 1 + video_seq = latent_num_frames * (HEIGHT // 32) * (WIDTH // 32) + audio_num_frames = round((NUM_FRAMES / 24.0) * 24.97) + + backbone_neuron_config = NeuronConfig( + tp_degree=TP_DEGREE, + world_size=TP_DEGREE, + torch_dtype=torch.bfloat16, + ) + config = LTX2BackboneInferenceConfig( + neuron_config=backbone_neuron_config, + num_layers=hf_config["num_layers"], + num_attention_heads=num_heads, + attention_head_dim=head_dim, + inner_dim=inner_dim, + audio_num_attention_heads=audio_num_heads, + audio_attention_head_dim=audio_head_dim, + audio_inner_dim=audio_inner_dim, + audio_cross_attention_dim=audio_ca_dim, + caption_channels=hf_config.get("caption_channels", 3840), + video_seq=video_seq, + audio_seq=audio_num_frames, + text_seq=1024, + height=HEIGHT, + width=WIDTH, + num_frames=NUM_FRAMES, + ) + config.hf_config_dict = hf_config + + from diffusers import LTX2Pipeline + + pipe = LTX2Pipeline.from_pretrained("Lightricks/LTX-2", torch_dtype=torch.bfloat16) + + local_transformer_path = snapshot_download( + "Lightricks/LTX-2", allow_patterns=["transformer/*"] + ) + local_transformer_path = os.path.join(local_transformer_path, "transformer") + cpu_transformer = pipe.transformer + backbone_app = NeuronLTX2BackboneApplication( + model_path=local_transformer_path, config=config + ) + + compiled_model_file = os.path.join(DIT_COMPILE_DIR, "model.pt") + if not os.path.exists(compiled_model_file): + os.makedirs(DIT_COMPILE_DIR, exist_ok=True) + backbone_app.compile(DIT_COMPILE_DIR) + backbone_app.load(DIT_COMPILE_DIR) + + wrapper = NeuronTransformerWrapper( + compiled_backbone=backbone_app, cpu_transformer=cpu_transformer, text_seq=1024 + ) + del cpu_transformer.transformer_blocks + del cpu_transformer.norm_out, cpu_transformer.proj_out + del cpu_transformer.audio_norm_out, cpu_transformer.audio_proj_out + gc.collect() + pipe.transformer = wrapper + + import torch_neuronx + from neuronx_distributed.trace.trace import ( + replace_weights, + TensorParallelNeuronModel, + ) + + del pipe.text_encoder + gc.collect() + + models = [] + for rank in range(TP_DEGREE): + ckpt = torch.load( + os.path.join(GEMMA3_SHARDED_DIR, f"rank_{rank}.pt"), weights_only=True + ) + with torch_neuronx.contexts.disable_nrt_load(): + traced = torch.jit.load(os.path.join(GEMMA3_COMPILE_DIR, f"tp_{rank}.pt")) + replace_weights(traced, ckpt) + models.append(traced) + del ckpt + gc.collect() + + compiled_gemma3 = TensorParallelNeuronModel(models) + + class _Output: + def __init__(self, hs): + self.hidden_states = hs + + class _Wrapper: + def __init__(self, m): + self.compiled_model = m + self.dtype = torch.bfloat16 + self._device = torch.device("cpu") + self.config = type("C", (), {"output_hidden_states": True})() + + def __call__(self, input_ids=None, attention_mask=None, **kw): + with torch.no_grad(): + s = self.compiled_model(input_ids, attention_mask) + return _Output(tuple(s[:, :, :, i] for i in range(s.shape[-1]))) + + def eval(self): + return self + + def to(self, *a, **k): + return self + + @property + def device(self): + return self._device + + pipe.text_encoder = _Wrapper(compiled_gemma3) + print(f"Pipeline loaded in {time.time() - t0:.1f}s") + + print("\n1. Smoke Test...") + test_smoke_pipeline_loads(pipe) + + print("\n2. Generation Test...") + test_generation_produces_frames(pipe) + + print("\n3. Accuracy vs GPU Reference...") + test_accuracy_vs_gpu_reference(pipe) + + print("\n4. Warm Generation Time...") + test_warm_generation_time(pipe) + + print("\n" + "=" * 70) + print("All tests passed!") + print("=" * 70)