wan22-vae

1

2 languages

—

by

wangkanai

Video Model

OTHER

New

0 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

Unknown

Mobile

Laptop

Server

Quick Summary

High-performance Variational Autoencoder (VAE) component for the WAN (World Anything Now) video generation system.

Code Examples

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Custom Latent Space Manipulationpythonpytorch

import torch
import numpy as np

# Encode input video
latents = vae.encode(input_frames).latent_dist.sample()

# Apply transformations in latent space (e.g., interpolation)
latents_start = latents[0]
latents_end = latents[-1]

# Create smooth interpolation between frames
interpolated_latents = []
for alpha in np.linspace(0, 1, 16):
    interpolated = (1 - alpha) * latents_start + alpha * latents_end
    interpolated_latents.append(interpolated)

# Decode interpolated latents
smooth_video = vae.decode(torch.stack(interpolated_latents)).sample

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.