RTX 3080 12GB, Image 1024 x 1024, VAE FLUX. Размер изображения 207 KB, размер латента 513 KB. Как можно сжать латент без потери качества?

```python
import sys, os, time

from typing import Dict

COMFY_PATH = "C:/NeuralNetworks/automatic1111/ComfyUI/"   # путь до исходников ComfyUI
sys.path.append(COMFY_PATH)

import comfy.utils, comfy.sd, comfy.model_management   # после добавления пути эти импорты работают
import PIL.Image         # pillow
import numpy as np
import torch
import safetensors.torch
from pathlib import Path

def benchmark(fn, *, warmup: int = 2, repeat: int = 10, label: str = ""):
    """
    Замеряет время выполнения произвольной функции fn().
    • warmup  – количество прогревочных вызовов (не участвуют в статистике)
    • repeat  – сколько раз выполнить функцию для усреднения
    Возвращает (результат_последнего_вызова, среднее_время_сек, ит/сек)
    """
    # прогрев
    for _ in range(warmup):
        fn()
    torch.cuda.synchronize()

    # измерение
    start = time.perf_counter()
    result = None
    for _ in range(repeat):
        result = fn()
    torch.cuda.synchronize()
    total = time.perf_counter() - start

    avg = total / repeat
    ips = repeat / total
    print(f"[{label or fn.__name__}] {repeat}×  {total:.3f}s  →  {avg*1e3:.1f} ms/it,  {ips:.2f} it/s   "
          f"(GPU peak {torch.cuda.max_memory_allocated()/1024**2:.0f} MB)")
    return result, avg, ips

def load_vae(vae_path: str) -> comfy.sd.VAE:
  """
  Загружает VAE из .ckpt/.pt/.safetensors, создаёт объект comfy.sd.VAE
  и валидирует веса.
  """
  # ComfyUI уже умеет прозрачно читать safetensors/ckpt/pt
  state_dict = comfy.utils.load_torch_file(vae_path)

  vae = comfy.sd.VAE(sd=state_dict, device="cuda", dtype=torch.float16)
  vae.throw_exception_if_invalid()

  return vae


def load_image(image_path: str) -> torch.Tensor:
  """
  Загружает изображение в формате   (batch, H, W, 3)  c диапазоном [0,1].
  Повторяет то, как это делает nodes.LoadImage.
  """
  img = PIL.Image.open(image_path)
  img = img.convert("RGB")                # гарантируем 3-канальное RGB

  arr = np.asarray(img).astype(np.float32) / 255.0    # [H, W, 3], float32 в [0,1]
  tensor = torch.from_numpy(arr).unsqueeze(0)       # -> (1, H, W, 3)

  return tensor


def save_image(decoded_image: torch.Tensor, output_path: str):
  """
  Сохраняет первый кадр / первую картинку батча на диск.
  Ожидает формат (batch, H, W, 3) с диапазоном [0,1].
  """
  img = decoded_image[0].detach().cpu().numpy()
  img = np.clip(img, 0.0, 1.0) * 255.0
  img = PIL.Image.fromarray(img.astype(np.uint8))
  os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
  img.save(output_path)


def save_latent(latent: torch.Tensor, file_path: str):
  """
  Сохраняет латент (B, C, H, W) или dict{"samples":...} на диск.
  • .safetensors – сохраняем через safetensors
  • .pt / .pth  – через torch.save
  """
  latent=latent.to(torch.float16)
  payload = { "latent": latent.detach().cpu()}
  safetensors.torch.save_file(payload, file_path)

def load_latent(file_path: str) -> torch.Tensor:
  state = safetensors.torch.load_file(file_path)
  return state["latent"].to("cuda", dtype=torch.float16)  

def encode_image(vae: comfy.sd.VAE, image: torch.Tensor) -> torch.Tensor:
  """
  Кодирует картинку в латент; результат совместим с тем,
  что выдаёт узел VAEEncode в ComfyUI (dict{"samples": ...}).
  """
  with torch.inference_mode():
    latent = vae.encode(image).to("cuda", dtype=torch.float16)  # VAE внутри ComfyUI принимает тензор в формате (B, H, W, 3).
  torch.cuda.empty_cache() 
  return latent


def decode_image(vae: comfy.sd.VAE, latent_image: torch.Tensor) -> torch.Tensor:
  """
  Декодирует латент обратно в пиксельное пространство.
  Возвращает тензор (B, H, W, 3) с диапазоном [0,1].
  """
  with torch.inference_mode():
    images = vae.decode(latent_image)     # (B, H, W, 3)  или  (B, 1, H, W, 3) 
  return images

def mainq():
  torch.backends.cudnn.benchmark = True
  torch.set_float32_matmul_precision("high")
  torch.set_flush_denormal(True)
  torch.backends.cuda.enable_flash_sdp = True

  vae_path  = "D:/NeuralNetworks/StableDiffusion/models/VAE/FLUX/ae.safetensors"
  image_path  = "input.jpg"
  output_path = "output.jpg"
  latent_path = "latent.safetensors"

  print("Loading VAE …")
  vae = load_vae(vae_path)

  print("Loading latent …")
  latent_image = load_latent(latent_path)

  print("VAE:", vae.vae_dtype, vae.device)
  print("latent :", latent_image.dtype, latent_image.device)

  def _inner():
    with torch.inference_mode():
      return decode_image(vae, latent_image)
    
  benchmark(
        _inner, warmup=2, repeat=8, label="VAE.decode"
    )

def main():
  torch.backends.cudnn.benchmark = True
  torch.set_float32_matmul_precision("high")
  torch.set_flush_denormal(True)
  torch.backends.cuda.enable_flash_sdp = True

  vae_path  = "D:/NeuralNetworks/StableDiffusion/models/VAE/FLUX/ae.safetensors"
  image_path  = "input.jpg"
  output_path = "output.jpg"
  latent_path = "latent.safetensors"

  print("Loading VAE …")
  vae = load_vae(vae_path)

  if not Path(latent_path).exists():
    print("Loading image …")
    image = load_image(image_path)

    print("Encoding …")
    latent_image = encode_image(vae, image)

    print("Saving …")
    save_latent(latent_image, latent_path)

  print("Loading latent …")
  latent_image = load_latent(latent_path)

  print("Decoding …")
  decoded_image = decode_image(vae, latent_image)
  torch.cuda.empty_cache()  

  print("Saving …")
  save_image(decoded_image, output_path)
  print("Done! →", output_path)


if __name__ == "__main__":
  main()
```