diff --git a/.gitignore b/.gitignore index 948e514..1e955c4 100644 --- a/.gitignore +++ b/.gitignore @@ -19,4 +19,5 @@ gcsfuse.yml *.csv *.tsv *.parquet -*.arrow \ No newline at end of file +*.arrow +artifacts \ No newline at end of file diff --git a/flaxdiff/data/__init__.py b/flaxdiff/data/__init__.py index d3410cd..5b02ea6 100644 --- a/flaxdiff/data/__init__.py +++ b/flaxdiff/data/__init__.py @@ -1 +1,5 @@ -from .online_loader import OnlineStreamingDataLoader \ No newline at end of file +from .online_loader import * +from .dataloaders import * +from .sources.base import * +from .sources.images import * +from .sources.videos import * \ No newline at end of file diff --git a/flaxdiff/data/__temp__.mp3 b/flaxdiff/data/__temp__.mp3 new file mode 100644 index 0000000..7fac251 Binary files /dev/null and b/flaxdiff/data/__temp__.mp3 differ diff --git a/flaxdiff/data/benchmark_decord.py b/flaxdiff/data/benchmark_decord.py new file mode 100644 index 0000000..4cf6bf6 --- /dev/null +++ b/flaxdiff/data/benchmark_decord.py @@ -0,0 +1,443 @@ +#!/usr/bin/env python3 +""" +Benchmark script to test for memory leaks and performance in decord library. + +This script specifically targets the read_av function and provides comprehensive +memory usage tracking and performance metrics. +""" + +import os +import sys +import time +import random +import gc +import argparse +import numpy as np +import matplotlib.pyplot as plt +import psutil +from tqdm import tqdm + +try: + from decord import AVReader, VideoReader, cpu, gpu + HAS_DECORD = True +except ImportError: + print("Warning: decord library not found. Only OpenCV mode will be available.") + HAS_DECORD = False + +import cv2 + + +def gather_video_paths(directory): + """Gather all video file paths in a directory (recursively). + + Args: + directory: Directory to search for video files. + + Returns: + List of video file paths. + """ + video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.webm'] + video_paths = [] + + for root, _, files in os.walk(directory): + for file in files: + if any(file.lower().endswith(ext) for ext in video_extensions): + video_paths.append(os.path.join(root, file)) + + return video_paths + + +def read_av_standard(path, start=0, end=None, ctx=None): + """Read audio-video with standard decord approach. + + Args: + path: Path to the video file. + start: Start frame index. + end: End frame index. + ctx: Decord context (CPU or GPU). + + Returns: + Tuple of (audio, video) arrays. + """ + if not HAS_DECORD: + raise ImportError("decord library not installed") + + ctx = ctx or cpu(0) + vr = AVReader(path, ctx=ctx) + audio, video = vr[start:end] + return audio, video.asnumpy() + + +def read_av_cleanup(path, start=0, end=None, ctx=None): + """Read audio-video with explicit cleanup of decord objects. + + Args: + path: Path to the video file. + start: Start frame index. + end: End frame index. + ctx: Decord context (CPU or GPU). + + Returns: + Tuple of (audio, video) arrays. + """ + if not HAS_DECORD: + raise ImportError("decord library not installed") + + ctx = ctx or cpu(0) + vr = AVReader(path, ctx=ctx) + audio, video = vr[start:end] + audio_list = list(audio) # Copy audio data + video_np = video.asnumpy() # Convert to numpy array + del vr # Explicitly delete AVReader object + return audio_list, video_np + + +def read_video_opencv(path, max_frames=None): + """Read video using OpenCV instead of decord. + + Args: + path: Path to the video file. + max_frames: Maximum number of frames to read. + + Returns: + Video frames as numpy array. + """ + cap = cv2.VideoCapture(path) + frames = [] + + while True: + ret, frame = cap.read() + if not ret: + break + + # Convert BGR to RGB + frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) + frames.append(frame) + + if max_frames and len(frames) >= max_frames: + break + + cap.release() + + # Stack frames into a video tensor [num_frames, height, width, channels] + if frames: + return np.stack(frames, axis=0) + else: + return np.array([]) # Empty array if no frames were read + + +def get_memory_usage(): + """Get current memory usage in MB. + + Returns: + Current memory usage in MB. + """ + process = psutil.Process(os.getpid()) + mem_info = process.memory_info() + return mem_info.rss / (1024 * 1024) # Convert bytes to MB + + +def test_for_memory_leak(video_paths, method='standard', num_iterations=100, sample_size=20): + """Test for memory leaks by repeatedly loading videos. + + Args: + video_paths: List of video file paths. + method: Method to use for loading videos ('standard', 'cleanup', or 'opencv'). + num_iterations: Number of iterations to run. + sample_size: Number of video paths to sample from. + + Returns: + List of memory usage measurements. + """ + memory_usage = [] + sample_paths = random.sample(video_paths, min(sample_size, len(video_paths))) + + # Record baseline memory usage + gc.collect() + baseline_memory = get_memory_usage() + memory_usage.append(baseline_memory) + + print(f"Initial memory usage: {baseline_memory:.2f} MB") + + # Load videos repeatedly and track memory usage + for i in tqdm(range(num_iterations), desc=f"Testing {method} method"): + path = random.choice(sample_paths) + + try: + # Load the video using the specified method + if method == 'standard' and HAS_DECORD: + audio, video = read_av_standard(path) + del audio, video + elif method == 'cleanup' and HAS_DECORD: + audio, video = read_av_cleanup(path) + del audio, video + elif method == 'opencv': + video = read_video_opencv(path) + del video + else: + raise ValueError(f"Unknown method: {method}") + + # Periodic garbage collection + if i % 5 == 0: + gc.collect() + + # Record memory + memory_usage.append(get_memory_usage()) + + except Exception as e: + print(f"Error processing video {path}: {e}") + continue + + # Final cleanup + gc.collect() + final_memory = get_memory_usage() + memory_usage.append(final_memory) + + print(f"Final memory usage: {final_memory:.2f} MB") + print(f"Memory change: {final_memory - baseline_memory:.2f} MB") + + return memory_usage + + +def benchmark_loading_speed(video_paths, method='standard', num_videos=30): + """Benchmark video loading speed. + + Args: + video_paths: List of video file paths. + method: Method to use for loading videos ('standard', 'cleanup', or 'opencv'). + num_videos: Number of videos to benchmark. + + Returns: + Tuple of (load times, video sizes). + """ + # Select random videos to load + selected_paths = random.sample(video_paths, min(num_videos, len(video_paths))) + + load_times = [] + video_sizes = [] + + print(f"Benchmarking {method} method...") + + for path in tqdm(selected_paths, desc=f"Benchmarking {method}"): + try: + start_time = time.time() + + # Load the video using specified method + if method == 'standard' and HAS_DECORD: + audio, video = read_av_standard(path) + elif method == 'cleanup' and HAS_DECORD: + audio, video = read_av_cleanup(path) + elif method == 'opencv': + video = read_video_opencv(path) + audio = None + else: + raise ValueError(f"Unknown method: {method}") + + end_time = time.time() + + # Calculate and store metrics + load_time = end_time - start_time + load_times.append(load_time) + + # Get video size in MB + video_size = video.nbytes / (1024 * 1024) # Convert bytes to MB + video_sizes.append(video_size) + + # Cleanup + del video + if audio is not None: + del audio + + if len(load_times) % 10 == 0: + gc.collect() + + except Exception as e: + print(f"Error benchmarking {path}: {e}") + continue + + if not load_times: + print("No videos were successfully processed.") + return [], [] + + # Calculate statistics + avg_time = sum(load_times) / len(load_times) + avg_size = sum(video_sizes) / len(video_sizes) if video_sizes else 0 + avg_speed = sum(video_sizes) / sum(load_times) if sum(load_times) > 0 else 0 # MB/s + + print(f"Average load time: {avg_time:.4f} seconds") + print(f"Average video size: {avg_size:.2f} MB") + print(f"Average loading speed: {avg_speed:.2f} MB/s") + + return load_times, video_sizes + + +def plot_memory_usage(results, output_dir=None): + """Plot memory usage over time. + + Args: + results: Dictionary of memory usage results. + output_dir: Directory to save plots to. + """ + plt.figure(figsize=(12, 6)) + + for method, memory_usage in results.items(): + plt.plot(memory_usage, label=method) + + plt.title('Memory Usage During Repeated Video Loading') + plt.xlabel('Iteration') + plt.ylabel('Memory Usage (MB)') + plt.legend() + plt.grid(True) + + if output_dir: + plt.savefig(os.path.join(output_dir, 'memory_usage.png')) + + plt.show() + + +def plot_loading_speed(results, output_dir=None): + """Plot loading speed comparison. + + Args: + results: Dictionary of loading speed results. + output_dir: Directory to save plots to. + """ + methods = list(results.keys()) + times = [results[m][0] for m in methods] + sizes = [results[m][1] for m in methods] + + plt.figure(figsize=(15, 5)) + + # Plot 1: Load time comparison (box plot) + plt.subplot(1, 3, 1) + plt.boxplot(times, labels=methods) + plt.title('Load Time Comparison') + plt.ylabel('Time (seconds)') + + # Plot 2: Load time vs video size (scatter) + plt.subplot(1, 3, 2) + for i, method in enumerate(methods): + plt.scatter(sizes[i], times[i], alpha=0.7, label=method) + plt.title('Load Time vs. Video Size') + plt.xlabel('Video Size (MB)') + plt.ylabel('Time (seconds)') + plt.legend() + + # Plot 3: Loading speed comparison (box plot) + plt.subplot(1, 3, 3) + speeds = [] + for i in range(len(methods)): + # Calculate MB/s for each video + speed = [s/t for s, t in zip(sizes[i], times[i]) if t > 0] + speeds.append(speed) + + plt.boxplot(speeds, labels=methods) + plt.title('Loading Speed Comparison') + plt.ylabel('Speed (MB/s)') + + plt.tight_layout() + + if output_dir: + plt.savefig(os.path.join(output_dir, 'loading_speed.png')) + + plt.show() + + +def run_full_benchmark(videos_dir, output_dir=None, iterations=100, num_videos=30, sample_size=20): + """Run a full benchmark suite. + + Args: + videos_dir: Directory containing video files. + output_dir: Directory to save results to. + iterations: Number of iterations for memory leak test. + num_videos: Number of videos for performance benchmark. + sample_size: Sample size for memory leak test. + """ + # Create output directory if it doesn't exist + if output_dir and not os.path.exists(output_dir): + os.makedirs(output_dir) + + # Gather video paths + print(f"Searching for videos in {videos_dir}...") + video_paths = gather_video_paths(videos_dir) + print(f"Found {len(video_paths)} videos.") + + if not video_paths: + print("No videos found. Exiting.") + return + + # Memory leak tests + print("\n=== Running memory leak tests ===\n") + memory_results = {} + + methods = ['opencv'] + if HAS_DECORD: + methods = ['standard', 'cleanup', 'opencv'] # Test all methods if decord is available + + for method in methods: + print(f"\nTesting {method} method for memory leaks...") + memory_usage = test_for_memory_leak( + video_paths, + method=method, + num_iterations=iterations, + sample_size=sample_size + ) + memory_results[method] = memory_usage + + # Plot memory usage results + plot_memory_usage(memory_results, output_dir) + + # Performance benchmarks + print("\n=== Running performance benchmarks ===\n") + performance_results = {} + + for method in methods: + print(f"\nBenchmarking {method} method...") + times, sizes = benchmark_loading_speed( + video_paths, + method=method, + num_videos=num_videos + ) + performance_results[method] = (times, sizes) + + # Plot performance results + plot_loading_speed(performance_results, output_dir) + + # Save results to files if output_dir is specified + if output_dir: + # Save memory results + for method, usage in memory_results.items(): + with open(os.path.join(output_dir, f'memory_{method}.txt'), 'w') as f: + f.write('\n'.join(str(x) for x in usage)) + + # Save performance results + for method, (times, sizes) in performance_results.items(): + with open(os.path.join(output_dir, f'performance_{method}.txt'), 'w') as f: + f.write('time,size\n') + for t, s in zip(times, sizes): + f.write(f'{t},{s}\n') + + print("\nBenchmark complete.") + + +def main(): + """Main function.""" + parser = argparse.ArgumentParser(description='Benchmark decord and OpenCV video loading.') + parser.add_argument('--videos_dir', '-d', required=True, help='Directory containing video files') + parser.add_argument('--output_dir', '-o', help='Directory to save results to') + parser.add_argument('--iterations', '-i', type=int, default=100, help='Number of iterations for memory leak test') + parser.add_argument('--num_videos', '-n', type=int, default=30, help='Number of videos for performance benchmark') + parser.add_argument('--sample_size', '-s', type=int, default=20, help='Sample size for memory leak test') + args = parser.parse_args() + + run_full_benchmark( + args.videos_dir, + args.output_dir, + args.iterations, + args.num_videos, + args.sample_size + ) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/flaxdiff/data/dataloaders.py b/flaxdiff/data/dataloaders.py new file mode 100644 index 0000000..af6ad32 --- /dev/null +++ b/flaxdiff/data/dataloaders.py @@ -0,0 +1,608 @@ +import jax.numpy as jnp +import grain.python as pygrain +from typing import Dict, Any, Optional, Union, List, Callable +import numpy as np +import jax +import cv2 # Added missing import +from flaxdiff.utils import convert_to_global_tree, AutoTextTokenizer +from .dataset_map import datasetMap, onlineDatasetMap, mediaDatasetMap +import traceback +from .online_loader import OnlineStreamingDataLoader +import queue +from jax.sharding import Mesh +import threading +from functools import partial + + +def batch_mesh_map(mesh): + """Create an augmenter that maps batches to a mesh.""" + class augmenters(pygrain.MapTransform): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def map(self, batch) -> Dict[str, jnp.array]: + return convert_to_global_tree(mesh, batch) + return augmenters + + +class DataLoaderWithMesh: + """A wrapper for data loaders that distributes data to a JAX mesh. + + This class wraps any iterable dataset and maps the data to a JAX mesh. + It runs a background thread that fetches data from the loader and + distributes it to the mesh. + """ + + def __init__(self, dataloader, mesh, buffer_size=20): + """Initialize a DataLoaderWithMesh. + + Args: + dataloader: The data loader to wrap. + mesh: The JAX mesh to distribute data to. + buffer_size: Size of the prefetch buffer. + """ + self.dataloader = dataloader + self.mesh = mesh + self.buffer_size = buffer_size + self.tmp_queue = queue.Queue(buffer_size) + self.loader_thread = None + self._start_loader_thread() + + def _start_loader_thread(self): + """Start the background thread for data loading.""" + def batch_loader(): + try: + for batch in self.dataloader: + try: + self.tmp_queue.put(convert_to_global_tree(self.mesh, batch)) + except Exception as e: + print("Error processing batch", e) + traceback.print_exc() + except Exception as e: + print("Error in batch loader thread", e) + traceback.print_exc() + + self.loader_thread = threading.Thread(target=batch_loader, daemon=True) + self.loader_thread.start() + + def __iter__(self): + return self + + def __next__(self): + try: + return self.tmp_queue.get(timeout=60) # Add timeout to prevent hanging + except queue.Empty: + if not self.loader_thread.is_alive(): + raise StopIteration("Loader thread died") + raise queue.Empty("Timed out waiting for batch") + + def __del__(self): + # Clean up resources + if hasattr(self, 'loader_thread') and self.loader_thread is not None: + self.loader_thread.join(timeout=1) + + +def generate_collate_fn(media_type="image"): + """Generate a collate function based on media type. + + Args: + media_type: Type of media ("image" or "video"). + + Returns: + A collate function for the specified media type. + """ + auto_tokenize = AutoTextTokenizer(tensor_type="np") + + def image_collate(batch): + try: + # Check if batch is valid + if not batch or len(batch) == 0: + print("Warning: Empty batch received") + # Return an empty batch with the correct structure + return { + "image": np.zeros((0, 0, 0, 3), dtype=np.float32), + "text": { + "input_ids": np.zeros((0, 0), dtype=np.int32), + "attention_mask": np.zeros((0, 0), dtype=np.int32), + } + } + + captions = [sample.get("caption", "") for sample in batch] + results = auto_tokenize(captions) + + # Check if all images have the same shape + image_shapes = [sample["image"].shape for sample in batch] + if len(set(str(shape) for shape in image_shapes)) > 1: + # Different shapes, need to resize all to the same shape + target_shape = max(shape[0] for shape in image_shapes), max(shape[1] for shape in image_shapes) + images = np.stack([ + cv2.resize(sample["image"], target_shape) if sample["image"].shape[:2] != target_shape else sample["image"] + for sample in batch + ], axis=0) + else: + # All same shape, can just stack + images = np.stack([sample["image"] for sample in batch], axis=0) + + return { + "image": images, + "text": { + "input_ids": results['input_ids'], + "attention_mask": results['attention_mask'], + } + } + except Exception as e: + print("Error in image collate function", e) + traceback.print_exc() + # Return a fallback batch + return fallback_batch(batch, media_type="image") + + def video_collate(batch): + try: + # Check if batch is valid + if not batch or len(batch) == 0: + print("Warning: Empty batch received") + # Return an empty batch with the correct structure + return { + "video": np.zeros((0, 0, 0, 0, 3), dtype=np.float32), + "text": { + "input_ids": np.zeros((0, 0), dtype=np.int32), + "attention_mask": np.zeros((0, 0), dtype=np.int32), + } + } + + captions = [sample.get("caption", "") for sample in batch] + results = auto_tokenize(captions) + + # Check if all videos have the same shape + video_shapes = [sample["video"].shape for sample in batch] + if len(set(str(shape) for shape in video_shapes)) > 1: + # Get max dimensions + max_frames = max(shape[0] for shape in video_shapes) + max_height = max(shape[1] for shape in video_shapes) + max_width = max(shape[2] for shape in video_shapes) + + # Resize videos to the same shape + videos = [] + for sample in batch: + video = sample["video"] + num_frames, height, width = video.shape[:3] + + if height != max_height or width != max_width: + # Resize each frame + resized_frames = np.array([ + cv2.resize(frame, (max_width, max_height)) + for frame in video + ]) + video = resized_frames + + if num_frames < max_frames: + # Pad with duplicates of the last frame + padding = np.tile(video[-1:], (max_frames - num_frames, 1, 1, 1)) + video = np.concatenate([video, padding], axis=0) + + videos.append(video) + + videos = np.stack(videos, axis=0) + else: + # All videos have the same shape, can just stack + videos = np.stack([sample["video"] for sample in batch], axis=0) + + return { + "video": videos, + "text": { + "input_ids": results['input_ids'], + "attention_mask": results['attention_mask'], + } + } + except Exception as e: + print("Error in video collate function", e) + traceback.print_exc() + # Return a fallback batch + return fallback_batch(batch, media_type="video") + + def fallback_batch(batch, media_type="image"): + """Create a fallback batch when an error occurs.""" + try: + batch_size = len(batch) if batch else 1 + if media_type == "video": + # Create a small valid video batch + dummy_video = np.zeros((batch_size, 4, 32, 32, 3), dtype=np.uint8) + dummy_text = auto_tokenize(["Error processing video"] * batch_size) + return { + "video": dummy_video, + "text": { + "input_ids": dummy_text['input_ids'], + "attention_mask": dummy_text['attention_mask'], + } + } + else: + # Create a small valid image batch + dummy_image = np.zeros((batch_size, 32, 32, 3), dtype=np.uint8) + dummy_text = auto_tokenize(["Error processing image"] * batch_size) + return { + "image": dummy_image, + "text": { + "input_ids": dummy_text['input_ids'], + "attention_mask": dummy_text['attention_mask'], + } + } + except Exception as e: + print("Error creating fallback batch", e) + # Last resort fallback + if media_type == "video": + return { + "video": np.zeros((1, 4, 32, 32, 3), dtype=np.uint8), + "text": { + "input_ids": np.zeros((1, 16), dtype=np.int32), + "attention_mask": np.zeros((1, 16), dtype=np.int32), + } + } + else: + return { + "image": np.zeros((1, 32, 32, 3), dtype=np.uint8), + "text": { + "input_ids": np.zeros((1, 16), dtype=np.int32), + "attention_mask": np.zeros((1, 16), dtype=np.int32), + } + } + + if media_type == "video": + return video_collate + else: # Default to image + return image_collate + + +def get_dataset_grain( + data_name="cc12m", + batch_size=64, + image_scale=256, + count=None, + num_epochs=None, + method=jax.image.ResizeMethod.LANCZOS3, + worker_count=32, + read_thread_count=64, + read_buffer_size=50, + worker_buffer_size=20, + seed=0, + dataset_source="/mnt/gcs_mount/arrayrecord2/cc12m/", +): + """Legacy function for getting grain dataset loaders for images. + + Args: + data_name: Name of the dataset in datasetMap. + batch_size: Batch size for the dataset. + image_scale: Size to scale images to. + count: Optional count limit for the dataset. + num_epochs: Number of epochs to iterate. + method: Interpolation method for resizing. + worker_count: Number of worker processes. + read_thread_count: Number of read threads. + read_buffer_size: Size of the read buffer. + worker_buffer_size: Size of the worker buffer. + seed: Random seed. + dataset_source: Source path for the dataset. + + Returns: + Dictionary with train dataset function and metadata. + """ + dataset = datasetMap[data_name] + data_source = dataset["source"](dataset_source) + augmenter = dataset["augmenter"](image_scale, method) + + local_batch_size = batch_size // jax.process_count() + + sampler = pygrain.IndexSampler( + num_records=len(data_source) if count is None else count, + shuffle=True, + seed=seed, + num_epochs=num_epochs, + shard_options=pygrain.ShardByJaxProcess(), + ) + + def get_trainset(): + transformations = [ + augmenter(), + pygrain.Batch(local_batch_size, drop_remainder=True), + ] + + loader = pygrain.DataLoader( + data_source=data_source, + sampler=sampler, + operations=transformations, + worker_count=worker_count, + read_options=pygrain.ReadOptions( + read_thread_count, read_buffer_size + ), + worker_buffer_size=worker_buffer_size, + ) + return loader + + return { + "train": get_trainset, + "train_len": len(data_source), + "local_batch_size": local_batch_size, + "global_batch_size": batch_size, + } + + +def get_dataset_online( + data_name="combined_online", + batch_size=64, + image_scale=256, + count=None, + num_epochs=None, + method=jax.image.ResizeMethod.LANCZOS3, + worker_count=32, + read_thread_count=64, + read_buffer_size=50, + worker_buffer_size=20, + seed=0, + dataset_source="/mnt/gcs_mount/arrayrecord2/cc12m/", + ): + """Legacy function for getting online streaming dataloader for images. + + Args: + data_name: Name of the dataset in onlineDatasetMap. + batch_size: Batch size for the dataset. + image_scale: Size to scale images to. + count: Optional count limit for the dataset. + num_epochs: Number of epochs to iterate. + method: Interpolation method for resizing. + worker_count: Number of worker processes. + read_thread_count: Number of read threads. + read_buffer_size: Size of the read buffer. + worker_buffer_size: Size of the worker buffer. + seed: Random seed. + dataset_source: Source path for the dataset. + + Returns: + Dictionary with train dataset function and metadata. + """ + local_batch_size = batch_size // jax.process_count() + + sources = onlineDatasetMap[data_name]["source"] + dataloader = OnlineStreamingDataLoader( + sources, + batch_size=local_batch_size, + num_workers=worker_count, + num_threads=read_thread_count, + image_shape=(image_scale, image_scale), + global_process_count=jax.process_count(), + global_process_index=jax.process_index(), + prefetch=worker_buffer_size, + collate_fn=generate_collate_fn(), + default_split="train", + ) + + def get_trainset(mesh: Mesh = None): + if mesh is not None: + return DataLoaderWithMesh(dataloader, mesh, buffer_size=worker_buffer_size) + return dataloader + + return { + "train": get_trainset, + "train_len": len(dataloader) * jax.process_count(), + "local_batch_size": local_batch_size, + "global_batch_size": batch_size, + } + + +# --------------------------------------------------------------------------------- +# New unified dataset loader for both images and videos +# --------------------------------------------------------------------------------- + +def get_media_dataset_grain( + data_name: str, + batch_size: int = 64, + media_scale: int = 256, + sequence_length: int = 1, + count: Optional[int] = None, + num_epochs: Optional[int] = None, + method: Any = cv2.INTER_AREA, + worker_count: int = 32, + read_thread_count: int = 64, + read_buffer_size: int = 50, + worker_buffer_size: int = 20, + seed: int = 0, + dataset_source: str = None, + media_type: Optional[str] = None, # Will be auto-detected if None + mesh: Optional[Mesh] = None, + additional_transform_kwargs: Dict[str, Any] = None, +): + """Get a grain dataset loader for any media type (image or video). + + Args: + data_name: Name of the dataset in mediaDatasetMap. + batch_size: Batch size for the dataset. + media_scale: Size to scale media (image or video frames) to. + sequence_length: Length of the sequence for video data. + count: Optional count limit for the dataset. + num_epochs: Number of epochs to iterate. + method: Interpolation method for resizing. + worker_count: Number of worker processes. + read_thread_count: Number of read threads. + read_buffer_size: Size of the read buffer. + worker_buffer_size: Size of the worker buffer. + seed: Random seed. + dataset_source: Source path for the dataset. + media_type: Type of media ("image" or "video"). Auto-detected if None. + mesh: Optional JAX mesh for distributed training. + additional_transform_kwargs: Additional arguments for the transform. + + Returns: + Dictionary with train dataset function and metadata. + """ + if data_name not in mediaDatasetMap: + raise ValueError(f"Dataset {data_name} not found in mediaDatasetMap") + + media_dataset = mediaDatasetMap[data_name] + + # Auto-detect media_type if not provided + if media_type is None: + media_type = media_dataset.media_type + + # Get the data source and augmenter + data_source = media_dataset.get_source(dataset_source) + + # Prepare transform kwargs + transform_kwargs = { + "image_scale" if media_type == "image" else "frame_size": media_scale, + "method": method, + "sequence_length": sequence_length, + } + if additional_transform_kwargs: + transform_kwargs.update(additional_transform_kwargs) + + augmenter = media_dataset.get_augmenter(**transform_kwargs) + + # Calculate local batch size for distributed training + local_batch_size = batch_size // jax.process_count() + + # Create a sampler for the dataset + if hasattr(data_source, "__len__"): + dataset_length = len(data_source) if count is None else count + else: + # Some data sources like video files list don't have __len__ + dataset_length = count if count is not None else 1000000 # Default large number + + sampler = pygrain.IndexSampler( + num_records=dataset_length, + shuffle=True, + seed=seed, + num_epochs=num_epochs, + shard_options=pygrain.ShardByJaxProcess(), + ) + + def get_trainset(mesh_override: Optional[Mesh] = None): + """Get a training dataset iterator. + + Args: + mesh_override: Optional mesh to override the default. + + Returns: + A dataset iterator. + """ + current_mesh = mesh_override or mesh + + transformations = [ + augmenter(), + pygrain.Batch(local_batch_size, drop_remainder=True), + ] + + # # Add mesh mapping if needed + # if current_mesh is not None: + # transformations.append(batch_mesh_map(current_mesh)()) + + loader = pygrain.DataLoader( + data_source=data_source, + sampler=sampler, + operations=transformations, + worker_count=worker_count, + read_options=pygrain.ReadOptions( + read_thread_count, read_buffer_size + ), + worker_buffer_size=worker_buffer_size, + ) + return loader + + return { + "train": get_trainset, + "train_len": dataset_length, + "local_batch_size": local_batch_size, + "global_batch_size": batch_size, + "media_type": media_type, + } + + +def get_media_dataset_online( + data_name: str = "combined_online", + batch_size: int = 64, + media_scale: int = 256, + worker_count: int = 16, + read_thread_count: int = 512, + worker_buffer_size: int = 20, + dataset_sources: List[str] = None, + media_type: str = "image", # Default to image for online datasets + mesh: Optional[Mesh] = None, + timeout: int = 15, + retries: int = 3, + min_media_scale: int = 128, +): + """Get an online streaming dataset loader for any media type. + + Args: + data_name: Name of the dataset in onlineDatasetMap, or "custom" for custom sources. + batch_size: Batch size for the dataset. + media_scale: Size to scale media (image or video frames) to. + worker_count: Number of worker processes. + read_thread_count: Number of read threads. + worker_buffer_size: Size of the worker buffer. + dataset_sources: Custom dataset sources if data_name is "custom". + media_type: Type of media ("image" or "video"). + mesh: Optional JAX mesh for distributed training. + timeout: Timeout for dataset operations. + retries: Number of retries for dataset operations. + min_media_scale: Minimum scale for media items. + + Returns: + Dictionary with train dataset function and metadata. + """ + local_batch_size = batch_size // jax.process_count() + + # Get dataset sources + if dataset_sources is None: + if data_name not in onlineDatasetMap: + raise ValueError(f"Dataset {data_name} not found in onlineDatasetMap") + sources = onlineDatasetMap[data_name]["source"] + else: + sources = dataset_sources + + # Configure shape parameter based on media type + shape_param = "image_shape" if media_type == "image" else "frame_size" + shape_value = (media_scale, media_scale) if media_type == "image" else media_scale + + # Configure min scale parameter based on media type + min_scale_param = "min_image_shape" if media_type == "image" else "min_frame_size" + min_scale_value = (min_media_scale, min_media_scale) if media_type == "image" else min_media_scale + + # Prepare dataloader kwargs + dataloader_kwargs = { + "batch_size": local_batch_size, + "num_workers": worker_count, + "num_threads": read_thread_count, + shape_param: shape_value, + min_scale_param: min_scale_value, + "global_process_count": jax.process_count(), + "global_process_index": jax.process_index(), + "prefetch": worker_buffer_size, + "collate_fn": generate_collate_fn(media_type), + "default_split": "train", + "timeout": timeout, + "retries": retries, + } + + dataloader = OnlineStreamingDataLoader(sources, **dataloader_kwargs) + + def get_trainset(mesh_override: Optional[Mesh] = None): + """Get a training dataset iterator. + + Args: + mesh_override: Optional mesh to override the default. + + Returns: + A dataset iterator. + """ + current_mesh = mesh_override or mesh + + if current_mesh is not None: + return DataLoaderWithMesh(dataloader, current_mesh, buffer_size=worker_buffer_size) + + return dataloader + + return { + "train": get_trainset, + "train_len": len(dataloader) * jax.process_count(), + "local_batch_size": local_batch_size, + "global_batch_size": batch_size, + "media_type": media_type, + } \ No newline at end of file diff --git a/flaxdiff/data/dataset_map.py b/flaxdiff/data/dataset_map.py index 1c808b9..6df9065 100644 --- a/flaxdiff/data/dataset_map.py +++ b/flaxdiff/data/dataset_map.py @@ -1,5 +1,14 @@ -from .sources.tfds import data_source_tfds, tfds_augmenters -from .sources.gcs import data_source_gcs, data_source_combined_gcs, gcs_augmenters +from .sources.base import MediaDataset, DataSource, DataAugmenter +from .sources.images import ImageTFDSSource, ImageGCSSource, CombinedImageGCSSource +from .sources.images import ImageTFDSAugmenter, ImageGCSAugmenter +from .sources.videos import VideoTFDSSource, VideoLocalSource, AudioVideoAugmenter + +# --------------------------------------------------------------------------------- +# Legacy compatibility mappings +# --------------------------------------------------------------------------------- + +from .sources.images import data_source_tfds, tfds_augmenters, data_source_gcs +from .sources.images import data_source_combined_gcs, gcs_augmenters # Configure the following for your datasets datasetMap = { @@ -50,9 +59,6 @@ onlineDatasetMap = { "combined_online": { "source": [ - # "gs://flaxdiff-datasets-regional/datasets/laion-aesthetics-12m+mscoco-2017.parquet" - # "ChristophSchuhmann/MS_COCO_2017_URL_TEXT", - # "dclure/laion-aesthetics-12m-umap", "gs://flaxdiff-datasets-regional/datasets/laion-aesthetics-12m+mscoco-2017", "gs://flaxdiff-datasets-regional/datasets/coyo700m-aesthetic-5.4_25M", "gs://flaxdiff-datasets-regional/datasets/leonardo-liked-1.8m", @@ -65,7 +71,56 @@ "gs://flaxdiff-datasets-regional/datasets/cc3m", "gs://flaxdiff-datasets-regional/datasets/cc3m", "gs://flaxdiff-datasets-regional/datasets/laion2B-en-aesthetic-4.2_37M", - # "gs://flaxdiff-datasets-regional/datasets/laiion400m-185M" ] } +} + +# --------------------------------------------------------------------------------- +# New media datasets configuration with the unified architecture +# --------------------------------------------------------------------------------- + +mediaDatasetMap = { + # Image datasets + "oxford_flowers102": MediaDataset( + source=ImageTFDSSource(name="oxford_flowers102", use_tf=False), + augmenter=ImageTFDSAugmenter(), + media_type="image" + ), + "cc12m": MediaDataset( + source=ImageGCSSource(source='arrayrecord2/cc12m'), + augmenter=ImageGCSAugmenter(), + media_type="image" + ), + "laiona_coco": MediaDataset( + source=ImageGCSSource(source='arrayrecord2/laion-aesthetics-12m+mscoco-2017'), + augmenter=ImageGCSAugmenter(), + media_type="image" + ), + "combined_aesthetic": MediaDataset( + source=CombinedImageGCSSource(sources=[ + 'arrayrecord2/laion-aesthetics-12m+mscoco-2017', + 'arrayrecords/aestheticCoyo_0.25clip_6aesthetic', + 'arrayrecord2/cc12m', + 'arrayrecords/aestheticCoyo_0.25clip_6aesthetic', + ]), + augmenter=ImageGCSAugmenter(), + media_type="image" + ), + "combined_30m": MediaDataset( + source=CombinedImageGCSSource(sources=[ + 'arrayrecord2/laion-aesthetics-12m+mscoco-2017', + 'arrayrecord2/cc12m', + 'arrayrecord2/aestheticCoyo_0.26_clip_5.5aesthetic_256plus', + "arrayrecord2/playground+leonardo_x4+cc3m.parquet", + ]), + augmenter=ImageGCSAugmenter(), + media_type="image" + ), + + # Video dataset + "voxceleb2": MediaDataset( + source=VideoLocalSource(), + augmenter=AudioVideoAugmenter(), + media_type="video" + ), } \ No newline at end of file diff --git a/flaxdiff/data/datasets.py b/flaxdiff/data/datasets.py deleted file mode 100644 index 6c6c5ef..0000000 --- a/flaxdiff/data/datasets.py +++ /dev/null @@ -1,169 +0,0 @@ -import jax.numpy as jnp -import grain.python as pygrain -from typing import Dict -import numpy as np -import jax -from flaxdiff.utils import convert_to_global_tree, AutoTextTokenizer -from .dataset_map import datasetMap, onlineDatasetMap -import traceback -from .online_loader import OnlineStreamingDataLoader -import queue -from jax.sharding import Mesh -import threading - -def batch_mesh_map(mesh): - class augmenters(pygrain.MapTransform): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - - def map(self, batch) -> Dict[str, jnp.array]: - return convert_to_global_tree(mesh, batch) - return augmenters - -def get_dataset_grain( - data_name="cc12m", - batch_size=64, - image_scale=256, - count=None, - num_epochs=None, - method=jax.image.ResizeMethod.LANCZOS3, - worker_count=32, - read_thread_count=64, - read_buffer_size=50, - worker_buffer_size=20, - seed=0, - dataset_source="/mnt/gcs_mount/arrayrecord2/cc12m/", -): - dataset = datasetMap[data_name] - data_source = dataset["source"](dataset_source) - augmenter = dataset["augmenter"](image_scale, method) - - local_batch_size = batch_size // jax.process_count() - - sampler = pygrain.IndexSampler( - num_records=len(data_source) if count is None else count, - shuffle=True, - seed=seed, - num_epochs=num_epochs, - shard_options=pygrain.ShardByJaxProcess(), - ) - - def get_trainset(): - transformations = [ - augmenter(), - pygrain.Batch(local_batch_size, drop_remainder=True), - ] - - # if mesh != None: - # transformations += [batch_mesh_map(mesh)] - - loader = pygrain.DataLoader( - data_source=data_source, - sampler=sampler, - operations=transformations, - worker_count=worker_count, - read_options=pygrain.ReadOptions( - read_thread_count, read_buffer_size - ), - worker_buffer_size=worker_buffer_size, - ) - return loader - - - return { - "train": get_trainset, - "train_len": len(data_source), - "local_batch_size": local_batch_size, - "global_batch_size": batch_size, - # "null_labels": null_labels, - # "null_labels_full": null_labels_full, - # "model": model, - # "tokenizer": tokenizer, - } - -def generate_collate_fn(): - auto_tokenize = AutoTextTokenizer(tensor_type="np") - def default_collate(batch): - try: - # urls = [sample["url"] for sample in batch] - captions = [sample["caption"] for sample in batch] - results = auto_tokenize(captions) - images = np.stack([sample["image"] for sample in batch], axis=0) - return { - "image": images, - "input_ids": results['input_ids'], - "attention_mask": results['attention_mask'], - } - except Exception as e: - print("Error in collate function", e, [sample["image"].shape for sample in batch]) - traceback.print_exc() - - return default_collate - -def get_dataset_online( - data_name="combined_online", - batch_size=64, - image_scale=256, - count=None, - num_epochs=None, - method=jax.image.ResizeMethod.LANCZOS3, - worker_count=32, - read_thread_count=64, - read_buffer_size=50, - worker_buffer_size=20, - seed=0, - dataset_source="/mnt/gcs_mount/arrayrecord2/cc12m/", - ): - local_batch_size = batch_size // jax.process_count() - - sources = onlineDatasetMap[data_name]["source"] - dataloader = OnlineStreamingDataLoader( - sources, - batch_size=local_batch_size, - num_workers=worker_count, - num_threads=read_thread_count, - image_shape=(image_scale, image_scale), - global_process_count=jax.process_count(), - global_process_index=jax.process_index(), - prefetch=worker_buffer_size, - collate_fn=generate_collate_fn(), - default_split="train", - ) - - def get_trainset(mesh: Mesh = None): - if mesh != None: - class dataLoaderWithMesh: - def __init__(self, dataloader, mesh): - self.dataloader = dataloader - self.mesh = mesh - self.tmp_queue = queue.Queue(worker_buffer_size) - def batch_loader(): - for batch in self.dataloader: - try: - self.tmp_queue.put(convert_to_global_tree(mesh, batch)) - except Exception as e: - print("Error processing batch", e) - self.loader_thread = threading.Thread(target=batch_loader) - self.loader_thread.start() - - def __iter__(self): - return self - - def __next__(self): - return self.tmp_queue.get() - - dataloader_with_mesh = dataLoaderWithMesh(dataloader, mesh) - - return dataloader_with_mesh - return dataloader - - return { - "train": get_trainset, - "train_len": len(dataloader) * jax.process_count(), - "local_batch_size": local_batch_size, - "global_batch_size": batch_size, - # "null_labels": null_labels, - # "null_labels_full": null_labels_full, - # "model": model, - # "tokenizer": tokenizer, - } \ No newline at end of file diff --git a/flaxdiff/data/debug.ipynb b/flaxdiff/data/debug.ipynb new file mode 100644 index 0000000..4de5551 --- /dev/null +++ b/flaxdiff/data/debug.ipynb @@ -0,0 +1,4060 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4bdffcbf", + "metadata": {}, + "source": [ + "# Decord Memory Leak and Performance Benchmark\n", + "\n", + "This notebook tests the decord library for potential memory leaks and benchmarks the video loading performance." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8174843a", + "metadata": {}, + "outputs": [], + "source": [ + "from decord import AudioReader, VideoReader, AVReader\n", + "import numpy as np\n", + "import os \n", + "import shutil\n", + "from sources.videos import gather_video_paths\n", + "from sources.utils import AVReader\n", + "from decord import cpu, gpu\n", + "\n", + "# Additional imports for memory tracking and benchmarking\n", + "import psutil\n", + "import gc\n", + "import time\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "from tqdm.notebook import tqdm\n", + "import gc\n", + "# Import additional libraries we'll need\n", + "import av\n", + "import sys\n", + "from functools import partial\n", + "\n", + "import cv2\n", + "import os\n", + "import shutil\n", + "import subprocess\n", + "import numpy as np\n", + "from typing import Tuple, Optional, Union, List, Dict, Any, Callable\n", + "from video_reader import PyVideoReader\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4e788311", + "metadata": {}, + "outputs": [], + "source": [ + "videos_dir = '/home/mrwhite0racle/persist/data/vox2/test_filtered/'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "651656a8", + "metadata": {}, + "outputs": [], + "source": [ + "video_paths = gather_video_paths(videos_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "67fe8a8a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total number of videos: 1663\n", + "Sample video path: /home/mrwhite0racle/persist/data/vox2/test_filtered/id00017/M6PYYNz3pac/00033.mp4\n" + ] + } + ], + "source": [ + "print(f\"Total number of videos: {len(video_paths)}\")\n", + "print(f\"Sample video path: {video_paths[0]}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "960f0211", + "metadata": {}, + "outputs": [], + "source": [ + "def read_av_random_clip_moviepy(\n", + " video_path: str,\n", + " num_frames: int = 16,\n", + " audio_frames_per_video_frame: int = 1,\n", + " audio_frame_padding: int = 0,\n", + " target_sr: int = 16000,\n", + " target_fps: float = 25.0,\n", + " random_seed: Optional[int] = None,\n", + "):\n", + " \"\"\"\n", + " Read a random clip of audio and video frames.\n", + " Works by first selecting a random appropriate start frame, then reading the specified number of frames (1, N, H, W, C).\n", + " It then selects the audio clip corresponding to the video frames + some extra padding frames on either side. This is \n", + " of shape (1, P + N + P, K) where P is the padding, N is the number of video frames, and K is the audio data shape per frame.\n", + " if audio_frames_per_video_frame > 1, It then also creates a tensor of shape (1, N, F, K) where F = audio_frames_per_video_frame.\n", + " Otherwise (1, N, 1, K) is returned in the case of audio_frames_per_video_frame = 1.\n", + " \n", + " The final audio and video tensors are returned.\n", + " Args:\n", + " video_path: Path to the video file.\n", + " num_frames: Number of video frames to read.\n", + " audio_frames_per_video_frame: Number of audio frames per video frame.\n", + " audio_frame_padding: Padding for audio frames.\n", + " target_sr: Target sample rate for the audio.\n", + " target_fps: Target frames per second for the video.\n", + " random_seed: Random seed for reproducibility (optional).\n", + " \n", + " Returns:\n", + " Tuple of (frame_wise_audio, full_padded_audio, video_frames) where video_frames is a numpy array.\n", + " \"\"\"\n", + " from moviepy import VideoFileClip\n", + " # Set random seed if provided\n", + " if random_seed is not None:\n", + " np.random.seed(random_seed)\n", + " # Load the video\n", + " video = VideoFileClip(video_path).with_fps(target_fps)\n", + " original_duration = video.duration\n", + " total_frames = video.n_frames#int(original_duration * target_fps)\n", + " \n", + " # Calculate effective padding needed based on audio segmentation\n", + " effective_padding = max(audio_frame_padding, (audio_frames_per_video_frame) // 2)\n", + "\n", + " # Make sure we have enough frames\n", + " if total_frames < num_frames + 2 * effective_padding:\n", + " raise ValueError(f\"Video has only {total_frames} frames, but {num_frames + 2 * effective_padding} were requested (including effective padding)\")\n", + "\n", + " # Adjust the range for start_idx to account for effective padding\n", + " min_start_idx = effective_padding\n", + " max_start_idx = total_frames - num_frames - effective_padding\n", + "\n", + " # Select a random start frame that allows for padding on both sides\n", + " start_idx = np.random.randint(min_start_idx, max_start_idx) if max_start_idx > min_start_idx else min_start_idx\n", + " end_idx = start_idx + num_frames\n", + " \n", + " # Convert to time\n", + " video_start_time = start_idx / target_fps\n", + " video_end_time = end_idx / target_fps\n", + " \n", + " # Extract video frames\n", + " main_clip : VideoFileClip = video.subclipped(video_start_time, video_end_time)\n", + " # Replace the video frame extraction with:\n", + " frame_count = 0\n", + " video_frames = []\n", + " for frame in video.iter_frames(fps=target_fps, dtype='uint8'):\n", + " if frame_count >= start_idx and frame_count < start_idx + num_frames:\n", + " video_frames.append(frame)\n", + " frame_count += 1\n", + " if len(video_frames) == num_frames:\n", + " break\n", + " \n", + " # Convert to numpy array\n", + " video_frames = np.array(video_frames)\n", + " \n", + " audio_start_time = (start_idx - effective_padding) / target_fps\n", + " audio_end_time = (end_idx + effective_padding) / target_fps\n", + " num_audio_frames = num_frames + 2 * effective_padding\n", + " audio_duration = audio_end_time - audio_start_time\n", + " # Ensure we don't go out of bounds\n", + " if audio_start_time < 0 or audio_end_time > original_duration:\n", + " raise ValueError(f\"Audio start time {audio_start_time} or end time {audio_end_time} is out of bounds for video duration {original_duration}\")\n", + " \n", + " # Extract the subclip\n", + " clip : VideoFileClip = video.subclipped(audio_start_time, audio_end_time)\n", + " # Extract audio\n", + " audio = clip.audio.with_fps(target_sr)\n", + " audio_data = audio.to_soundarray()\n", + " # Make sure len(audio_data) == (num_frames + 2 * effective_padding) * target_sr\n", + " num_audio_samples_required = int(round(audio_duration * target_sr))\n", + " if len(audio_data) < num_audio_samples_required:\n", + " raise ValueError(f\"Audio data length {len(audio_data)} is less than required {num_audio_samples_required}\")\n", + " audio_data = audio_data[:num_audio_samples_required]\n", + " # Convert to mono if stereo\n", + " if audio_data.ndim > 1 and audio_data.shape[1] > 1:\n", + " audio_data = np.mean(audio_data, axis=1)\n", + " \n", + " # Close the clips\n", + " clip.close()\n", + " main_clip.close()\n", + " video.close()\n", + " \n", + " # Reshape audio data\n", + " audio_data = np.array(audio_data) # This is just 1D\n", + " \n", + " # Calculate dimensions for audio\n", + " audio_data_per_frame = int(round(target_sr / target_fps))\n", + " # print(f\"Audio {audio_duration * target_sr}->{num_audio_samples_required} data len {audio_data.shape}, shape: {num_audio_frames}, {audio_data_per_frame}\")\n", + " audio_data = audio_data.reshape(num_audio_frames, audio_data_per_frame)\n", + " \n", + " # Create frame-wise audio\n", + " if audio_frames_per_video_frame > 1:\n", + " raise NotImplementedError(\"Frame-wise audio extraction is not implemented yet.\")\n", + " else:\n", + " # Extract the central part (for effective frames) and reshape to (1, N, 1, K)\n", + " start_idx = effective_padding\n", + " end_idx = start_idx + num_frames\n", + " central_audio = audio_data[start_idx:end_idx]\n", + " frame_wise_audio = central_audio.reshape(1, num_frames, 1, audio_data_per_frame)\n", + " \n", + " return frame_wise_audio, audio_data, video_frames\n", + "\n", + "\n", + "def read_av_random_clip_alt(\n", + " video_path: str,\n", + " num_frames: int = 16,\n", + " audio_frames_per_video_frame: int = 1,\n", + " audio_frame_padding: int = 0,\n", + " target_sr: int = 16000,\n", + " target_fps: float = 25.0,\n", + " random_seed: Optional[int] = None,\n", + "):\n", + " \"\"\"\n", + " Read a random clip of audio and video frames.\n", + " Works by first selecting a random appropriate start frame, then reading the specified number of frames (1, N, H, W, C).\n", + " It then selects the audio clip corresponding to the video frames + some extra padding frames on either side. This is \n", + " of shape (1, P + N + P, K) where P is the padding, N is the number of video frames, and K is the audio data shape per frame.\n", + " if audio_frames_per_video_frame > 1, It then also creates a tensor of shape (1, N, F, K) where F = audio_frames_per_video_frame.\n", + " Otherwise (1, N, 1, K) is returned in the case of audio_frames_per_video_frame = 1.\n", + " \n", + " The final audio and video tensors are returned.\n", + " Args:\n", + " video_path: Path to the video file.\n", + " num_frames: Number of video frames to read.\n", + " audio_frames_per_video_frame: Number of audio frames per video frame.\n", + " audio_frame_padding: Padding for audio frames.\n", + " target_sr: Target sample rate for the audio.\n", + " target_fps: Target frames per second for the video.\n", + " random_seed: Random seed for reproducibility (optional).\n", + " \n", + " Returns:\n", + " Tuple of (frame_wise_audio, full_padded_audio, video_frames) where video_frames is a numpy array.\n", + " \"\"\"\n", + " from moviepy import VideoFileClip, AudioFileClip\n", + " # Set random seed if provided\n", + " if random_seed is not None:\n", + " np.random.seed(random_seed)\n", + " # Load the video\n", + " vr = PyVideoReader(video_path)\n", + " info = vr.get_info()\n", + " total_frames = int(info['frame_count'])\n", + " \n", + " # Calculate effective padding needed based on audio segmentation\n", + " effective_padding = max(audio_frame_padding, (audio_frames_per_video_frame) // 2)\n", + "\n", + " # Make sure we have enough frames\n", + " if total_frames < num_frames + 2 * effective_padding:\n", + " raise ValueError(f\"Video has only {total_frames} frames, but {num_frames + 2 * effective_padding} were requested (including effective padding)\")\n", + "\n", + " # Adjust the range for start_idx to account for effective padding\n", + " min_start_idx = effective_padding\n", + " max_start_idx = total_frames - num_frames - effective_padding\n", + "\n", + " # Select a random start frame that allows for padding on both sides\n", + " start_idx = np.random.randint(min_start_idx, max_start_idx) if max_start_idx > min_start_idx else min_start_idx\n", + " end_idx = start_idx + num_frames\n", + " \n", + " video_frames = vr.decode(start_idx, end_idx)\n", + " \n", + " audio_start_time = (start_idx - effective_padding) / target_fps\n", + " audio_end_time = (end_idx + effective_padding) / target_fps\n", + " num_audio_frames = num_frames + 2 * effective_padding\n", + " audio_duration = audio_end_time - audio_start_time\n", + " \n", + " assert audio_duration > 0, f\"Audio duration {audio_duration} is not positive\"\n", + " assert audio_start_time >= 0, f\"Audio start time {audio_start_time} is negative\"\n", + " \n", + " # Extract the subclip\n", + " audio_clip : AudioFileClip = VideoFileClip(video_path).audio.with_fps(target_sr).subclipped(audio_start_time, audio_end_time)\n", + " audio_data = audio_clip.to_soundarray()\n", + " # Make sure len(audio_data) == (num_frames + 2 * effective_padding) * target_sr\n", + " num_audio_samples_required = int(round(audio_duration * target_sr))\n", + " \n", + " if len(audio_data) < num_audio_samples_required:\n", + " raise ValueError(f\"Audio data length {len(audio_data)} is less than required {num_audio_samples_required}\")\n", + " \n", + " audio_data = audio_data[:num_audio_samples_required]\n", + " # Convert to mono if stereo\n", + " if audio_data.ndim > 1 and audio_data.shape[1] > 1:\n", + " audio_data = np.mean(audio_data, axis=1)\n", + " \n", + " # Close the clips\n", + " audio_clip.close()\n", + " \n", + " # Reshape audio data\n", + " audio_data = np.array(audio_data) # This is just 1D\n", + " \n", + " # Calculate dimensions for audio\n", + " audio_data_per_frame = int(round(target_sr / target_fps))\n", + " # print(f\"Audio {audio_duration * target_sr}->{num_audio_samples_required} data len {audio_data.shape}, shape: {num_audio_frames}, {audio_data_per_frame}\")\n", + " audio_data = audio_data.reshape(num_audio_frames, audio_data_per_frame)\n", + " \n", + " # Create frame-wise audio\n", + " if audio_frames_per_video_frame > 1:\n", + " raise NotImplementedError(\"Frame-wise audio extraction is not implemented yet.\")\n", + " else:\n", + " # Extract the central part (for effective frames) and reshape to (1, N, 1, K)\n", + " start_idx = effective_padding\n", + " end_idx = start_idx + num_frames\n", + " central_audio = audio_data[start_idx:end_idx]\n", + " frame_wise_audio = central_audio.reshape(1, num_frames, 1, audio_data_per_frame)\n", + " \n", + " return frame_wise_audio, audio_data, video_frames\n", + "\n", + "def read_av_random_clip_pyav(\n", + " video_path: str,\n", + " num_frames: int = 16,\n", + " audio_frames_per_video_frame: int = 1,\n", + " audio_frame_padding: int = 0,\n", + " target_sr: int = 16000,\n", + " target_fps: float = 25.0,\n", + " random_seed: Optional[int] = None,\n", + ") -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n", + " \"\"\"\n", + " Decodes a random video clip and its corresponding audio from `video_path`,\n", + " padding audio by `audio_frame_padding` on each side in terms of video frames.\n", + " Uses PyAV's built-in resampler to produce mono 16-bit audio at `target_sr`.\n", + "\n", + " Returns:\n", + " (frame_wise_audio, full_padded_audio, video_frames)\n", + " * frame_wise_audio: (1, num_frames, 1, audio_data_per_frame)\n", + " * full_padded_audio: (num_frames + 2*padding, audio_data_per_frame)\n", + " * video_frames: (num_frames, H, W, 3)\n", + " \"\"\"\n", + "\n", + " if random_seed is not None:\n", + " np.random.seed(random_seed)\n", + "\n", + " # --- 1) Determine which video frames to read ---\n", + " vr = PyVideoReader(video_path)\n", + " total_frames = int(vr.get_info()[\"frame_count\"])\n", + " eff_pad = max(audio_frame_padding, audio_frames_per_video_frame // 2)\n", + " needed_frames = num_frames + 2 * eff_pad\n", + " if total_frames < needed_frames:\n", + " raise ValueError(\n", + " f\"Video has only {total_frames} frames but needs {needed_frames} (with padding).\"\n", + " )\n", + "\n", + " min_start = eff_pad\n", + " max_start = total_frames - num_frames - eff_pad\n", + " start_idx = (\n", + " np.random.randint(min_start, max_start)\n", + " if max_start > min_start\n", + " else min_start\n", + " )\n", + " end_idx = start_idx + num_frames\n", + "\n", + " # --- 2) Decode the chosen video frames ---\n", + " video_frames = vr.decode(start_idx, end_idx) # shape => (num_frames, H, W, 3)\n", + " del vr\n", + "\n", + " # --- 3) Define audio time window ---\n", + " audio_start_time = max(0.0, (start_idx - eff_pad) / target_fps)\n", + " audio_end_time = (end_idx + eff_pad) / target_fps\n", + " with av.open(video_path) as container:\n", + " audio_stream = next((s for s in container.streams if s.type == \"audio\"), None)\n", + " if audio_stream is None:\n", + " raise ValueError(\"No audio stream found in the file.\")\n", + "\n", + " # --- 4) Decode all audio, resample to s16 mono @ target_sr ---\n", + " resampler = av.AudioResampler(format=\"s16\", layout=\"mono\", rate=target_sr)\n", + " audio_segments = []\n", + " segment_times = []\n", + " for packet in container.demux(audio_stream):\n", + " for frame in packet.decode():\n", + " if frame.pts is None:\n", + " continue\n", + " out = resampler.resample(frame)\n", + " out = [out] if not isinstance(out, list) else out\n", + " for oframe in out:\n", + " # Extract samples from the PyAV audio frame\n", + " arr = oframe.to_ndarray() # shape: (1, samples) for mono\n", + " samples = arr.flatten().astype(np.int16)\n", + " start_t = float(oframe.pts * audio_stream.time_base)\n", + " end_t = start_t + oframe.samples / oframe.sample_rate\n", + " audio_segments.append(samples)\n", + " segment_times.append((start_t, end_t))\n", + " \n", + " del resampler\n", + " \n", + " if not audio_segments:\n", + " raise ValueError(\"No audio frames were decoded.\")\n", + "\n", + " full_audio = np.concatenate(audio_segments, axis=0)\n", + " seg_lens = [len(seg) for seg in audio_segments]\n", + " offsets = np.cumsum([0] + seg_lens)\n", + "\n", + " # Helper: convert time -> sample index in full_audio\n", + " def time_to_sample(t):\n", + " if t <= segment_times[0][0]:\n", + " return 0\n", + " if t >= segment_times[-1][1]:\n", + " return len(full_audio)\n", + " for i, (st, ed) in enumerate(segment_times):\n", + " if st <= t < ed:\n", + " seg_offset = int(round((t - st) * audio_stream.rate))\n", + " return offsets[i] + min(seg_offset, seg_lens[i] - 1)\n", + " return len(full_audio)\n", + "\n", + " start_sample = time_to_sample(audio_start_time)\n", + " end_sample = time_to_sample(audio_end_time)\n", + " if end_sample <= start_sample:\n", + " raise ValueError(\"No audio in the requested range.\")\n", + "\n", + " # Slice out the desired portion\n", + " sliced_audio = full_audio[start_sample:end_sample]\n", + "\n", + " # --- 5) Convert to float32 in [-1,1], pad or trim to the exact length ---\n", + " # Overall expected sample count for the window\n", + " needed_samples_window = int(round((audio_end_time - audio_start_time) * target_sr))\n", + " if len(sliced_audio) < needed_samples_window:\n", + " pad = needed_samples_window - len(sliced_audio)\n", + " sliced_audio = np.pad(sliced_audio, (0, pad), \"constant\")\n", + " else:\n", + " sliced_audio = sliced_audio[:needed_samples_window]\n", + " # Convert to float in [-1, 1]\n", + " sliced_audio = sliced_audio.astype(np.float32) / 32768.0\n", + "\n", + " # We ultimately need (num_frames + 2*pad) * audio_data_per_frame\n", + " num_audio_frames = num_frames + 2 * eff_pad\n", + " audio_data_per_frame = int(round(target_sr / target_fps))\n", + " needed_total_samples = num_audio_frames * audio_data_per_frame\n", + "\n", + " # Final pad/trim to expected shape\n", + " if len(sliced_audio) < needed_total_samples:\n", + " pad = needed_total_samples - len(sliced_audio)\n", + " sliced_audio = np.pad(sliced_audio, (0, pad), \"constant\")\n", + " else:\n", + " sliced_audio = sliced_audio[:needed_total_samples]\n", + "\n", + " full_padded_audio = sliced_audio.reshape(num_audio_frames, audio_data_per_frame)\n", + "\n", + " # --- 6) Extract the clip's central audio & reshape for per-frame usage ---\n", + " if audio_frames_per_video_frame > 1:\n", + " raise NotImplementedError(\"Multiple audio frames per video frame not supported.\")\n", + " center = full_padded_audio[eff_pad:eff_pad + num_frames]\n", + " frame_wise_audio = center.reshape(1, num_frames, 1, audio_data_per_frame)\n", + "\n", + " return frame_wise_audio, full_padded_audio, video_frames\n", + "\n", + "# Create a registry of all random clip readers for easier function selection\n", + "CLIP_READERS = {\n", + " 'moviepy': read_av_random_clip_moviepy,\n", + " 'alt': read_av_random_clip_alt,\n", + " 'pyav': read_av_random_clip_pyav\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1f059142", + "metadata": {}, + "outputs": [], + "source": [ + "def read_av(path: str, start: int=0, end: int = None, method='pyav'):\n", + " \"\"\"Generic read_av function that uses the selected implementation\"\"\"\n", + " if method not in CLIP_READERS:\n", + " raise ValueError(f\"Unknown method: {method}. Available methods: {', '.join(CLIP_READERS.keys())}\")\n", + " \n", + " _, a, v = CLIP_READERS[method](path)\n", + " return a, v" + ] + }, + { + "cell_type": "markdown", + "id": "0eebcf2c", + "metadata": {}, + "source": [ + "## Basic Test\n", + "\n", + "Let's first try loading a single video to ensure everything works correctly." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b65ee693", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Audio length: 16\n", + "Video shape: (16, 256, 256, 3)\n" + ] + } + ], + "source": [ + "framewise, audio, video = read_av_random_clip_pyav(video_paths[0], audio_frame_padding=0)#, ctx=cpu(0))\n", + "\n", + "print(f\"Audio length: {len(audio)}\")\n", + "print(f\"Video shape: {video.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7ce5006f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(16, 640)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "audio.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1682410e", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "\n", + "class ClapAudioEncoder(nn.Module):\n", + " \"\"\"\n", + " A simple module that converts raw audio arrays to a CLAP embedding of shape [B, 1, 768].\n", + " 1) Runs the audio through a CLAP processor and model.\n", + " 2) (Optionally) linear-projects from CLAP's hidden_dim to out_dim if needed.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " clap_model_name: str = \"laion/larger_clap_general\",\n", + " output_dim: int = 768,\n", + " trainable_projection: bool = True,\n", + " ):\n", + " \"\"\"\n", + " Args:\n", + " clap_model_name: The HuggingFace model name or path for the CLAP model+processor.\n", + " output_dim: The desired final embedding dimension. Many CLAP models produce 512 or 768 by default.\n", + " trainable_projection: If True, include a linear layer to project from CLAP dim to output_dim.\n", + " \"\"\"\n", + " super().__init__()\n", + "\n", + "\n", + " from transformers import ClapAudioModelWithProjection, ClapProcessor\n", + " # 1. Load the CLAP model & processor\n", + " self.processor = ClapProcessor.from_pretrained(clap_model_name)\n", + " self.clap_model = ClapAudioModelWithProjection.from_pretrained(clap_model_name)\n", + " self.clap_model.eval()\n", + "\n", + " # 2. Determine the dimension of CLAP's embedding\n", + " # Usually .audio_embeds is shape [B, 512] or [B, 768]. Let's read it from the config if possible.\n", + " clap_hidden_dim = self.clap_model.config.projection_dim # Commonly 512 or 768\n", + "\n", + " # 3. Optionally create a trainable projection from CLAP dimension -> output_dim\n", + " if trainable_projection and (clap_hidden_dim != output_dim):\n", + " self.proj = nn.Linear(clap_hidden_dim, output_dim, bias=True)\n", + " else:\n", + " self.proj = None\n", + " # If the dims match, no projection needed.\n", + " \n", + " self.expected_num_tokens = 1\n", + "\n", + " @torch.no_grad() # We can freeze CLAP's forward pass\n", + " def encode_clap(self, audio_waveforms: torch.Tensor, sampling_rate: int = 48000) -> torch.Tensor:\n", + " \"\"\"\n", + " Run the clap_model in inference mode to get [B, clap_hidden_dim] embeddings.\n", + " audio_waveforms: shape [B, samples] or a list of shape [variable_len_samples] if you want a python list.\n", + " sampling_rate: the sample rate for the waveforms.\n", + " \"\"\"\n", + " # Call the ClapProcessor in a batched way. \n", + " # 1) If audio_waveforms is shape [B, T], we convert each row to an item for the processor.\n", + " # Alternatively, CLAP can handle lists of wave arrays. We'll do that approach:\n", + "\n", + " # if isinstance(audio_waveforms, torch.Tensor):\n", + " # # convert each row to CPU numpy. This can be memory heavy if T is large.\n", + " # # Alternatively, if audio is short or you do one sample at a time, this is fine.\n", + " # wave_list = [audio_waveforms[i].cpu().numpy() for i in range(audio_waveforms.size(0))]\n", + " # else:\n", + " # # we assume it's already a list of numpy arrays\n", + " # wave_list = audio_waveforms\n", + "\n", + " inputs = self.processor(audios=audio_waveforms, sampling_rate=sampling_rate, return_tensors=\"pt\")\n", + "\n", + " # Move inputs to same device as clap_model\n", + " # We do not remove the @torch.no_grad to keep the forward pass non-trainable by default.\n", + " # If you want to train CLAP, remove @torch.no_grad and remove the .eval() from constructor.\n", + " for k, v in inputs.items():\n", + " inputs[k] = v.to(self.clap_model.device)\n", + "\n", + " outputs = self.clap_model(**inputs)\n", + " # Typically outputs.audio_embeds is [B, 512 or 768]\n", + " # We just return that\n", + " return outputs.audio_embeds\n", + "\n", + " def forward(self, wav: torch.Tensor, sampling_rate: int = 48000, *args, **kwargs) -> torch.Tensor:\n", + " \"\"\"\n", + " Forward pass. Returns shape [B, 1, output_dim].\n", + " \"\"\"\n", + " # 1. Get CLAP embedding (frozen by default, unless you remove @torch.no_grad from encode_clap)\n", + " with torch.no_grad():\n", + " clap_embeds = self.encode_clap(wav, sampling_rate=sampling_rate) \n", + " # shape e.g. [B, 512]\n", + "\n", + " # 2. If we have a trainable projection layer, apply it\n", + " if self.proj is not None:\n", + " clap_embeds = self.proj(clap_embeds) # shape [B, output_dim]\n", + "\n", + " # 3. Return in shape [B, 1, output_dim]\n", + " clap_embeds = clap_embeds.unsqueeze(1) # [B, 1, output_dim]\n", + " return clap_embeds\n", + " \n", + "\n", + "class Wav2Vec2AudioEncoder(nn.Module):\n", + " \"\"\"\n", + " A module that converts raw audio arrays to a single wav2vec2-based embedding\n", + " of shape [B, 1, output_dim].\n", + " \n", + " 1) Runs the audio through a Wav2Vec2Processor and Wav2Vec2Model.\n", + " 2) Pools over time (mean pooling).\n", + " 3) Optionally projects to a specified output dimension.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " wav2vec2_model_name: str = \"facebook/wav2vec2-base-960h\",\n", + " sampling_rate: int = 16000,\n", + " freeze_wav2vec2: bool = True,\n", + " ):\n", + " from transformers import Wav2Vec2Model, Wav2Vec2Processor, Wav2Vec2Config\n", + "\n", + " \"\"\"\n", + " Args:\n", + " wav2vec2_model_name: HF model name/path for the Wav2Vec2 model + processor.\n", + " output_dim: final embedding dimension after pooling. If the Wav2Vec2 hidden size\n", + " is e.g. 768, you can keep it or project it to some other size.\n", + " trainable_projection: if True, we add a linear layer to project from hidden_dim\n", + " to output_dim. \n", + " freeze_wav2vec2: if True, we do not train Wav2Vec2 (use it as a frozen feature extractor).\n", + " \"\"\"\n", + " super().__init__()\n", + "\n", + " # 1. Load the Wav2Vec2 processor and model\n", + " self.processor = Wav2Vec2Processor.from_pretrained(wav2vec2_model_name)\n", + " self.wav2vec2 = Wav2Vec2Model.from_pretrained(wav2vec2_model_name)\n", + "\n", + " if freeze_wav2vec2:\n", + " self.wav2vec2.eval()\n", + " for param in self.wav2vec2.parameters():\n", + " param.requires_grad = False\n", + "\n", + " self.sampling_rate = sampling_rate\n", + "\n", + " def forward(\n", + " self,\n", + " wav: torch.Tensor, # shape [B, samples]\n", + " *args,\n", + " **kwargs\n", + " ) -> torch.Tensor:\n", + " \"\"\"\n", + " Forward pass: returns shape [B, 1, output_dim].\n", + " \n", + " wav: float tensor of shape [B, T], T can vary per batch if you make a list of arrays,\n", + " but typically we handle the largest in the batch with padding. \n", + " sampling_rate: sample rate for the waveforms, must match what the processor expects (e.g. 16k).\n", + " \"\"\"\n", + " assert wav.ndim == 2, f\"Expecting [B, samples] input, got {wav.shape}\"\n", + " inputs = [self.processor(\n", + " i, # can be a list of 1D arrays or a 2D tensor\n", + " sampling_rate=self.sampling_rate,\n", + " return_tensors=\"pt\",\n", + " padding=\"longest\",\n", + " # truncation=True\n", + " ) for i in wav]\n", + " # Now the inputs are a list of dicts. We need to make 1 dict with all the values stacked.\n", + " # Each dict can have multiple keys, e.g. \"input_values\", \"attention_mask\"\n", + " device = self.wav2vec2.device\n", + " inputs = {k: torch.cat([d[k].to(device) for d in inputs], dim=0) for k in inputs[0].keys()}\n", + "\n", + " # 2) Pass through Wav2Vec2Model\n", + " # If we've set it to eval/freeze, this won't compute grads for Wav2Vec2\n", + " with torch.no_grad():\n", + " outputs = self.wav2vec2(**inputs) # Wav2Vec2BaseModelOutput\n", + " # outputs.last_hidden_state -> shape [B, T', hidden_dim]\n", + " audio_embeds = outputs.last_hidden_state\n", + " return audio_embeds\n", + "\n", + "\n", + "class WhisperAudioEncoder(nn.Module):\n", + " \"\"\"\n", + " A module that converts raw audio arrays to a single Whisper-based embedding \n", + " of shape [B, 1, output_dim].\n", + "\n", + " 1) Runs the audio through a WhisperProcessor, which creates log-mel spectrograms.\n", + " 2) Calls WhisperModel's encoder on the spectrogram features.\n", + " 3) Pools over the time dimension (mean pool).\n", + " 4) Optionally projects to a chosen output dimension.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " whisper_model_name: str = \"openai/whisper-large-v2\",\n", + " output_dim: int = 768,\n", + " trainable_projection: bool = True,\n", + " freeze_whisper: bool = True,\n", + " ):\n", + " \"\"\"\n", + " Args:\n", + " whisper_model_name: The HuggingFace model name or path (e.g., 'openai/whisper-large-v2').\n", + " output_dim: Final embedding dimension after pooling. \n", + " If Whisper's hidden size is e.g. 1280, you can reduce or keep it the same.\n", + " trainable_projection: If True, we add a linear layer from hidden_dim -> output_dim.\n", + " freeze_whisper: If True, we do not train the Whisper model (encoder) \n", + " and use it as a frozen feature extractor.\n", + " \"\"\"\n", + " super().__init__()\n", + " from transformers import WhisperProcessor, WhisperModel, AutoFeatureExtractor\n", + " \n", + " # 1. Load processor & model\n", + " # self.processor = WhisperProcessor.from_pretrained(whisper_model_name)\n", + " self.model = WhisperModel.from_pretrained(whisper_model_name)\n", + " self.processor = AutoFeatureExtractor.from_pretrained(whisper_model_name)\n", + "\n", + " # 2. Optionally freeze the entire model\n", + " if freeze_whisper:\n", + " self.model.eval()\n", + " for param in self.model.parameters():\n", + " param.requires_grad = False\n", + "\n", + " # 3. The \"encoder\" hidden size is typically in config.d_model\n", + " hidden_dim = self.model.config.d_model # e.g. 1280 for 'large-v2'\n", + "\n", + " # 4. Optionally create a projection from hidden_dim -> output_dim\n", + " # If the dims match, no projection needed.\n", + " if trainable_projection and (hidden_dim != output_dim):\n", + " print(f\"Creating projection layer from {hidden_dim} -> {output_dim}\")\n", + " self.proj = nn.Linear(hidden_dim, output_dim, bias=True)\n", + " else:\n", + " self.proj = None\n", + " \n", + " self.expected_num_tokens = 1\n", + "\n", + " def forward(\n", + " self,\n", + " wav: torch.Tensor, # shape [B, samples]\n", + " sampling_rate: int = 16000\n", + " ) -> torch.Tensor:\n", + " \"\"\"\n", + " Forward pass. Returns shape [B, 1, output_dim].\n", + " \n", + " wav: float tensor [B, T], one waveform per row.\n", + " sampling_rate: sample rate for the waveforms, typically 16k for Whisper (or 44100, etc.).\n", + " \"\"\"\n", + " assert wav.ndim == 2, \"Expecting [B, samples] input\"\n", + " inputs = [self.processor(\n", + " i, # can be a list of 1D arrays or a 2D tensor\n", + " sampling_rate=sampling_rate,\n", + " return_tensors=\"pt\",\n", + " # padding=\"longest\",\n", + " # truncation=True\n", + " ) for i in wav]\n", + " \n", + " # Now the inputs are a list of dicts. We need to make 1 dict with all the values stacked.\n", + " # Each dict can have multiple keys, e.g. \"input_values\", \"attention_mask\"\n", + " device = self.model.device\n", + " inputs = {k: torch.cat([d[k].to(device) for d in inputs], dim=0) for k in inputs[0].keys()}\n", + " \n", + " print(f\"Inputs: {inputs['input_features'].shape}\")\n", + "\n", + " # 2) Pass to Whisper encoder \n", + " # The whisper model has an encoder & decoder. We'll only use the encoder here.\n", + " # (We want hidden states => set output_hidden_states=True if you want them all.)\n", + " decoder_input_ids = torch.tensor([[1, 1]]) * self.model.config.decoder_start_token_id\n", + " encoder_outputs = self.model(inputs['input_features'], decoder_input_ids=decoder_input_ids)\n", + " # encoder_outputs.last_hidden_state -> shape [B, T's, hidden_dim]\n", + " hidden_states = encoder_outputs.last_hidden_state\n", + "\n", + " # 3) Pool over time dimension (mean pool)\n", + " # shape => [B, hidden_dim]\n", + " audio_embeds = hidden_states.mean(dim=1)\n", + "\n", + " # 4) Optionally apply the projection layer\n", + " if self.proj is not None:\n", + " audio_embeds = self.proj(audio_embeds) # [B, output_dim]\n", + "\n", + " # 5) Final shape => [B, 1, output_dim]\n", + " audio_embeds = audio_embeds.unsqueeze(1)\n", + "\n", + " return audio_embeds\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "e996c94d", + "metadata": {}, + "outputs": [], + "source": [ + "# encoder = Wav2Vec2AudioEncoder(\n", + "# wav2vec2_model_name=\"facebook/wav2vec2-base-960h\",\n", + "# sampling_rate=16000,\n", + "# freeze_wav2vec2=True\n", + "# )\n", + "\n", + "# encoder_clap = ClapAudioEncoder(\n", + "# clap_model_name=\"laion/larger_clap_general\",\n", + "# output_dim=768,\n", + "# trainable_projection=False\n", + "# )\n", + "\n", + "encoder_whisper = WhisperAudioEncoder(\n", + " whisper_model_name=\"openai/whisper-large-v2\",\n", + " output_dim=768,\n", + " trainable_projection=False\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "6d5ed42e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inputs: torch.Size([16, 80, 3000])\n" + ] + } + ], + "source": [ + "out = encoder_whisper.forward(audio, sampling_rate=16000)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f8404c77", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "43.2 ms ± 404 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n" + ] + } + ], + "source": [ + "%timeit out = encoder.forward(audio)" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "58cd0067", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([1, 1, 1280])" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "725c44d2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 150, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 8.0, 'bitrate': 218, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 150, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 8.0, 'video_n_frames': 200}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id00017/M6PYYNz3pac/00033.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n" + ] + } + ], + "source": [ + "from moviepy import VideoFileClip\n", + "video = VideoFileClip(video_paths[0])" + ] + }, + { + "cell_type": "markdown", + "id": "a1e020f0", + "metadata": {}, + "source": [ + "## Memory Leak Test\n", + "\n", + "Now we'll monitor memory usage while repeatedly loading videos to check for leaks." + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "dac14e31", + "metadata": {}, + "outputs": [], + "source": [ + "def get_memory_usage():\n", + " \"\"\"Get current memory usage in MB\"\"\"\n", + " process = psutil.Process(os.getpid())\n", + " mem_info = process.memory_info()\n", + " return mem_info.rss / (1024 * 1024) # Convert bytes to MB\n", + "\n", + "def test_for_memory_leak(num_iterations=50, sample_size=10, method='pyav'):\n", + " \"\"\"Test for memory leaks by loading videos repeatedly\"\"\"\n", + " memory_usage = []\n", + " sample_paths = random.sample(video_paths, min(sample_size, len(video_paths)))\n", + " \n", + " # Record baseline memory usage\n", + " gc.collect()\n", + " baseline_memory = get_memory_usage()\n", + " memory_usage.append(baseline_memory)\n", + " \n", + " print(f\"Initial memory usage: {baseline_memory:.2f} MB\")\n", + " \n", + " # Load videos repeatedly and track memory usage\n", + " for i in tqdm(range(num_iterations)):\n", + " path = random.choice(sample_paths)\n", + " audio, video = read_av(path, method=method)\n", + " \n", + " # Force variable clearing\n", + " del audio, video\n", + " \n", + " # Periodic garbage collection\n", + " if i % 5 == 0:\n", + " gc.collect()\n", + " \n", + " # Record memory\n", + " memory_usage.append(get_memory_usage())\n", + " \n", + " # Final cleanup\n", + " gc.collect()\n", + " final_memory = get_memory_usage()\n", + " memory_usage.append(final_memory)\n", + " \n", + " print(f\"Final memory usage: {final_memory:.2f} MB\")\n", + " print(f\"Memory change: {final_memory - baseline_memory:.2f} MB\")\n", + " \n", + " return memory_usage" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "1dc705ac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial memory usage: 552.23 MB\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9e19537e757b4ce0b407223fbac2fb74", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot memory usage over iterations\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(memory_usage)\n", + "plt.title('Memory Usage During Repeated Video Loading')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Memory Usage (MB)')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "1694e28a", + "metadata": {}, + "source": [ + "## Memory Leak Test with Explicit Deletion of AVReader\n", + "\n", + "Let's modify the test to explicitly delete the AVReader object." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "60e85065", + "metadata": {}, + "outputs": [], + "source": [ + "def read_av_with_cleanup(path: str, start: int=0, end: int = None, ctx=cpu(0)):\n", + " \"\"\"Read audio-video with explicit cleanup\"\"\"\n", + " vr = AVReader(path, ctx=ctx)\n", + " audio, video = vr[start:end]\n", + " video_np = video.asnumpy() # Convert to numpy array\n", + " audio_list = list(audio) # Make a copy of audio data\n", + " del vr # Explicitly delete AVReader object\n", + " return audio_list, video_np\n", + "\n", + "def test_for_memory_leak_with_cleanup(num_iterations=50, sample_size=10):\n", + " \"\"\"Test for memory leaks with explicit cleanup\"\"\"\n", + " memory_usage = []\n", + " sample_paths = random.sample(video_paths, min(sample_size, len(video_paths)))\n", + " \n", + " # Record baseline memory usage\n", + " gc.collect()\n", + " baseline_memory = get_memory_usage()\n", + " memory_usage.append(baseline_memory)\n", + " \n", + " print(f\"Initial memory usage: {baseline_memory:.2f} MB\")\n", + " \n", + " # Load videos repeatedly and track memory usage\n", + " for i in tqdm(range(num_iterations)):\n", + " path = random.choice(sample_paths)\n", + " audio, video = read_av_with_cleanup(path)\n", + " \n", + " # Force variable clearing\n", + " del audio, video\n", + " \n", + " # Periodic garbage collection\n", + " if i % 5 == 0:\n", + " gc.collect()\n", + " \n", + " # Record memory\n", + " memory_usage.append(get_memory_usage())\n", + " \n", + " # Final cleanup\n", + " gc.collect()\n", + " final_memory = get_memory_usage()\n", + " memory_usage.append(final_memory)\n", + " \n", + " print(f\"Final memory usage: {final_memory:.2f} MB\")\n", + " print(f\"Memory change: {final_memory - baseline_memory:.2f} MB\")\n", + " \n", + " return memory_usage" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ba653e3d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial memory usage: 417.49 MB\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ec6c91e603db49678882771d779ceca9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot memory usage over iterations for both approaches\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot([i - memory_usage[0] for i in memory_usage], label='Standard')\n", + "plt.plot([i - memory_usage_with_cleanup[0] for i in memory_usage_with_cleanup], label='With Explicit Cleanup')\n", + "plt.title('Memory Usage Comparison')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Memory Usage (MB)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "14fc2d0e", + "metadata": {}, + "source": [ + "## Performance Benchmark\n", + "\n", + "Let's measure the performance of loading videos at random." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "d747c18b", + "metadata": {}, + "outputs": [], + "source": [ + "def benchmark_video_loading(num_videos=50, method='pyav'):\n", + " \"\"\"Benchmark video loading performance\"\"\"\n", + " # Select random videos to load\n", + " selected_paths = random.sample(video_paths, min(num_videos, len(video_paths)))\n", + " \n", + " load_times = []\n", + " video_sizes = []\n", + " \n", + " print(f\"Benchmarking {method} method...\")\n", + " \n", + " for path in tqdm(selected_paths):\n", + " start_time = time.time()\n", + " \n", + " # Load the video using specified method\n", + " audio, video = read_av(path, method=method)\n", + " end_time = time.time()\n", + " \n", + " # Calculate and store metrics\n", + " load_time = end_time - start_time\n", + " load_times.append(load_time)\n", + " \n", + " # Get video size in MB\n", + " video_size = video.nbytes / (1024 * 1024) # Convert bytes to MB\n", + " video_sizes.append(video_size)\n", + " \n", + " # Cleanup\n", + " del audio, video\n", + " if len(load_times) % 10 == 0:\n", + " gc.collect()\n", + " \n", + " # Calculate statistics\n", + " avg_time = sum(load_times) / len(load_times)\n", + " avg_size = sum(video_sizes) / len(video_sizes)\n", + " avg_speed = sum(video_sizes) / sum(load_times) # MB/s\n", + " \n", + " print(f\"Average load time: {avg_time:.4f} seconds\")\n", + " print(f\"Average video size: {avg_size:.2f} MB\")\n", + " print(f\"Average loading speed: {avg_speed:.2f} MB/s\")\n", + " \n", + " return load_times, video_sizes" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "f8ca1fb1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Benchmarking pyav method...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2791f2d49f904fd6911d10b219d7a406", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/30 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Benchmark standard method\n", + "pyav_times, pyav_sizes = benchmark_video_loading(num_videos=30, method='pyav')\n", + "alt_times, alt_sizes = benchmark_video_loading(num_videos=30, method='alt')\n", + "\n", + "# Plot performance comparison\n", + "plt.figure(figsize=(14, 6))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.boxplot([pyav_times, alt_times], labels=['pyav', 'alt'])\n", + "plt.title('Load Time Comparison')\n", + "plt.ylabel('Time (seconds)')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(alt_sizes, alt_times, alpha=0.7, label='alt')\n", + "plt.scatter(pyav_sizes, pyav_times, alpha=0.7, label='pyav')\n", + "plt.title('Load Time vs. Video Size')\n", + "plt.xlabel('Video Size (MB)')\n", + "plt.ylabel('Load Time (seconds)')\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "de1006c2", + "metadata": {}, + "outputs": [], + "source": [ + "def benchmark_clip_reader(\n", + " reader_fn: Callable,\n", + " reader_name: str,\n", + " video_path: str,\n", + " num_iterations: int = 5,\n", + " base_params: Dict[str, Any] = None,\n", + " base_random_seed: int = 42\n", + "):\n", + " \"\"\"Benchmark a single clip reader implementation\"\"\"\n", + " results = {\n", + " 'memory_usage': [],\n", + " 'times': [],\n", + " 'errors': 0\n", + " }\n", + " \n", + " # Default parameters\n", + " if base_params is None:\n", + " base_params = {\n", + " 'video_path': video_path,\n", + " 'num_frames': 16,\n", + " 'audio_frames_per_video_frame': 1,\n", + " 'audio_frame_padding': 2,\n", + " 'target_sr': 16000,\n", + " 'target_fps': 25.0\n", + " }\n", + " \n", + " print(f\"Benchmarking {reader_name}...\")\n", + " for i in tqdm(range(num_iterations)):\n", + " # Prepare parameters with unique random seed\n", + " params = base_params.copy()\n", + " params['random_seed'] = base_random_seed + i\n", + " \n", + " # Measure memory before\n", + " gc.collect()\n", + " memory_before = get_memory_usage()\n", + " \n", + " # Measure time\n", + " start_time = time.time()\n", + " try:\n", + " frame_wise_audio, full_padded_audio, video_frames = reader_fn(**params)\n", + " \n", + " # Record stats\n", + " end_time = time.time()\n", + " results['times'].append(end_time - start_time)\n", + " \n", + " # Clean up and measure memory after\n", + " del frame_wise_audio, full_padded_audio, video_frames\n", + " gc.collect()\n", + " memory_after = get_memory_usage()\n", + " results['memory_usage'].append(memory_after - memory_before)\n", + " except Exception as e:\n", + " results['errors'] += 1\n", + " print(f\"Error with {reader_name}: {e}\")\n", + " \n", + " return results\n", + "\n", + "def benchmark_all_clip_readers(\n", + " video_path: str, \n", + " readers: List[str] = None, \n", + " num_iterations: int = 5, \n", + " params: Dict[str, Any] = None\n", + "):\n", + " \"\"\"Benchmark multiple clip reader implementations\"\"\"\n", + " if readers is None:\n", + " readers = list(CLIP_READERS.keys())\n", + " \n", + " # Run benchmarks for each reader\n", + " all_results = {}\n", + " base_random_seed = 42\n", + " \n", + " for reader_name in readers:\n", + " if reader_name not in CLIP_READERS:\n", + " print(f\"Unknown reader: {reader_name}. Skipping...\")\n", + " continue\n", + " \n", + " reader_fn = CLIP_READERS[reader_name]\n", + " all_results[reader_name] = benchmark_clip_reader(\n", + " reader_fn, \n", + " reader_name, \n", + " video_path, \n", + " num_iterations,\n", + " params,\n", + " base_random_seed\n", + " )\n", + " \n", + " # Print statistics\n", + " print(\"\\nBenchmark Results:\")\n", + " for reader_name, results in all_results.items():\n", + " if results['times']:\n", + " avg_time = sum(results['times']) / len(results['times'])\n", + " avg_memory = sum(results['memory_usage']) / len(results['memory_usage'])\n", + " print(f\"{reader_name} method:\")\n", + " print(f\" Average time: {avg_time:.4f} seconds\")\n", + " print(f\" Average memory change: {avg_memory:.2f} MB\")\n", + " print(f\" Errors: {results['errors']}\")\n", + " else:\n", + " print(f\"{reader_name} method: No successful runs\")\n", + " \n", + " return all_results" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "5261a1a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Testing video 1/5: 00250.mp4\n", + "------------------------------------------------------------\n", + "Benchmarking alt...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "165f32dc79b049288207796edcfc1d1c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_benchmark_results(results_dict, metric='times'):\n", + " \"\"\"Plot benchmark results for comparison\"\"\"\n", + " plt.figure(figsize=(12, 6))\n", + " \n", + " # Prepare data for plotting\n", + " methods = list(next(iter(results_dict.values())).keys())\n", + " videos = [os.path.basename(path) for path in results_dict.keys()]\n", + " \n", + " # Create bar position indices\n", + " x = np.arange(len(videos))\n", + " width = 0.8 / len(methods)\n", + " \n", + " # Plot bars for each method\n", + " for i, method in enumerate(methods):\n", + " values = []\n", + " for video_path in results_dict:\n", + " result = results_dict[video_path][method]\n", + " if metric in result and result[metric]:\n", + " values.append(np.mean(result[metric]))\n", + " else:\n", + " values.append(0) # No data = 0\n", + " \n", + " plt.bar(\n", + " x + (i - len(methods)/2 + 0.5) * width, \n", + " values, \n", + " width, \n", + " label=method\n", + " )\n", + " \n", + " # Set labels and title\n", + " metric_labels = {\n", + " 'times': 'Execution Time (s)',\n", + " 'memory_usage': 'Memory Change (MB)',\n", + " }\n", + " plt.xlabel('Video')\n", + " plt.ylabel(metric_labels.get(metric, metric))\n", + " plt.title(f'{metric_labels.get(metric, metric)} Comparison')\n", + " plt.xticks(x, videos, rotation=45)\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " \n", + "# Plot benchmark results\n", + "plt.figure(figsize=(15, 6))\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plot_benchmark_results(all_benchmark_results, 'times')\n", + "plt.title('Execution Time Comparison')\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plot_benchmark_results(all_benchmark_results, 'memory_usage')\n", + "plt.title('Memory Usage Comparison')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f3815b04", + "metadata": {}, + "source": [ + "## Unified Output Comparison Testing\n", + "\n", + "Let's compare the outputs of all three implementations to ensure they produce similar results with the same inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "83048981", + "metadata": {}, + "outputs": [], + "source": [ + "def compare_all_outputs(video_path, random_seed=42, params=None):\n", + " \"\"\"Compare outputs from all reader implementations\"\"\"\n", + " print(f\"Testing outputs for {os.path.basename(video_path)} with seed {random_seed}\")\n", + " \n", + " # Default parameters\n", + " if params is None:\n", + " params = {\n", + " 'video_path': video_path,\n", + " 'num_frames': 16,\n", + " 'audio_frames_per_video_frame': 1,\n", + " 'audio_frame_padding': 2,\n", + " 'target_sr': 16000,\n", + " 'target_fps': 25.0,\n", + " 'random_seed': random_seed\n", + " }\n", + " else:\n", + " # Ensure params has the necessary keys\n", + " params = params.copy()\n", + " params['video_path'] = video_path\n", + " params['random_seed'] = random_seed\n", + " \n", + " # Get outputs from all implementations\n", + " results = {}\n", + " for name, reader_fn in CLIP_READERS.items():\n", + " try:\n", + " print(f\"\\nRunning {name} implementation...\")\n", + " frame_wise, padded, video = reader_fn(**params)\n", + " results[name] = {\n", + " 'frame_wise': frame_wise,\n", + " 'padded': padded,\n", + " 'video': video\n", + " }\n", + " print(f\" Frame-wise shape: {frame_wise.shape}\")\n", + " print(f\" Padded shape: {padded.shape}\")\n", + " print(f\" Video shape: {video.shape}\")\n", + " except Exception as e:\n", + " print(f\"Error with {name}: {e}\")\n", + " \n", + " # Compare all implementations\n", + " print(\"\\nCross-implementation comparisons:\")\n", + " comparison_results = {}\n", + " methods = list(results.keys())\n", + " \n", + " for i in range(len(methods)):\n", + " for j in range(i+1, len(methods)):\n", + " method1, method2 = methods[i], methods[j]\n", + " comparison_key = f\"{method1}_vs_{method2}\"\n", + " print(f\"\\nComparing {method1} vs {method2}:\")\n", + " \n", + " # Compare video frames\n", + " video1 = results[method1]['video']\n", + " video2 = results[method2]['video']\n", + " \n", + " if video1.shape == video2.shape:\n", + " video_diff = np.abs(video1.astype(np.float32) - video2.astype(np.float32))\n", + " max_video_diff = np.max(video_diff)\n", + " mean_video_diff = np.mean(video_diff)\n", + " print(f\" Video frames - max diff: {max_video_diff:.4f}, mean diff: {mean_video_diff:.4f}. Video ranges: ({np.max(video1)}, {np.min(video1)}) vs ({np.max(video2)}, {np.min(video2)})\")\n", + " video_match = max_video_diff < 5.0 # Allow small differences\n", + " else:\n", + " print(f\" Video shapes don't match: {video1.shape} vs {video2.shape}\")\n", + " video_match = False\n", + " \n", + " # Compare frame-wise audio\n", + " audio1 = results[method1]['frame_wise']\n", + " audio2 = results[method2]['frame_wise']\n", + " \n", + " if audio1.shape == audio2.shape:\n", + " audio_diff = np.abs(audio1 - audio2)\n", + " max_audio_diff = np.max(audio_diff)\n", + " mean_audio_diff = np.mean(audio_diff)\n", + " print(f\" Audio - max diff: {max_audio_diff:.4f}, mean diff: {mean_audio_diff:.4f}\")\n", + " audio_match = mean_audio_diff < 0.01 # Allow small differences\n", + " else:\n", + " print(f\" Audio shapes don't match: {audio1.shape} vs {audio2.shape}\")\n", + " audio_match = False\n", + " \n", + " # Store comparison results\n", + " comparison_results[comparison_key] = {\n", + " 'video_match': video_match,\n", + " 'audio_match': audio_match,\n", + " 'video_diff': {'max': max_video_diff if video_match else None, 'mean': mean_video_diff if video_match else None},\n", + " 'audio_diff': {'max': max_audio_diff if audio_match else None, 'mean': mean_audio_diff if audio_match else None},\n", + " }\n", + " \n", + " print(f\" Result: {'✓' if video_match and audio_match else '✗'}\")\n", + " \n", + " return results, comparison_results\n", + "\n", + "def visualize_all_implementations(result):\n", + " \"\"\"Visualize sample frames and audio from all implementations\"\"\"\n", + " if not result or not result.get('outputs'):\n", + " print(\"No results available to visualize\")\n", + " return\n", + " \n", + " # Set up visualization\n", + " outputs = result['outputs']\n", + " methods = list(outputs.keys())\n", + " n_methods = len(methods)\n", + " \n", + " # Create grid of plots for video frames\n", + " plt.figure(figsize=(15, 5 * n_methods))\n", + " \n", + " for i, method in enumerate(methods):\n", + " # Get data\n", + " try:\n", + " video_frames = outputs[method]['video']\n", + " audio_data = outputs[method]['frame_wise'].reshape(-1)\n", + " \n", + " # Video frame\n", + " plt.subplot(n_methods, 2, i*2+1)\n", + " plt.title(f\"First video frame - {method}\")\n", + " plt.imshow(video_frames[0])\n", + " plt.axis('off')\n", + " \n", + " # Audio waveform\n", + " plt.subplot(n_methods, 2, i*2+2)\n", + " plt.title(f\"Audio waveform sample - {method}\")\n", + " plt.plot(audio_data[:1000])\n", + " plt.xlabel('Sample index')\n", + " plt.ylabel('Amplitude')\n", + " except Exception as e:\n", + " plt.subplot(n_methods, 2, i*2+1)\n", + " plt.text(0.5, 0.5, f\"Error visualizing {method}: {e}\", \n", + " ha='center', va='center', transform=plt.gca().transAxes)\n", + " plt.axis('off')\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + " \n", + " # Plot differences between implementations\n", + " if len(methods) > 1:\n", + " plt.figure(figsize=(15, 5 * (n_methods-1)))\n", + " plot_idx = 1\n", + " \n", + " for i in range(len(methods)):\n", + " for j in range(i+1, len(methods)):\n", + " method1, method2 = methods[i], methods[j]\n", + " try:\n", + " # Get video frames\n", + " video1 = outputs[method1]['video'][0]\n", + " video2 = outputs[method2]['video'][0]\n", + " \n", + " if video1.shape == video2.shape:\n", + " # Compute difference\n", + " diff = np.abs(video1.astype(np.float32) - video2.astype(np.float32))\n", + " \n", + " plt.subplot(n_methods-1, 2, plot_idx)\n", + " plt.title(f\"Frame difference: {method1} vs {method2}\")\n", + " plt.imshow(diff, cmap='hot')\n", + " plt.colorbar(label='Absolute Difference')\n", + " plt.axis('off')\n", + " \n", + " # Compare audio\n", + " audio1 = outputs[method1]['frame_wise'].reshape(-1)[:1000]\n", + " audio2 = outputs[method2]['frame_wise'].reshape(-1)[:1000]\n", + " \n", + " plt.subplot(n_methods-1, 2, plot_idx+1)\n", + " plt.title(f\"Audio comparison: {method1} vs {method2}\")\n", + " plt.plot(audio1, label=method1)\n", + " plt.plot(audio2, label=method2)\n", + " plt.legend()\n", + " \n", + " plot_idx += 2\n", + " except Exception as e:\n", + " plt.subplot(n_methods-1, 1, plot_idx)\n", + " plt.text(0.5, 0.5, f\"Error comparing {method1} vs {method2}: {e}\", \n", + " ha='center', va='center', transform=plt.gca().transAxes)\n", + " plt.axis('off')\n", + " plot_idx += 1\n", + " \n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "8f0ee706", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "TESTING 00150.mp4\n", + "============================================================\n", + "Testing outputs for 00150.mp4 with seed 42\n", + "\n", + "Running moviepy implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 1.040000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running alt implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running pyav implementation...\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Cross-implementation comparisons:\n", + "\n", + "Comparing moviepy vs alt:\n", + " Video frames - max diff: 4.0000, mean diff: 1.1771. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0000, mean diff: 0.0000\n", + " Result: ✓\n", + "\n", + "Comparing moviepy vs pyav:\n", + " Video frames - max diff: 4.0000, mean diff: 1.1771. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0817, mean diff: 0.0100\n", + " Result: ✓\n", + "\n", + "Comparing alt vs pyav:\n", + " Video frames - max diff: 0.0000, mean diff: 0.0000. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0817, mean diff: 0.0100\n", + " Result: ✓\n", + "Testing outputs for 00150.mp4 with seed 123\n", + "\n", + "Running moviepy implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 1.640000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running alt implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 177, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.1, 'bitrate': 244, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 177, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.1, 'video_n_frames': 102}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01333/O2fyABKMP7I/00150.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running pyav implementation...\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Cross-implementation comparisons:\n", + "\n", + "Comparing moviepy vs alt:\n", + " Video frames - max diff: 4.0000, mean diff: 1.1870. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0000, mean diff: 0.0000\n", + " Result: ✓\n", + "\n", + "Comparing moviepy vs pyav:\n", + " Video frames - max diff: 4.0000, mean diff: 1.1870. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0811, mean diff: 0.0095\n", + " Result: ✓\n", + "\n", + "Comparing alt vs pyav:\n", + " Video frames - max diff: 0.0000, mean diff: 0.0000. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0811, mean diff: 0.0095\n", + " Result: ✓\n", + "\n", + "TESTING 00067.mp4\n", + "============================================================\n", + "Testing outputs for 00067.mp4 with seed 42\n", + "\n", + "Running moviepy implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 1.040000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running alt implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running pyav implementation...\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Cross-implementation comparisons:\n", + "\n", + "Comparing moviepy vs alt:\n", + " Video frames - max diff: 4.0000, mean diff: 1.3030. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0000, mean diff: 0.0000\n", + " Result: ✓\n", + "\n", + "Comparing moviepy vs pyav:\n", + " Video frames - max diff: 4.0000, mean diff: 1.3030. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.1290, mean diff: 0.0200\n", + " Result: ✗\n", + "\n", + "Comparing alt vs pyav:\n", + " Video frames - max diff: 0.0000, mean diff: 0.0000. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.1290, mean diff: 0.0200\n", + " Result: ✗\n", + "Testing outputs for 00067.mp4 with seed 123\n", + "\n", + "Running moviepy implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 1.640000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running alt implementation...\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 4.8, 'bitrate': 257, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 4.8, 'video_n_frames': 120}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id01822/QDWgjZqOkvM/00067.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Running pyav implementation...\n", + " Frame-wise shape: (1, 16, 1, 640)\n", + " Padded shape: (20, 640)\n", + " Video shape: (16, 256, 256, 3)\n", + "\n", + "Cross-implementation comparisons:\n", + "\n", + "Comparing moviepy vs alt:\n", + " Video frames - max diff: 4.0000, mean diff: 1.3077. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.0000, mean diff: 0.0000\n", + " Result: ✓\n", + "\n", + "Comparing moviepy vs pyav:\n", + " Video frames - max diff: 4.0000, mean diff: 1.3077. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.1290, mean diff: 0.0228\n", + " Result: ✗\n", + "\n", + "Comparing alt vs pyav:\n", + " Video frames - max diff: 0.0000, mean diff: 0.0000. Video ranges: (255, 0) vs (255, 0)\n", + " Audio - max diff: 0.1290, mean diff: 0.0228\n", + " Result: ✗\n", + "Visualizing results for: 00150.mp4_42\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.0..4.0].\n", + "WARNING:matplotlib.image:Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers). Got range [0.0..4.0].\n" + ] + }, + { + "ename": "ValueError", + "evalue": "num must be an integer with 1 <= num <= 2, not 5", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[137]\u001b[39m\u001b[32m, line 148\u001b[39m, in \u001b[36mvisualize_all_implementations\u001b[39m\u001b[34m(result)\u001b[39m\n\u001b[32m 146\u001b[39m diff = np.abs(video1.astype(np.float32) - video2.astype(np.float32))\n\u001b[32m--> \u001b[39m\u001b[32m148\u001b[39m \u001b[43mplt\u001b[49m\u001b[43m.\u001b[49m\u001b[43msubplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_methods\u001b[49m\u001b[43m-\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m2\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mplot_idx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 149\u001b[39m plt.title(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mFrame difference: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmethod1\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m vs \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmethod2\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/matplotlib/pyplot.py:1544\u001b[39m, in \u001b[36msubplot\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 1543\u001b[39m \u001b[38;5;66;03m# First, search for an existing subplot with a matching spec.\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1544\u001b[39m key = \u001b[43mSubplotSpec\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_from_subplot_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1546\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m fig.axes:\n\u001b[32m 1547\u001b[39m \u001b[38;5;66;03m# If we found an Axes at the position, we can reuse it if the user passed no\u001b[39;00m\n\u001b[32m 1548\u001b[39m \u001b[38;5;66;03m# kwargs or if the Axes class and kwargs are identical.\u001b[39;00m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/matplotlib/gridspec.py:589\u001b[39m, in \u001b[36mSubplotSpec._from_subplot_args\u001b[39m\u001b[34m(figure, args)\u001b[39m\n\u001b[32m 588\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(num, Integral) \u001b[38;5;129;01mor\u001b[39;00m num < \u001b[32m1\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m num > rows*cols:\n\u001b[32m--> \u001b[39m\u001b[32m589\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 590\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnum must be an integer with 1 <= num <= \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mrows*cols\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 591\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnot \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnum\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 592\u001b[39m )\n\u001b[32m 593\u001b[39m i = j = num\n", + "\u001b[31mValueError\u001b[39m: num must be an integer with 1 <= num <= 4, not 5", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[138]\u001b[39m\u001b[32m, line 24\u001b[39m\n\u001b[32m 22\u001b[39m first_key = \u001b[38;5;28mlist\u001b[39m(all_comparison_results.keys())[\u001b[32m0\u001b[39m]\n\u001b[32m 23\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mVisualizing results for: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfirst_key\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m24\u001b[39m \u001b[43mvisualize_all_implementations\u001b[49m\u001b[43m(\u001b[49m\u001b[43mall_comparison_results\u001b[49m\u001b[43m[\u001b[49m\u001b[43mfirst_key\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[137]\u001b[39m\u001b[32m, line 166\u001b[39m, in \u001b[36mvisualize_all_implementations\u001b[39m\u001b[34m(result)\u001b[39m\n\u001b[32m 164\u001b[39m plot_idx += \u001b[32m2\u001b[39m\n\u001b[32m 165\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[32m--> \u001b[39m\u001b[32m166\u001b[39m \u001b[43mplt\u001b[49m\u001b[43m.\u001b[49m\u001b[43msubplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mn_methods\u001b[49m\u001b[43m-\u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[32;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mplot_idx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 167\u001b[39m plt.text(\u001b[32m0.5\u001b[39m, \u001b[32m0.5\u001b[39m, \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mError comparing \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmethod1\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m vs \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mmethod2\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00me\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m, \n\u001b[32m 168\u001b[39m ha=\u001b[33m'\u001b[39m\u001b[33mcenter\u001b[39m\u001b[33m'\u001b[39m, va=\u001b[33m'\u001b[39m\u001b[33mcenter\u001b[39m\u001b[33m'\u001b[39m, transform=plt.gca().transAxes)\n\u001b[32m 169\u001b[39m plt.axis(\u001b[33m'\u001b[39m\u001b[33moff\u001b[39m\u001b[33m'\u001b[39m)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/matplotlib/pyplot.py:1544\u001b[39m, in \u001b[36msubplot\u001b[39m\u001b[34m(*args, **kwargs)\u001b[39m\n\u001b[32m 1541\u001b[39m fig = gcf()\n\u001b[32m 1543\u001b[39m \u001b[38;5;66;03m# First, search for an existing subplot with a matching spec.\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1544\u001b[39m key = \u001b[43mSubplotSpec\u001b[49m\u001b[43m.\u001b[49m\u001b[43m_from_subplot_args\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfig\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 1546\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m ax \u001b[38;5;129;01min\u001b[39;00m fig.axes:\n\u001b[32m 1547\u001b[39m \u001b[38;5;66;03m# If we found an Axes at the position, we can reuse it if the user passed no\u001b[39;00m\n\u001b[32m 1548\u001b[39m \u001b[38;5;66;03m# kwargs or if the Axes class and kwargs are identical.\u001b[39;00m\n\u001b[32m 1549\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (ax.get_subplotspec() == key\n\u001b[32m 1550\u001b[39m \u001b[38;5;129;01mand\u001b[39;00m (kwargs == {}\n\u001b[32m 1551\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m (ax._projection_init\n\u001b[32m 1552\u001b[39m == fig._process_projection_requirements(**kwargs)))):\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/matplotlib/gridspec.py:589\u001b[39m, in \u001b[36mSubplotSpec._from_subplot_args\u001b[39m\u001b[34m(figure, args)\u001b[39m\n\u001b[32m 587\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 588\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(num, Integral) \u001b[38;5;129;01mor\u001b[39;00m num < \u001b[32m1\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m num > rows*cols:\n\u001b[32m--> \u001b[39m\u001b[32m589\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 590\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnum must be an integer with 1 <= num <= \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mrows*cols\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 591\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mnot \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnum\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[33m\"\u001b[39m\n\u001b[32m 592\u001b[39m )\n\u001b[32m 593\u001b[39m i = j = num\n\u001b[32m 594\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m gs[i-\u001b[32m1\u001b[39m:j]\n", + "\u001b[31mValueError\u001b[39m: num must be an integer with 1 <= num <= 2, not 5" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Test a few videos with different seeds\n", + "test_videos = random.sample(video_paths, 2)\n", + "all_comparison_results = {}\n", + "\n", + "for video_path in test_videos:\n", + " print(f\"\\nTESTING {os.path.basename(video_path)}\")\n", + " print(\"=\" * 60)\n", + " \n", + " for seed in [42, 123]:\n", + " result_key = f\"{os.path.basename(video_path)}_{seed}\"\n", + " try:\n", + " outputs, comparisons = compare_all_outputs(video_path, random_seed=seed)\n", + " all_comparison_results[result_key] = {\n", + " 'outputs': outputs,\n", + " 'comparisons': comparisons\n", + " }\n", + " except Exception as e:\n", + " print(f\"Failed comparison test: {e}\")\n", + " \n", + "# Visualize comparison for the first test case\n", + "if all_comparison_results:\n", + " first_key = list(all_comparison_results.keys())[0]\n", + " print(f\"Visualizing results for: {first_key}\")\n", + " visualize_all_implementations(all_comparison_results[first_key])" + ] + }, + { + "cell_type": "markdown", + "id": "c44c888c", + "metadata": {}, + "source": [ + "## Parameter Impact Test\n", + "\n", + "Let's evaluate how different parameters affect the performance of each implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "76229f1d", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'int' object has no attribute 'AVR_TIME_BASE'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mAttributeError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[56]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mav\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtime_base\u001b[49m\u001b[43m.\u001b[49m\u001b[43mAVR_TIME_BASE\u001b[49m\n", + "\u001b[31mAttributeError\u001b[39m: 'int' object has no attribute 'AVR_TIME_BASE'" + ] + } + ], + "source": [ + "av.time_base.AVR_TIME_BASE" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53e47858", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02137e53", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "b9d91ac2", + "metadata": {}, + "outputs": [], + "source": [ + "def test_parameter_impacts(video_path, methods=None):\n", + " \"\"\"Test how different parameters affect performance across implementations\"\"\"\n", + " if methods is None:\n", + " methods = list(CLIP_READERS.keys())\n", + " \n", + " # Base parameters\n", + " base_params = {\n", + " 'video_path': video_path,\n", + " 'num_frames': 16,\n", + " 'audio_frames_per_video_frame': 1,\n", + " 'audio_frame_padding': 2,\n", + " 'target_sr': 16000,\n", + " 'target_fps': 25.0,\n", + " 'random_seed': 42\n", + " }\n", + " \n", + " # Parameter variations to test\n", + " param_variations = {\n", + " 'num_frames': [8, 16, 32, 64],\n", + " 'target_sr': [8000, 16000, 32000, 44100],\n", + " 'audio_frame_padding': [0, 2, 4, 8]\n", + " }\n", + " \n", + " # Store results\n", + " all_results = {}\n", + " \n", + " # Test each parameter variation for each method\n", + " for param_name, param_values in param_variations.items():\n", + " print(f\"\\nTesting impact of {param_name}...\")\n", + " param_results = {method: [] for method in methods}\n", + " \n", + " for value in param_values:\n", + " print(f\" Testing {param_name}={value}\")\n", + " params = base_params.copy()\n", + " params[param_name] = value\n", + " \n", + " for method in methods:\n", + " reader_fn = CLIP_READERS[method]\n", + " \n", + " try:\n", + " # Measure time\n", + " gc.collect() # Clean up\n", + " start_time = time.time()\n", + " frame_wise, padded, video = reader_fn(**params)\n", + " end_time = time.time()\n", + " \n", + " # Record result\n", + " param_results[method].append({\n", + " 'value': value,\n", + " 'time': end_time - start_time,\n", + " 'success': True\n", + " })\n", + " \n", + " # Cleanup\n", + " del frame_wise, padded, video\n", + " \n", + " except Exception as e:\n", + " print(f\" Error with {method} at {param_name}={value}: {e}\")\n", + " param_results[method].append({\n", + " 'value': value,\n", + " 'time': None,\n", + " 'success': False,\n", + " 'error': str(e)\n", + " })\n", + " \n", + " all_results[param_name] = param_results\n", + " \n", + " return all_results" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "68f41060", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Testing parameter impacts on 00214.mp4\n", + "\n", + "\n", + "Testing impact of num_frames...\n", + " Testing num_frames=8\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing num_frames=16\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing num_frames=32\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 1.040000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing num_frames=64\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 1.040000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "\n", + "Testing impact of target_sr...\n", + " Testing target_sr=8000\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing target_sr=16000\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing target_sr=32000\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing target_sr=44100\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "\n", + "Testing impact of audio_frame_padding...\n", + " Testing audio_frame_padding=0\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing audio_frame_padding=2\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.160000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing audio_frame_padding=4\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.240000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + " Testing audio_frame_padding=8\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.400000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n", + "{'video_found': True, 'audio_found': True, 'metadata': {'major_brand': 'isom', 'minor_version': '512', 'compatible_brands': 'isomiso2avc1mp41', 'encoder': 'Lavf58.76.100'}, 'inputs': [{'streams': [{'input_number': 0, 'stream_number': 0, 'stream_type': 'video', 'language': None, 'default': True, 'size': [256, 256], 'bitrate': 188, 'fps': 25.0, 'codec_name': 'h264', 'profile': '(High)', 'metadata': {'Metadata': '', 'handler_name': 'VideoHandler', 'vendor_id': '[0][0][0][0]'}}, {'input_number': 0, 'stream_number': 1, 'stream_type': 'audio', 'language': None, 'default': True, 'fps': 16000, 'bitrate': 62, 'metadata': {'Metadata': '', 'handler_name': 'SoundHandler', 'vendor_id': '[0][0][0][0]'}}], 'input_number': 0}], 'duration': 5.44, 'bitrate': 255, 'start': 0.0, 'default_video_input_number': 0, 'default_video_stream_number': 0, 'video_codec_name': 'h264', 'video_profile': '(High)', 'video_size': [256, 256], 'video_bitrate': 188, 'video_fps': 25.0, 'default_audio_input_number': 0, 'default_audio_stream_number': 1, 'audio_fps': 16000, 'audio_bitrate': 62, 'video_duration': 5.44, 'video_n_frames': 136}\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/imageio_ffmpeg/binaries/ffmpeg-linux-x86_64-v7.0.2 -ss 3.080000 -i /home/mrwhite0racle/persist/data/vox2/test_filtered/id08552/nuf_7mt5ktk/00214.mp4 -ss 1.000000 -loglevel error -f image2pipe -vf scale=256:256 -sws_flags bicubic -pix_fmt rgb24 -vcodec rawvideo -\n" + ] + } + ], + "source": [ + "# Run parameter test on a single video\n", + "test_video = random.choice(video_paths)\n", + "print(f\"Testing parameter impacts on {os.path.basename(test_video)}\\n\")\n", + "\n", + "parameter_results = test_parameter_impacts(\n", + " video_path=test_video,\n", + " methods=['alt', 'moviepy', 'pyav']\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "2c98963d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot parameter impact results\n", + "plt.figure(figsize=(15, 12))\n", + "param_names = list(parameter_results.keys())\n", + "method_colors = {\n", + " 'alt': 'blue',\n", + " 'moviepy': 'green',\n", + " 'pyav': 'red'\n", + "}\n", + "\n", + "for i, param_name in enumerate(param_names):\n", + " plt.subplot(len(param_names), 1, i+1)\n", + " \n", + " # Get results for this parameter\n", + " param_data = parameter_results[param_name]\n", + " \n", + " # Plot each method\n", + " for method, color in method_colors.items():\n", + " if method in param_data:\n", + " # Extract data points where success=True\n", + " values = [r['value'] for r in param_data[method] if r['success']]\n", + " times = [r['time'] for r in param_data[method] if r['success']]\n", + " \n", + " if values and times:\n", + " plt.plot(values, times, 'o-', color=color, label=method)\n", + " \n", + " plt.title(f'Impact of {param_name}')\n", + " plt.xlabel(param_name)\n", + " plt.ylabel('Time (seconds)')\n", + " plt.grid(True)\n", + " plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "1a527d6e", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'all_results' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[63]\u001b[39m\u001b[32m, line 10\u001b[39m\n\u001b[32m 7\u001b[39m times_moviepy = []\n\u001b[32m 8\u001b[39m labels = []\n\u001b[32m---> \u001b[39m\u001b[32m10\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m path, results \u001b[38;5;129;01min\u001b[39;00m \u001b[43mall_results\u001b[49m.items():\n\u001b[32m 11\u001b[39m basename = os.path.basename(path)\n\u001b[32m 12\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m results[\u001b[33m'\u001b[39m\u001b[33malt\u001b[39m\u001b[33m'\u001b[39m][\u001b[33m'\u001b[39m\u001b[33mtimes\u001b[39m\u001b[33m'\u001b[39m] \u001b[38;5;129;01mand\u001b[39;00m results[\u001b[33m'\u001b[39m\u001b[33mmoviepy\u001b[39m\u001b[33m'\u001b[39m][\u001b[33m'\u001b[39m\u001b[33mtimes\u001b[39m\u001b[33m'\u001b[39m]:\n", + "\u001b[31mNameError\u001b[39m: name 'all_results' is not defined" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot comparison results\n", + "plt.figure(figsize=(15, 6))\n", + "\n", + "# Time comparison\n", + "plt.subplot(1, 2, 1)\n", + "times_alt = []\n", + "times_moviepy = []\n", + "labels = []\n", + "\n", + "for path, results in all_results.items():\n", + " basename = os.path.basename(path)\n", + " if results['alt']['times'] and results['moviepy']['times']:\n", + " times_alt.append(np.mean(results['alt']['times']))\n", + " times_moviepy.append(np.mean(results['moviepy']['times']))\n", + " labels.append(basename)\n", + "\n", + "x = np.arange(len(labels))\n", + "width = 0.35\n", + "\n", + "plt.bar(x - width/2, times_alt, width, label='Alt')\n", + "plt.bar(x + width/2, times_moviepy, width, label='MoviePy')\n", + "plt.xlabel('Video')\n", + "plt.ylabel('Time (s)')\n", + "plt.title('Execution Time Comparison')\n", + "plt.xticks(x, labels, rotation=45)\n", + "plt.legend()\n", + "\n", + "# Memory comparison\n", + "plt.subplot(1, 2, 2)\n", + "memory_alt = []\n", + "memory_moviepy = []\n", + "\n", + "for path, results in all_results.items():\n", + " basename = os.path.basename(path)\n", + " if results['alt']['memory_usage'] and results['moviepy']['memory_usage']:\n", + " memory_alt.append(np.mean(results['alt']['memory_usage']))\n", + " memory_moviepy.append(np.mean(results['moviepy']['memory_usage']))\n", + "\n", + "plt.bar(x - width/2, memory_alt, width, label='Alt')\n", + "plt.bar(x + width/2, memory_moviepy, width, label='MoviePy')\n", + "plt.xlabel('Video')\n", + "plt.ylabel('Memory Change (MB)')\n", + "plt.title('Memory Usage Comparison')\n", + "plt.xticks(x, labels, rotation=45)\n", + "plt.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ead2b6ed", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaxdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/flaxdiff/data/online_loader.py b/flaxdiff/data/online_loader.py index a571ed5..0e1d7f7 100644 --- a/flaxdiff/data/online_loader.py +++ b/flaxdiff/data/online_loader.py @@ -1,14 +1,12 @@ import multiprocessing import threading from multiprocessing import Queue -# from arrayqueues.shared_arrays import ArrayQueue -# from faster_fifo import Queue import time import albumentations as A import queue import cv2 from functools import partial -from typing import Any, Dict, List, Tuple +from typing import Any, Dict, List, Tuple, Optional, Union, Callable import numpy as np from functools import partial @@ -18,18 +16,42 @@ from concurrent.futures import ThreadPoolExecutor import io import urllib +import os import PIL.Image -import cv2 import traceback USER_AGENT = get_datasets_user_agent() -data_queue = Queue(16*2000) + +class ResourceManager: + """A manager for shared resources across data loading processes.""" + + def __init__(self, max_queue_size: int = 32000): + """Initialize a resource manager. + + Args: + max_queue_size: Maximum size of the data queue. + """ + self.data_queue = Queue(max_queue_size) + + def get_data_queue(self) -> Queue: + """Get the data queue.""" + return self.data_queue -def fetch_single_image(image_url, timeout=None, retries=0): - for _ in range(retries + 1): +def fetch_single_image(image_url: str, timeout: Optional[int] = None, retries: int = 0) -> Optional[PIL.Image.Image]: + """Fetch a single image from a URL. + + Args: + image_url: URL of the image to fetch. + timeout: Timeout in seconds for the request. + retries: Number of times to retry the request. + + Returns: + A PIL image or None if the image couldn't be fetched. + """ + for attempt in range(retries + 1): try: request = urllib.request.Request( image_url, @@ -38,38 +60,135 @@ def fetch_single_image(image_url, timeout=None, retries=0): ) with urllib.request.urlopen(request, timeout=timeout) as req: image = PIL.Image.open(io.BytesIO(req.read())) - break - except Exception: - image = None - return image + return image + except Exception as e: + if attempt < retries: + # Wait a bit before retrying + time.sleep(0.1 * (attempt + 1)) + continue + # Log the error on the final attempt + print(f"Error fetching image {image_url}: {e}") + return None + + +def fetch_single_video(video_url: str, timeout: Optional[int] = None, retries: int = 0, + max_frames: int = 32) -> Optional[List[np.ndarray]]: + """Fetch a single video from a URL. + + Args: + video_url: URL of the video to fetch. + timeout: Timeout in seconds for the request. + retries: Number of times to retry the request. + max_frames: Maximum number of frames to extract. + + Returns: + A list of video frames as numpy arrays or None if the video couldn't be fetched. + """ + # Create a temporary file to download the video + import tempfile + + for attempt in range(retries + 1): + try: + with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_file: + tmp_path = tmp_file.name + + request = urllib.request.Request( + video_url, + data=None, + headers={"user-agent": USER_AGENT}, + ) + with urllib.request.urlopen(request, timeout=timeout) as req: + with open(tmp_path, 'wb') as f: + f.write(req.read()) + + # Load the video frames + cap = cv2.VideoCapture(tmp_path) + frames = [] + + while len(frames) < max_frames: + ret, frame = cap.read() + if not ret: + break + frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)) + + cap.release() + + # Delete the temporary file + try: + os.remove(tmp_path) + except: + pass + + return frames if frames else None + + except Exception as e: + if attempt < retries: + # Wait a bit before retrying + time.sleep(0.1 * (attempt + 1)) + continue + # Log the error on the final attempt + print(f"Error fetching video {video_url}: {e}") + + # Clean up the temporary file + try: + if 'tmp_path' in locals(): + os.remove(tmp_path) + except: + pass + + return None def default_image_processor( - image, image_shape, - min_image_shape=(128, 128), - upscale_interpolation=cv2.INTER_CUBIC, - downscale_interpolation=cv2.INTER_AREA, -): + image: PIL.Image.Image, + image_shape: Tuple[int, int], + min_image_shape: Tuple[int, int] = (128, 128), + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, +) -> Tuple[Optional[np.ndarray], int, int]: + """Process an image for training. + + Args: + image: PIL image to process. + image_shape: Target shape (height, width). + min_image_shape: Minimum acceptable shape. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + + Returns: + Tuple of (processed image, original height, original width). + Processed image may be None if the image couldn't be processed. + """ try: + # Convert to numpy image = np.array(image) + + # Check if image has 3 channels if len(image.shape) != 3 or image.shape[2] != 3: return None, 0, 0 + original_height, original_width = image.shape[:2] - # check if the image is too small + + # Check if the image is too small if min(original_height, original_width) < min(min_image_shape): return None, original_height, original_width - # check if wrong aspect ratio + + # Check if wrong aspect ratio if max(original_height, original_width) / min(original_height, original_width) > 2.4: return None, original_height, original_width - # check if the variance is too low + + # Check if the variance is too low (likely a blank/solid color image) if np.std(image) < 1e-5: return None, original_height, original_width - # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + + # Choose interpolation method based on whether we're upscaling or downscaling downscale = max(original_width, original_height) > max(image_shape) interpolation = downscale_interpolation if downscale else upscale_interpolation - image = A.longest_max_size(image, max( - image_shape), interpolation=interpolation) + # Resize while keeping aspect ratio + image = A.longest_max_size(image, max(image_shape), interpolation=interpolation) + + # Pad to target shape image = A.pad( image, min_height=image_shape[0], @@ -77,30 +196,114 @@ def default_image_processor( border_mode=cv2.BORDER_CONSTANT, value=[255, 255, 255], ) + return image, original_height, original_width + + except Exception as e: + # Log the error + print(f"Error processing image: {e}") + return None, 0, 0 + + +def default_video_processor( + frames: List[np.ndarray], + frame_size: int = 256, + min_frame_size: int = 128, + num_frames: int = 16, + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, +) -> Tuple[Optional[np.ndarray], int, int]: + """Process video frames for training. + + Args: + frames: List of video frames as numpy arrays. + frame_size: Target size for each frame. + min_frame_size: Minimum acceptable frame size. + num_frames: Target number of frames. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + + Returns: + Tuple of (processed video array, original height, original width). + Processed video may be None if the video couldn't be processed. + """ + try: + if not frames or len(frames) == 0: + return None, 0, 0 + + # Get dimensions of the first frame + first_frame = frames[0] + original_height, original_width = first_frame.shape[:2] + + # Check if frames are too small + if min(original_height, original_width) < min_frame_size: + return None, original_height, original_width + + # Sample frames evenly + if len(frames) < num_frames: + # Not enough frames, duplicate some + indices = np.linspace(0, len(frames) - 1, num_frames, dtype=int) + sampled_frames = [frames[i] for i in indices] + else: + # Sample frames evenly + indices = np.linspace(0, len(frames) - 1, num_frames, dtype=int) + sampled_frames = [frames[i] for i in indices] + + # Process each frame + processed_frames = [] + for frame in sampled_frames: + # Choose interpolation method based on whether we're upscaling or downscaling + downscale = max(frame.shape[1], frame.shape[0]) > frame_size + interpolation = downscale_interpolation if downscale else upscale_interpolation + + # Resize frame + resized_frame = cv2.resize(frame, (frame_size, frame_size), interpolation=interpolation) + processed_frames.append(resized_frame) + + # Stack frames into a video tensor [num_frames, height, width, channels] + video_tensor = np.stack(processed_frames, axis=0) + + return video_tensor, original_height, original_width + except Exception as e: - # print("Error processing image", e, image_shape, interpolation) - # traceback.print_exc() + # Log the error + print(f"Error processing video: {e}") return None, 0, 0 -def map_sample( - url, - caption, - image_shape=(256, 256), - min_image_shape=(128, 128), - timeout=15, - retries=3, - upscale_interpolation=cv2.INTER_CUBIC, - downscale_interpolation=cv2.INTER_AREA, - image_processor=default_image_processor, +def map_image_sample( + url: str, + caption: str, + data_queue: Queue, + image_shape: Tuple[int, int] = (256, 256), + min_image_shape: Tuple[int, int] = (128, 128), + timeout: int = 15, + retries: int = 3, + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, + image_processor: Callable = default_image_processor, ): + """Process a single image sample and put it in the queue. + + Args: + url: URL of the image. + caption: Caption for the image. + data_queue: Queue to put the processed sample in. + image_shape: Target shape for the image. + min_image_shape: Minimum acceptable shape. + timeout: Timeout for image fetching. + retries: Number of retries for image fetching. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + image_processor: Function to process the image. + """ try: - # Assuming fetch_single_image is defined elsewhere + # Fetch the image image = fetch_single_image(url, timeout=timeout, retries=retries) if image is None: return + # Process the image image, original_height, original_width = image_processor( image, image_shape, min_image_shape=min_image_shape, upscale_interpolation=upscale_interpolation, @@ -110,6 +313,7 @@ def map_sample( if image is None: return + # Put the processed sample in the queue data_queue.put({ "url": url, "caption": caption, @@ -117,158 +321,426 @@ def map_sample( "original_height": original_height, "original_width": original_width, }) + except Exception as e: - # print(f"Error maping sample {url}", e) - # traceback.print_exc() - # error_queue.put_nowait({ - # "url": url, - # "caption": caption, - # "error": str(e) - # }) - pass - -def default_feature_extractor(sample): + # Log the error + print(f"Error mapping image sample {url}: {e}") + + +def map_video_sample( + url: str, + caption: str, + data_queue: Queue, + frame_size: int = 256, + min_frame_size: int = 128, + num_frames: int = 16, + timeout: int = 30, + retries: int = 3, + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, + video_processor: Callable = default_video_processor, +): + """Process a single video sample and put it in the queue. + + Args: + url: URL of the video. + caption: Caption for the video. + data_queue: Queue to put the processed sample in. + frame_size: Target size for each frame. + min_frame_size: Minimum acceptable frame size. + num_frames: Target number of frames. + timeout: Timeout for video fetching. + retries: Number of retries for video fetching. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + video_processor: Function to process the video. + """ + try: + # Fetch the video frames + frames = fetch_single_video(url, timeout=timeout, retries=retries, max_frames=num_frames*2) + if frames is None or len(frames) == 0: + return + + # Process the video + video, original_height, original_width = video_processor( + frames, frame_size, min_frame_size=min_frame_size, + num_frames=num_frames, + upscale_interpolation=upscale_interpolation, + downscale_interpolation=downscale_interpolation, + ) + + if video is None: + return + + # Put the processed sample in the queue + data_queue.put({ + "url": url, + "caption": caption, + "video": video, + "original_height": original_height, + "original_width": original_width, + }) + + except Exception as e: + # Log the error + print(f"Error mapping video sample {url}: {e}") + + +def default_feature_extractor(sample: Dict[str, Any]) -> Dict[str, Any]: + """Extract features from a sample. + + Args: + sample: Sample to extract features from. + + Returns: + Dictionary with extracted url and caption. + """ + # Extract URL url = None - if "url" in sample: - url = sample["url"] - elif "URL" in sample: - url = sample["URL"] - elif "image_url" in sample: - url = sample["image_url"] - else: - print("No url found in sample, skipping", sample.keys()) + for key in ["url", "URL", "image_url", "video_url"]: + if key in sample: + url = sample[key] + break + + if url is None: + print("No URL found in sample, keys:", sample.keys()) + return {"url": None, "caption": None} + # Extract caption caption = None - if "caption" in sample: - caption = sample["caption"] - elif "CAPTION" in sample: - caption = sample["CAPTION"] - elif "txt" in sample: - caption = sample["txt"] - elif "TEXT" in sample: - caption = sample["TEXT"] - elif "text" in sample: - caption = sample["text"] - else: - print("No caption found in sample, skipping", sample.keys()) + for key in ["caption", "CAPTION", "txt", "TEXT", "text"]: + if key in sample and sample[key] is not None: + caption = sample[key] + break + + if caption is None: + caption = "No caption available" return { "url": url, "caption": caption, } + def map_batch( - batch, num_threads=256, image_shape=(256, 256), - min_image_shape=(128, 128), - timeout=15, retries=3, image_processor=default_image_processor, - upscale_interpolation=cv2.INTER_CUBIC, - downscale_interpolation=cv2.INTER_AREA, - feature_extractor=default_feature_extractor, + batch: Dict[str, Any], + data_queue: Queue, + media_type: str = "image", + num_threads: int = 256, + image_shape: Tuple[int, int] = (256, 256), + min_image_shape: Tuple[int, int] = (128, 128), + frame_size: int = 256, + min_frame_size: int = 128, + num_frames: int = 16, + timeout: int = 15, + retries: int = 3, + image_processor: Callable = default_image_processor, + video_processor: Callable = default_video_processor, + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, + feature_extractor: Callable = default_feature_extractor, ): + """Map a batch of samples and process them in parallel. + + Args: + batch: Batch of samples to process. + data_queue: Queue to put processed samples in. + media_type: Type of media ("image" or "video"). + num_threads: Number of threads to use for processing. + image_shape: Target shape for images. + min_image_shape: Minimum acceptable shape for images. + frame_size: Target size for video frames. + min_frame_size: Minimum acceptable size for video frames. + num_frames: Target number of frames for videos. + timeout: Timeout for fetching. + retries: Number of retries for fetching. + image_processor: Function to process images. + video_processor: Function to process videos. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + feature_extractor: Function to extract features from samples. + """ try: - map_sample_fn = partial( - map_sample, image_shape=image_shape, min_image_shape=min_image_shape, - timeout=timeout, retries=retries, image_processor=image_processor, - upscale_interpolation=upscale_interpolation, - downscale_interpolation=downscale_interpolation - ) + # Choose mapping function based on media type + if media_type == "video": + map_func = partial( + map_video_sample, + data_queue=data_queue, + frame_size=frame_size, + min_frame_size=min_frame_size, + num_frames=num_frames, + timeout=timeout, + retries=retries, + video_processor=video_processor, + upscale_interpolation=upscale_interpolation, + downscale_interpolation=downscale_interpolation, + ) + else: # Default to image + map_func = partial( + map_image_sample, + data_queue=data_queue, + image_shape=image_shape, + min_image_shape=min_image_shape, + timeout=timeout, + retries=retries, + image_processor=image_processor, + upscale_interpolation=upscale_interpolation, + downscale_interpolation=downscale_interpolation, + ) + + # Extract features from batch + features = feature_extractor(batch) + urls, captions = features["url"], features["caption"] + + if urls is None or captions is None: + return + + # Process samples in parallel with ThreadPoolExecutor(max_workers=num_threads) as executor: - features = feature_extractor(batch) - url, caption = features["url"], features["caption"] - executor.map(map_sample_fn, url, caption) + executor.map(map_func, urls, captions) + except Exception as e: - print(f"Error maping batch", e) + # Log the error + print(f"Error mapping batch: {e}") traceback.print_exc() - # error_queue.put_nowait({ - # "batch": batch, - # "error": str(e) - # }) - pass - - -def parallel_image_loader( - dataset: Dataset, num_workers: int = 8, image_shape=(256, 256), - min_image_shape=(128, 128), - num_threads=256, timeout=15, retries=3, image_processor=default_image_processor, - upscale_interpolation=cv2.INTER_CUBIC, - downscale_interpolation=cv2.INTER_AREA, - feature_extractor=default_feature_extractor, + + +def parallel_media_loader( + dataset: Dataset, + data_queue: Queue, + media_type: str = "image", + num_workers: int = 8, + image_shape: Tuple[int, int] = (256, 256), + min_image_shape: Tuple[int, int] = (128, 128), + frame_size: int = 256, + min_frame_size: int = 128, + num_frames: int = 16, + num_threads: int = 256, + timeout: int = 15, + retries: int = 3, + image_processor: Callable = default_image_processor, + video_processor: Callable = default_video_processor, + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, + feature_extractor: Callable = default_feature_extractor, ): + """Load and process media from a dataset in parallel. + + Args: + dataset: Dataset to load from. + data_queue: Queue to put processed samples in. + media_type: Type of media ("image" or "video"). + num_workers: Number of worker processes. + image_shape: Target shape for images. + min_image_shape: Minimum acceptable shape for images. + frame_size: Target size for video frames. + min_frame_size: Minimum acceptable size for video frames. + num_frames: Target number of frames for videos. + num_threads: Number of threads per worker. + timeout: Timeout for fetching. + retries: Number of retries for fetching. + image_processor: Function to process images. + video_processor: Function to process videos. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + feature_extractor: Function to extract features from samples. + """ + # Create mapping function map_batch_fn = partial( - map_batch, num_threads=num_threads, image_shape=image_shape, + map_batch, + data_queue=data_queue, + media_type=media_type, + num_threads=num_threads, + image_shape=image_shape, min_image_shape=min_image_shape, - timeout=timeout, retries=retries, image_processor=image_processor, + frame_size=frame_size, + min_frame_size=min_frame_size, + num_frames=num_frames, + timeout=timeout, + retries=retries, + image_processor=image_processor, + video_processor=video_processor, upscale_interpolation=upscale_interpolation, downscale_interpolation=downscale_interpolation, feature_extractor=feature_extractor ) + + # Calculate shard length shard_len = len(dataset) // num_workers - print(f"Local Shard lengths: {shard_len}") + print(f"Local Shard length: {shard_len}") + + # Process dataset in parallel with multiprocessing.Pool(num_workers) as pool: iteration = 0 while True: - # Repeat forever - shards = [dataset[i*shard_len:(i+1)*shard_len] - for i in range(num_workers)] - print(f"mapping {len(shards)} shards") + # Create shards for each worker + shards = [dataset[i*shard_len:(i+1)*shard_len] for i in range(num_workers)] + print(f"Mapping {len(shards)} shards") + + # Process shards in parallel pool.map(map_batch_fn, shards) + + # Shuffle dataset for next iteration iteration += 1 print(f"Shuffling dataset with seed {iteration}") dataset = dataset.shuffle(seed=iteration) - # Clear the error queue - # while not error_queue.empty(): - # error_queue.get_nowait() -class ImageBatchIterator: +class MediaBatchIterator: + """Iterator for batches of media samples.""" + def __init__( - self, dataset: Dataset, batch_size: int = 64, image_shape=(256, 256), - min_image_shape=(128, 128), - num_workers: int = 8, num_threads=256, timeout=15, retries=3, - image_processor=default_image_processor, - upscale_interpolation=cv2.INTER_CUBIC, - downscale_interpolation=cv2.INTER_AREA, - feature_extractor=default_feature_extractor, + self, + dataset: Dataset, + batch_size: int = 64, + media_type: str = "image", + image_shape: Tuple[int, int] = (256, 256), + min_image_shape: Tuple[int, int] = (128, 128), + frame_size: int = 256, + min_frame_size: int = 128, + num_frames: int = 16, + num_workers: int = 8, + num_threads: int = 256, + timeout: int = 15, + retries: int = 3, + image_processor: Callable = default_image_processor, + video_processor: Callable = default_video_processor, + upscale_interpolation: int = cv2.INTER_CUBIC, + downscale_interpolation: int = cv2.INTER_AREA, + feature_extractor: Callable = default_feature_extractor, + resource_manager: Optional[ResourceManager] = None, ): + """Initialize a media batch iterator. + + Args: + dataset: Dataset to iterate over. + batch_size: Batch size. + media_type: Type of media ("image" or "video"). + image_shape: Target shape for images. + min_image_shape: Minimum acceptable shape for images. + frame_size: Target size for video frames. + min_frame_size: Minimum acceptable size for video frames. + num_frames: Target number of frames for videos. + num_workers: Number of worker processes. + num_threads: Number of threads per worker. + timeout: Timeout for fetching. + retries: Number of retries for fetching. + image_processor: Function to process images. + video_processor: Function to process videos. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + feature_extractor: Function to extract features from samples. + resource_manager: Resource manager to use. Will create one if None. + """ self.dataset = dataset - self.num_workers = num_workers self.batch_size = batch_size + self.media_type = media_type + + # Create or use resource manager + self.resource_manager = resource_manager or ResourceManager() + self.data_queue = self.resource_manager.get_data_queue() + + # Start loader thread loader = partial( - parallel_image_loader, - num_threads=num_threads, + parallel_media_loader, + data_queue=self.data_queue, + media_type=media_type, + num_workers=num_workers, image_shape=image_shape, min_image_shape=min_image_shape, - num_workers=num_workers, - timeout=timeout, retries=retries, + frame_size=frame_size, + min_frame_size=min_frame_size, + num_frames=num_frames, + num_threads=num_threads, + timeout=timeout, + retries=retries, image_processor=image_processor, + video_processor=video_processor, upscale_interpolation=upscale_interpolation, downscale_interpolation=downscale_interpolation, feature_extractor=feature_extractor ) - self.thread = threading.Thread(target=loader, args=(dataset,)) + + # Start loader in background thread + self.thread = threading.Thread(target=loader, args=(dataset,), daemon=True) self.thread.start() def __iter__(self): return self def __next__(self): + """Get the next batch of samples.""" def fetcher(_): - return data_queue.get() + try: + return self.data_queue.get(timeout=60) # Add timeout to prevent hanging + except: + # Return a dummy sample on timeout + if self.media_type == "video": + return { + "url": "timeout", + "caption": "Timeout occurred while waiting for sample", + "video": np.zeros((4, 32, 32, 3), dtype=np.uint8), + "original_height": 32, + "original_width": 32, + } + else: + return { + "url": "timeout", + "caption": "Timeout occurred while waiting for sample", + "image": np.zeros((32, 32, 3), dtype=np.uint8), + "original_height": 32, + "original_width": 32, + } + + # Fetch batch in parallel with ThreadPoolExecutor(max_workers=self.batch_size) as executor: batch = list(executor.map(fetcher, range(self.batch_size))) + return batch - def __del__(self): - self.thread.join() - def __len__(self): + """Get the number of batches in the dataset.""" return len(self.dataset) // self.batch_size -def default_collate(batch): +def default_image_collate(batch): + """Default collate function for image batches. + + Args: + batch: Batch of samples to collate. + + Returns: + Collated batch. + """ urls = [sample["url"] for sample in batch] captions = [sample["caption"] for sample in batch] - images = np.stack([sample["image"] for sample in batch], axis=0) + + # Check if all images have the same shape + image_shapes = [sample["image"].shape for sample in batch] + if len(set(str(shape) for shape in image_shapes)) > 1: + # Get max height and width + max_height = max(shape[0] for shape in image_shapes) + max_width = max(shape[1] for shape in image_shapes) + + # Resize all images to the same shape + images = [] + for sample in batch: + image = sample["image"] + height, width = image.shape[:2] + + if height != max_height or width != max_width: + # Pad with white + padded_image = np.ones((max_height, max_width, 3), dtype=image.dtype) * 255 + padded_image[:height, :width] = image + images.append(padded_image) + else: + images.append(image) + + images = np.stack(images, axis=0) + else: + # All images have the same shape, just stack them + images = np.stack([sample["image"] for sample in batch], axis=0) + return { "url": urls, "caption": captions, @@ -276,7 +748,83 @@ def default_collate(batch): } +def default_video_collate(batch): + """Default collate function for video batches. + + Args: + batch: Batch of samples to collate. + + Returns: + Collated batch. + """ + urls = [sample["url"] for sample in batch] + captions = [sample["caption"] for sample in batch] + + # Check if all videos have the same shape + video_shapes = [sample["video"].shape for sample in batch] + if len(set(str(shape) for shape in video_shapes)) > 1: + # Get max dimensions + max_frames = max(shape[0] for shape in video_shapes) + max_height = max(shape[1] for shape in video_shapes) + max_width = max(shape[2] for shape in video_shapes) + + # Resize all videos to the same shape + videos = [] + for sample in batch: + video = sample["video"] + num_frames, height, width = video.shape[:3] + + if num_frames != max_frames or height != max_height or width != max_width: + # Create a new video tensor with the max dimensions + padded_video = np.zeros((max_frames, max_height, max_width, 3), dtype=video.dtype) + + # Copy the original video frames + padded_video[:num_frames, :height, :width] = video + + # If we need more frames, duplicate the last frame + if num_frames < max_frames: + padded_video[num_frames:] = padded_video[num_frames-1:num_frames] + + videos.append(padded_video) + else: + videos.append(video) + + videos = np.stack(videos, axis=0) + else: + # All videos have the same shape, just stack them + videos = np.stack([sample["video"] for sample in batch], axis=0) + + return { + "url": urls, + "caption": captions, + "video": videos, + } + + +def get_default_collate(media_type="image"): + """Get the default collate function for a media type. + + Args: + media_type: Type of media ("image" or "video"). + + Returns: + Collate function for the specified media type. + """ + if media_type == "video": + return default_video_collate + else: # Default to image + return default_image_collate + + def dataMapper(map: Dict[str, Any]): + """Create a function to map dataset samples to a standard format. + + Args: + map: Dictionary mapping standard keys to dataset-specific keys. + + Returns: + Function that maps a sample to the standard format. + """ def _map(sample) -> Dict[str, Any]: return { "url": sample[map["url"]], @@ -285,13 +833,19 @@ def _map(sample) -> Dict[str, Any]: return _map -class OnlineStreamingDataLoader(): +class OnlineStreamingDataLoader: + """Data loader for streaming media data from online sources.""" + def __init__( self, dataset, batch_size=64, + media_type="image", image_shape=(256, 256), min_image_shape=(128, 128), + frame_size=256, + min_frame_size=128, + num_frames=16, num_workers=16, num_threads=512, default_split="all", @@ -303,17 +857,49 @@ def __init__( global_process_count=1, global_process_index=0, prefetch=1000, - collate_fn=default_collate, + collate_fn=None, timeout=15, retries=3, image_processor=default_image_processor, + video_processor=default_video_processor, upscale_interpolation=cv2.INTER_CUBIC, downscale_interpolation=cv2.INTER_AREA, feature_extractor=default_feature_extractor, + resource_manager=None, ): + """Initialize an online streaming data loader. + + Args: + dataset: Dataset to load from, can be a path or a dataset object. + batch_size: Batch size. + media_type: Type of media ("image" or "video"). + image_shape: Target shape for images. + min_image_shape: Minimum acceptable shape for images. + frame_size: Target size for video frames. + min_frame_size: Minimum acceptable size for video frames. + num_frames: Target number of frames for videos. + num_workers: Number of worker processes. + num_threads: Number of threads per worker. + default_split: Default split to use when loading datasets. + pre_map_maker: Function to create a mapping function. + pre_map_def: Default mapping definition. + global_process_count: Total number of processes. + global_process_index: Index of this process. + prefetch: Number of batches to prefetch. + collate_fn: Function to collate samples into batches. + timeout: Timeout for fetching. + retries: Number of retries for fetching. + image_processor: Function to process images. + video_processor: Function to process videos. + upscale_interpolation: Interpolation method for upscaling. + downscale_interpolation: Interpolation method for downscaling. + feature_extractor: Function to extract features from samples. + resource_manager: Resource manager to use. + """ + # Load dataset from path if needed if isinstance(dataset, str): dataset_path = dataset - print("Loading dataset from path") + print(f"Loading dataset from path: {dataset_path}") if "gs://" in dataset: dataset = load_from_disk(dataset_path) else: @@ -321,43 +907,86 @@ def __init__( elif isinstance(dataset, list): if isinstance(dataset[0], str): print("Loading multiple datasets from paths") - dataset = [load_from_disk(dataset_path) if "gs://" in dataset_path else load_dataset( - dataset_path, split=default_split) for dataset_path in dataset] - print("Concatenating multiple datasets") + dataset = [ + load_from_disk(dataset_path) if "gs://" in dataset_path + else load_dataset(dataset_path, split=default_split) + for dataset_path in dataset + ] + print(f"Concatenating {len(dataset)} datasets") dataset = concatenate_datasets(dataset) dataset = dataset.shuffle(seed=0) - # dataset = dataset.map(pre_map_maker(pre_map_def), batched=True, batch_size=10000000) + + # Shard dataset for distributed training self.dataset = dataset.shard( num_shards=global_process_count, index=global_process_index) print(f"Dataset length: {len(dataset)}") - self.iterator = ImageBatchIterator(self.dataset, image_shape=image_shape, - min_image_shape=min_image_shape, - num_workers=num_workers, batch_size=batch_size, num_threads=num_threads, - timeout=timeout, retries=retries, image_processor=image_processor, - upscale_interpolation=upscale_interpolation, - downscale_interpolation=downscale_interpolation, - feature_extractor=feature_extractor) + + # Get or create resource manager + self.resource_manager = resource_manager or ResourceManager() + + # Choose default collate function if not provided + if collate_fn is None: + collate_fn = get_default_collate(media_type) + + # Create media batch iterator + self.iterator = MediaBatchIterator( + self.dataset, + batch_size=batch_size, + media_type=media_type, + image_shape=image_shape, + min_image_shape=min_image_shape, + frame_size=frame_size, + min_frame_size=min_frame_size, + num_frames=num_frames, + num_workers=num_workers, + num_threads=num_threads, + timeout=timeout, + retries=retries, + image_processor=image_processor, + video_processor=video_processor, + upscale_interpolation=upscale_interpolation, + downscale_interpolation=downscale_interpolation, + feature_extractor=feature_extractor, + resource_manager=self.resource_manager, + ) + self.batch_size = batch_size + self.collate_fn = collate_fn - # Launch a thread to load batches in the background + # Create batch queue for prefetching self.batch_queue = queue.Queue(prefetch) - + + # Start batch loader thread def batch_loader(): - for batch in self.iterator: - try: - self.batch_queue.put(collate_fn(batch)) - except Exception as e: - print("Error collating batch", e) - - self.loader_thread = threading.Thread(target=batch_loader) + try: + for batch in self.iterator: + try: + if batch: + self.batch_queue.put(collate_fn(batch)) + except Exception as e: + print(f"Error collating batch: {e}") + traceback.print_exc() + except Exception as e: + print(f"Error in batch loader thread: {e}") + traceback.print_exc() + + self.loader_thread = threading.Thread(target=batch_loader, daemon=True) self.loader_thread.start() def __iter__(self): + """Get an iterator for the data loader.""" return self def __next__(self): - return self.batch_queue.get() - # return self.collate_fn(next(self.iterator)) + """Get the next batch.""" + try: + return self.batch_queue.get(timeout=60) # Add timeout to prevent hanging + except queue.Empty: + if not self.loader_thread.is_alive(): + raise StopIteration("Loader thread died") + print("Timeout waiting for batch, retrying...") + return self.__next__() def __len__(self): + """Get the number of samples in the dataset.""" return len(self.dataset) \ No newline at end of file diff --git a/flaxdiff/data/sources/audio_utils.py b/flaxdiff/data/sources/audio_utils.py new file mode 100644 index 0000000..36c8939 --- /dev/null +++ b/flaxdiff/data/sources/audio_utils.py @@ -0,0 +1,142 @@ +""" +Audio utilities for efficiently loading audio data from video files. +This module provides alternatives to decord's AudioReader/AVReader (which have memory leaks). +""" + +import os +import tempfile +import subprocess +import numpy as np +from typing import Tuple, Optional, Union + + +def read_audio_ffmpeg( + video_path: str, + start_time: Optional[float] = None, + duration: Optional[float] = None, + target_sr: int = 16000 +) -> Tuple[np.ndarray, int]: + """ + Extract audio from video file using ffmpeg subprocess calls. + + Args: + video_path: Path to the video file. + start_time: Start time in seconds (optional). + duration: Duration to extract in seconds (optional). + target_sr: Target sample rate for the audio. + + Returns: + Tuple of (audio_data, sample_rate) where audio_data is a numpy array. + """ + # Create a temporary file for the audio + with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp_file: + tmp_path = tmp_file.name + + try: + # Build the ffmpeg command + cmd = ['ffmpeg', '-y', '-i', video_path] + + # Add time parameters if specified + if start_time is not None: + cmd.extend(['-ss', str(start_time)]) + + if duration is not None: + cmd.extend(['-t', str(duration)]) + + # Set output parameters (mono, target sample rate) + cmd.extend([ + '-ac', '1', # mono + '-ar', str(target_sr), # sample rate + '-vn', # no video + '-f', 'wav', # wav format + tmp_path + ]) + + # Execute the command + subprocess.run(cmd, check=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE) + + # Read the audio file using numpy + audio_data = np.fromfile(tmp_path, np.int16).astype(np.float32) / 32768.0 # Convert to float in [-1, 1] + + return audio_data, target_sr + + finally: + # Always clean up the temporary file + try: + os.unlink(tmp_path) + except: + pass + + +def read_audio_moviepy( + video_path: str, + start_time: Optional[float] = None, + duration: Optional[float] = None, + target_sr: int = 16000 +) -> Tuple[np.ndarray, int]: + """ + Extract audio from video file using moviepy. + Requires the moviepy package: pip install moviepy + + Args: + video_path: Path to the video file. + start_time: Start time in seconds (optional). + duration: Duration to extract in seconds (optional). + target_sr: Target sample rate for the audio. + + Returns: + Tuple of (audio_data, sample_rate) where audio_data is a numpy array. + """ + try: + from moviepy import VideoFileClip + except ImportError: + raise ImportError("moviepy is not installed. Install it with 'pip install moviepy'") + + # Load video file + if start_time is not None or duration is not None: + start_t = start_time if start_time is not None else 0 + end_t = start_t + duration if duration is not None else None + video = VideoFileClip(video_path).subclipped(start_t, end_t) + else: + video = VideoFileClip(video_path) + # Extract audio + audio = video.audio.with_fps(target_sr) + + # Get audio data + audio_data = audio.to_soundarray() + + # Convert to mono if stereo + if audio_data.ndim > 1 and audio_data.shape[1] > 1: + audio_data = np.mean(audio_data, axis=1) + + # Clean up + video.close() + + return audio_data, target_sr + + +# Helper function to choose the best available method +def read_audio( + video_path: str, + start_time: Optional[float] = None, + duration: Optional[float] = None, + target_sr: int = 16000, + method: str = 'ffmpeg' +) -> Tuple[np.ndarray, int]: + """ + Extract audio from video file using the specified method. + + Args: + video_path: Path to the video file. + start_time: Start time in seconds (optional). + duration: Duration to extract in seconds (optional). + target_sr: Target sample rate for the audio. + method: Method to use ('ffmpeg' or 'moviepy'). + + Returns: + Tuple of (audio_data, sample_rate) where audio_data is a numpy array. + """ + if method == 'moviepy': + return read_audio_moviepy(video_path, start_time, duration, target_sr) + else: # default to ffmpeg + return read_audio_ffmpeg(video_path, start_time, duration, target_sr) diff --git a/flaxdiff/data/sources/av_example.py b/flaxdiff/data/sources/av_example.py new file mode 100644 index 0000000..6dc9ad7 --- /dev/null +++ b/flaxdiff/data/sources/av_example.py @@ -0,0 +1,125 @@ +#!/usr/bin/env python3 +""" +Example script demonstrating how to use the memory-leak-free audio-video reading functions. +""" + +import os +import time +import numpy as np +import matplotlib.pyplot as plt +from av_utils import read_av_improved, read_av_batch +from audio_utils import read_audio +import argparse + + +def visualize_av_data(audio_data, video_frames, output_path=None): + """ + Visualize audio and video data. + + Args: + audio_data: Audio data as numpy array or list. + video_frames: Video frames as numpy array. + output_path: Path to save visualization (optional). + """ + fig = plt.figure(figsize=(12, 6)) + + # Number of frames to show + num_frames = min(4, len(video_frames)) + + # Plot audio waveform + plt.subplot(2, num_frames, 1) + plt.plot(audio_data[:10000]) + plt.title('Audio Waveform') + plt.grid(True) + + # Plot audio spectrogram + plt.subplot(2, num_frames, 2) + plt.specgram(audio_data, NFFT=1024, Fs=16000) + plt.title('Audio Spectrogram') + + # Plot sample frames + for i in range(num_frames): + plt.subplot(2, num_frames, num_frames+i+1) + plt.imshow(video_frames[i*len(video_frames)//num_frames]) + plt.title(f'Frame {i*len(video_frames)//num_frames}') + plt.axis('off') + + plt.tight_layout() + + if output_path: + plt.savefig(output_path) + print(f"Visualization saved to {output_path}") + + plt.show() + + +def benchmark_av_reading(video_path, num_iterations=10, use_batch=False): + """ + Benchmark audio-video reading performance. + + Args: + video_path: Path to the video file. + num_iterations: Number of iterations for benchmarking. + use_batch: Whether to use batch reading. + """ + print(f"Benchmarking {'batch' if use_batch else 'single'} reading...") + + # Perform warmup + if use_batch: + _ = read_av_batch([video_path]) + else: + _ = read_av_improved(video_path) + + # Measure performance + start_time = time.time() + + for i in range(num_iterations): + if use_batch: + results = read_av_batch([video_path]) + else: + audio, video = read_av_improved(video_path) + + end_time = time.time() + avg_time = (end_time - start_time) / num_iterations + + print(f"Average time per read: {avg_time:.4f} seconds") + + return avg_time + + +def main(): + parser = argparse.ArgumentParser(description="Demo for memory-leak-free audio-video reading") + parser.add_argument("--video", "-v", required=True, help="Path to the video file") + parser.add_argument("--output", "-o", help="Path to save visualization") + parser.add_argument("--benchmark", "-b", action="store_true", help="Run benchmarks") + parser.add_argument("--iterations", "-i", type=int, default=10, help="Number of benchmark iterations") + + args = parser.parse_args() + + if not os.path.exists(args.video): + print(f"Error: Video file not found: {args.video}") + return + + # Load audio-video data + print(f"Reading audio-video data from {args.video}...") + audio, video = read_av_improved(args.video) + + print(f"Video shape: {video.shape}") + print(f"Audio length: {len(audio)}") + + # Visualize data + visualize_av_data(audio, video, args.output) + + # Run benchmarks if requested + if args.benchmark: + print("\nRunning benchmarks...") + single_time = benchmark_av_reading(args.video, args.iterations, use_batch=False) + batch_time = benchmark_av_reading(args.video, args.iterations, use_batch=True) + + print("\nBenchmark results:") + print(f"Single reading: {single_time:.4f} seconds per video") + print(f"Batch reading: {batch_time:.4f} seconds per video") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/flaxdiff/data/sources/av_utils.py b/flaxdiff/data/sources/av_utils.py new file mode 100644 index 0000000..7489ee2 --- /dev/null +++ b/flaxdiff/data/sources/av_utils.py @@ -0,0 +1,590 @@ +""" +Functions for reading audio-video data without memory leaks. +""" +import cv2 +import os +import shutil +import subprocess +import numpy as np +from typing import Tuple, Optional, Union, List +from video_reader import PyVideoReader +from .audio_utils import read_audio + +def get_video_fps(video_path: str): + cam = cv2.VideoCapture(video_path) + fps = cam.get(cv2.CAP_PROP_FPS) + cam.release() + return fps + +def read_video(video_path: str, change_fps=False, reader="rsreader"): + temp_dir = None + try: + if change_fps: + print(f"Changing fps of {video_path} to 25") + temp_dir = "temp" + if os.path.exists(temp_dir): + shutil.rmtree(temp_dir) + os.makedirs(temp_dir, exist_ok=True) + command = ( + f"ffmpeg -loglevel error -y -nostdin -i {video_path} -r 25 -crf 18 {os.path.join(temp_dir, 'video.mp4')}" + ) + subprocess.run(command, shell=True) + target_video_path = os.path.join(temp_dir, "video.mp4") + else: + target_video_path = video_path + + if reader == "rsreader": + return read_video_rsreader(target_video_path) + elif reader == "rsreader_fast": + return read_video_rsreader(target_video_path, fast=True) + elif reader == "decord": + return read_video_decord(target_video_path) + elif reader == "opencv": + return read_video_opencv(target_video_path) + else: + raise ValueError(f"Unknown reader: {reader}") + finally: + # Clean up temp directory when done + if change_fps and temp_dir and os.path.exists(temp_dir): + shutil.rmtree(temp_dir) + +def read_video_decord(video_path: str): + from decord import VideoReader + vr = VideoReader(video_path) + video_frames = vr[:].asnumpy() + vr.seek(0) + return video_frames + +# Fixed OpenCV video reader - properly release resources +def read_video_opencv(video_path): + cap = cv2.VideoCapture(video_path) + try: + frames = [] + while True: + ret, frame = cap.read() + if not ret: + break + frames.append(frame) + return np.array(frames)[:, :, :, ::-1] + finally: + cap.release() + +def read_video_rsreader(video_path, fast=False): + from video_reader import PyVideoReader + vr = PyVideoReader(video_path) + return vr.decode_fast() if fast else vr.decode() + +def read_audio_decord(audio_path:str): + from decord import AudioReader + ar = AudioReader(audio_path) + audio_frames = ar[:].asnumpy() + ar.seek(0) + return audio_frames + +def read_av_decord(path: str, start: int=0, end: int = None, ctx=None): + from decord import AVReader, cpu + if ctx is None: + ctx = cpu(0) + vr = AVReader(path, ctx=ctx, sample_rate=16000) + audio, video = vr[start:end] + return audio, video.asnumpy() + +def read_av_improved( + path: str, + start: int = 0, + end: Optional[int] = None, + fps: float = 25.0, + target_sr: int = 16000, + audio_method: str = 'ffmpeg' +) -> Tuple[Union[List, np.ndarray], np.ndarray]: + """ + Read audio-video data with explicit cleanup and without memory leaks. + Uses PyVideoReader for video (which doesn't have memory leaks) and + FFmpeg/moviepy for audio extraction. + + Args: + path: Path to the video file. + start: Start frame index. + end: End frame index (or None to read until the end). + fps: Video frames per second (used for audio timing). + target_sr: Target audio sample rate. + audio_method: Method to extract audio ('ffmpeg' or 'moviepy'). + + Returns: + Tuple of (audio_data, video_frames) where video_frames is a numpy array. + """ + # Calculate time information for audio extraction + start_time = start / fps if start > 0 else 0 + duration = None + if end is not None: + duration = (end - start) / fps + + # Get video frames using PyVideoReader + vr = PyVideoReader(path) + video = vr.decode(start_frame=start, end_frame=None) + + # Get audio data using our custom audio utilities + audio, _ = read_audio( + path, + start_time=start_time, + duration=duration, + target_sr=target_sr, + method=audio_method + ) + + # Convert audio to list for API compatibility with original read_av + audio_list = list(audio) + + return audio_list, video + +def read_av_moviepy( + video_path: str, + start_idx: Optional[int] = None, + end_idx: Optional[int] = None, + target_fps: float = 25.0, + target_sr: int = 16000, +): + """ + Read audio-video data using moviepy. + + Args: + video_path: Path to the video file. + start_idx: Start frame index (optional). + end_idx: End frame index (optional). + target_sr: Target sample rate for the audio. + + Returns: + Tuple of (audio_data, video_frames) where video_frames is a numpy array. + """ + # Use moviepy to read audio and video + from moviepy import VideoFileClip + + video = VideoFileClip(video_path).with_fps(target_fps) + + # Convert frame indexes to time + start_time = start_idx / target_fps if start_idx is not None else 0 + end_time = end_idx / target_fps if end_idx is not None else None + video = video.subclipped(start_time, end_time) + + # Extract audio + audio = video.audio.with_fps(target_sr) + audio_data = audio.to_soundarray() + if audio_data.ndim > 1 and audio_data.shape[1] > 1: + audio_data = np.mean(audio_data, axis=1) + + # Extract video frames + video_frames = [] + for frame in video.iter_frames(fps=target_fps, dtype='uint8'): + video_frames.append(frame) + video_frames = np.array(video_frames) + video.close() + return audio_data, video_frames +def read_av_random_clip_moviepy( + video_path: str, + num_frames: int = 16, + audio_frames_per_video_frame: int = 1, + audio_frame_padding: int = 0, + target_sr: int = 16000, + target_fps: float = 25.0, + random_seed: Optional[int] = None, +): + """ + Read a random clip of audio and video frames. + Works by first selecting a random appropriate start frame, then reading the specified number of frames (1, N, H, W, C). + It then selects the audio clip corresponding to the video frames + some extra padding frames on either side. This is + of shape (1, P + N + P, K) where P is the padding, N is the number of video frames, and K is the audio data shape per frame. + if audio_frames_per_video_frame > 1, It then also creates a tensor of shape (1, N, F, K) where F = audio_frames_per_video_frame. + Otherwise (1, N, 1, K) is returned in the case of audio_frames_per_video_frame = 1. + + The final audio and video tensors are returned. + Args: + video_path: Path to the video file. + num_frames: Number of video frames to read. + audio_frames_per_video_frame: Number of audio frames per video frame. + audio_frame_padding: Padding for audio frames. + target_sr: Target sample rate for the audio. + target_fps: Target frames per second for the video. + random_seed: Random seed for reproducibility (optional). + + Returns: + Tuple of (frame_wise_audio, full_padded_audio, video_frames) where video_frames is a numpy array. + """ + from moviepy import VideoFileClip + # Set random seed if provided + if random_seed is not None: + np.random.seed(random_seed) + # Load the video + video = VideoFileClip(video_path).with_fps(target_fps) + original_duration = video.duration + total_frames = video.n_frames#int(original_duration * target_fps) + + # Calculate effective padding needed based on audio segmentation + effective_padding = max(audio_frame_padding, (audio_frames_per_video_frame) // 2) + + # Make sure we have enough frames + if total_frames < num_frames + 2 * effective_padding: + raise ValueError(f"Video has only {total_frames} frames, but {num_frames + 2 * effective_padding} were requested (including effective padding)") + + # Adjust the range for start_idx to account for effective padding + min_start_idx = effective_padding + max_start_idx = total_frames - num_frames - effective_padding + + # Select a random start frame that allows for padding on both sides + start_idx = np.random.randint(min_start_idx, max_start_idx) if max_start_idx > min_start_idx else min_start_idx + end_idx = start_idx + num_frames + + # Convert to time + video_start_time = start_idx / target_fps + video_end_time = end_idx / target_fps + + # Extract video frames + main_clip : VideoFileClip = video.subclipped(video_start_time, video_end_time) + # Replace the video frame extraction with: + frame_count = 0 + video_frames = [] + for frame in video.iter_frames(fps=target_fps, dtype='uint8'): + if frame_count >= start_idx and frame_count < start_idx + num_frames: + video_frames.append(frame) + frame_count += 1 + if len(video_frames) == num_frames: + break + + # Convert to numpy array + video_frames = np.array(video_frames) + + audio_start_time = (start_idx - effective_padding) / target_fps + audio_end_time = (end_idx + effective_padding) / target_fps + num_audio_frames = num_frames + 2 * effective_padding + audio_duration = audio_end_time - audio_start_time + # Ensure we don't go out of bounds + if audio_start_time < 0 or audio_end_time > original_duration: + raise ValueError(f"Audio start time {audio_start_time} or end time {audio_end_time} is out of bounds for video duration {original_duration}") + + # Extract the subclip + clip : VideoFileClip = video.subclipped(audio_start_time, audio_end_time) + # Extract audio + audio = clip.audio.with_fps(target_sr) + audio_data = audio.to_soundarray() + # Make sure len(audio_data) == (num_frames + 2 * effective_padding) * target_sr + num_audio_samples_required = int(round(audio_duration * target_sr)) + if len(audio_data) < num_audio_samples_required: + raise ValueError(f"Audio data length {len(audio_data)} is less than required {num_audio_samples_required}") + audio_data = audio_data[:num_audio_samples_required] + # Convert to mono if stereo + if audio_data.ndim > 1 and audio_data.shape[1] > 1: + audio_data = np.mean(audio_data, axis=1) + + # Close the clips + clip.close() + main_clip.close() + video.close() + + # Reshape audio data + audio_data = np.array(audio_data) # This is just 1D + + # Calculate dimensions for audio + audio_data_per_frame = int(round(target_sr / target_fps)) + # print(f"Audio {audio_duration * target_sr}->{num_audio_samples_required} data len {audio_data.shape}, shape: {num_audio_frames}, {audio_data_per_frame}") + audio_data = audio_data.reshape(num_audio_frames, audio_data_per_frame) + + # Create frame-wise audio + if audio_frames_per_video_frame > 1: + raise NotImplementedError("Frame-wise audio extraction is not implemented yet.") + else: + # Extract the central part (for effective frames) and reshape to (1, N, 1, K) + start_idx = effective_padding + end_idx = start_idx + num_frames + central_audio = audio_data[start_idx:end_idx] + frame_wise_audio = central_audio.reshape(1, num_frames, 1, audio_data_per_frame) + + return frame_wise_audio, audio_data, video_frames + + +def read_av_random_clip_alt( + video_path: str, + num_frames: int = 16, + audio_frames_per_video_frame: int = 1, + audio_frame_padding: int = 0, + target_sr: int = 16000, + target_fps: float = 25.0, + random_seed: Optional[int] = None, +): + """ + Read a random clip of audio and video frames. + Works by first selecting a random appropriate start frame, then reading the specified number of frames (1, N, H, W, C). + It then selects the audio clip corresponding to the video frames + some extra padding frames on either side. This is + of shape (1, P + N + P, K) where P is the padding, N is the number of video frames, and K is the audio data shape per frame. + if audio_frames_per_video_frame > 1, It then also creates a tensor of shape (1, N, F, K) where F = audio_frames_per_video_frame. + Otherwise (1, N, 1, K) is returned in the case of audio_frames_per_video_frame = 1. + + The final audio and video tensors are returned. + Args: + video_path: Path to the video file. + num_frames: Number of video frames to read. + audio_frames_per_video_frame: Number of audio frames per video frame. + audio_frame_padding: Padding for audio frames. + target_sr: Target sample rate for the audio. + target_fps: Target frames per second for the video. + random_seed: Random seed for reproducibility (optional). + + Returns: + Tuple of (frame_wise_audio, full_padded_audio, video_frames) where video_frames is a numpy array. + """ + from moviepy import VideoFileClip, AudioFileClip + from video_reader import PyVideoReader + # Set random seed if provided + if random_seed is not None: + np.random.seed(random_seed) + # Load the video + vr = PyVideoReader(video_path) + info = vr.get_info() + total_frames = int(info['frame_count']) + + # Calculate effective padding needed based on audio segmentation + effective_padding = max(audio_frame_padding, (audio_frames_per_video_frame) // 2) + + # Make sure we have enough frames + if total_frames < num_frames + 2 * effective_padding: + raise ValueError(f"Video has only {total_frames} frames, but {num_frames + 2 * effective_padding} were requested (including effective padding)") + + # Adjust the range for start_idx to account for effective padding + min_start_idx = effective_padding + max_start_idx = total_frames - num_frames - effective_padding + + # Select a random start frame that allows for padding on both sides + start_idx = np.random.randint(min_start_idx, max_start_idx) if max_start_idx > min_start_idx else min_start_idx + end_idx = start_idx + num_frames + + video_frames = vr.decode(start_idx, end_idx) + + audio_start_time = (start_idx - effective_padding) / target_fps + audio_end_time = (end_idx + effective_padding) / target_fps + num_audio_frames = num_frames + 2 * effective_padding + audio_duration = audio_end_time - audio_start_time + + assert audio_duration > 0, f"Audio duration {audio_duration} is not positive" + assert audio_start_time >= 0, f"Audio start time {audio_start_time} is negative" + + # Extract the subclip + audio_clip : AudioFileClip = VideoFileClip(video_path).audio.with_fps(target_sr).subclipped(audio_start_time, audio_end_time) + audio_data = audio_clip.to_soundarray() + # Make sure len(audio_data) == (num_frames + 2 * effective_padding) * target_sr + num_audio_samples_required = int(round(audio_duration * target_sr)) + + if len(audio_data) < num_audio_samples_required: + raise ValueError(f"Audio data length {len(audio_data)} is less than required {num_audio_samples_required}") + + audio_data = audio_data[:num_audio_samples_required] + # Convert to mono if stereo + if audio_data.ndim > 1 and audio_data.shape[1] > 1: + audio_data = np.mean(audio_data, axis=1) + + # Close the clips + audio_clip.close() + + # Reshape audio data + audio_data = np.array(audio_data) # This is just 1D + + # Calculate dimensions for audio + audio_data_per_frame = int(round(target_sr / target_fps)) + # print(f"Audio {audio_duration * target_sr}->{num_audio_samples_required} data len {audio_data.shape}, shape: {num_audio_frames}, {audio_data_per_frame}") + audio_data = audio_data.reshape(num_audio_frames, audio_data_per_frame) + + # Create frame-wise audio + if audio_frames_per_video_frame > 1: + raise NotImplementedError("Frame-wise audio extraction is not implemented yet.") + else: + # Extract the central part (for effective frames) and reshape to (1, N, 1, K) + start_idx = effective_padding + end_idx = start_idx + num_frames + central_audio = audio_data[start_idx:end_idx] + frame_wise_audio = central_audio.reshape(1, num_frames, 1, audio_data_per_frame) + + return frame_wise_audio, audio_data, video_frames + +def read_av_random_clip_pyav( + video_path: str, + num_frames: int = 16, + audio_frames_per_video_frame: int = 1, + audio_frame_padding: int = 0, + target_sr: int = 16000, + target_fps: float = 25.0, + random_seed: Optional[int] = None, +) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Decodes a random video clip and its corresponding audio from `video_path`, + padding audio by `audio_frame_padding` on each side in terms of video frames. + Uses PyAV's built-in resampler to produce mono 16-bit audio at `target_sr`. + + Returns: + (frame_wise_audio, full_padded_audio, video_frames) + * frame_wise_audio: (1, num_frames, 1, audio_data_per_frame) + * full_padded_audio: (num_frames + 2*padding, audio_data_per_frame) + * video_frames: (num_frames, H, W, 3) + """ + from video_reader import PyVideoReader + import av + + if random_seed is not None: + np.random.seed(random_seed) + + # --- 1) Determine which video frames to read --- + vr = PyVideoReader(video_path) + total_frames = int(vr.get_info()["frame_count"]) + eff_pad = max(audio_frame_padding, audio_frames_per_video_frame // 2) + needed_frames = num_frames + 2 * eff_pad + if total_frames < needed_frames: + raise ValueError( + f"Video has only {total_frames} frames but needs {needed_frames} (with padding)." + ) + + min_start = eff_pad + max_start = total_frames - num_frames - eff_pad + start_idx = ( + np.random.randint(min_start, max_start) + if max_start > min_start + else min_start + ) + end_idx = start_idx + num_frames + + # --- 2) Decode the chosen video frames --- + video_frames = vr.decode(start_idx, end_idx) # shape => (num_frames, H, W, 3) + del vr + + # --- 3) Define audio time window --- + audio_start_time = max(0.0, (start_idx - eff_pad) / target_fps) + audio_end_time = (end_idx + eff_pad) / target_fps + with av.open(video_path) as container: + audio_stream = next((s for s in container.streams if s.type == "audio"), None) + if audio_stream is None: + raise ValueError("No audio stream found in the file.") + + # --- 4) Decode all audio, resample to s16 mono @ target_sr --- + resampler = av.AudioResampler(format="s16", layout="mono", rate=target_sr) + audio_segments = [] + segment_times = [] + for packet in container.demux(audio_stream): + for frame in packet.decode(): + if frame.pts is None: + continue + out = resampler.resample(frame) + out = [out] if not isinstance(out, list) else out + for oframe in out: + # Extract samples from the PyAV audio frame + arr = oframe.to_ndarray() # shape: (1, samples) for mono + samples = arr.flatten().astype(np.int16) + start_t = float(oframe.pts * audio_stream.time_base) + end_t = start_t + oframe.samples / oframe.sample_rate + audio_segments.append(samples) + segment_times.append((start_t, end_t)) + + del resampler + + if not audio_segments: + raise ValueError("No audio frames were decoded.") + + full_audio = np.concatenate(audio_segments, axis=0) + seg_lens = [len(seg) for seg in audio_segments] + offsets = np.cumsum([0] + seg_lens) + + # Helper: convert time -> sample index in full_audio + def time_to_sample(t): + if t <= segment_times[0][0]: + return 0 + if t >= segment_times[-1][1]: + return len(full_audio) + for i, (st, ed) in enumerate(segment_times): + if st <= t < ed: + seg_offset = int(round((t - st) * audio_stream.rate)) + return offsets[i] + min(seg_offset, seg_lens[i] - 1) + return len(full_audio) + + start_sample = time_to_sample(audio_start_time) + end_sample = time_to_sample(audio_end_time) + if end_sample <= start_sample: + raise ValueError("No audio in the requested range.") + + # Slice out the desired portion + sliced_audio = full_audio[start_sample:end_sample] + + # --- 5) Convert to float32 in [-1,1], pad or trim to the exact length --- + # Overall expected sample count for the window + needed_samples_window = int(round((audio_end_time - audio_start_time) * target_sr)) + if len(sliced_audio) < needed_samples_window: + pad = needed_samples_window - len(sliced_audio) + sliced_audio = np.pad(sliced_audio, (0, pad), "constant") + else: + sliced_audio = sliced_audio[:needed_samples_window] + # Convert to float in [-1, 1] + sliced_audio = sliced_audio.astype(np.float32) / 32768.0 + + # We ultimately need (num_frames + 2*pad) * audio_data_per_frame + num_audio_frames = num_frames + 2 * eff_pad + audio_data_per_frame = int(round(target_sr / target_fps)) + needed_total_samples = num_audio_frames * audio_data_per_frame + + # Final pad/trim to expected shape + if len(sliced_audio) < needed_total_samples: + pad = needed_total_samples - len(sliced_audio) + sliced_audio = np.pad(sliced_audio, (0, pad), "constant") + else: + sliced_audio = sliced_audio[:needed_total_samples] + + full_padded_audio = sliced_audio.reshape(num_audio_frames, audio_data_per_frame) + + # --- 6) Extract the clip's central audio & reshape for per-frame usage --- + if audio_frames_per_video_frame > 1: + raise NotImplementedError("Multiple audio frames per video frame not supported.") + center = full_padded_audio[eff_pad:eff_pad + num_frames] + frame_wise_audio = center.reshape(1, num_frames, 1, audio_data_per_frame) + + return frame_wise_audio, full_padded_audio, video_frames + +# Create a registry of all random clip readers for easier function selection +CLIP_READERS = { + 'moviepy': read_av_random_clip_moviepy, + 'alt': read_av_random_clip_alt, + 'pyav': read_av_random_clip_pyav +} + +def read_av_random_clip( + path: str, + num_frames: int = 16, + audio_frames_per_video_frame: int = 1, + audio_frame_padding: int = 0, + target_sr: int = 16000, + target_fps: float = 25.0, + random_seed: Optional[int] = None, + method: str = 'alt' +) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: + """ + Read a random clip of audio and video frames using specified method. + Args: + path (str): Path to the media file. + num_frames (int): Number of video frames to read. + audio_frames_per_video_frame (int): Number of audio frames per video frame. + audio_frame_padding (int): Padding for audio frames. + target_sr (int): Target sample rate for audio. + target_fps (float): Target frames per second for video. + random_seed (Optional[int]): Seed for random number generator. + method (str): Method to use for reading the clip. + Options: 'moviepy', 'alt', 'pyav'. + Returns: + Tuple[np.ndarray, np.ndarray, np.ndarray]: Tuple of (frame_wise_audio, full_padded_audio, video_frames). + - frame_wise_audio: Shape (1, num_frames, 1, audio_data_per_frame) + - full_padded_audio: Shape (num_frames + 2*padding, audio_data_per_frame) + - video_frames: Shape (num_frames, H, W, 3) + """ + + if method not in CLIP_READERS: + raise ValueError(f"Unknown method: {method}. Available methods: {list(CLIP_READERS.keys())}") + + return CLIP_READERS[method]( + path, + num_frames=num_frames, + audio_frames_per_video_frame=audio_frames_per_video_frame, + audio_frame_padding=audio_frame_padding, + target_sr=target_sr, + target_fps=target_fps, + random_seed=random_seed + ) \ No newline at end of file diff --git a/flaxdiff/data/sources/base.py b/flaxdiff/data/sources/base.py new file mode 100644 index 0000000..e18ddfc --- /dev/null +++ b/flaxdiff/data/sources/base.py @@ -0,0 +1,129 @@ +from abc import ABC, abstractmethod +import grain.python as pygrain +from typing import Dict, Any, Callable, List, Optional +import jax.numpy as jnp +from functools import partial + + +class DataSource(ABC): + """Base class for all data sources in FlaxDiff.""" + + @abstractmethod + def get_source(self, path_override: str) -> Any: + """Return the data source object. + + Args: + path_override: Path to the dataset, overriding the default. + + Returns: + A data source object compatible with grain or other loaders. + """ + pass + + @staticmethod + def create(source_type: str, **kwargs) -> 'DataSource': + """Factory method to create a data source of the specified type. + + Args: + source_type: Type of the data source ("image", "video", etc.) + **kwargs: Additional arguments for the specific data source. + + Returns: + An instance of a DataSource subclass. + """ + from .images import ImageTFDSSource, ImageGCSSource, CombinedImageGCSSource + from .videos import VideoTFDSSource, VideoLocalSource + + source_map = { + "image_tfds": ImageTFDSSource, + "image_gcs": ImageGCSSource, + "image_combined_gcs": CombinedImageGCSSource, + "video_tfds": VideoTFDSSource, + "video_local": VideoLocalSource + } + + if source_type not in source_map: + raise ValueError(f"Unknown source type: {source_type}") + return source_map[source_type](**kwargs) + + +class DataAugmenter(ABC): + """Base class for all data augmenters in FlaxDiff.""" + + @abstractmethod + def create_transform(self, **kwargs) -> Callable[[], pygrain.MapTransform]: + """Create a transformation function for the data. + + Args: + **kwargs: Additional arguments for the transformation. + + Returns: + A callable that returns a pygrain.MapTransform instance. + """ + pass + + @staticmethod + def create(augmenter_type: str, **kwargs) -> 'DataAugmenter': + """Factory method to create a data augmenter of the specified type. + + Args: + augmenter_type: Type of the data augmenter ("image", "video", etc.) + **kwargs: Additional arguments for the specific augmenter. + + Returns: + An instance of a DataAugmenter subclass. + """ + from .images import ImageTFDSAugmenter, ImageGCSAugmenter + from .videos import VideoAugmenter + + augmenter_map = { + "image_tfds": ImageTFDSAugmenter, + "image_gcs": ImageGCSAugmenter, + "video": VideoAugmenter + } + + if augmenter_type not in augmenter_map: + raise ValueError(f"Unknown augmenter type: {augmenter_type}") + + return augmenter_map[augmenter_type](**kwargs) + + +class MediaDataset: + """A class combining a data source and an augmenter for a complete dataset.""" + + def __init__(self, + source: DataSource, + augmenter: DataAugmenter, + media_type: str = "image"): + """Initialize a MediaDataset. + + Args: + source: The data source. + augmenter: The data augmenter. + media_type: Type of media ("image", "video", etc.) + """ + self.source = source + self.augmenter = augmenter + self.media_type = media_type + + def get_source(self, path_override: str) -> Any: + """Get the data source. + + Args: + path_override: Path to override the default data source path. + + Returns: + A data source object. + """ + return self.source.get_source(path_override) + + def get_augmenter(self, **kwargs) -> Callable[[], pygrain.MapTransform]: + """Get the augmenter transformation. + + Args: + **kwargs: Additional arguments for the augmenter. + + Returns: + A callable that returns a pygrain.MapTransform instance. + """ + return self.augmenter.create_transform(**kwargs) \ No newline at end of file diff --git a/flaxdiff/data/sources/gcs.py b/flaxdiff/data/sources/gcs.py deleted file mode 100644 index 12ce17a..0000000 --- a/flaxdiff/data/sources/gcs.py +++ /dev/null @@ -1,81 +0,0 @@ -import cv2 -import jax.numpy as jnp -import grain.python as pygrain -from flaxdiff.utils import AutoTextTokenizer -from typing import Dict -import os -import struct as st -from functools import partial -import numpy as np - -# -----------------------------------------------------------------------------------------------# -# CC12m and other GCS data sources --------------------------------------------------------------# -# -----------------------------------------------------------------------------------------------# - -def data_source_gcs(source='arrayrecord/laion-aesthetics-12m+mscoco-2017'): - def data_source(base="/home/mrwhite0racle/gcs_mount"): - records_path = os.path.join(base, source) - records = [os.path.join(records_path, i) for i in os.listdir( - records_path) if 'array_record' in i] - ds = pygrain.ArrayRecordDataSource(records) - return ds - return data_source - -def data_source_combined_gcs( - sources=[]): - def data_source(base="/home/mrwhite0racle/gcs_mount"): - records_paths = [os.path.join(base, source) for source in sources] - records = [] - for records_path in records_paths: - records += [os.path.join(records_path, i) for i in os.listdir( - records_path) if 'array_record' in i] - ds = pygrain.ArrayRecordDataSource(records) - return ds - return data_source - -def unpack_dict_of_byte_arrays(packed_data): - unpacked_dict = {} - offset = 0 - while offset < len(packed_data): - # Unpack the key length - key_length = st.unpack_from('I', packed_data, offset)[0] - offset += st.calcsize('I') - # Unpack the key bytes and convert to string - key = packed_data[offset:offset+key_length].decode('utf-8') - offset += key_length - # Unpack the byte array length - byte_array_length = st.unpack_from('I', packed_data, offset)[0] - offset += st.calcsize('I') - # Unpack the byte array - byte_array = packed_data[offset:offset+byte_array_length] - offset += byte_array_length - unpacked_dict[key] = byte_array - return unpacked_dict - -def image_augmenter(image, image_scale, method=cv2.INTER_AREA): - image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) - image = cv2.resize(image, (image_scale, image_scale), - interpolation=cv2.INTER_AREA) - return image - -def gcs_augmenters(image_scale, method): - labelizer = lambda sample : sample['txt'] - class augmenters(pygrain.MapTransform): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.auto_tokenize = AutoTextTokenizer(tensor_type="np") - self.image_augmenter = partial(image_augmenter, image_scale=image_scale, method=method) - - def map(self, element) -> Dict[str, jnp.array]: - element = unpack_dict_of_byte_arrays(element) - image = np.asarray(bytearray(element['jpg']), dtype="uint8") - image = cv2.imdecode(image, cv2.IMREAD_UNCHANGED) - image = self.image_augmenter(image) - caption = labelizer(element).decode('utf-8') - results = self.auto_tokenize(caption) - return { - "image": image, - "input_ids": results['input_ids'][0], - "attention_mask": results['attention_mask'][0], - } - return augmenters diff --git a/flaxdiff/data/sources/images.py b/flaxdiff/data/sources/images.py new file mode 100644 index 0000000..8679d88 --- /dev/null +++ b/flaxdiff/data/sources/images.py @@ -0,0 +1,309 @@ +import cv2 +import jax.numpy as jnp +import grain.python as pygrain +from flaxdiff.utils import AutoTextTokenizer +from typing import Dict, Any, Callable, List, Optional +import random +import augmax +import jax +import os +import struct as st +from functools import partial +import numpy as np +from .base import DataSource, DataAugmenter + + +# ---------------------------------------------------------------------------------- +# Utility functions +# ---------------------------------------------------------------------------------- + +def unpack_dict_of_byte_arrays(packed_data): + """Unpacks a dictionary of byte arrays from a packed binary format.""" + unpacked_dict = {} + offset = 0 + while offset < len(packed_data): + # Unpack the key length + key_length = st.unpack_from('I', packed_data, offset)[0] + offset += st.calcsize('I') + # Unpack the key bytes and convert to string + key = packed_data[offset:offset+key_length].decode('utf-8') + offset += key_length + # Unpack the byte array length + byte_array_length = st.unpack_from('I', packed_data, offset)[0] + offset += st.calcsize('I') + # Unpack the byte array + byte_array = packed_data[offset:offset+byte_array_length] + offset += byte_array_length + unpacked_dict[key] = byte_array + return unpacked_dict + + +# ---------------------------------------------------------------------------------- +# Image augmentation utilities +# ---------------------------------------------------------------------------------- + +def image_augmenter(image, image_scale, method=cv2.INTER_AREA): + """Basic image augmentation: convert color and resize.""" + image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + image = cv2.resize(image, (image_scale, image_scale), + interpolation=method) + return image + + +PROMPT_TEMPLATES = [ + "a photo of a {}", + "a photo of a {} flower", + "This is a photo of a {}", + "This is a photo of a {} flower", + "A photo of a {} flower", +] + + +def labelizer_oxford_flowers102(path): + """Creates a label generator for Oxford Flowers 102 dataset.""" + with open(path, "r") as f: + textlabels = [i.strip() for i in f.readlines()] + + def load_labels(sample): + raw = textlabels[int(sample['label'])] + # randomly select a prompt template + template = random.choice(PROMPT_TEMPLATES) + # format the template with the label + caption = template.format(raw) + # return the caption + return caption + return load_labels + + +# ---------------------------------------------------------------------------------- +# TFDS Image Source +# ---------------------------------------------------------------------------------- + +class ImageTFDSSource(DataSource): + """Data source for TensorFlow Datasets (TFDS) image datasets.""" + + def __init__(self, name: str, use_tf: bool = True, split: str = "all"): + """Initialize a TFDS image data source. + + Args: + name: Name of the TFDS dataset. + use_tf: Whether to use TensorFlow for loading. + split: Dataset split to use. + """ + self.name = name + self.use_tf = use_tf + self.split = split + + def get_source(self, path_override: str) -> Any: + """Get the TFDS data source. + + Args: + path_override: Override path for the dataset. + + Returns: + A TFDS dataset. + """ + import tensorflow_datasets as tfds + if self.use_tf: + return tfds.load(self.name, split=self.split, shuffle_files=True) + else: + return tfds.data_source(self.name, split=self.split, try_gcs=False) + + +class ImageTFDSAugmenter(DataAugmenter): + """Augmenter for TFDS image datasets.""" + + def __init__(self, label_path: str = "/home/mrwhite0racle/tensorflow_datasets/oxford_flowers102/2.1.1/label.labels.txt"): + """Initialize a TFDS image augmenter. + + Args: + label_path: Path to the labels file for datasets like Oxford Flowers. + """ + self.label_path = label_path + + def create_transform(self, image_scale: int = 256, method: Any = None) -> Callable[[], pygrain.MapTransform]: + """Create a transform for TFDS image datasets. + + Args: + image_scale: Size to scale images to. + method: Interpolation method for resizing. + + Returns: + A callable that returns a pygrain.MapTransform. + """ + labelizer = labelizer_oxford_flowers102(self.label_path) + + if image_scale > 256: + interpolation = cv2.INTER_CUBIC + else: + interpolation = cv2.INTER_AREA + + from torchvision.transforms import v2 + augments = v2.Compose([ + v2.RandomHorizontalFlip(p=0.5), + v2.ColorJitter(brightness=0.2, contrast=0.05, saturation=0.2) + ]) + + class TFDSTransform(pygrain.MapTransform): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.tokenize = AutoTextTokenizer(tensor_type="np") + + def map(self, element) -> Dict[str, jnp.array]: + image = element['image'] + image = cv2.resize(image, (image_scale, image_scale), + interpolation=interpolation) + image = augments(image) + + caption = labelizer(element) + results = self.tokenize(caption) + return { + "image": image, + "text": { + "input_ids": results['input_ids'][0], + "attention_mask": results['attention_mask'][0], + } + } + + return TFDSTransform + + +# ---------------------------------------------------------------------------------- +# GCS Image Source +# ---------------------------------------------------------------------------------- + +class ImageGCSSource(DataSource): + """Data source for Google Cloud Storage (GCS) image datasets.""" + + def __init__(self, source: str = 'arrayrecord/laion-aesthetics-12m+mscoco-2017'): + """Initialize a GCS image data source. + + Args: + source: Path to the GCS dataset. + """ + self.source = source + + def get_source(self, path_override: str = "/home/mrwhite0racle/gcs_mount") -> Any: + """Get the GCS data source. + + Args: + path_override: Base path for GCS mounts. + + Returns: + A grain ArrayRecordDataSource. + """ + records_path = os.path.join(path_override, self.source) + records = [os.path.join(records_path, i) for i in os.listdir( + records_path) if 'array_record' in i] + return pygrain.ArrayRecordDataSource(records) + + +class CombinedImageGCSSource(DataSource): + """Data source that combines multiple GCS image datasets.""" + + def __init__(self, sources: List[str] = []): + """Initialize a combined GCS image data source. + + Args: + sources: List of paths to GCS datasets. + """ + self.sources = sources + + def get_source(self, path_override: str = "/home/mrwhite0racle/gcs_mount") -> Any: + """Get the combined GCS data source. + + Args: + path_override: Base path for GCS mounts. + + Returns: + A grain ArrayRecordDataSource. + """ + records_paths = [os.path.join(path_override, source) for source in self.sources] + records = [] + for records_path in records_paths: + records += [os.path.join(records_path, i) for i in os.listdir( + records_path) if 'array_record' in i] + return pygrain.ArrayRecordDataSource(records) + + +class ImageGCSAugmenter(DataAugmenter): + """Augmenter for GCS image datasets.""" + + def __init__(self, labelizer: Callable = None): + """Initialize a GCS image augmenter. + + Args: + labelizer: Function to extract text labels from samples. + """ + self.labelizer = labelizer or (lambda sample: sample['txt']) + + def create_transform(self, image_scale: int = 256, method: Any = None) -> Callable[[], pygrain.MapTransform]: + """Create a transform for GCS image datasets. + + Args: + image_scale: Size to scale images to. + method: Interpolation method for resizing. + + Returns: + A callable that returns a pygrain.MapTransform. + """ + labelizer = self.labelizer + + class GCSTransform(pygrain.MapTransform): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.auto_tokenize = AutoTextTokenizer(tensor_type="np") + self.image_augmenter = partial(image_augmenter, image_scale=image_scale, method=method) + + def map(self, element) -> Dict[str, jnp.array]: + element = unpack_dict_of_byte_arrays(element) + image = np.asarray(bytearray(element['jpg']), dtype="uint8") + image = cv2.imdecode(image, cv2.IMREAD_UNCHANGED) + image = self.image_augmenter(image) + caption = labelizer(element).decode('utf-8') + results = self.auto_tokenize(caption) + return { + "image": image, + "text": { + "input_ids": results['input_ids'][0], + "attention_mask": results['attention_mask'][0], + } + } + + return GCSTransform + + +# ---------------------------------------------------------------------------------- +# Legacy compatibility functions +# ---------------------------------------------------------------------------------- + +# These functions maintain backward compatibility with existing code + +def data_source_tfds(name, use_tf=True, split="all"): + """Legacy function for TFDS data sources.""" + source = ImageTFDSSource(name=name, use_tf=use_tf, split=split) + return source.get_source + + +def tfds_augmenters(image_scale, method): + """Legacy function for TFDS augmenters.""" + augmenter = ImageTFDSAugmenter() + return augmenter.create_transform(image_scale=image_scale, method=method) + + +def data_source_gcs(source='arrayrecord/laion-aesthetics-12m+mscoco-2017'): + """Legacy function for GCS data sources.""" + source_obj = ImageGCSSource(source=source) + return source_obj.get_source + + +def data_source_combined_gcs(sources=[]): + """Legacy function for combined GCS data sources.""" + source_obj = CombinedImageGCSSource(sources=sources) + return source_obj.get_source + + +def gcs_augmenters(image_scale, method): + """Legacy function for GCS augmenters.""" + augmenter = ImageGCSAugmenter() + return augmenter.create_transform(image_scale=image_scale, method=method) diff --git a/flaxdiff/data/sources/tfds.py b/flaxdiff/data/sources/tfds.py deleted file mode 100644 index f29e75e..0000000 --- a/flaxdiff/data/sources/tfds.py +++ /dev/null @@ -1,79 +0,0 @@ -import cv2 -import jax.numpy as jnp -import grain.python as pygrain -from flaxdiff.utils import AutoTextTokenizer -from typing import Dict -import random -import augmax -import jax - -# -----------------------------------------------------------------------------------------------# -# Oxford flowers and other TFDS datasources -----------------------------------------------------# -# -----------------------------------------------------------------------------------------------# - -PROMPT_TEMPLATES = [ - "a photo of a {}", - "a photo of a {} flower", - "This is a photo of a {}", - "This is a photo of a {} flower", - "A photo of a {} flower", -] - -def data_source_tfds(name, use_tf=True, split="all"): - import tensorflow_datasets as tfds - if use_tf: - def data_source(path_override): - return tfds.load(name, split=split, shuffle_files=True) - else: - def data_source(path_override): - return tfds.data_source(name, split=split, try_gcs=False) - return data_source - -def labelizer_oxford_flowers102(path): - with open(path, "r") as f: - textlabels = [i.strip() for i in f.readlines()] - - def load_labels(sample): - raw = textlabels[int(sample['label'])] - # randomly select a prompt template - template = random.choice(PROMPT_TEMPLATES) - # format the template with the label - caption = template.format(raw) - # return the caption - return caption - return load_labels - -def tfds_augmenters(image_scale, method): - labelizer = labelizer_oxford_flowers102("/home/mrwhite0racle/tensorflow_datasets/oxford_flowers102/2.1.1/label.labels.txt") - if image_scale > 256: - interpolation = cv2.INTER_CUBIC - else: - interpolation = cv2.INTER_AREA - - from torchvision.transforms import v2 - - augments = v2.Compose([ - v2.RandomHorizontalFlip(p=0.5), - v2.ColorJitter(brightness=0.2, contrast=0.05, saturation=0.2) - ]) - - class augmenters(pygrain.MapTransform): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - self.tokenize = AutoTextTokenizer(tensor_type="np") - - def map(self, element) -> Dict[str, jnp.array]: - image = element['image'] - image = cv2.resize(image, (image_scale, image_scale), - interpolation=interpolation) - image = augments(image) - # image = (image - 127.5) / 127.5 - - caption = labelizer(element) - results = self.tokenize(caption) - return { - "image": image, - "input_ids": results['input_ids'][0], - "attention_mask": results['attention_mask'][0], - } - return augmenters \ No newline at end of file diff --git a/flaxdiff/data/sources/utils.py b/flaxdiff/data/sources/utils.py new file mode 100644 index 0000000..8ab7b3c --- /dev/null +++ b/flaxdiff/data/sources/utils.py @@ -0,0 +1,158 @@ + +import numpy as np +from decord.video_reader import VideoReader +from decord.audio_reader import AudioReader + +from decord.ndarray import cpu +from decord import ndarray as _nd +from decord.bridge import bridge_out + +class AVReader(object): + """Individual audio video reader with convenient indexing function. + + Parameters + ---------- + uri: str + Path of file. + ctx: decord.Context + The context to decode the file, can be decord.cpu() or decord.gpu(). + sample_rate: int, default is -1 + Desired output sample rate of the audio, unchanged if `-1` is specified. + mono: bool, default is True + Desired output channel layout of the audio. `True` is mono layout. `False` is unchanged. + width : int, default is -1 + Desired output width of the video, unchanged if `-1` is specified. + height : int, default is -1 + Desired output height of the video, unchanged if `-1` is specified. + num_threads : int, default is 0 + Number of decoding thread, auto if `0` is specified. + fault_tol : int, default is -1 + The threshold of corupted and recovered frames. This is to prevent silent fault + tolerance when for example 50% frames of a video cannot be decoded and duplicate + frames are returned. You may find the fault tolerant feature sweet in many cases, + but not for training models. Say `N = # recovered frames` + If `fault_tol` < 0, nothing will happen. + If 0 < `fault_tol` < 1.0, if N > `fault_tol * len(video)`, raise `DECORDLimitReachedError`. + If 1 < `fault_tol`, if N > `fault_tol`, raise `DECORDLimitReachedError`. + """ + + def __init__( + self, uri, ctx=cpu(0), sample_rate=-1, mono=True, width=-1, height=-1, num_threads=0, fault_tol=-1 + ): + self.__audio_reader = AudioReader(uri, ctx, sample_rate, mono) + self.__audio_reader.add_padding() + if hasattr(uri, "read"): + uri.seek(0) + self.__video_reader = VideoReader(uri, ctx, width, height, num_threads, fault_tol) + self.__video_reader.seek(0) + + def __del__(self): + del self.__video_reader + del self.__audio_reader + + def __len__(self): + """Get length of the video. Note that sometimes FFMPEG reports inaccurate number of frames, + we always follow what FFMPEG reports. + Returns + ------- + int + The number of frames in the video file. + """ + return len(self.__video_reader) + + def __getitem__(self, idx): + """Get audio samples and video frame at `idx`. + + Parameters + ---------- + idx : int or slice + The frame index, can be negative which means it will index backwards, + or slice of frame indices. + + Returns + ------- + (ndarray/list of ndarray, ndarray) + First element is samples of shape CxS or a list of length N containing samples of shape CxS, + where N is the number of frames, C is the number of channels, + S is the number of samples of the corresponding frame. + + Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3, + where N is the length of the slice. + """ + assert self.__video_reader is not None and self.__audio_reader is not None + if isinstance(idx, slice): + return self.get_batch(range(*idx.indices(len(self.__video_reader)))) + if idx < 0: + idx += len(self.__video_reader) + if idx >= len(self.__video_reader) or idx < 0: + raise IndexError("Index: {} out of bound: {}".format(idx, len(self.__video_reader))) + audio_start_idx, audio_end_idx = self.__video_reader.get_frame_timestamp(idx) + audio_start_idx = self.__audio_reader._time_to_sample(audio_start_idx) + audio_end_idx = self.__audio_reader._time_to_sample(audio_end_idx) + results = (self.__audio_reader[audio_start_idx:audio_end_idx], self.__video_reader[idx]) + self.__video_reader.seek(0) + return results + + def get_batch(self, indices): + """Get entire batch of audio samples and video frames. + + Parameters + ---------- + indices : list of integers + A list of frame indices. If negative indices detected, the indices will be indexed from backward + Returns + ------- + (list of ndarray, ndarray) + First element is a list of length N containing samples of shape CxS, + where N is the number of frames, C is the number of channels, + S is the number of samples of the corresponding frame. + + Second element is Frame of shape HxWx3 or batch of image frames with shape NxHxWx3, + where N is the length of the slice. + + """ + assert self.__video_reader is not None and self.__audio_reader is not None + indices = self._validate_indices(indices) + audio_arr = [] + prev_video_idx = None + prev_audio_end_idx = None + for idx in list(indices): + frame_start_time, frame_end_time = self.__video_reader.get_frame_timestamp(idx) + # timestamp and sample conversion could have some error that could cause non-continuous audio + # we detect if retrieving continuous frame and make the audio continuous + if prev_video_idx and idx == prev_video_idx + 1: + audio_start_idx = prev_audio_end_idx + else: + audio_start_idx = self.__audio_reader._time_to_sample(frame_start_time) + audio_end_idx = self.__audio_reader._time_to_sample(frame_end_time) + audio_arr.append(self.__audio_reader[audio_start_idx:audio_end_idx]) + prev_video_idx = idx + prev_audio_end_idx = audio_end_idx + results = (audio_arr, self.__video_reader.get_batch(indices)) + self.__video_reader.seek(0) + return results + + def _get_slice(self, sl): + audio_arr = np.empty(shape=(self.__audio_reader.shape()[0], 0), dtype="float32") + for idx in list(sl): + audio_start_idx, audio_end_idx = self.__video_reader.get_frame_timestamp(idx) + audio_start_idx = self.__audio_reader._time_to_sample(audio_start_idx) + audio_end_idx = self.__audio_reader._time_to_sample(audio_end_idx) + audio_arr = np.concatenate( + (audio_arr, self.__audio_reader[audio_start_idx:audio_end_idx].asnumpy()), axis=1 + ) + results = (bridge_out(_nd.array(audio_arr)), self.__video_reader.get_batch(sl)) + self.__video_reader.seek(0) + return results + + def _validate_indices(self, indices): + """Validate int64 integers and convert negative integers to positive by backward search""" + assert self.__video_reader is not None and self.__audio_reader is not None + indices = np.array(indices, dtype=np.int64) + # process negative indices + indices[indices < 0] += len(self.__video_reader) + if not (indices >= 0).all(): + raise IndexError("Invalid negative indices: {}".format(indices[indices < 0] + len(self.__video_reader))) + if not (indices < len(self.__video_reader)).all(): + raise IndexError("Out of bound indices: {}".format(indices[indices >= len(self.__video_reader)])) + return indices \ No newline at end of file diff --git a/flaxdiff/data/sources/videos.py b/flaxdiff/data/sources/videos.py new file mode 100644 index 0000000..9c51c25 --- /dev/null +++ b/flaxdiff/data/sources/videos.py @@ -0,0 +1,250 @@ +import cv2 +import jax.numpy as jnp +import grain.python as pygrain +from flaxdiff.utils import AutoTextTokenizer +from typing import Dict, Any, Callable, List, Optional, Tuple +import random +import os +import numpy as np +from functools import partial +from .base import DataSource, DataAugmenter +import numpy as np +import subprocess +import shutil +from .av_utils import read_av_random_clip + +# ---------------------------------------------------------------------------------- +# Video augmentation utilities +# ---------------------------------------------------------------------------------- +def gather_video_paths_iter(input_dir, extensions=['.mp4', '.avi', '.mov', '.webm']): + # Ensure extensions have dots at the beginning and are lowercase + extensions = {ext.lower() if ext.startswith('.') else f'.{ext}'.lower() for ext in extensions} + + for root, _, files in os.walk(input_dir): + for file in sorted(files): + _, ext = os.path.splitext(file) + if ext.lower() in extensions: + video_input = os.path.join(root, file) + yield video_input + +def gather_video_paths(input_dir, extensions=['.mp4', '.avi', '.mov', '.webm']): + """Gather video paths from a directory.""" + video_paths = [] + for video_input in gather_video_paths_iter(input_dir, extensions): + video_paths.append(video_input) + + # Sort the video paths + video_paths.sort() + return video_paths + +# ---------------------------------------------------------------------------------- +# TFDS Video Source +# ---------------------------------------------------------------------------------- + +class VideoTFDSSource(DataSource): + """Data source for TensorFlow Datasets (TFDS) video datasets.""" + + def __init__(self, name: str, use_tf: bool = True, split: str = "train"): + """Initialize a TFDS video data source. + + Args: + name: Name of the TFDS dataset. + use_tf: Whether to use TensorFlow for loading. + split: Dataset split to use. + """ + self.name = name + self.use_tf = use_tf + self.split = split + + def get_source(self, path_override: str) -> Any: + """Get the TFDS video data source. + + Args: + path_override: Override path for the dataset. + + Returns: + A TFDS dataset. + """ + import tensorflow_datasets as tfds + if self.use_tf: + return tfds.load(self.name, split=self.split, shuffle_files=True) + else: + return tfds.data_source(self.name, split=self.split, try_gcs=False) + + +# ---------------------------------------------------------------------------------- +# Local Video Source +# ---------------------------------------------------------------------------------- + +class VideoLocalSource(DataSource): + """Data source for local video files.""" + + def __init__( + self, + directory: str = "", + extensions: List[str] = ['.mp4', '.avi', '.mov', '.webm'], + clear_cache: bool = False, + cache_dir: Optional[str] = './cache', + ): + """Initialize a local video data source. + + Args: + directory: Directory containing video files. + extensions: List of valid video file extensions. + clear_cache: Whether to clear the cache on initialization. + cache_dir: Directory to cache video paths. + """ + self.extensions = extensions + self.cache_dir = cache_dir + if directory: + self.load_paths(directory, clear_cache) + + def load_paths(self, directory: str, clear_cache: bool = False): + """Load video paths from a directory.""" + if self.directory == directory and not clear_cache: + # If the directory hasn't changed and cache is not cleared, return cached paths + return + self.directory = directory + + # Use gather_video_paths to get all video paths and cache them + # in a local dictionary for future use + + # Generate a hash for the directory to use as a key + self.directory_hash = hash(directory) + + # Check if the cache directory exists + if os.path.exists(self.cache_dir): + # Load cached video paths if available + cache_file = os.path.join(self.cache_dir, f"video_paths_{self.directory_hash}.txt") + import pickle + if os.path.exists(cache_file) and not clear_cache: + with open(cache_file, 'rb') as f: + video_paths = pickle.load(f) + print(f"Loaded cached video paths from {cache_file}") + else: + # If no cache file, gather video paths and save them + print(f"Cache file not found or clear_cache is True. Gathering video paths from {directory}") + video_paths = gather_video_paths(directory, self.extensions) + with open(cache_file, 'wb') as f: + pickle.dump(video_paths, f) + print(f"Cached video paths to {cache_file}") + + self.video_paths = video_paths + + def get_source(self, path_override: str = None) -> List[Dict[str, Any]]: + """Get the local video data source. + + Args: + path_override: Override directory path. + + Returns: + A list of dictionaries with video paths. + """ + if path_override: + self.load_paths(path_override) + + video_paths = self.video_paths + dataset = [] + for video_path in video_paths: + dataset.append({"video_path": video_path}) + return dataset + +# ---------------------------------------------------------------------------------- +# Video Augmenter +# ---------------------------------------------------------------------------------- + +class AudioVideoAugmenter(DataAugmenter): + """Augmenter for audio-video datasets.""" + + def __init__(self, + preprocess_fn: Callable = None): + """Initialize a AV augmenter. + + Args: + num_frames: Number of frames to sample from each video. + preprocess_fn: Optional function to preprocess video frames. + """ + self.preprocess_fn = preprocess_fn + + def create_transform( + self, + frame_size: int = 256, + sequence_length: int = 16, + audio_frame_padding: int = 3, + method: Any = cv2.INTER_AREA, + ) -> Callable[[], pygrain.MapTransform]: + """Create a transform for video datasets. + + Args: + frame_size: Size to scale video frames to. + sequence_length: Number of frames to sample from each video. + method: Interpolation method for resizing. + + Returns: + A callable that returns a pygrain.MapTransform. + """ + num_frames = sequence_length + + class AudioVideoTransform(pygrain.RandomMapTransform): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.tokenize = AutoAudioTokenizer(tensor_type="np") + + def random_map(self, element, rng: np.random.Generator) -> Dict[str, jnp.array]: + video_path = element["video_path"] + random_seed = rng.integers(0, 2**32 - 1) + # Read video frames + framewise_audio, full_audio, video_frames = read_av_random_clip( + video_path, + num_frames=num_frames, + audio_frame_padding=audio_frame_padding, + random_seed=random_seed, + ) + + # Process caption + results = self.tokenize(full_audio) + + return { + "video": video_frames, + "audio": { + "input_ids": results['input_ids'][0], + "attention_mask": results['attention_mask'][0], + "full_audio": full_audio, + "framewise_audio": framewise_audio, + } + } + + return AudioVideoTransform + + +# ---------------------------------------------------------------------------------- +# Helper functions for video datasets +# ---------------------------------------------------------------------------------- + +# def create_video_dataset_from_directory( +# directory: str, +# extensions: List[str] = ['.mp4', '.avi', '.mov', '.webm'], +# frame_size: int = 256, +# ) -> Tuple[List[Dict[str, Any]], AudioVideoAugmenter]: +# """Create a video dataset from a directory of video files. + +# Args: +# directory: Directory containing video files. +# extensions: List of valid video file extensions. +# frame_size: Size to scale video frames to. +# num_frames: Number of frames to sample from each video. + +# Returns: +# Tuple of (dataset, augmenter) for the video dataset. +# """ +# source = VideoLocalSource( +# directory=directory, +# extensions=extensions, +# ) + +# augmenter = AudioVideoAugmenter( +# num_frames=num_frames +# ) + +# dataset = source.get_source() +# return dataset, augmenter \ No newline at end of file diff --git a/flaxdiff/data/sources/voxceleb2.py b/flaxdiff/data/sources/voxceleb2.py new file mode 100644 index 0000000..c077237 --- /dev/null +++ b/flaxdiff/data/sources/voxceleb2.py @@ -0,0 +1,412 @@ +from logging import warn, warning +import os +import random +from arrow import get +import einops +import numpy as np +from os.path import join +from PIL import Image +import torch +from torch.utils.data import Dataset +from torchvision import transforms +from torchvision.transforms import functional as F +import decord +from decord import VideoReader, AudioReader, cpu +import traceback + +from d2lv2_lightning.config import DataConfig +from d2lv2_lightning.utils import dist_util +from .face_mask import FaceMaskGenerator +from .prompt_templates import TEMPLATE_MAP +from .utils import ImageProcessor +from .audio import crop_wav_window, melspectrogram, crop_mel_window, get_segmented_wavs, get_segmented_mels + +class Voxceleb2Decord(Dataset): + """ + A dataset module for video-to-video (audio guided) diffusion training. + This implementation uses decord to load videos and audio on the fly + """ + default_video_fps = 25 + default_mel_steps_per_sec = 80. + + def __init__( + self, + split, + data_config: DataConfig, # expects attributes like: data_root, filelists_path, nframes, syncnet_mel_step_size, image_size, face_hide_percentage, video_fps, etc. + tokenizer = None, + token_map: dict = None, + use_template: str = None, + audio_format: str = "mel", + h_flip: bool = True, + color_jitter: bool = False, + blur_amount: int = 70, + sample_rate: int = 16000, + shared_audio_dict=None, + val_ratio: float = 0.001, + num_val_ids: int = -1, + val_split_seed: int = 787, + dataset_name: str = "voxceleb2", + face_mask_type: str = "fixed", + ): + random.seed(dist_util.get_rank() + 1) + print(f"Dataset split: {split}, rank: {dist_util.get_rank() + 1}") + self.split = split + self.data_config = data_config + self.tokenizer = tokenizer + self.token_map = token_map + self.use_template = use_template + self.audio_format = audio_format + self.h_flip = h_flip + self.color_jitter = color_jitter + self.blur_amount = blur_amount + self.sample_rate = sample_rate + self.shared_audio_dict = shared_audio_dict if shared_audio_dict is not None else {} + self.val_ratio = val_ratio + self.num_val_ids = num_val_ids + self.val_split_seed = val_split_seed + self.dataset_name = dataset_name + self.face_mask_type = face_mask_type + + decord.bridge.set_bridge('torch') + + # Video properties (either from args or defaults) + self.video_fps = getattr(data_config, "video_fps", self.__class__.default_video_fps) + self.mel_steps_per_sec = self.__class__.default_mel_steps_per_sec + + # Set the data root based on the split. + if split in ["train", "trainfull"]: + self.data_root = os.path.join(data_config.data_root, "train") + else: + self.data_root = os.path.join(data_config.data_root, "test") + # self.data_root = data_config.data_root + + # Determine file list path + if hasattr(data_config, "filelists_path") and data_config.filelists_path is not None: + self.filelists_path = data_config.filelists_path + else: + self.filelists_path = os.path.join('./data/voxceleb2/', "filelists") + # Warn the user that the default filelists path is being used. + warning(f"Using default filelists path: {self.filelists_path}. Please set data_config.filelists_path to a custom path if needed.") + os.makedirs(self.filelists_path, exist_ok=True) + + filelist_file = join(self.filelists_path, f"{dataset_name}_{split}.txt") + if not os.path.exists(filelist_file): + warning(f"File list {filelist_file} not found. Creating a new file list. Please make sure to the data_root: {data_config.data_root} is correct for the split {split}.") + self.all_videos = self.create_filelist() + else: + self.all_videos = self.get_video_list(filelist_file) + print(f"Using file list: {filelist_file} with {len(self.all_videos)} videos.") + + # Image transforms (assumes 3-channel images) + size = data_config.resolution + self.size = size + self.image_transforms = ImageProcessor(size) + self.mask_transforms = ImageProcessor(size) + + if use_template is not None: + assert token_map is not None, "token_map must be provided if using a template." + self.templates = TEMPLATE_MAP[use_template] + + def worker_init_fn(self, worker_id): + self.worker_id = worker_id + if self.face_mask_type != "fixed": + # Initialize dynamic face mask generator. + self.mask_generator = FaceMaskGenerator( + video_mode=False, + mask_type=self.face_mask_type, + ) + + + def get_video_list(self, filelist_file): + videos = [] + with open(filelist_file, "r") as f: + for line in f: + line = line.strip() + if line: + # Each line is relative to data_root. + videos.append(os.path.join(self.data_root, line)) + return videos + + def create_filelist(self): + # Create a filelist by scanning the directory structure. + # (This example assumes VoxCeleb2 videos are stored under data_root/id/vid/utterance.mp4) + all_videos = [] + print("Creating filelist for dataset", self.dataset_name) + if self.dataset_name == 'voxceleb2': + for identity in os.listdir(self.data_root): + id_path = os.path.join(self.data_root, identity) + if not os.path.isdir(id_path): + continue + for vid in os.listdir(id_path): + vid_path = os.path.join(id_path, vid) + if not os.path.isdir(vid_path): + continue + for utt in os.listdir(vid_path): + if utt.endswith(".mp4") or utt.endswith(".avi"): + # Save relative path (so that data_root can be prepended) + all_videos.append(os.path.join(identity, vid, utt)) + else: + raise NotImplementedError("Filelist creation for this dataset is not implemented.") + print("Total videos found:", len(all_videos)) + # Write filelist to disk. + filelist_file = join(self.filelists_path, f"{self.dataset_name}_{self.split}.txt") + with open(filelist_file, "w") as f: + for v in all_videos: + f.write(v + "\n") + # Return full paths. + return [os.path.join(self.data_root, v) for v in all_videos] + + def get_masks(self, imgs, pad=0): + if hasattr(self, 'mask_generator'): + try: + if imgs.shape[-1] == 3: + B, H, W, C = imgs.shape + else: + B, C, H, W = imgs.shape + imgs = einops.rearrange(imgs, "b c h w -> b h w c") + masks = self.mask_generator.generate_mask_video(imgs.numpy(), mask_expansion=10, expansion_factor=1.1) + return torch.from_numpy(np.stack(masks, axis=0, dtype=np.float16).reshape(B, 1, H, W) // 255) + except Exception as e: + print(f"Error generating masks with mask_generator: {e}") + # Fallback to simple mask generation if the generator fails. + print("Falling back to simple mask generation.") + return self.get_simple_mask(pad) + else: + return self.get_simple_mask(pad) + + def get_simple_mask(self, pad=0): + if getattr(self, 'mask_cache', None) is not None: + return self.mask_cache + H = W = self.size + # Define a crop region similar to the original crop function. + y1, y2 = 0, H - int(H * 2.36 / 8) + x1, x2 = int(W * 1.8 / 8), W - int(W * 1.8 / 8) + # Apply face_hide_percentage to determine the mask region. + y1 = y2 - int(np.ceil(self.data_config.face_hide_percentage * (y2 - y1))) + if pad: + y1 = max(y1 - pad, 0) + y2 = min(y2 + pad, H) + x1 = max(x1 - pad, 0) + x2 = min(x2 + pad, W) + msk = Image.new("L", (W, H), 0) + msk_arr = np.array(msk).astype(np.float16) + msk_arr[y1:y2, x1:x2] = 255 + + msk_arr = msk_arr // 255 + + # msk = Image.fromarray(msk_arr) + # msk = self.mask_transforms.preprocess_frames(msk) * 0.5 + 0.5 # normalize to [0,1] + # Duplicate the mask for each frame. + mask = torch.from_numpy(msk_arr).to(torch.float16).unsqueeze(0).repeat(self.data_config.nframes, 1, 1, 1) + # Cache the mask for all frames. + self.mask_cache = mask + return mask + + def read_frames(self, videoreader: VideoReader, start_frame, num_frames): + """ + Read a batch of frames from the video using decord. + Returns a tuple: (list of transformed frames, list of reference frames, list of raw PIL frames). + """ + try: + total_frames = len(videoreader) + if total_frames < num_frames: + return None, None, None + # Get the target window of frames. + frame_indices = list(range(start_frame, start_frame + num_frames)) + frames_array = videoreader.get_batch(frame_indices) # shape: (num_frames, H, W, C) + + # Determine valid start indices for a "wrong" window that does not overlap the instance window. + valid_starts = [] + # Left interval: ensure wrong_start + num_frames - 1 < start_frame. + left_max = start_frame - num_frames + if left_max >= 0: + valid_starts.extend(range(0, left_max + 1)) + # Right interval: ensure wrong_start > start_frame + num_frames - 1. + right_min = start_frame + num_frames + if right_min <= total_frames - num_frames: + valid_starts.extend(range(right_min, total_frames - num_frames + 1)) + + if not valid_starts: + # Fallback: if no valid index is available, choose the farthest possible window. + wrong_start = 0 if start_frame > total_frames // 2 else total_frames - num_frames + else: + wrong_start = random.choice(valid_starts) + + wrong_indices = list(range(wrong_start, wrong_start + num_frames)) + + wrong_indices = list(range(wrong_start, wrong_start + num_frames)) + wrong_array = videoreader.get_batch(wrong_indices) + return frames_array, wrong_array + except Exception as e: + print(f"Error reading frames from {videoreader}: {e}") + return None, None, None + + def read_audio(self, video_path): + try: + ar = AudioReader(video_path, ctx=cpu(self.worker_id), sample_rate=self.sample_rate) + audio = ar[:].squeeze() # assume mono + del ar + return audio + except Exception as e: + print(f"Error reading audio from {video_path}: {e}") + return None + + def compute_mel(self, audio): + try: + mel = melspectrogram(audio) + return mel.T + except Exception as e: + print("Error computing mel spectrogram:", e) + return None + + def get_mel(self, audio, path): + # First try to find the mel in the cache directory + cache_dir = self.data_config.data_cache_path if self.data_config.data_cache_path else os.path.join(self.data_root, "cache") + cache_dir = os.path.join(cache_dir, self.split) + cache_path = os.path.join(cache_dir, os.path.basename(path) + ".mel") + if os.path.exists(cache_path): + mel = np.load(cache_path) + return mel + # If not found, compute the mel and save it to the cache + mel = self.compute_mel(audio) + if mel is None: + return None + os.makedirs(cache_dir, exist_ok=True) + np.save(cache_path, mel) + return mel + + def __len__(self): + return len(self.all_videos) + + def __getitem__(self, index): + """ + Returns a dictionary with: + - instance_images: [F, C, H, W] + - reference_images: [F, C, H, W] + - mask: [F, 1, H, W] + - instance_masks: same as mask + - (optionally) instance_masks_dilated + - instance_masked_images: instance_images * (mask < 0.5) + - instance_prompt_ids: tokenized caption + - raw_audio / indiv_raw_audios, mels / indiv_mels if audio_format is specified. + """ + example = {} + attempt = 0 + while True: + attempt += 1 + if attempt > 10: + raise RuntimeError("Failed to get a valid sample after multiple attempts.") + try: + # Select a random video. + video_idx = random.randint(0, len(self.all_videos) - 1) + video_path = self.all_videos[video_idx] + vr = VideoReader(video_path, ctx=cpu(self.worker_id)) + total_frames = len(vr) + if total_frames < 3 * self.data_config.nframes: + continue + + # Randomly choose a start frame ensuring enough frames for the window. + start_frame = random.randint(self.data_config.nframes // 2, total_frames - self.data_config.nframes - self.data_config.nframes // 2) + inst_frames, ref_frames = self.read_frames(vr, start_frame, self.data_config.nframes) + if inst_frames is None or ref_frames is None: + continue + + vr.seek(0) # avoid memory leak + del vr + + # Generate masks + masks = self.get_masks(inst_frames) + masks = self.image_transforms.resize(masks) + + dilated_masks = None + if getattr(self.data_config, "dilate_masked_loss", False): + dilated_masks = self.get_masks(inst_frames, pad=self.data_config.resolution // 10) + dilated_masks = self.image_transforms.resize(dilated_masks) + + # Preprocess frames. + inst_frames = self.image_transforms.preprocess_frames(inst_frames) + ref_frames = self.image_transforms.preprocess_frames(ref_frames) + + # Optionally apply horizontal flip. + if self.h_flip and random.random() > 0.5: + inst_frames = F.hflip(inst_frames) + ref_frames = F.hflip(ref_frames) + masks = F.hflip(masks) + if dilated_masks is not None: + dilated_masks = F.hflip(dilated_masks) + + # Audio processing. + if "wav" in self.audio_format or "mel" in self.audio_format: + audio = self.read_audio(video_path) + + audio_chunk = crop_wav_window( + audio, + start_frame=start_frame, + nframes=self.data_config.nframes, + video_fps=self.video_fps, + sample_rate=self.sample_rate, + ) + if audio_chunk is None: + continue + example["raw_audio"] = audio_chunk + if getattr(self.data_config, "use_indiv_audio", False): + indiv_audios = get_segmented_wavs( + audio, + start_frame, + self.data_config.nframes, + self.video_fps, + self.sample_rate, + indiv_audio_mode=self.data_config.indiv_audio_mode, + ) + example["indiv_raw_audios"] = torch.FloatTensor(indiv_audios) + if "mel" in self.audio_format: + mel = self.get_mel(audio, video_path) + if mel is None: + continue + mel_window = crop_mel_window( + mel, + start_frame, + self.mel_steps_per_sec, + self.data_config.syncnet_mel_step_size, + self.video_fps, + ) + if mel_window.shape[0] != self.data_config.syncnet_mel_step_size: + continue + example["mels"] = torch.FloatTensor(mel_window.T).unsqueeze(0) + indiv_mels = get_segmented_mels( + mel, + start_frame, + self.data_config.nframes, + self.mel_steps_per_sec, + self.data_config.syncnet_mel_step_size, + self.video_fps, + ) + if indiv_mels is None: + continue + example["indiv_mels"] = torch.FloatTensor(indiv_mels) + + example["instance_images"] = inst_frames # [F, C, H, W] + example["reference_images"] = ref_frames # [F, C, H, W] + example["mask"] = masks # [F, 1, H, W] + example["instance_masks"] = example["mask"] + if dilated_masks is not None: + example["instance_masks_dilated"] = dilated_masks + example["instance_masked_images"] = example["instance_images"] * (example["mask"] < 0.5) + + # Process the caption prompt. + if self.use_template and self.tokenizer is not None: + input_tok = list(self.token_map.values())[0] + text = random.choice(self.templates).format(input_tok) + example["instance_prompt_ids"] = self.tokenizer( + text, + padding="do_not_pad", + truncation=True, + max_length=self.tokenizer.model_max_length, + ).input_ids + # else: + # raise NotImplementedError("Only template-based captions are supported.") + return example + except Exception as e: + print("Exception in __getitem__:", e) + traceback.print_exc() + continue diff --git a/flaxdiff/inference/__init__.py b/flaxdiff/inference/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/flaxdiff/inference/pipeline.py b/flaxdiff/inference/pipeline.py new file mode 100644 index 0000000..c31e991 --- /dev/null +++ b/flaxdiff/inference/pipeline.py @@ -0,0 +1,260 @@ +import jax +import flax.linen as nn +from dataclasses import dataclass, field +from typing import Optional, Dict, Any, Union, List, Tuple, Type + +from flaxdiff.trainer import ( + SimpleTrainState, + TrainState, +) +from flaxdiff.samplers import ( + DiffusionSampler, +) +from flaxdiff.schedulers import ( + NoiseScheduler, +) +from flaxdiff.predictors import ( + DiffusionPredictionTransform, +) +from flaxdiff.models.autoencoder import AutoEncoder +from flaxdiff.inputs import DiffusionInputConfig +from flaxdiff.utils import defaultTextEncodeModel, RandomMarkovState +from flaxdiff.samplers.euler import EulerAncestralSampler +from .utils import parse_config, load_from_wandb_run, load_from_wandb_registry + +@dataclass +class InferencePipeline: + """Inference pipeline for a general model.""" + model: nn.Module = None + state: SimpleTrainState = None + best_state: SimpleTrainState = None + + def from_wandb( + self, + wandb_run: str, + wandb_project: str, + wandb_entity: str, + ): + raise NotImplementedError("InferencePipeline does not support from_wandb.") + +@dataclass +class DiffusionInferencePipeline(InferencePipeline): + """Inference pipeline for diffusion models. + + This pipeline handles loading models from wandb and generating samples using the + DiffusionSampler from FlaxDiff. + """ + state: TrainState = None + best_state: TrainState = None + rngstate: Optional[RandomMarkovState] = None + noise_schedule: NoiseScheduler = None + model_output_transform: DiffusionPredictionTransform = None + autoencoder: AutoEncoder = None + input_config: DiffusionInputConfig = None + samplers: Dict[Type[DiffusionSampler], Dict[float, DiffusionSampler]] = field(default_factory=dict) + config: Dict[str, Any] = field(default_factory=dict) + + @classmethod + def from_wandb_run( + cls, + wandb_run: str, + project: str, + entity: str, + ): + """Create an inference pipeline from a wandb run. + + Args: + wandb_run: Run ID or display name + project: Wandb project name + entity: Wandb entity name + wandb_modelname: Model name in wandb registry (if None, loads from checkpoint) + checkpoint_step: Specific checkpoint step to load (if None, loads latest) + config_overrides: Optional dictionary to override config values + checkpoint_base_path: Base path for checkpoint storage + + Returns: + DiffusionInferencePipeline instance + """ + states, config = load_from_wandb_run( + wandb_run, + project=project, + entity=entity, + ) + + if states is None: + raise ValueError("Failed to load model parameters from wandb.") + + state, best_state = states + parsed_config = parse_config(config) + + # Create the pipeline + pipeline = cls.create( + config=parsed_config, + state=state, + best_state=best_state, + rngstate=RandomMarkovState(jax.random.PRNGKey(42)), + ) + return pipeline + + @classmethod + def from_wandb_registry( + cls, + modelname: str, + project: str, + entity: str = None, + version: str = 'latest', + registry: str = 'wandb-registry-model', + ): + """Create an inference pipeline from a wandb model registry. + + Args: + modelname: Model name in wandb registry + project: Wandb project name + entity: Wandb entity name + version: Version of the model to load (default is 'latest') + registry: Registry name (default is 'wandb-registry-model') + + Returns: + DiffusionInferencePipeline instance + """ + states, config = load_from_wandb_registry( + modelname=modelname, + project=project, + entity=entity, + version=version, + registry=registry, + ) + + if states is None: + raise ValueError("Failed to load model parameters from wandb.") + + state, best_state = states + parsed_config = parse_config(config) + + # Create the pipeline + pipeline = cls.create( + config=parsed_config, + state=state, + best_state=best_state, + rngstate=RandomMarkovState(jax.random.PRNGKey(42)), + ) + return pipeline + + @classmethod + def create( + cls, + config: Dict[str, Any], + state: Dict[str, Any], + best_state: Optional[Dict[str, Any]] = None, + rngstate: Optional[RandomMarkovState] = None, + ): + if rngstate is None: + rngstate = RandomMarkovState(jax.random.PRNGKey(42)) + # Build and return pipeline + return cls( + model=config['model'], + state=state, + best_state=best_state, + rngstate=rngstate, + noise_schedule=config['noise_schedule'], + model_output_transform=config['prediction_transform'], + autoencoder=config['autoencoder'], + input_config=config['input_config'], + config=config, + ) + + def get_sampler( + self, + guidance_scale: float = 3.0, + sampler_class=EulerAncestralSampler, + ) -> DiffusionSampler: + """Get (or create) a sampler for generating samples. + + This method caches samplers by their class and guidance scale for reuse. + + Args: + sampler_class: Class for the diffusion sampler + guidance_scale: Classifier-free guidance scale (0.0 to disable) + + Returns: + DiffusionSampler instance + """ + # Get or create dictionary for this sampler class + if sampler_class not in self.samplers: + self.samplers[sampler_class] = {} + + # Check if we already have a sampler with this guidance scale + if guidance_scale not in self.samplers[sampler_class]: + # Create unconditional embeddings if using guidance + null_embeddings = None + if guidance_scale > 0.0: + null_text = self.input_config.conditions[0].get_unconditional() + null_embeddings = null_text + print(f"Created null embeddings for guidance with shape {null_embeddings.shape}") + + # Create and cache the sampler + self.samplers[sampler_class][guidance_scale] = sampler_class( + model=self.model, + noise_schedule=self.noise_schedule, + model_output_transform=self.model_output_transform, + guidance_scale=guidance_scale, + input_config=self.input_config, + autoencoder=self.autoencoder, + ) + + return self.samplers[sampler_class][guidance_scale] + + def generate_samples( + self, + num_samples: int, + resolution: int, + conditioning_data: Optional[List[Union[Tuple, Dict]]] = None, # one list per modality or list of tuples + sequence_length: Optional[int] = None, + diffusion_steps: int = 50, + guidance_scale: float = 1.0, + sampler_class=EulerAncestralSampler, + timestep_spacing: str = 'linear', + seed: Optional[int] = None, + start_step: Optional[int] = None, + end_step: int = 0, + steps_override=None, + priors=None, + use_best_params: bool = False, + use_ema: bool = False, + ): + # Setup RNG + rngstate = self.rngstate or RandomMarkovState(jax.random.PRNGKey(seed or 0)) + + # Get cached or new sampler + sampler = self.get_sampler( + guidance_scale=guidance_scale, + sampler_class=sampler_class, + ) + if hasattr(sampler, 'timestep_spacing'): + sampler.timestep_spacing = timestep_spacing + print(f"Generating samples: steps={diffusion_steps}, num_samples={num_samples}, guidance={guidance_scale}") + + if use_best_params: + state = self.best_state + else: + state = self.state + + if use_ema: + params = state['ema_params'] + else: + params = state['params'] + + + return sampler.generate_samples( + params=params, + num_samples=num_samples, + resolution=resolution, + sequence_length=sequence_length, + diffusion_steps=diffusion_steps, + start_step=start_step, + end_step=end_step, + steps_override=steps_override, + priors=priors, + rngstate=rngstate, + conditioning=conditioning_data + ) \ No newline at end of file diff --git a/flaxdiff/inference/utils.py b/flaxdiff/inference/utils.py new file mode 100644 index 0000000..4d9ad10 --- /dev/null +++ b/flaxdiff/inference/utils.py @@ -0,0 +1,320 @@ +import jax +import jax.numpy as jnp +import json +from flaxdiff.schedulers import ( + CosineNoiseScheduler, + KarrasVENoiseScheduler, +) +from flaxdiff.predictors import ( + VPredictionTransform, + KarrasPredictionTransform, +) +from flaxdiff.models.common import kernel_init +from flaxdiff.models.simple_unet import Unet +from flaxdiff.models.simple_vit import UViT +from flaxdiff.models.general import BCHWModelWrapper +from flaxdiff.models.autoencoder.diffusers import StableDiffusionVAE +from flaxdiff.inputs import DiffusionInputConfig, ConditionalInputConfig +from flaxdiff.utils import defaultTextEncodeModel +from diffusers import FlaxUNet2DConditionModel +import wandb +from flaxdiff.models.simple_unet import Unet +from flaxdiff.models.simple_vit import UViT +from flaxdiff.models.general import BCHWModelWrapper +from flaxdiff.models.autoencoder.diffusers import StableDiffusionVAE +from flaxdiff.inputs import DiffusionInputConfig, ConditionalInputConfig +from flaxdiff.utils import defaultTextEncodeModel + +from orbax.checkpoint import CheckpointManager, CheckpointManagerOptions, PyTreeCheckpointer +import os + +import warnings + +def get_wandb_run(wandb_run: str, project, entity): + """ + Try to get the wandb run for the given experiment name and project. + Return None if not found. + """ + import wandb + wandb_api = wandb.Api() + # First try to get the run by treating wandb_run as a run ID + try: + run = wandb_api.run(f"{entity}/{project}/{wandb_run}") + print(f"Found run: {run.name} ({run.id})") + return run + except wandb.Error as e: + print(f"Run not found by ID: {e}") + # If that fails, try to get the run by treating wandb_run as a display name + # This is a bit of a hack, but it works for now. + # Note: this will return all runs with the same display name, so be careful. + print(f"Trying to get run by display name: {wandb_run}") + runs = wandb_api.runs(path=f"{entity}/{project}", filters={"displayName": wandb_run}) + for run in runs: + print(f"Found run: {run.name} ({run.id})") + return run + return None + +def parse_config(config, overrides=None): + """Parse configuration for inference pipeline. + + Args: + config: Configuration dictionary from wandb run + overrides: Optional dictionary of overrides for config parameters + + Returns: + Dictionary containing model, sampler, scheduler, and other required components + including DiffusionInputConfig for the general diffusion framework + """ + warnings.filterwarnings("ignore") + + # Merge config with overrides if provided + if overrides is not None: + # Create a deep copy of config to avoid modifying the original + merged_config = dict(config) + # Update arguments with overrides + if 'arguments' in merged_config: + merged_config['arguments'] = {**merged_config['arguments'], **overrides} + # Also update top-level config for key parameters + for key in overrides: + if key in merged_config: + merged_config[key] = overrides[key] + else: + merged_config = config + + # Parse configuration from config dict + conf = merged_config + + # Setup mappings for dtype, precision, and activation + DTYPE_MAP = { + 'bfloat16': jnp.bfloat16, + 'float32': jnp.float32, + 'jax.numpy.float32': jnp.float32, + 'jax.numpy.bfloat16': jnp.bfloat16, + 'None': None, + None: None, + } + + PRECISION_MAP = { + 'high': jax.lax.Precision.HIGH, + 'HIGH': jax.lax.Precision.HIGH, + 'default': jax.lax.Precision.DEFAULT, + 'DEFAULT': jax.lax.Precision.DEFAULT, + 'highest': jax.lax.Precision.HIGHEST, + 'HIGHEST': jax.lax.Precision.HIGHEST, + 'None': None, + None: None, + } + + ACTIVATION_MAP = { + 'swish': jax.nn.swish, + 'silu': jax.nn.silu, + 'jax._src.nn.functions.silu': jax.nn.silu, + 'mish': jax.nn.mish, + } + + # Get model class based on architecture + MODEL_CLASSES = { + 'unet': Unet, + 'uvit': UViT, + 'diffusers_unet_simple': FlaxUNet2DConditionModel + } + + # Map all the leaves of the model config, converting strings to appropriate types + def map_nested_config(config): + new_config = {} + for key, value in config.items(): + if isinstance(value, dict): + new_config[key] = map_nested_config(value) + elif isinstance(value, list): + new_config[key] = [map_nested_config(item) if isinstance(item, dict) else item for item in value] + elif isinstance(value, str): + if value in DTYPE_MAP: + new_config[key] = DTYPE_MAP[value] + elif value in PRECISION_MAP: + new_config[key] = PRECISION_MAP[value] + elif value in ACTIVATION_MAP: + new_config[key] = ACTIVATION_MAP[value] + elif value == 'None': + new_config[key] = None + elif '.'in value: + # Ignore any other string that contains a dot + print(f"Ignoring key {key} with value {value} as it contains a dot.") + else: + new_config[key] = value + else: + new_config[key] = value + return new_config + + # Parse architecture and model config + model_config = conf['model'] + + # Get architecture type + architecture = conf.get('architecture', conf.get('arguments', {}).get('architecture', 'unet')) + + # Handle autoencoder + autoencoder_name = conf.get('autoencoder', conf.get('arguments', {}).get('autoencoder')) + autoencoder_opts_str = conf.get('autoencoder_opts', conf.get('arguments', {}).get('autoencoder_opts', '{}')) + autoencoder = None + autoencoder_opts = None + + if autoencoder_name: + print(f"Using autoencoder: {autoencoder_name}") + if isinstance(autoencoder_opts_str, str): + autoencoder_opts = json.loads(autoencoder_opts_str) + else: + autoencoder_opts = autoencoder_opts_str + + if autoencoder_name == 'stable_diffusion': + print("Using Stable Diffusion Autoencoder for Latent Diffusion Modeling") + autoencoder_opts = map_nested_config(autoencoder_opts) + autoencoder = StableDiffusionVAE(**autoencoder_opts) + + input_config = conf.get('input_config', None) + + # If not provided, create one based on the older format (backward compatibility) + if input_config is None: + # Warn if input_config is not provided + print("No input_config provided, creating a default one.") + image_size = conf['arguments'].get('image_size', 128) + image_channels = 3 # Default number of channels + # Create text encoder + text_encoder = defaultTextEncodeModel() + # Create a conditional input config for text conditioning + text_conditional_config = ConditionalInputConfig( + encoder=text_encoder, + conditioning_data_key='text', + pretokenized=True, + unconditional_input="", + model_key_override="textcontext" + ) + + # Create the main input config + input_config = DiffusionInputConfig( + sample_data_key='image', + sample_data_shape=(image_size, image_size, image_channels), + conditions=[text_conditional_config] + ) + else: + # Deserialize the input config if it's a string + input_config = DiffusionInputConfig.deserialize(input_config) + + model_kwargs = map_nested_config(model_config) + + print(f"Model kwargs after mapping: {model_kwargs}") + + model_class = MODEL_CLASSES.get(architecture) + if not model_class: + raise ValueError(f"Unknown architecture: {architecture}. Supported architectures: {', '.join(MODEL_CLASSES.keys())}") + + # Instantiate the model + model = model_class(**model_kwargs) + + # If using diffusers UNet, wrap it for consistent interface + if 'diffusers' in architecture: + model = BCHWModelWrapper(model) + + # Create noise scheduler based on configuration + noise_schedule_type = conf.get('noise_schedule', conf.get('arguments', {}).get('noise_schedule', 'edm')) + if noise_schedule_type in ['edm', 'karras']: + # For both EDM and karras, we use the karras scheduler for inference + noise_schedule = KarrasVENoiseScheduler(1, sigma_max=80, rho=7, sigma_data=0.5) + prediction_transform = KarrasPredictionTransform(sigma_data=noise_schedule.sigma_data) + elif noise_schedule_type == 'cosine': + noise_schedule = CosineNoiseScheduler(1000, beta_end=1) + prediction_transform = VPredictionTransform() + else: + raise ValueError(f"Unknown noise schedule: {noise_schedule_type}") + + # Prepare return dictionary with all components + result = { + 'model': model, + 'model_config': model_kwargs, + 'architecture': architecture, + 'autoencoder': autoencoder, + 'noise_schedule': noise_schedule, + 'prediction_transform': prediction_transform, + 'input_config': input_config, + 'raw_config': conf, + } + + return result + +def load_from_checkpoint( + checkpoint_dir: str, +): + try: + checkpointer = PyTreeCheckpointer() + options = CheckpointManagerOptions(create=False) + # Convert checkpoint_dir to absolute path + checkpoint_dir = os.path.abspath(checkpoint_dir) + manager = CheckpointManager(checkpoint_dir, checkpointer, options) + ckpt = manager.restore(checkpoint_dir) + # Extract as above + state, best_state = None, None + if 'state' in ckpt: + state = ckpt['state'] + if 'best_state' in ckpt: + best_state = ckpt['best_state'] + print(f"Loaded checkpoint from local dir {checkpoint_dir}") + return state, best_state + except Exception as e: + print(f"Warning: Failed to load checkpoint from local dir: {e}") + return None, None + +def load_from_wandb_run( + run, + project: str, + entity: str = None, +): + """ + Loads model from wandb model registry. + """ + # Get the model version from wandb + states = None + config = None + try: + if isinstance(run, str): + run = get_wandb_run(run, project, entity) + # Search for model artifact + models = [i for i in run.logged_artifacts() if i.type == 'model'] + if len(models) == 0: + raise ValueError(f"No model artifacts found in run {run.id}") + # Pick out any model artifact + highest_version = max([{'version':int(i.version[1:]), 'name': i.qualified_name} for i in models], key=lambda x: x['version']) + wandb_modelname = highest_version['name'] + + print(f"Loading model from wandb: {wandb_modelname} out of versions {[i.version for i in models]}") + artifact = run.use_artifact(wandb.Api().artifact(wandb_modelname)) + ckpt_dir = artifact.download() + print(f"Loaded model from wandb: {wandb_modelname} at path {ckpt_dir}") + # Load the model from the checkpoint directory + states = load_from_checkpoint(ckpt_dir) + config = run.config + except Exception as e: + print(f"Warning: Failed to load model from wandb: {e}") + return states, config + +def load_from_wandb_registry( + modelname: str, + project: str, + entity: str = None, + version: str = 'latest', + registry: str = 'wandb-registry-model', +): + """ + Loads model from wandb model registry. + """ + # Get the model version from wandb + states = None + config = None + try: + artifact = wandb.Api().artifact(f"{registry}/{modelname}:{version}") + ckpt_dir = artifact.download() + print(f"Loaded model from wandb registry: {modelname} at path {ckpt_dir}") + # Load the model from the checkpoint directory + states = load_from_checkpoint(ckpt_dir) + run = artifact.logged_by() + config = run.config + except Exception as e: + print(f"Warning: Failed to load model from wandb: {e}") + return states, config \ No newline at end of file diff --git a/flaxdiff/inputs/__init__.py b/flaxdiff/inputs/__init__.py new file mode 100644 index 0000000..49c4659 --- /dev/null +++ b/flaxdiff/inputs/__init__.py @@ -0,0 +1,173 @@ +import jax +import jax.numpy as jnp +import flax.struct as struct +import flax.linen as nn +from typing import Any, Callable, Dict, List, Optional, Tuple +from dataclasses import dataclass +from functools import partial +import numpy as np +from jax.sharding import Mesh, PartitionSpec as P +from abc import ABC, abstractmethod + +from flaxdiff.models.autoencoder import AutoEncoder +from .encoders import * + +@dataclass +class ConditionalInputConfig: + """Class representing a conditional input for the model.""" + encoder: ConditioningEncoder + conditioning_data_key: str = None # Key in the batch for this conditioning input + pretokenized: bool = False + unconditional_input: Any = None + model_key_override: Optional[str] = None # Optional key override for the model + + __uncond_cache__ = None # Cache for unconditional input + + def __post_init__(self): + if self.unconditional_input is not None: + uncond = self.encoder([self.unconditional_input]) + else: + uncond = self.encoder([""]) # Default empty text + self.__uncond_cache__ = uncond # Cache the unconditional input + + def __call__(self, batch_data): + """Process batch data to produce conditioning.""" + key = self.conditioning_data_key if self.conditioning_data_key else self.encoder.key + if self.pretokenized: + return self.encoder.encode_from_tokens(batch_data[key]) + return self.encoder(batch_data[key]) + + def get_unconditional(self): + """Get unconditional version of this input.""" + return self.__uncond_cache__ + + def serialize(self): + """Serialize the configuration.""" + serialized_config = { + "encoder": self.encoder.serialize(), + "encoder_key": self.encoder.key, + "conditioning_data_key": self.conditioning_data_key, + "unconditional_input": self.unconditional_input, + "model_key_override": self.model_key_override, + } + return serialized_config + + @staticmethod + def deserialize(serialized_config): + """Deserialize the configuration.""" + encoder_key = serialized_config["encoder_key"] + encoder_class = CONDITIONAL_ENCODERS_REGISTRY.get(encoder_key) + if encoder_class is None: + raise ValueError(f"Unknown encoder type: {encoder_key}") + + # Create the encoder instance + encoder = encoder_class.deserialize(serialized_config["encoder"]) + # Deserialize the rest of the configuration + conditioning_data_key = serialized_config.get("conditioning_data_key") + unconditional_input = serialized_config.get("unconditional_input") + model_key_override = serialized_config.get("model_key_override") + return ConditionalInputConfig( + encoder=encoder, + conditioning_data_key=conditioning_data_key, + unconditional_input=unconditional_input, + model_key_override=model_key_override, + ) + +@dataclass +class DiffusionInputConfig: + """Configuration for the input data.""" + sample_data_key: str # Key in the batch for the sample data + sample_data_shape: Tuple[int, ...] + conditions: List[ConditionalInputConfig] + + def get_input_shapes( + self, + autoencoder: AutoEncoder = None, + sample_model_key:str = 'x', + time_embeddings_model_key:str = 'temb', + ) -> Dict[str, Tuple[int, ...]]: + """Get the shapes of the input data.""" + if len(self.sample_data_shape) == 3: + H, W, C = self.sample_data_shape + elif len(self.sample_data_shape) == 4: + T, H, W, C = self.sample_data_shape + else: + raise ValueError(f"Unsupported shape for sample data {self.sample_data_shape}") + if autoencoder is not None: + downscale_factor = autoencoder.downscale_factor + H = H // downscale_factor + W = W // downscale_factor + C = autoencoder.latent_channels + + input_shapes = { + sample_model_key: (H, W, C), + time_embeddings_model_key: (), + } + for cond in self.conditions: + # Get the shape of the conditioning data by calling the get_unconditional method + unconditional = cond.get_unconditional() + key = cond.model_key_override if cond.model_key_override else cond.encoder.key + input_shapes[key] = unconditional[0].shape + + print(f"Calculated input shapes: {input_shapes}") + return input_shapes + + def get_unconditionals(self): + """Get unconditional inputs for all conditions.""" + unconditionals = [] + for cond in self.conditions: + uncond = cond.get_unconditional() + unconditionals.append(uncond) + return unconditionals + + def process_conditioning(self, batch_data, uncond_mask: Optional[jnp.ndarray] = None): + """Process the conditioning data.""" + results = [] + + for cond in self.conditions: + cond_embeddings = cond(batch_data) + if uncond_mask is not None: + assert len(uncond_mask) == len(cond_embeddings), "Unconditional mask length must match the batch size." + uncond_embedding = cond.get_unconditional() + + # Reshape uncond_mask to be broadcastable with the conditioning embeddings + # If cond_embeddings has shape (B, T, D), reshape uncond_mask to (B, 1, 1) + broadcast_shape = [len(uncond_mask)] + [1] * (cond_embeddings.ndim - 1) + reshaped_mask = jnp.reshape(uncond_mask, broadcast_shape) + + # Repeat uncond_embedding to match batch size + batch_size = len(cond_embeddings) + repeated_uncond = jnp.repeat(uncond_embedding, batch_size, axis=0) + + # Apply unconditional embedding based on the mask + cond_embeddings = jnp.where(reshaped_mask, repeated_uncond, cond_embeddings) + + results.append(cond_embeddings) + return results + + def serialize(self): + """Serialize the configuration.""" + serialized_config = { + "sample_data_key": self.sample_data_key, + "sample_data_shape": self.sample_data_shape, + "conditions": [cond.serialize() for cond in self.conditions], + } + return serialized_config + + @staticmethod + def deserialize(serialized_config): + """Deserialize the configuration.""" + sample_data_key = serialized_config["sample_data_key"] + sample_data_shape = tuple(serialized_config["sample_data_shape"]) + conditions = serialized_config["conditions"] + + # Deserialize each condition + deserialized_conditions = [] + for cond in conditions: + deserialized_conditions.append(ConditionalInputConfig.deserialize(cond)) + + return DiffusionInputConfig( + sample_data_key=sample_data_key, + sample_data_shape=sample_data_shape, + conditions=deserialized_conditions, + ) \ No newline at end of file diff --git a/flaxdiff/inputs/encoders.py b/flaxdiff/inputs/encoders.py new file mode 100644 index 0000000..1987ed6 --- /dev/null +++ b/flaxdiff/inputs/encoders.py @@ -0,0 +1,98 @@ +import jax.numpy as jnp +import flax.linen as nn +from typing import Callable +from dataclasses import dataclass +from abc import ABC, abstractmethod + +@dataclass +class ConditioningEncoder(ABC): + model: nn.Module + tokenizer: Callable + + @property + def key(self): + name = self.tokenizer.__name__ + # Remove the 'Encoder' suffix from the name and lowercase it + if name.endswith("Encoder"): + name = name[:-7].lower() + return name + + def __call__(self, data): + tokens = self.tokenize(data) + outputs = self.encode_from_tokens(tokens) + return outputs + + def encode_from_tokens(self, tokens): + outputs = self.model(input_ids=tokens['input_ids'], + attention_mask=tokens['attention_mask']) + last_hidden_state = outputs.last_hidden_state + return last_hidden_state + + def tokenize(self, data): + tokens = self.tokenizer(data, padding="max_length", + max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="np") + return tokens + + @abstractmethod + def serialize(self): + """Serialize the encoder configuration.""" + pass + + @staticmethod + @abstractmethod + def deserialize(serialized_config): + """Deserialize the encoder configuration.""" + pass + +@dataclass +class TextEncoder(ConditioningEncoder): + """Text Encoder.""" + @property + def key(self): + return "text" + +@dataclass +class CLIPTextEncoder(TextEncoder): + """CLIP Text Encoder.""" + modelname: str + backend: str + + @staticmethod + def from_modelname(modelname: str = "openai/clip-vit-large-patch14", backend: str="jax"): + from transformers import ( + CLIPTextModel, + FlaxCLIPTextModel, + AutoTokenizer, + ) + modelname = "openai/clip-vit-large-patch14" + if backend == "jax": + model = FlaxCLIPTextModel.from_pretrained( + modelname, dtype=jnp.bfloat16) + else: + model = CLIPTextModel.from_pretrained(modelname) + tokenizer = AutoTokenizer.from_pretrained(modelname, dtype=jnp.float16) + return CLIPTextEncoder( + model=model, + tokenizer=tokenizer, + modelname=modelname, + backend=backend + ) + + def serialize(self): + """Serialize the encoder configuration.""" + serialized_config = { + "modelname": self.modelname, + "backend": self.backend, + } + return serialized_config + + @staticmethod + def deserialize(serialized_config): + """Deserialize the encoder configuration.""" + modelname = serialized_config["modelname"] + backend = serialized_config["backend"] + return CLIPTextEncoder.from_modelname(modelname=modelname, backend=backend) + +CONDITIONAL_ENCODERS_REGISTRY = { + "text": CLIPTextEncoder, +} diff --git a/flaxdiff/models/__init__.py b/flaxdiff/models/__init__.py index 9904861..2048142 100644 --- a/flaxdiff/models/__init__.py +++ b/flaxdiff/models/__init__.py @@ -1 +1,2 @@ -from .simple_unet import * \ No newline at end of file +from .simple_unet import * +# from .video_unet import FlaxUNet3DConditionModel, BCHWModelWrapper, FlaxTemporalConvLayer \ No newline at end of file diff --git a/flaxdiff/models/autoencoder/autoencoder.py b/flaxdiff/models/autoencoder/autoencoder.py index db800ea..ab2454d 100644 --- a/flaxdiff/models/autoencoder/autoencoder.py +++ b/flaxdiff/models/autoencoder/autoencoder.py @@ -1,19 +1,151 @@ import jax import jax.numpy as jnp from flax import linen as nn -from typing import Dict, Callable, Sequence, Any, Union +from typing import Dict, Callable, Sequence, Any, Union, Optional import einops from ..common import kernel_init, ConvLayer, Upsample, Downsample, PixelShuffle +from dataclasses import dataclass +from abc import ABC, abstractmethod - -class AutoEncoder(): - def encode(self, x: jnp.ndarray, **kwargs) -> jnp.ndarray: +@dataclass +class AutoEncoder(ABC): + """Base class for autoencoder models with video support. + + This class defines the interface for autoencoders and provides + video handling functionality, allowing child classes to focus + on implementing the core encoding/decoding for individual frames. + """ + @abstractmethod + def __encode__(self, x: jnp.ndarray, **kwargs) -> jnp.ndarray: + """Abstract method for encoding a batch of images. + + Child classes must implement this method to perform the actual encoding. + + Args: + x: Input tensor of shape [B, H, W, C] (batch of images) + **kwargs: Additional arguments for the encoding process + + Returns: + Encoded latent representation + """ + raise NotImplementedError + + @abstractmethod + def __decode__(self, z: jnp.ndarray, **kwargs) -> jnp.ndarray: + """Abstract method for decoding a batch of latents. + + Child classes must implement this method to perform the actual decoding. + + Args: + z: Latent tensor of shape [B, h, w, c] (encoded representation) + **kwargs: Additional arguments for the decoding process + + Returns: + Decoded images + """ raise NotImplementedError - def decode(self, z: jnp.ndarray, **kwargs) -> jnp.ndarray: + def encode(self, x: jnp.ndarray, key: Optional[jax.random.PRNGKey] = None, **kwargs) -> jnp.ndarray: + """Encode input data, with special handling for video data. + + This method handles both standard image batches and video data (5D tensors). + For videos, it reshapes the input, processes each frame, and then restores + the temporal dimension. + + Args: + x: Input tensor, either [B, H, W, C] for images or [B, T, H, W, C] for videos + key: Optional random key for stochastic encoding + **kwargs: Additional arguments passed to __encode__ + + Returns: + Encoded representation with the same batch and temporal dimensions as input + """ + # Check for video data (5D tensor) + is_video = len(x.shape) == 5 + + if is_video: + # Extract dimensions for reshaping + batch_size, seq_len, height, width, channels = x.shape + + # Reshape to [B*T, H, W, C] to process as regular images + x_reshaped = x.reshape(-1, height, width, channels) + + # Encode all frames + latent = self.__encode__(x_reshaped, key=key, **kwargs) + + # Reshape back to include temporal dimension [B, T, h, w, c] + latent_shape = latent.shape + return latent.reshape(batch_size, seq_len, *latent_shape[1:]) + else: + # Standard image processing + return self.__encode__(x, key=key, **kwargs) + + def decode(self, z: jnp.ndarray, key: Optional[jax.random.PRNGKey] = None, **kwargs) -> jnp.ndarray: + """Decode latent representations, with special handling for video data. + + This method handles both standard image latents and video latents (5D tensors). + For videos, it reshapes the input, processes each frame, and then restores + the temporal dimension. + + Args: + z: Latent tensor, either [B, h, w, c] for images or [B, T, h, w, c] for videos + key: Optional random key for stochastic decoding + **kwargs: Additional arguments passed to __decode__ + + Returns: + Decoded output with the same batch and temporal dimensions as input + """ + # Check for video data (5D tensor) + is_video = len(z.shape) == 5 + + if is_video: + # Extract dimensions for reshaping + batch_size, seq_len, height, width, channels = z.shape + + # Reshape to [B*T, h, w, c] to process as regular latents + z_reshaped = z.reshape(-1, height, width, channels) + + # Decode all frames + decoded = self.__decode__(z_reshaped, key=key, **kwargs) + + # Reshape back to include temporal dimension [B, T, H, W, C] + decoded_shape = decoded.shape + return decoded.reshape(batch_size, seq_len, *decoded_shape[1:]) + else: + # Standard latent processing + return self.__decode__(z, key=key, **kwargs) + + def __call__(self, x: jnp.ndarray, key: Optional[jax.random.PRNGKey] = None, **kwargs): + """Encode and then decode the input (autoencoder). + + Args: + x: Input tensor, either [B, H, W, C] for images or [B, T, H, W, C] for videos + key: Optional random key for stochastic encoding/decoding + **kwargs: Additional arguments for encoding and decoding + + Returns: + Reconstructed output with the same dimensions as input + """ + if key is not None: + encode_key, decode_key = jax.random.split(key) + else: + encode_key = decode_key = None + + # Encode then decode + z = self.encode(x, key=encode_key, **kwargs) + return self.decode(z, key=decode_key, **kwargs) + + @property + def spatial_scale(self) -> int: + """Get the spatial scale factor between input and latent spaces.""" + return getattr(self, "_spatial_scale", None) + + @property + def name(self) -> str: + """Get the name of the autoencoder model.""" raise NotImplementedError - def __call__(self, x: jnp.ndarray): - latents = self.encode(x) - reconstructions = self.decode(latents) - return reconstructions \ No newline at end of file + @abstractmethod + def serialize(self) -> Dict[str, Any]: + """Serialize the model parameters and configuration.""" + raise NotImplementedError \ No newline at end of file diff --git a/flaxdiff/models/autoencoder/diffusers.py b/flaxdiff/models/autoencoder/diffusers.py index 6e3ad67..6a409fd 100644 --- a/flaxdiff/models/autoencoder/diffusers.py +++ b/flaxdiff/models/autoencoder/diffusers.py @@ -22,7 +22,9 @@ def __init__(self, modelname = "CompVis/stable-diffusion-v1-4", revision="bf16", dtype=dtype, ) - # vae = pipeline.vae + self.modelname = modelname + self.revision = revision + self.dtype = dtype enc = FlaxEncoder( in_channels=vae.config.in_channels, @@ -63,29 +65,90 @@ def __init__(self, modelname = "CompVis/stable-diffusion-v1-4", revision="bf16", dtype=vae.dtype, ) - self.enc = enc - self.dec = dec - self.post_quant_conv = post_quant_conv - self.quant_conv = quant_conv - self.params = params - self.scaling_factor = vae.scaling_factor + scaling_factor = vae.scaling_factor + print(f"Scaling factor: {scaling_factor}") - def encode(self, images, rngkey: jax.random.PRNGKey = None): - latents = self.enc.apply({"params": self.params["vae"]['encoder']}, images, deterministic=True) - latents = self.quant_conv.apply({"params": self.params["vae"]['quant_conv']}, latents) - if rngkey is not None: - mean, log_std = jnp.split(latents, 2, axis=-1) - log_std = jnp.clip(log_std, -30, 20) - std = jnp.exp(0.5 * log_std) - latents = mean + std * jax.random.normal(rngkey, mean.shape, dtype=mean.dtype) - # print("Sampled") - else: - # return the mean - latents, _ = jnp.split(latents, 2, axis=-1) - latents *= self.scaling_factor - return latents + def encode_single_frame(images, rngkey: jax.random.PRNGKey = None): + latents = enc.apply({"params": params['encoder']}, images, deterministic=True) + latents = quant_conv.apply({"params": params['quant_conv']}, latents) + if rngkey is not None: + mean, log_std = jnp.split(latents, 2, axis=-1) + log_std = jnp.clip(log_std, -30, 20) + std = jnp.exp(0.5 * log_std) + latents = mean + std * jax.random.normal(rngkey, mean.shape, dtype=mean.dtype) + else: + latents, _ = jnp.split(latents, 2, axis=-1) + latents *= scaling_factor + return latents + + def decode_single_frame(latents): + latents = (1.0 / scaling_factor) * latents + latents = post_quant_conv.apply({"params": params['post_quant_conv']}, latents) + return dec.apply({"params": params['decoder']}, latents) + + self.encode_single_frame = jax.jit(encode_single_frame) + self.decode_single_frame = jax.jit(decode_single_frame) + + # Calculate downscale factor by passing a dummy input through the encoder + print("Calculating downscale factor...") + dummy_input = jnp.ones((1, 128, 128, 3), dtype=dtype) + dummy_latents = self.encode_single_frame(dummy_input) + _, h, w, c = dummy_latents.shape + _, H, W, C = dummy_input.shape + self.__downscale_factor__ = H // h + self.__latent_channels__ = c + print(f"Downscale factor: {self.__downscale_factor__}") + print(f"Latent channels: {self.__latent_channels__}") + + def __encode__(self, images, key: jax.random.PRNGKey = None, **kwargs): + """Encode a batch of images to latent representations. + + Implements the abstract method from the parent class. + + Args: + images: Image tensor of shape [B, H, W, C] + key: Optional random key for stochastic encoding + **kwargs: Additional arguments (unused) + + Returns: + Latent representations of shape [B, h, w, c] + """ + return self.encode_single_frame(images, key) + + def __decode__(self, latents, **kwargs): + """Decode latent representations to images. + + Implements the abstract method from the parent class. + + Args: + latents: Latent tensor of shape [B, h, w, c] + **kwargs: Additional arguments (unused) + + Returns: + Decoded images of shape [B, H, W, C] + """ + return self.decode_single_frame(latents) + + @property + def downscale_factor(self) -> int: + """Returns the downscale factor for the encoder.""" + return self.__downscale_factor__ + + @property + def latent_channels(self) -> int: + """Returns the number of channels in the latent space.""" + return self.__latent_channels__ + + @property + def name(self) -> str: + """Get the name of the autoencoder model.""" + return "stable_diffusion" - def decode(self, latents): - latents = (1.0 / self.scaling_factor) * latents - latents = self.post_quant_conv.apply({"params": self.params["vae"]['post_quant_conv']}, latents) - return self.dec.apply({"params": self.params["vae"]['decoder']}, latents) + def serialize(self): + """Serialize the model to a dictionary format.""" + return { + "modelname": self.modelname, + "revision": self.revision, + "dtype": str(self.dtype), + } + \ No newline at end of file diff --git a/flaxdiff/models/autoencoder/simple_autoenc.py b/flaxdiff/models/autoencoder/simple_autoenc.py index 89e26e2..d838c56 100644 --- a/flaxdiff/models/autoencoder/simple_autoenc.py +++ b/flaxdiff/models/autoencoder/simple_autoenc.py @@ -6,21 +6,53 @@ from .autoencoder import AutoEncoder class SimpleAutoEncoder(AutoEncoder): + """A simple autoencoder implementation using the abstract method pattern. + + This implementation allows for handling both image and video data through + the parent class's handling of video reshaping. + """ latent_channels: int feature_depths: List[int]=[64, 128, 256, 512] - attention_configs:list=[{"heads":8}, {"heads":8}, {"heads":8}, {"heads":8}], + attention_configs:list=[{"heads":8}, {"heads":8}, {"heads":8}, {"heads":8}] num_res_blocks: int=2 - num_middle_res_blocks:int=1, + num_middle_res_blocks:int=1 activation:Callable = jax.nn.swish norm_groups:int=8 dtype: Optional[Dtype] = None precision: PrecisionLike = None - # def encode(self, x: jnp.ndarray): + def __encode__(self, x: jnp.ndarray, **kwargs): + """Encode a batch of images to latent representations. + + Implements the abstract method from the parent class. + Args: + x: Image tensor of shape [B, H, W, C] + **kwargs: Additional arguments + + Returns: + Latent representations of shape [B, h, w, c] + """ + # TODO: Implement the actual encoding logic for single frames + # This is just a placeholder implementation + B, H, W, C = x.shape + h, w = H // 8, W // 8 # Example downsampling factor + return jnp.zeros((B, h, w, self.latent_channels)) - @nn.compact - def __call__(self, x: jnp.ndarray): - latents = self.encode(x) - reconstructions = self.decode(latents) - return reconstructions \ No newline at end of file + def __decode__(self, z: jnp.ndarray, **kwargs): + """Decode latent representations to images. + + Implements the abstract method from the parent class. + + Args: + z: Latent tensor of shape [B, h, w, c] + **kwargs: Additional arguments + + Returns: + Decoded images of shape [B, H, W, C] + """ + # TODO: Implement the actual decoding logic for single frames + # This is just a placeholder implementation + B, h, w, c = z.shape + H, W = h * 8, w * 8 # Example upsampling factor + return jnp.zeros((B, H, W, 3)) \ No newline at end of file diff --git a/flaxdiff/models/simple_unet.py b/flaxdiff/models/simple_unet.py index 06693cf..ae9e3c4 100644 --- a/flaxdiff/models/simple_unet.py +++ b/flaxdiff/models/simple_unet.py @@ -10,11 +10,11 @@ class Unet(nn.Module): output_channels:int=3 - emb_features:int=64*4, - feature_depths:list=[64, 128, 256, 512], - attention_configs:list=[{"heads":8}, {"heads":8}, {"heads":8}, {"heads":8}], - num_res_blocks:int=2, - num_middle_res_blocks:int=1, + emb_features:int=64*4 + feature_depths:list=(64, 128, 256, 512) + attention_configs:list=({"heads":8}, {"heads":8}, {"heads":8}, {"heads":8}) + num_res_blocks:int=2 + num_middle_res_blocks:int=1 activation:Callable = jax.nn.swish norm_groups:int=8 dtype: Optional[Dtype] = None diff --git a/flaxdiff/models/simple_vit.py b/flaxdiff/models/simple_vit.py index 0745e1e..8029546 100644 --- a/flaxdiff/models/simple_vit.py +++ b/flaxdiff/models/simple_vit.py @@ -51,7 +51,7 @@ def __call__(self, x): class UViT(nn.Module): output_channels:int=3 patch_size: int = 16 - emb_features:int=768, + emb_features:int=768 num_layers: int = 12 num_heads: int = 12 dropout_rate: float = 0.1 diff --git a/flaxdiff/models/unet_3d.py b/flaxdiff/models/unet_3d.py new file mode 100644 index 0000000..7635680 --- /dev/null +++ b/flaxdiff/models/unet_3d.py @@ -0,0 +1,446 @@ +from typing import Dict, Optional, Tuple, Union + +import flax +import flax.linen as nn +import jax +import jax.numpy as jnp +from flax.core.frozen_dict import FrozenDict + +from diffusers.configuration_utils import ConfigMixin, flax_register_to_config +from diffusers.utils import BaseOutput +from diffusers.models.embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps +from diffusers.models.modeling_flax_utils import FlaxModelMixin + +from .unet_3d_blocks import ( + FlaxCrossAttnDownBlock3D, + FlaxCrossAttnUpBlock3D, + FlaxDownBlock3D, + FlaxUNetMidBlock3DCrossAttn, + FlaxUpBlock3D, +) + + +@flax_register_to_config +class FlaxUNet3DConditionModel(nn.Module, FlaxModelMixin, ConfigMixin): + r""" + A conditional 3D UNet model for video diffusion. + + Parameters: + sample_size (`int` or `Tuple[int, int, int]`, *optional*, defaults to (16, 32, 32)): + The spatial and temporal size of the input sample. Can be provided as a single integer for square spatial size and fixed temporal size. + in_channels (`int`, *optional*, defaults to 4): + The number of channels in the input sample. + out_channels (`int`, *optional*, defaults to 4): + The number of channels in the output. + down_block_types (`Tuple[str]`, *optional*, defaults to ("CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "CrossAttnDownBlock3D", "DownBlock3D")): + The tuple of downsample blocks to use. + up_block_types (`Tuple[str]`, *optional*, defaults to ("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D")): + The tuple of upsample blocks to use. + block_out_channels (`Tuple[int]`, *optional*, defaults to (320, 640, 1280, 1280)): + The tuple of output channels for each block. + layers_per_block (`int`, *optional*, defaults to 2): + The number of layers per block. + attention_head_dim (`int`, *optional*, defaults to 8): + The dimension of the attention heads. + cross_attention_dim (`int`, *optional*, defaults to 1280): + The dimension of the cross attention features. + dropout (`float`, *optional*, defaults to 0): + Dropout probability for down, up and bottleneck blocks. + use_linear_projection (`bool`, *optional*, defaults to False): + Whether to use linear projection in attention blocks. + dtype (`jnp.dtype`, *optional*, defaults to jnp.float32): + The dtype of the model weights. + flip_sin_to_cos (`bool`, *optional*, defaults to True): + Whether to flip the sin to cos in the time embedding. + freq_shift (`int`, *optional*, defaults to 0): + The frequency shift to apply to the time embedding. + use_memory_efficient_attention (`bool`, *optional*, defaults to False): + Whether to use memory-efficient attention. + split_head_dim (`bool`, *optional*, defaults to False): + Whether to split the head dimension into a new axis for the self-attention computation. + """ + + sample_size: Union[int, Tuple[int, int, int]] = (16, 32, 32) + in_channels: int = 4 + out_channels: int = 4 + down_block_types: Tuple[str, ...] = ( + "CrossAttnDownBlock3D", + "CrossAttnDownBlock3D", + "CrossAttnDownBlock3D", + "DownBlock3D", + ) + up_block_types: Tuple[str, ...] = ("UpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D", "CrossAttnUpBlock3D") + block_out_channels: Tuple[int, ...] = (320, 640, 1280, 1280) + layers_per_block: int = 2 + attention_head_dim: Union[int, Tuple[int, ...]] = 8 + num_attention_heads: Optional[Union[int, Tuple[int, ...]]] = None + cross_attention_dim: int = 1280 + dropout: float = 0.0 + use_linear_projection: bool = False + dtype: jnp.dtype = jnp.float32 + flip_sin_to_cos: bool = True + freq_shift: int = 0 + use_memory_efficient_attention: bool = False + split_head_dim: bool = False + transformer_layers_per_block: Union[int, Tuple[int, ...]] = 1 + addition_embed_type: Optional[str] = None + addition_time_embed_dim: Optional[int] = None + + def init_weights(self, rng: jax.Array) -> FrozenDict: + # init input tensors + if isinstance(self.sample_size, int): + sample_size = (self.sample_size, self.sample_size, self.sample_size) + else: + sample_size = self.sample_size + + # Shape: [batch, frames, height, width, channels] + sample_shape = (1, sample_size[0], sample_size[1], sample_size[2], self.in_channels) + sample = jnp.zeros(sample_shape, dtype=jnp.float32) + timesteps = jnp.ones((1,), dtype=jnp.int32) + encoder_hidden_states = jnp.zeros((1, 1, self.cross_attention_dim), dtype=jnp.float32) + + params_rng, dropout_rng = jax.random.split(rng) + rngs = {"params": params_rng, "dropout": dropout_rng} + + added_cond_kwargs = None + if self.addition_embed_type == "text_time": + # For text-time conditioning for video diffusion + text_embeds_dim = self.cross_attention_dim + time_ids_dims = 6 # Default value for video models + added_cond_kwargs = { + "text_embeds": jnp.zeros((1, text_embeds_dim), dtype=jnp.float32), + "time_ids": jnp.zeros((1, time_ids_dims), dtype=jnp.float32), + } + + return self.init(rngs, sample, timesteps, encoder_hidden_states, added_cond_kwargs)["params"] + + def setup(self) -> None: + block_out_channels = self.block_out_channels + time_embed_dim = block_out_channels[0] * 4 + + if self.num_attention_heads is not None: + raise ValueError( + "At the moment it is not possible to define the number of attention heads via `num_attention_heads` because of a naming issue. " + "Use `attention_head_dim` instead." + ) + + # Default behavior: if num_attention_heads is not set, use attention_head_dim + num_attention_heads = self.num_attention_heads or self.attention_head_dim + + # input + self.conv_in = nn.Conv( + block_out_channels[0], + kernel_size=(3, 3, 3), + strides=(1, 1, 1), + padding=((1, 1), (1, 1), (1, 1)), + dtype=self.dtype, + ) + + # time + self.time_proj = FlaxTimesteps( + block_out_channels[0], flip_sin_to_cos=self.flip_sin_to_cos, freq_shift=self.freq_shift + ) + self.time_embedding = FlaxTimestepEmbedding(time_embed_dim, dtype=self.dtype) + + # Handle attention head configurations + if isinstance(num_attention_heads, int): + num_attention_heads = (num_attention_heads,) * len(self.down_block_types) + + # transformer layers per block + transformer_layers_per_block = self.transformer_layers_per_block + if isinstance(transformer_layers_per_block, int): + transformer_layers_per_block = [transformer_layers_per_block] * len(self.down_block_types) + + # addition embed types + if self.addition_embed_type == "text_time": + if self.addition_time_embed_dim is None: + raise ValueError( + f"addition_embed_type {self.addition_embed_type} requires `addition_time_embed_dim` to not be None" + ) + self.add_time_proj = FlaxTimesteps(self.addition_time_embed_dim, self.flip_sin_to_cos, self.freq_shift) + self.add_embedding = FlaxTimestepEmbedding(time_embed_dim, dtype=self.dtype) + else: + self.add_embedding = None + + # down blocks + down_blocks = [] + output_channel = block_out_channels[0] + for i, down_block_type in enumerate(self.down_block_types): + input_channel = output_channel + output_channel = block_out_channels[i] + is_final_block = i == len(block_out_channels) - 1 + + if down_block_type == "CrossAttnDownBlock3D": + down_block = FlaxCrossAttnDownBlock3D( + in_channels=input_channel, + out_channels=output_channel, + dropout=self.dropout, + num_layers=self.layers_per_block, + transformer_layers_per_block=transformer_layers_per_block[i], + num_attention_heads=num_attention_heads[i], + add_downsample=not is_final_block, + use_linear_projection=self.use_linear_projection, + only_cross_attention=False, # We don't use only cross attention in 3D UNet + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + elif down_block_type == "DownBlock3D": + down_block = FlaxDownBlock3D( + in_channels=input_channel, + out_channels=output_channel, + dropout=self.dropout, + num_layers=self.layers_per_block, + add_downsample=not is_final_block, + dtype=self.dtype, + ) + else: + raise ValueError(f"Unknown down block type: {down_block_type}") + + down_blocks.append(down_block) + self.down_blocks = down_blocks + + # mid block + self.mid_block = FlaxUNetMidBlock3DCrossAttn( + in_channels=block_out_channels[-1], + dropout=self.dropout, + num_attention_heads=num_attention_heads[-1], + transformer_layers_per_block=transformer_layers_per_block[-1], + use_linear_projection=self.use_linear_projection, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + + # up blocks + up_blocks = [] + reversed_block_out_channels = list(reversed(block_out_channels)) + reversed_num_attention_heads = list(reversed(num_attention_heads)) + output_channel = reversed_block_out_channels[0] + reversed_transformer_layers_per_block = list(reversed(transformer_layers_per_block)) + + for i, up_block_type in enumerate(self.up_block_types): + prev_output_channel = output_channel + output_channel = reversed_block_out_channels[i] + input_channel = reversed_block_out_channels[min(i + 1, len(block_out_channels) - 1)] + + is_final_block = i == len(block_out_channels) - 1 + + if up_block_type == "CrossAttnUpBlock3D": + up_block = FlaxCrossAttnUpBlock3D( + in_channels=input_channel, + out_channels=output_channel, + prev_output_channel=prev_output_channel, + num_layers=self.layers_per_block + 1, + transformer_layers_per_block=reversed_transformer_layers_per_block[i], + num_attention_heads=reversed_num_attention_heads[i], + add_upsample=not is_final_block, + dropout=self.dropout, + use_linear_projection=self.use_linear_projection, + only_cross_attention=False, # We don't use only cross attention in 3D UNet + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + elif up_block_type == "UpBlock3D": + up_block = FlaxUpBlock3D( + in_channels=input_channel, + out_channels=output_channel, + prev_output_channel=prev_output_channel, + num_layers=self.layers_per_block + 1, + add_upsample=not is_final_block, + dropout=self.dropout, + dtype=self.dtype, + ) + else: + raise ValueError(f"Unknown up block type: {up_block_type}") + + up_blocks.append(up_block) + prev_output_channel = output_channel + self.up_blocks = up_blocks + + # out + self.conv_norm_out = nn.GroupNorm(num_groups=32, epsilon=1e-5) + self.conv_out = nn.Conv( + self.out_channels, + kernel_size=(3, 3, 3), + strides=(1, 1, 1), + padding=((1, 1), (1, 1), (1, 1)), + dtype=self.dtype, + ) + + def __call__( + self, + sample: jnp.ndarray, + timesteps: Union[jnp.ndarray, float, int], + encoder_hidden_states: jnp.ndarray, + frame_encoder_hidden_states: Optional[jnp.ndarray] = None, + added_cond_kwargs: Optional[Union[Dict, FrozenDict]] = None, + down_block_additional_residuals: Optional[Tuple[jnp.ndarray, ...]] = None, + mid_block_additional_residual: Optional[jnp.ndarray] = None, + return_dict: bool = True, + train: bool = False, + ) -> Union[jnp.ndarray]: + r""" + Args: + sample (`jnp.ndarray`): (batch, frames, height, width, channels) noisy inputs tensor + timestep (`jnp.ndarray` or `float` or `int`): timesteps + encoder_hidden_states (`jnp.ndarray`): (batch_size, sequence_length, hidden_size) encoder hidden states + frame_encoder_hidden_states (`jnp.ndarray`, *optional*): + (batch_size, frames, sequence_length, hidden_size) per-frame encoder hidden states + added_cond_kwargs: (`dict`, *optional*): + Additional embeddings to add to the time embeddings + down_block_additional_residuals: (`tuple` of `jnp.ndarray`, *optional*): + Additional residual connections for down blocks + mid_block_additional_residual: (`jnp.ndarray`, *optional*): + Additional residual connection for mid block + return_dict (`bool`, *optional*, defaults to `True`): + Whether to return a dict or tuple + train (`bool`, *optional*, defaults to `False`): + Training mode flag for dropout + """ + # Extract the number of frames from the input + batch, num_frames, height, width, channels = sample.shape + + # 1. Time embedding + if not isinstance(timesteps, jnp.ndarray): + timesteps = jnp.array([timesteps], dtype=jnp.int32) + elif isinstance(timesteps, jnp.ndarray) and len(timesteps.shape) == 0: + timesteps = timesteps.astype(dtype=jnp.float32) + timesteps = jnp.expand_dims(timesteps, 0) + + t_emb = self.time_proj(timesteps) + t_emb = self.time_embedding(t_emb) + + # Repeat time embedding for each frame + t_emb = jnp.repeat(t_emb, repeats=num_frames, axis=0) + + + # additional embeddings + if self.add_embedding is not None and added_cond_kwargs is not None: + if "text_embeds" not in added_cond_kwargs: + raise ValueError( + "text_embeds must be provided for text_time addition_embed_type" + ) + if "time_ids" not in added_cond_kwargs: + raise ValueError( + "time_ids must be provided for text_time addition_embed_type" + ) + + text_embeds = added_cond_kwargs["text_embeds"] + time_ids = added_cond_kwargs["time_ids"] + + # Compute time embeds + time_embeds = self.add_time_proj(jnp.ravel(time_ids)) + time_embeds = jnp.reshape(time_embeds, (text_embeds.shape[0], -1)) + + # Concatenate text and time embeds + add_embeds = jnp.concatenate([text_embeds, time_embeds], axis=-1) + + # Project to time embedding dimension + aug_emb = self.add_embedding(add_embeds) + t_emb = t_emb + aug_emb + + # 2. Pre-process input - reshape from [B, F, H, W, C] to [B*F, H, W, C] for 2D operations + sample = sample.reshape(batch * num_frames, height, width, channels) + sample = self.conv_in(sample) + + # Process encoder hidden states - repeat for each frame and combine with frame-specific conditioning if provided + if encoder_hidden_states is not None: + # Repeat video-wide conditioning for each frame: (B, S, X) -> (B*F, S, X) + encoder_hidden_states_expanded = jnp.repeat( + encoder_hidden_states, repeats=num_frames, axis=0 + ) + + # If we have frame-specific conditioning, reshape and concatenate with video conditioning + if frame_encoder_hidden_states is not None: + # Reshape from (B, F, S, X) to (B*F, S, X) + frame_encoder_hidden_states = frame_encoder_hidden_states.reshape( + batch * num_frames, *frame_encoder_hidden_states.shape[2:] + ) + + # Concatenate along the sequence dimension + encoder_hidden_states_combined = jnp.concatenate( + [encoder_hidden_states_expanded, frame_encoder_hidden_states], + axis=1 + ) + else: + encoder_hidden_states_combined = encoder_hidden_states_expanded + else: + encoder_hidden_states_combined = None + + # 3. Down blocks + down_block_res_samples = (sample,) + for down_block in self.down_blocks: + if isinstance(down_block, FlaxCrossAttnDownBlock3D): + sample, res_samples = down_block( + sample, + t_emb, + encoder_hidden_states_combined, + num_frames=num_frames, + deterministic=not train + ) + else: + sample, res_samples = down_block( + sample, + t_emb, + num_frames=num_frames, + deterministic=not train + ) + down_block_res_samples += res_samples + + # Add additional residuals if provided + if down_block_additional_residuals is not None: + new_down_block_res_samples = () + + for down_block_res_sample, down_block_additional_residual in zip( + down_block_res_samples, down_block_additional_residuals + ): + down_block_res_sample += down_block_additional_residual + new_down_block_res_samples += (down_block_res_sample,) + + down_block_res_samples = new_down_block_res_samples + + # 4. Mid block + sample = self.mid_block( + sample, + t_emb, + encoder_hidden_states_combined, + num_frames=num_frames, + deterministic=not train + ) + + # Add mid block residual if provided + if mid_block_additional_residual is not None: + sample += mid_block_additional_residual + + # 5. Up blocks + for up_block in self.up_blocks: + res_samples = down_block_res_samples[-(self.layers_per_block + 1) :] + down_block_res_samples = down_block_res_samples[: -(self.layers_per_block + 1)] + if isinstance(up_block, FlaxCrossAttnUpBlock3D): + sample = up_block( + sample, + res_hidden_states_tuple=res_samples, + temb=t_emb, + encoder_hidden_states=encoder_hidden_states_combined, + num_frames=num_frames, + deterministic=not train, + ) + else: + sample = up_block( + sample, + res_hidden_states_tuple=res_samples, + temb=t_emb, + num_frames=num_frames, + deterministic=not train + ) + + # 6. Post-process + sample = self.conv_norm_out(sample) + sample = nn.silu(sample) + sample = self.conv_out(sample) + + # Reshape back to [B, F, H, W, C] + sample = sample.reshape(batch, num_frames, height, width, self.out_channels) + return sample \ No newline at end of file diff --git a/flaxdiff/models/unet_3d_blocks.py b/flaxdiff/models/unet_3d_blocks.py new file mode 100644 index 0000000..bb0d127 --- /dev/null +++ b/flaxdiff/models/unet_3d_blocks.py @@ -0,0 +1,505 @@ +from typing import Tuple, Optional + +import flax.linen as nn +import jax +import jax.numpy as jnp + +from diffusers.models.attention_flax import ( + FlaxBasicTransformerBlock, + FlaxTransformer2DModel, +) + +from diffusers.models.resnet_flax import ( + FlaxResnetBlock2D, + FlaxUpsample2D, + FlaxDownsample2D, +) + +from diffusers.models.unets.unet_2d_blocks_flax import ( + FlaxCrossAttnDownBlock2D, + FlaxDownBlock2D, + FlaxUNetMidBlock2DCrossAttn, + FlaxUpBlock2D, + FlaxCrossAttnUpBlock2D, +) + +class FlaxTransformerTemporalModel(nn.Module): + """ + Transformer for temporal attention in 3D UNet. + """ + in_channels: int + n_heads: int + d_head: int + depth: int = 1 + dropout: float = 0.0 + only_cross_attention: bool = False + dtype: jnp.dtype = jnp.float32 + use_memory_efficient_attention: bool = False + split_head_dim: bool = False + + def setup(self): + self.norm = nn.GroupNorm(num_groups=32, epsilon=1e-5) + + inner_dim = self.n_heads * self.d_head + self.proj_in = nn.Dense(inner_dim, dtype=self.dtype) + # Use existing FlaxBasicTransformerBlock from diffusers + self.transformer_blocks = [ + FlaxBasicTransformerBlock( + inner_dim, + self.n_heads, + self.d_head, + dropout=self.dropout, + only_cross_attention=self.only_cross_attention, + dtype=self.dtype, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + ) + for _ in range(self.depth) + ] + + self.proj_out = nn.Dense(inner_dim, dtype=self.dtype) + + self.dropout_layer = nn.Dropout(rate=self.dropout) + + def __call__(self, hidden_states: jnp.ndarray, context: jnp.ndarray, num_frames: int, deterministic=True): + # Save original shape for later reshaping + batch_depth, height, width, channels = hidden_states.shape + batch = batch_depth // num_frames + + # Reshape to (batch, depth, height, width, channels) + hidden_states = hidden_states.reshape(batch, num_frames, height, width, channels) + residual = hidden_states + + # Apply normalization + hidden_states = self.norm(hidden_states) + + # Reshape for temporal attention: (batch, depth, height, width, channels) -> + # (batch*height*width, depth, channels) + hidden_states = hidden_states.transpose(0, 2, 3, 1, 4) + hidden_states = hidden_states.reshape(batch * height * width, num_frames, channels) + + # Project input + hidden_states = self.proj_in(hidden_states) + + # Apply transformer blocks + for block in self.transformer_blocks: + hidden_states = block(hidden_states, context=context, deterministic=deterministic) + + # Project output + hidden_states = self.proj_out(hidden_states) + + # Reshape back to original shape + hidden_states = hidden_states.reshape(batch, height, width, num_frames, channels) + hidden_states = hidden_states.transpose(0, 3, 1, 2, 4) + + # Add residual connection + hidden_states = hidden_states + residual + + # Reshape back to (batch*depth, height, width, channels) + hidden_states = hidden_states.reshape(batch_depth, height, width, channels) + + return hidden_states + +class TemporalConvLayer(nn.Module): + in_channels: int + out_channels: Optional[int] = None + dropout: float = 0.0 + norm_num_groups: int = 32 + dtype: jnp.dtype = jnp.float32 + + @nn.compact + def __call__(self, x: jnp.ndarray, num_frames: int, deterministic=True) -> jnp.ndarray: + """ + Args: + x: shape (B*F, H, W, C) + num_frames: number of frames F per batch element + + Returns: + A jnp.ndarray of shape (B*F, H, W, C) + """ + out_channels = self.out_channels or self.in_channels + bf, h, w, c = x.shape + b = bf // num_frames + + # Reshape to [B, F, H, W, C], interpret F as "depth" for 3D conv + x = x.reshape(b, num_frames, h, w, c) + identity = x + + # conv1: in_channels -> out_channels + x = nn.GroupNorm(num_groups=self.norm_num_groups)(x) + x = nn.silu(x) + x = nn.Conv(features=out_channels, kernel_size=(3, 1, 1), + dtype=self.dtype, + padding=((1,1), (0,0), (0,0)))(x) + + # conv2: out_channels -> in_channels + x = nn.GroupNorm(num_groups=self.norm_num_groups)(x) + x = nn.silu(x) + x = nn.Dropout(rate=self.dropout)(x, deterministic=deterministic) + x = nn.Conv(features=self.in_channels, kernel_size=(3, 1, 1), + dtype=self.dtype, + padding=((1,1), (0,0), (0,0)))(x) + + # conv3: in_channels -> in_channels + x = nn.GroupNorm(num_groups=self.norm_num_groups)(x) + x = nn.silu(x) + x = nn.Dropout(rate=self.dropout)(x, deterministic=deterministic) + x = nn.Conv(features=self.in_channels, kernel_size=(3, 1, 1), + dtype=self.dtype, + padding=((1,1), (0,0), (0,0)))(x) + + # conv4 (zero-init): in_channels -> in_channels + x = nn.GroupNorm(num_groups=self.norm_num_groups)(x) + x = nn.silu(x) + x = nn.Dropout(rate=self.dropout)(x, deterministic=deterministic) + x = nn.Conv( + features=self.in_channels, + kernel_size=(3, 1, 1), + padding=((1,1), (0,0), (0,0)), + kernel_init=nn.initializers.zeros, + bias_init=nn.initializers.zeros, + dtype=self.dtype, + )(x) + + # Residual connection and reshape back to (B*F, H, W, C) + x = identity + x + x = x.reshape(bf, h, w, c) + return x + + +class FlaxCrossAttnDownBlock3D(FlaxCrossAttnDownBlock2D): + """ + Cross attention 3D downsampling block. + """ + + def setup(self): + resnets = [] + temp_convs = [] + attentions = [] + temp_attentions = [] + + for i in range(self.num_layers): + in_channels = self.in_channels if i == 0 else self.out_channels + + res_block = FlaxResnetBlock2D( + in_channels=in_channels, + out_channels=self.out_channels, + dropout_prob=self.dropout, + dtype=self.dtype, + ) + resnets.append(res_block) + temp_conv = TemporalConvLayer( + in_channels=self.out_channels, + out_channels=self.out_channels, + dropout=self.dropout, + dtype=self.dtype, + ) + temp_convs.append(temp_conv) + attn_block = FlaxTransformer2DModel( + in_channels=self.out_channels, + n_heads=self.num_attention_heads, + d_head=self.out_channels // self.num_attention_heads, + depth=self.transformer_layers_per_block, + use_linear_projection=self.use_linear_projection, + only_cross_attention=self.only_cross_attention, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + attentions.append(attn_block) + temp_attn_block = FlaxTransformerTemporalModel( + in_channels=self.out_channels, + n_heads=self.num_attention_heads, + d_head=self.out_channels // self.num_attention_heads, + depth=self.transformer_layers_per_block, + dropout=self.dropout, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + temp_attentions.append(temp_attn_block) + + self.temp_convs = temp_convs + self.temp_attentions = temp_attentions + self.resnets = resnets + self.attentions = attentions + + if self.add_downsample: + # self.downsamplers_0 = FlaxDownsample3D(self.out_channels, dtype=self.dtype) + self.downsamplers_0 = FlaxDownsample2D(self.out_channels, dtype=self.dtype) + + def __call__(self, hidden_states, temb, encoder_hidden_states, num_frames, deterministic=True): + output_states = () + + for resnet, temp_conv, attn, temp_attn in zip(self.resnets, self.temp_convs, self.attentions, self.temp_attentions): + hidden_states = resnet(hidden_states, temb, deterministic=deterministic) + hidden_states = temp_conv(hidden_states, num_frames=num_frames, deterministic=deterministic) + hidden_states = attn(hidden_states, encoder_hidden_states, deterministic=deterministic) + hidden_states = temp_attn(hidden_states, None, num_frames=num_frames, deterministic=deterministic) + output_states += (hidden_states,) + + if self.add_downsample: + hidden_states = self.downsamplers_0(hidden_states) + output_states += (hidden_states,) + + return hidden_states, output_states + + +class FlaxDownBlock3D(FlaxDownBlock2D): + """ + Basic downsampling block without attention. + """ + def setup(self): + resnets = [] + temp_convs = [] + + for i in range(self.num_layers): + in_channels = self.in_channels if i == 0 else self.out_channels + + res_block = FlaxResnetBlock2D( + in_channels=in_channels, + out_channels=self.out_channels, + dropout_prob=self.dropout, + dtype=self.dtype, + ) + resnets.append(res_block) + temp_conv = TemporalConvLayer( + in_channels=self.out_channels, + out_channels=self.out_channels, + dropout=self.dropout, + dtype=self.dtype, + ) + temp_convs.append(temp_conv) + self.temp_convs = temp_convs + self.resnets = resnets + + if self.add_downsample: + self.downsamplers_0 = FlaxDownsample2D(self.out_channels, dtype=self.dtype) + + def __call__(self, hidden_states, temb, num_frames, deterministic=True): + output_states = () + + for resnet, temp_conv in zip(self.resnets, self.temp_convs): + hidden_states = resnet(hidden_states, temb, deterministic=deterministic) + hidden_states = temp_conv(hidden_states, num_frames=num_frames, deterministic=deterministic) + output_states += (hidden_states,) + + if self.add_downsample: + hidden_states = self.downsamplers_0(hidden_states) + output_states += (hidden_states,) + + return hidden_states, output_states + + +class FlaxCrossAttnUpBlock3D(FlaxCrossAttnUpBlock2D): + """ + Cross attention 3D upsampling block. + """ + + def setup(self): + resnets = [] + temp_convs = [] + attentions = [] + temp_attentions = [] + + for i in range(self.num_layers): + res_skip_channels = self.in_channels if (i == self.num_layers - 1) else self.out_channels + resnet_in_channels = self.prev_output_channel if i == 0 else self.out_channels + + res_block = FlaxResnetBlock2D( + in_channels=resnet_in_channels + res_skip_channels, + out_channels=self.out_channels, + dropout_prob=self.dropout, + dtype=self.dtype, + ) + resnets.append(res_block) + temp_conv = TemporalConvLayer( + in_channels=self.out_channels, + out_channels=self.out_channels, + dropout=self.dropout, + dtype=self.dtype, + ) + temp_convs.append(temp_conv) + attn_block = FlaxTransformer2DModel( + in_channels=self.out_channels, + n_heads=self.num_attention_heads, + d_head=self.out_channels // self.num_attention_heads, + depth=self.transformer_layers_per_block, + use_linear_projection=self.use_linear_projection, + only_cross_attention=self.only_cross_attention, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + attentions.append(attn_block) + temp_attn_block = FlaxTransformerTemporalModel( + in_channels=self.out_channels, + n_heads=self.num_attention_heads, + d_head=self.out_channels // self.num_attention_heads, + depth=self.transformer_layers_per_block, + dropout=self.dropout, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + temp_attentions.append(temp_attn_block) + + self.resnets = resnets + self.attentions = attentions + self.temp_convs = temp_convs + self.temp_attentions = temp_attentions + + if self.add_upsample: + self.upsamplers_0 = FlaxUpsample2D(self.out_channels, dtype=self.dtype) + + def __call__(self, hidden_states, res_hidden_states_tuple, temb, encoder_hidden_states, num_frames, deterministic=True): + for resnet, temp_conv, attn, temp_attn in zip(self.resnets, self.temp_convs, self.attentions, self.temp_attentions): + # pop res hidden states + res_hidden_states = res_hidden_states_tuple[-1] + res_hidden_states_tuple = res_hidden_states_tuple[:-1] + hidden_states = jnp.concatenate((hidden_states, res_hidden_states), axis=-1) + + hidden_states = resnet(hidden_states, temb, deterministic=deterministic) + hidden_states = temp_conv(hidden_states, num_frames=num_frames, deterministic=deterministic) + hidden_states = attn(hidden_states, encoder_hidden_states, deterministic=deterministic) + hidden_states = temp_attn(hidden_states, None, num_frames=num_frames, deterministic=deterministic) + + if self.add_upsample: + hidden_states = self.upsamplers_0(hidden_states) + + return hidden_states + + +class FlaxUpBlock3D(FlaxUpBlock2D): + """ + Basic upsampling block without attention. + """ + def setup(self): + resnets = [] + temp_convs = [] + + for i in range(self.num_layers): + res_skip_channels = self.in_channels if (i == self.num_layers - 1) else self.out_channels + resnet_in_channels = self.prev_output_channel if i == 0 else self.out_channels + + res_block = FlaxResnetBlock2D( + in_channels=resnet_in_channels + res_skip_channels, + out_channels=self.out_channels, + dropout_prob=self.dropout, + dtype=self.dtype, + ) + resnets.append(res_block) + temp_conv = TemporalConvLayer( + in_channels=self.out_channels, + out_channels=self.out_channels, + dropout=self.dropout, + dtype=self.dtype, + ) + temp_convs.append(temp_conv) + + self.resnets = resnets + self.temp_convs = temp_convs + + if self.add_upsample: + self.upsamplers_0 = FlaxUpsample2D(self.out_channels, dtype=self.dtype) + + def __call__(self, hidden_states, res_hidden_states_tuple, temb, num_frames, deterministic=True): + for resnet, temp_conv in zip(self.resnets, self.temp_convs): + # pop res hidden states + res_hidden_states = res_hidden_states_tuple[-1] + res_hidden_states_tuple = res_hidden_states_tuple[:-1] + hidden_states = jnp.concatenate((hidden_states, res_hidden_states), axis=-1) + + hidden_states = resnet(hidden_states, temb, deterministic=deterministic) + hidden_states = temp_conv(hidden_states, num_frames=num_frames, deterministic=deterministic) + + if self.add_upsample: + hidden_states = self.upsamplers_0(hidden_states) + + return hidden_states + + +class FlaxUNetMidBlock3DCrossAttn(FlaxUNetMidBlock2DCrossAttn): + """ + Middle block with cross-attention for 3D UNet. + """ + def setup(self): + # there is always at least one resnet + resnets = [ + FlaxResnetBlock2D( + in_channels=self.in_channels, + out_channels=self.in_channels, + dropout_prob=self.dropout, + dtype=self.dtype, + ) + ] + temp_convs = [ + TemporalConvLayer( + in_channels=self.in_channels, + out_channels=self.in_channels, + dropout=self.dropout, + dtype=self.dtype, + ) + ] + + attentions = [] + temp_attentions = [] + + for _ in range(self.num_layers): + attn_block = FlaxTransformer2DModel( + in_channels=self.in_channels, + n_heads=self.num_attention_heads, + d_head=self.in_channels // self.num_attention_heads, + depth=self.transformer_layers_per_block, + use_linear_projection=self.use_linear_projection, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + attentions.append(attn_block) + + temp_block = FlaxTransformerTemporalModel( + in_channels=self.in_channels, + n_heads=self.num_attention_heads, + d_head=self.in_channels // self.num_attention_heads, + depth=self.transformer_layers_per_block, + dropout=self.dropout, + use_memory_efficient_attention=self.use_memory_efficient_attention, + split_head_dim=self.split_head_dim, + dtype=self.dtype, + ) + temp_attentions.append(temp_block) + + res_block = FlaxResnetBlock2D( + in_channels=self.in_channels, + out_channels=self.in_channels, + dropout_prob=self.dropout, + dtype=self.dtype, + ) + resnets.append(res_block) + temp_conv = TemporalConvLayer( + in_channels=self.in_channels, + out_channels=self.in_channels, + dropout=self.dropout, + dtype=self.dtype, + ) + temp_convs.append(temp_conv) + + self.temp_convs = temp_convs + self.temp_attentions = temp_attentions + self.resnets = resnets + self.attentions = attentions + + def __call__(self, hidden_states, temb, encoder_hidden_states, num_frames, deterministic=True): + hidden_states = self.resnets[0](hidden_states, temb, deterministic=deterministic) + hidden_states = self.temp_convs[0](hidden_states, num_frames=num_frames, deterministic=deterministic) + + for attn, temp_attn, resnet, temp_conv in zip( + self.attentions, self.temp_attentions, self.resnets[1:], self.temp_convs[1:] + ): + hidden_states = attn(hidden_states, encoder_hidden_states, deterministic=deterministic) + hidden_states = temp_attn(hidden_states, None, num_frames=num_frames, deterministic=deterministic) + hidden_states = resnet(hidden_states, temb, deterministic=deterministic) + hidden_states = temp_conv(hidden_states, num_frames=num_frames, deterministic=deterministic) + + return hidden_states diff --git a/flaxdiff/samplers/common.py b/flaxdiff/samplers/common.py index e1dfe84..69d1559 100644 --- a/flaxdiff/samplers/common.py +++ b/flaxdiff/samplers/common.py @@ -1,148 +1,368 @@ -from flax import linen as nn +from typing import Union, Type + import jax import jax.numpy as jnp import tqdm -from typing import Union, Type +from flax import linen as nn +from typing import List, Tuple, Dict, Any, Optional + +from ..predictors import DiffusionPredictionTransform, EpsilonPredictionTransform from ..schedulers import NoiseScheduler from ..utils import RandomMarkovState, MarkovState, clip_images -from ..predictors import DiffusionPredictionTransform, EpsilonPredictionTransform +from jax.experimental.shard_map import shard_map +from jax.sharding import Mesh, PartitionSpec as P +from flaxdiff.models.autoencoder import AutoEncoder +from flaxdiff.inputs import DiffusionInputConfig -class DiffusionSampler(): - def __init__(self, model:nn.Module, params:dict, - noise_schedule:NoiseScheduler, - model_output_transform:DiffusionPredictionTransform, - guidance_scale:float = 0.0, - null_labels_seq:jax.Array=None, - autoencoder=None, - image_size=256, - autoenc_scale_reduction=8, - autoenc_latent_channels=4, - ): +class DiffusionSampler: + """Base class for diffusion samplers.""" + + def __init__( + self, + model: nn.Module, + noise_schedule: NoiseScheduler, + model_output_transform: DiffusionPredictionTransform, + input_config: DiffusionInputConfig, + guidance_scale: float = 0.0, + autoencoder: AutoEncoder = None, + timestep_spacing: str = 'linear', + ): + """Initialize the diffusion sampler. + + Args: + model: Neural network model + params: Model parameters + noise_schedule: Noise scheduler + model_output_transform: Transform for model predictions + guidance_scale: Scale for classifier-free guidance (0.0 means disabled) + autoencoder: Optional autoencoder for latent diffusion + timestep_spacing: Strategy for timestep spacing in sampling + 'linear' - Default equal spacing + 'quadratic' - Emphasizes early steps + 'karras' - Based on EDM paper, better with fewer steps + 'exponential' - Concentrates steps near the end + """ self.model = model self.noise_schedule = noise_schedule - self.params = params self.model_output_transform = model_output_transform self.guidance_scale = guidance_scale - self.image_size = image_size - self.autoenc_scale_reduction = autoenc_scale_reduction self.autoencoder = autoencoder - self.autoenc_latent_channels = autoenc_latent_channels + self.timestep_spacing = timestep_spacing + self.input_config = input_config + + unconditionals = input_config.get_unconditionals() + + # For Karras spacing if needed + if hasattr(noise_schedule, 'min_inv_rho') and hasattr(noise_schedule, 'max_inv_rho'): + self.min_inv_rho = noise_schedule.min_inv_rho + self.max_inv_rho = noise_schedule.max_inv_rho if self.guidance_scale > 0: # Classifier free guidance - assert null_labels_seq is not None, "Null labels sequence is required for classifier-free guidance" print("Using classifier-free guidance") - def sample_model(params, x_t, t, *additional_inputs): + + def sample_model(params, x_t, t, *conditioning_inputs): # Concatenate unconditional and conditional inputs x_t_cat = jnp.concatenate([x_t] * 2, axis=0) t_cat = jnp.concatenate([t] * 2, axis=0) rates_cat = self.noise_schedule.get_rates(t_cat) c_in_cat = self.model_output_transform.get_input_scale(rates_cat) - text_labels_seq, = additional_inputs - text_labels_seq = jnp.concatenate([text_labels_seq, jnp.broadcast_to(null_labels_seq, text_labels_seq.shape)], axis=0) - model_output = self.model.apply(params, *self.noise_schedule.transform_inputs(x_t_cat * c_in_cat, t_cat), text_labels_seq) + final_conditionals = [] + for conditional, unconditional in zip(conditioning_inputs, unconditionals): + final = jnp.concatenate([ + conditional, + jnp.broadcast_to(unconditional, conditional.shape) + ], axis=0) + final_conditionals.append(final) + final_conditionals = tuple(final_conditionals) + + model_output = self.model.apply( + params, + *self.noise_schedule.transform_inputs(x_t_cat * c_in_cat, t_cat), + *final_conditionals + ) + # Split model output into unconditional and conditional parts model_output_cond, model_output_uncond = jnp.split(model_output, 2, axis=0) model_output = model_output_uncond + guidance_scale * (model_output_cond - model_output_uncond) - + x_0, eps = self.model_output_transform(x_t, model_output, t, self.noise_schedule) return x_0, eps, model_output else: # Unconditional sampling - def sample_model(params, x_t, t, *additional_inputs): + def sample_model(params, x_t, t, *conditioning_inputs): rates = self.noise_schedule.get_rates(t) c_in = self.model_output_transform.get_input_scale(rates) - model_output = self.model.apply(params, *self.noise_schedule.transform_inputs(x_t * c_in, t), *additional_inputs) + model_output = self.model.apply( + params, + *self.noise_schedule.transform_inputs(x_t * c_in, t), + *conditioning_inputs + ) x_0, eps = self.model_output_transform(x_t, model_output, t, self.noise_schedule) return x_0, eps, model_output - # if jax.device_count() > 1: - # mesh = jax.sharding.Mesh(jax.devices(), 'data') - # sample_model = shard_map(sample_model, mesh=mesh, in_specs=(P('data'), P('data'), P('data')), - # out_specs=(P('data'), P('data'), P('data'))) - sample_model = jax.jit(sample_model) - self.sample_model = sample_model - - # Used to sample from the diffusion model - def sample_step(self, sample_model_fn, current_samples:jnp.ndarray, current_step, model_conditioning_inputs, next_step=None, state:MarkovState=None) -> tuple[jnp.ndarray, MarkovState]: - # First clip the noisy images - step_ones = jnp.ones((len(current_samples), ), dtype=jnp.int32) + # JIT compile the sampling function for better performance + def post_process(samples: jnp.ndarray): + """Post-process the generated samples.""" + if autoencoder is not None: + samples = autoencoder.decode(samples) + + samples = clip_images(samples) + return samples + + self.sample_model = jax.jit(sample_model) + self.post_process = jax.jit(post_process) + + def sample_step( + self, + sample_model_fn, + current_samples: jnp.ndarray, + current_step, + model_conditioning_inputs, + next_step=None, + state: RandomMarkovState = None + ) -> tuple[jnp.ndarray, RandomMarkovState]: + """Perform a single sampling step in the diffusion process. + + Args: + sample_model_fn: Function to sample from model + current_samples: Current noisy samples + current_step: Current diffusion timestep + model_conditioning_inputs: Conditioning inputs for the model + next_step: Next diffusion timestep + state: Current Markov state + + Returns: + Tuple of (new samples, updated state) + """ + step_ones = jnp.ones((len(current_samples),), dtype=jnp.int32) current_step = step_ones * current_step next_step = step_ones * next_step - pred_images, pred_noise, _ = sample_model_fn(current_samples, current_step, *model_conditioning_inputs) - # plotImages(pred_images) - # pred_images = clip_images(pred_images) - new_samples, state = self.take_next_step(current_samples=current_samples, reconstructed_samples=pred_images, - pred_noise=pred_noise, current_step=current_step, next_step=next_step, state=state, - model_conditioning_inputs=model_conditioning_inputs, - sample_model_fn=sample_model_fn, - ) + + pred_images, pred_noise, _ = sample_model_fn( + current_samples, current_step, *model_conditioning_inputs + ) + + new_samples, state = self.take_next_step( + current_samples=current_samples, + reconstructed_samples=pred_images, + pred_noise=pred_noise, + current_step=current_step, + next_step=next_step, + state=state, + model_conditioning_inputs=model_conditioning_inputs, + sample_model_fn=sample_model_fn, + ) return new_samples, state - def take_next_step(self, current_samples, reconstructed_samples, model_conditioning_inputs, - pred_noise, current_step, state:RandomMarkovState, sample_model_fn, next_step=1,) -> tuple[jnp.ndarray, RandomMarkovState]: - # estimate the q(x_{t-1} | x_t, x_0). - # pred_images is x_0, noisy_images is x_t, steps is t - return NotImplementedError - + + def take_next_step( + self, + current_samples, + reconstructed_samples, + model_conditioning_inputs, + pred_noise, + current_step, + state: RandomMarkovState, + sample_model_fn, + next_step=1, + ) -> tuple[jnp.ndarray, RandomMarkovState]: + """Take the next step in the diffusion process. + + This method needs to be implemented by subclasses. + """ + raise NotImplementedError("Subclasses must implement take_next_step method") + + def scale_steps(self, steps): + """Scale timesteps to match the noise schedule's range.""" scale_factor = self.noise_schedule.max_timesteps / 1000 return steps * scale_factor + def get_steps(self, start_step, end_step, diffusion_steps): + """Get the sequence of timesteps for the diffusion process. + + Args: + start_step: Starting timestep (typically the max) + end_step: Ending timestep (typically 0) + diffusion_steps: Number of steps to use + + Returns: + Array of timesteps for sampling + """ step_range = start_step - end_step if diffusion_steps is None or diffusion_steps == 0: - diffusion_steps = start_step - end_step + diffusion_steps = step_range diffusion_steps = min(diffusion_steps, step_range) - steps = jnp.linspace(end_step, start_step, diffusion_steps, dtype=jnp.int16)[::-1] + + # Linear spacing (default) + if getattr(self, 'timestep_spacing', 'linear') == 'linear': + steps = jnp.linspace( + end_step, start_step, + diffusion_steps, dtype=jnp.int16 + )[::-1] + + # Quadratic spacing (emphasizes early steps) + elif self.timestep_spacing == 'quadratic': + steps = jnp.linspace(0, 1, diffusion_steps) ** 2 + steps = (start_step - end_step) * steps + end_step + steps = jnp.asarray(steps, dtype=jnp.int16)[::-1] + + # Karras spacing from the EDM paper - often gives better results with fewer steps + elif self.timestep_spacing == 'karras': + # Implementation based on the EDM paper's recommendations + sigma_min = end_step / start_step + sigma_max = 1.0 + rho = 7.0 # Karras paper default, controls the distribution + + # Create log-spaced steps in sigma space + sigmas = jnp.exp(jnp.linspace( + jnp.log(sigma_max), jnp.log(sigma_min), diffusion_steps + )) + steps = jnp.clip( + (sigmas ** (1 / rho) - self.min_inv_rho) / + (self.max_inv_rho - self.min_inv_rho), + 0, 1 + ) * start_step + steps = jnp.asarray(steps, dtype=jnp.int16) + + # Exponential spacing (concentrates steps near the end) + elif self.timestep_spacing == 'exponential': + steps = jnp.linspace(0, 1, diffusion_steps) + steps = jnp.exp(steps * jnp.log((start_step + 1) / (end_step + 1))) * (end_step + 1) - 1 + steps = jnp.clip(steps, end_step, start_step) + steps = jnp.asarray(steps, dtype=jnp.int16)[::-1] + + # Fallback to linear spacing + else: + steps = jnp.linspace( + end_step, start_step, + diffusion_steps, dtype=jnp.int16 + )[::-1] + return steps - - def get_initial_samples(self, num_images, rngs:jax.random.PRNGKey, start_step): - start_step = self.scale_steps(start_step) - alpha_n, sigma_n = self.noise_schedule.get_rates(start_step) - variance = jnp.sqrt(alpha_n ** 2 + sigma_n ** 2) - image_size = self.image_size - image_channels = 3 - if self.autoencoder is not None: - image_size = image_size // self.autoenc_scale_reduction - image_channels = self.autoenc_latent_channels - return jax.random.normal(rngs, (num_images, image_size, image_size, image_channels)) * variance - - def generate_images(self, - params:dict=None, - num_images=16, - diffusion_steps=1000, - start_step:int = None, - end_step:int = 0, - steps_override=None, - priors=None, - rngstate:RandomMarkovState=None, - model_conditioning_inputs:tuple=() - ) -> jnp.ndarray: + + + def generate_samples( + self, + params: dict, + num_samples: int, + resolution: int, + sequence_length: int = None, + diffusion_steps: int = 1000, + start_step: int = None, + end_step: int = 0, + steps_override=None, + priors=None, + rngstate: RandomMarkovState = None, + conditioning: List[Union[Tuple, Dict]] = None, + model_conditioning_inputs: Tuple = None, + ) -> jnp.ndarray: + """Generate samples using the diffusion model. + + Provides a unified interface for generating both images and videos. + For images, just specify batch_size. + For videos, specify both batch_size and sequence_length. + + Args: + params: Model parameters (uses self.params if None) + num_samples: Number of samples to generate (videos or images) + resolution: Resolution of the generated samples (H, W) + sequence_length: Length of each sequence (for videos/audio/etc) + If None, generates regular images + diffusion_steps: Number of diffusion steps to perform + start_step: Starting timestep (defaults to max) + end_step: Ending timestep + steps_override: Override default timestep sequence + priors: Prior samples to start from instead of noise + rngstate: Random state for reproducibility + conditioning: (Optional) List of conditioning inputs for the model + model_conditioning_inputs: (Optional) Pre-processed conditioning inputs + + Returns: + Generated samples as a JAX array: + - For images: shape [batch_size, H, W, C] + - For videos: shape [batch_size, sequence_length, H, W, C] + """ if rngstate is None: rngstate = RandomMarkovState(jax.random.PRNGKey(42)) + + if start_step is None: + start_step = self.noise_schedule.max_timesteps + if priors is None: + # Determine if we're generating videos or images based on sequence_length + is_video = sequence_length is not None + rngstate, newrngs = rngstate.get_random_key() - samples = self.get_initial_samples(num_images, newrngs, start_step) + + # Get sample shape based on whether we're generating video or images + if is_video: + samples = self._get_initial_sequence_samples( + resolution, num_samples, sequence_length, newrngs, start_step + ) + else: + samples = self._get_initial_samples(resolution, num_samples, newrngs, start_step) else: print("Using priors") if self.autoencoder is not None: + # Let the autoencoder handle both image and video priors priors = self.autoencoder.encode(priors) samples = priors - - params = params if params is not None else self.params - # @jax.jit + if conditioning is not None: + if model_conditioning_inputs is not None: + raise ValueError("Cannot provide both conditioning and model_conditioning_inputs") + print("Processing raw conditioning inputs to generate model conditioning inputs") + separated: Dict[str, List] = {} + for cond in self.input_config.conditions: + separated[cond.encoder.key] = [] + # Separate the conditioning inputs, one for each condition + for vals in conditioning: + if isinstance(vals, tuple) or isinstance(vals, list): + # If its a tuple, assume that the ordering aligns with the ordering of the conditions + # Thus, use the conditioning encoder key as the key + for cond, val in zip(self.input_config.conditions, vals): + separated[cond.encoder.key].append(val) + elif isinstance(vals, dict): + # If its a dict, use the encoder key as the key + for cond in self.input_config.conditions: + if cond.encoder.key in vals: + separated[cond.encoder.key].append(vals[cond.encoder.key]) + else: + raise ValueError(f"Conditioning input {cond.encoder.key} not found in provided dictionary") + else: + # If its a single value, use the encoder key as the key + for cond in self.input_config.conditions: + separated[cond.encoder.key].append(vals) + + # Now we have a dictionary of lists, one for each condition, encode them + finals = [] + for cond in self.input_config.conditions: + # Get the encoder for the condition + encoder = cond.encoder + encoded = encoder(separated[encoder.key]) + finals.append(encoded) + + model_conditioning_inputs = tuple(finals) + + if model_conditioning_inputs is None: + model_conditioning_inputs = [] + def sample_model_fn(x_t, t, *additional_inputs): return self.sample_model(params, x_t, t, *additional_inputs) - # @jax.jit - def sample_step(sample_model_fn, state:RandomMarkovState, samples, current_step, next_step): - samples, state = self.sample_step(sample_model_fn=sample_model_fn, current_samples=samples, - current_step=current_step, - model_conditioning_inputs=model_conditioning_inputs, - state=state, next_step=next_step) + def sample_step(sample_model_fn, state: RandomMarkovState, samples, current_step, next_step): + samples, state = self.sample_step( + sample_model_fn=sample_model_fn, + current_samples=samples, + current_step=current_step, + model_conditioning_inputs=model_conditioning_inputs, + state=state, + next_step=next_step + ) return samples, state if start_step is None: @@ -153,19 +373,61 @@ def sample_step(sample_model_fn, state:RandomMarkovState, samples, current_step, else: steps = self.get_steps(start_step, end_step, diffusion_steps) - # print("Sampling steps", steps) for i in tqdm.tqdm(range(0, len(steps))): current_step = self.scale_steps(steps[i]) next_step = self.scale_steps(steps[i+1] if i+1 < len(steps) else 0) + if i != len(steps) - 1: - # print("normal step") - samples, rngstate = sample_step(sample_model_fn, rngstate, samples, current_step, next_step) + samples, rngstate = sample_step( + sample_model_fn, rngstate, samples, current_step, next_step + ) else: - # print("last step") - step_ones = jnp.ones((num_images, ), dtype=jnp.int32) - samples, _, _ = sample_model_fn(samples, current_step * step_ones, *model_conditioning_inputs) + step_ones = jnp.ones((samples.shape[0],), dtype=jnp.int32) + samples, _, _ = sample_model_fn( + samples, current_step * step_ones, *model_conditioning_inputs + ) + return self.post_process(samples) + + def _get_noise_parameters(self, resolution, start_step): + """Calculate common noise parameters for sample generation. + + Args: + start_step: Starting timestep for noise generation + + Returns: + Tuple of (variance, image_size, image_channels) + """ + start_step = self.scale_steps(start_step) + alpha_n, sigma_n = self.noise_schedule.get_rates(start_step) + variance = jnp.sqrt(alpha_n ** 2 + sigma_n ** 2) + + image_size = resolution + image_channels = 3 if self.autoencoder is not None: - samples = self.autoencoder.decode(samples) - samples = clip_images(samples) - return samples - \ No newline at end of file + image_size = image_size // self.autoencoder.downscale_factor + image_channels = self.autoencoder.latent_channels + + return variance, image_size, image_channels + + def _get_initial_samples(self, resolution, batch_size, rngs: jax.random.PRNGKey, start_step): + """Generate initial noisy samples for image generation.""" + variance, image_size, image_channels = self._get_noise_parameters(resolution, start_step) + + # Standard image generation + return jax.random.normal( + rngs, + (batch_size, image_size, image_size, image_channels) + ) * variance + + def _get_initial_sequence_samples(self, resolution, batch_size, sequence_length, rngs: jax.random.PRNGKey, start_step): + """Generate initial noisy samples for sequence data (video/audio).""" + variance, image_size, image_channels = self._get_noise_parameters(resolution, start_step) + + # Generate sequence data (like video) + return jax.random.normal( + rngs, + (batch_size, sequence_length, image_size, image_size, image_channels) + ) * variance + + # Alias for backward compatibility + generate_images = generate_samples diff --git a/flaxdiff/samplers/ddim.py b/flaxdiff/samplers/ddim.py index 5689800..4921952 100644 --- a/flaxdiff/samplers/ddim.py +++ b/flaxdiff/samplers/ddim.py @@ -1,10 +1,49 @@ import jax.numpy as jnp from .common import DiffusionSampler from ..utils import MarkovState, RandomMarkovState +import jax +from flaxdiff.schedulers import get_coeff_shapes_tuple class DDIMSampler(DiffusionSampler): - def take_next_step(self, current_samples, reconstructed_samples, model_conditioning_inputs, - pred_noise, current_step, state:RandomMarkovState, sample_model_fn, next_step=1) -> tuple[jnp.ndarray, RandomMarkovState]: - next_signal_rate, next_noise_rate = self.noise_schedule.get_rates(next_step) - return reconstructed_samples * next_signal_rate + pred_noise * next_noise_rate, state - \ No newline at end of file + def __init__(self, *args, eta=0.0, **kwargs): + """Initialize DDIM sampler with customizable noise level. + + Args: + eta: Controls the stochasticity of the sampler. + 0.0 = deterministic (DDIM), 1.0 = DDPM-like. + """ + super().__init__(*args, **kwargs) + self.eta = eta + + def take_next_step( + self, + current_samples, + reconstructed_samples, + model_conditioning_inputs, + pred_noise, + current_step, + state: RandomMarkovState, + sample_model_fn, + next_step=1 + ) -> tuple[jnp.ndarray, RandomMarkovState]: + # Get diffusion coefficients for current and next timesteps + alpha_t, sigma_t = self.noise_schedule.get_rates(current_step, get_coeff_shapes_tuple(current_samples)) + alpha_next, sigma_next = self.noise_schedule.get_rates(next_step, get_coeff_shapes_tuple(current_samples)) + + # Extract random noise if needed for stochastic sampling + if self.eta > 0: + # For DDIM, we need to compute the variance coefficient + # This is based on the original DDIM paper's formula + # When eta=0, it's deterministic DDIM, when eta=1.0 it approaches DDPM + sigma_tilde = self.eta * sigma_next * (1 - alpha_t**2 / alpha_next**2).sqrt() / (1 - alpha_t**2).sqrt() + state, noise_key = state.get_random_key() + noise = jax.random.normal(noise_key, current_samples.shape) + # Add the stochastic component + stochastic_term = sigma_tilde * noise + else: + stochastic_term = 0 + + # Direct DDIM update formula + new_samples = alpha_next * reconstructed_samples + sigma_next * pred_noise + stochastic_term + + return new_samples, state diff --git a/flaxdiff/schedulers/karras.py b/flaxdiff/schedulers/karras.py index d7c0d56..b651c75 100644 --- a/flaxdiff/schedulers/karras.py +++ b/flaxdiff/schedulers/karras.py @@ -5,35 +5,43 @@ from ..utils import RandomMarkovState class KarrasVENoiseScheduler(GeneralizedNoiseScheduler): - def __init__(self, timesteps, sigma_min=0.002, sigma_max=80, rho=7., sigma_data=0.5, *args, **kwargs): + def __init__(self, timesteps=1.0, sigma_min=0.002, sigma_max=80, rho=7., sigma_data=0.5, *args, **kwargs): super().__init__(timesteps=timesteps, sigma_min=sigma_min, sigma_max=sigma_max, sigma_data=sigma_data, *args, **kwargs) self.min_inv_rho = sigma_min ** (1 / rho) self.max_inv_rho = sigma_max ** (1 / rho) self.rho = rho - + def get_sigmas(self, steps) -> jnp.ndarray: - # steps = jnp.int16(steps) - # return self.sigmas[steps] - ramp = 1 - steps / self.max_timesteps + # Ensure steps are properly normalized and clamped to avoid edge cases + ramp = jnp.clip(1 - steps / self.max_timesteps, 0.0, 1.0) sigmas = (self.max_inv_rho + ramp * (self.min_inv_rho - self.max_inv_rho)) ** self.rho return sigmas - + def get_weights(self, steps, shape=(-1, 1, 1, 1)) -> jnp.ndarray: sigma = self.get_sigmas(steps) - weights = ((sigma ** 2 + self.sigma_data ** 2) / (sigma * self.sigma_data) ** 2) + # Add epsilon for numerical stability + epsilon = 1e-6 + weights = ((sigma ** 2 + self.sigma_data ** 2) / ((sigma * self.sigma_data) ** 2 + epsilon)) return weights.reshape(shape) def transform_inputs(self, x, steps, num_discrete_chunks=1000) -> tuple[jnp.ndarray, jnp.ndarray]: sigmas = self.get_sigmas(steps) - # sigmas = (sigmas / self.sigma_max) * num_discrete_chunks - sigmas = jnp.log(sigmas) / 4 + # Avoid log(0) by adding a small epsilon + epsilon = 1e-12 + sigmas = jnp.log(sigmas + epsilon) / 4 return x, sigmas def get_timesteps(self, sigmas:jnp.ndarray) -> jnp.ndarray: sigmas = sigmas.reshape(-1) - inv_rho = sigmas ** (1 / self.rho) - ramp = ((inv_rho - self.max_inv_rho) / (self.min_inv_rho - self.max_inv_rho)) - steps = 1 - ramp * self.max_timesteps + # Add epsilon for numerical stability + epsilon = 1e-12 + inv_rho = (sigmas + epsilon) ** (1 / self.rho) + # Ensure proper clamping to avoid numerical issues + denominator = (self.min_inv_rho - self.max_inv_rho) + if abs(denominator) < 1e-7: + denominator = jnp.sign(denominator) * 1e-7 + ramp = jnp.clip((inv_rho - self.max_inv_rho) / denominator, 0.0, 1.0) + steps = jnp.clip(1 - ramp, 0.0, 1.0) * self.max_timesteps return steps def generate_timesteps(self, batch_size, state:RandomMarkovState) -> tuple[jnp.ndarray, RandomMarkovState]: diff --git a/flaxdiff/trainer/__init__.py b/flaxdiff/trainer/__init__.py index b7dfc84..b89f89c 100644 --- a/flaxdiff/trainer/__init__.py +++ b/flaxdiff/trainer/__init__.py @@ -1,2 +1,3 @@ from .simple_trainer import SimpleTrainer, SimpleTrainState, Metrics -from .diffusion_trainer import DiffusionTrainer, TrainState \ No newline at end of file +from .diffusion_trainer import DiffusionTrainer, TrainState +from .general_diffusion_trainer import GeneralDiffusionTrainer, ConditionalInputConfig \ No newline at end of file diff --git a/flaxdiff/trainer/autoencoder_trainer.py b/flaxdiff/trainer/autoencoder_trainer.py index f57dccb..f7b2918 100644 --- a/flaxdiff/trainer/autoencoder_trainer.py +++ b/flaxdiff/trainer/autoencoder_trainer.py @@ -114,8 +114,7 @@ def train_step(train_state: TrainState, rng_state: RandomMarkovState, batch, loc # normalize image images = (images - 127.5) / 127.5 - output = text_embedder( - input_ids=batch['input_ids'], attention_mask=batch['attention_mask']) + output = text_embedder.encode_from_tokens(batch['text']) label_seq = output.last_hidden_state # Generate random probabilities to decide how much of this batch will be unconditional diff --git a/flaxdiff/trainer/diffusion_trainer.py b/flaxdiff/trainer/diffusion_trainer.py index 53f7978..44bafe6 100644 --- a/flaxdiff/trainer/diffusion_trainer.py +++ b/flaxdiff/trainer/diffusion_trainer.py @@ -22,7 +22,7 @@ from flaxdiff.models.autoencoder.autoencoder import AutoEncoder from flax.training import dynamic_scale as dynamic_scale_lib -from flaxdiff.utils import TextEncoder, ConditioningEncoder +from flaxdiff.inputs import TextEncoder, ConditioningEncoder class TrainState(SimpleTrainState): rngs: jax.random.PRNGKey @@ -42,6 +42,7 @@ class DiffusionTrainer(SimpleTrainer): noise_schedule: NoiseScheduler model_output_transform: DiffusionPredictionTransform ema_decay: float = 0.999 + native_resolution: int = None def __init__(self, model: nn.Module, @@ -54,6 +55,7 @@ def __init__(self, model_output_transform: DiffusionPredictionTransform = EpsilonPredictionTransform(), autoencoder: AutoEncoder = None, encoder: ConditioningEncoder = None, + native_resolution: int = None, **kwargs ): super().__init__( @@ -68,6 +70,20 @@ def __init__(self, self.model_output_transform = model_output_transform self.unconditional_prob = unconditional_prob + if native_resolution is None: + if 'image' in input_shapes: + native_resolution = input_shapes['image'][1] + elif 'x' in input_shapes: + native_resolution = input_shapes['x'][1] + elif 'sample' in input_shapes: + native_resolution = input_shapes['sample'][1] + else: + raise ValueError("No image input shape found in input shapes") + if autoencoder is not None: + native_resolution = native_resolution * 8 + + self.native_resolution = native_resolution + self.autoencoder = autoencoder self.encoder = encoder @@ -118,9 +134,6 @@ def _define_train_step(self, batch_size): model_output_transform = self.model_output_transform loss_fn = self.loss_fn unconditional_prob = self.unconditional_prob - - # Determine the number of unconditional samples - num_unconditional = int(batch_size * unconditional_prob) null_labels_full = self.encoder([""]) null_labels_seq = jnp.array(null_labels_full[0], dtype=jnp.float16) @@ -159,12 +172,19 @@ def train_step(train_state: TrainState, rng_state: RandomMarkovState, batch, loc local_rng_state, rngs = local_rng_state.get_random_key() images = autoencoder.encode(images, rngs) - label_seq = conditioning_encoder.encode_from_tokens(batch) + label_seq = conditioning_encoder.encode_from_tokens(batch['text']) # Generate random probabilities to decide how much of this batch will be unconditional + local_rng_state, uncond_key = local_rng_state.get_random_key() + # Efficient way to determine unconditional samples for JIT compatibility + uncond_mask = jax.random.bernoulli( + uncond_key, + shape=(local_batch_size,), + p=unconditional_prob + ) + num_unconditional = jnp.sum(uncond_mask).astype(jnp.int32) - label_seq = jnp.concat( - [null_labels_seq[:num_unconditional], label_seq[num_unconditional:]], axis=0) + label_seq = jnp.concatenate([null_labels_seq[:num_unconditional], label_seq[num_unconditional:]], axis=0) noise_level, local_rng_state = noise_schedule.generate_timesteps(local_batch_size, local_rng_state) @@ -200,21 +220,6 @@ def model_loss(params): loss, grads = grad_fn(train_state.params) if distributed_training: grads = jax.lax.pmean(grads, "data") - - # # check gradients for NaN/Inf - # has_nan_or_inf = jax.tree_util.tree_reduce( - # lambda acc, x: jnp.logical_or(acc, jnp.logical_or(jnp.isnan(x).any(), jnp.isinf(x).any())), - # grads, - # initializer=False - # ) - - # # Only apply gradients if they're valid - # new_state = jax.lax.cond( - # has_nan_or_inf, - # lambda _: train_state, # Skip gradient update - # lambda _: train_state.apply_gradients(grads=grads), - # operand=None - # ) new_state = train_state.apply_gradients(grads=grads) @@ -251,7 +256,7 @@ def model_loss(params): return train_step - def _define_vaidation_step(self, sampler_class: Type[DiffusionSampler]=DDIMSampler, sampling_noise_schedule: NoiseScheduler=None): + def _define_validation_step(self, sampler_class: Type[DiffusionSampler]=DDIMSampler, sampling_noise_schedule: NoiseScheduler=None): model = self.model encoder = self.encoder autoencoder = self.autoencoder @@ -260,7 +265,9 @@ def _define_vaidation_step(self, sampler_class: Type[DiffusionSampler]=DDIMSampl null_labels_full = null_labels_full.astype(jnp.float16) # null_labels_seq = jnp.array(null_labels_full[0], dtype=jnp.float16) - if 'image' in self.input_shapes: + if self.native_resolution is not None: + image_size = self.native_resolution + elif 'image' in self.input_shapes: image_size = self.input_shapes['image'][1] elif 'x' in self.input_shapes: image_size = self.input_shapes['x'][1] @@ -271,10 +278,8 @@ def _define_vaidation_step(self, sampler_class: Type[DiffusionSampler]=DDIMSampl sampler = sampler_class( model=model, - params=None, noise_schedule=self.noise_schedule if sampling_noise_schedule is None else sampling_noise_schedule, model_output_transform=self.model_output_transform, - image_size=image_size, null_labels_seq=null_labels_full, autoencoder=autoencoder, guidance_scale=3.0, @@ -290,7 +295,8 @@ def generate_samples( labels_seq = jnp.array(labels_seq, dtype=jnp.float16) samples = sampler.generate_images( params=val_state.ema_params, - num_images=len(labels_seq), + resolution=image_size, + num_samples=len(labels_seq), diffusion_steps=diffusion_steps, start_step=1000, end_step=0, diff --git a/flaxdiff/trainer/general_diffusion_trainer.py b/flaxdiff/trainer/general_diffusion_trainer.py new file mode 100644 index 0000000..c9dd1f9 --- /dev/null +++ b/flaxdiff/trainer/general_diffusion_trainer.py @@ -0,0 +1,583 @@ +import json +import flax +from flax import linen as nn +import jax +from typing import Callable, List, Dict, Tuple, Union, Any, Sequence, Type, Optional +from dataclasses import field, dataclass +import jax.numpy as jnp +import optax +import functools +from jax.sharding import Mesh, PartitionSpec as P +from jax.experimental.shard_map import shard_map + +from ..schedulers import NoiseScheduler, get_coeff_shapes_tuple +from ..predictors import DiffusionPredictionTransform, EpsilonPredictionTransform +from ..samplers.common import DiffusionSampler +from ..samplers.ddim import DDIMSampler + +from flaxdiff.utils import RandomMarkovState, serialize_model, get_latest_checkpoint +from flaxdiff.inputs import ConditioningEncoder, ConditionalInputConfig, DiffusionInputConfig + +from .simple_trainer import SimpleTrainer, SimpleTrainState, Metrics + +from flaxdiff.models.autoencoder.autoencoder import AutoEncoder +from flax.training import dynamic_scale as dynamic_scale_lib + +# Reuse the TrainState from the DiffusionTrainer +from flaxdiff.trainer.diffusion_trainer import TrainState, DiffusionTrainer +import shutil + +def generate_modelname( + dataset_name: str, + noise_schedule_name: str, + architecture_name: str, + model: nn.Module, + input_config: DiffusionInputConfig, + autoencoder: AutoEncoder = None, + frames_per_sample: int = None, +) -> str: + """ + Generate a model name based on the configuration. + + Args: + config: Configuration dictionary. + + Returns: + A string representing the model name. + """ + import hashlib + import json + + # Extract key components for the name + + model_name = f"diffusion-{dataset_name}-res{input_config.sample_data_shape[-2]}" + + # model_name = f"diffusion-{dataset_name}-res{input_config.sample_data_shape[-2]}-{noise_schedule_name}-{architecture_name}" + + # if autoencoder is not None: + # model_name += f"-vae" + + # if frames_per_sample is not None: + # model_name += f"-frames_{frames_per_sample}" + + # model_name += f"-{'.'.join([cond.encoder.key for cond in input_config.conditions])}" + + # # Create a sorted representation of model config for consistent hashing + # def sort_dict_recursively(d): + # if isinstance(d, dict): + # return {k: sort_dict_recursively(d[k]) for k in sorted(d.keys())} + # elif isinstance(d, list): + # return [sort_dict_recursively(v) for v in d] + # else: + # return d + + # # Extract model config and sort it + # model_config = serialize_model(model) + # sorted_model_config = sort_dict_recursively(model_config) + + # # Convert to JSON string with sorted keys for consistent hash + # try: + # config_json = json.dumps(sorted_model_config) + # except TypeError: + # # Handle non-serializable objects + # def make_serializable(obj): + # if isinstance(obj, dict): + # return {k: make_serializable(v) for k, v in obj.items()} + # elif isinstance(obj, list): + # return [make_serializable(v) for v in obj] + # else: + # try: + # # Test if object is JSON serializable + # json.dumps(obj) + # return obj + # except TypeError: + # return str(obj) + + # serializable_config = make_serializable(sorted_model_config) + # config_json = json.dumps(serializable_config) + + # # Generate a hash of the configuration + # config_hash = hashlib.md5(config_json.encode('utf-8')).hexdigest()[:8] + + # # Construct the model name + # model_name = f"{model_name}-{config_hash}" + return model_name + +class GeneralDiffusionTrainer(DiffusionTrainer): + """ + General trainer for diffusion models supporting both images and videos. + + Extends DiffusionTrainer to support: + 1. Both image data (4D tensors: B,H,W,C) and video data (5D tensors: B,T,H,W,C) + 2. Multiple conditioning inputs + 3. Various model architectures + """ + + def __init__(self, + model: nn.Module, + optimizer: optax.GradientTransformation, + noise_schedule: NoiseScheduler, + input_config: DiffusionInputConfig, + rngs: jax.random.PRNGKey, + unconditional_prob: float = 0.12, + name: str = "GeneralDiffusion", + model_output_transform: DiffusionPredictionTransform = EpsilonPredictionTransform(), + autoencoder: AutoEncoder = None, + native_resolution: int = None, + frames_per_sample: int = None, + wandb_config: Dict[str, Any] = None, + **kwargs + ): + """ + Initialize the general diffusion trainer. + + Args: + model: Neural network model + optimizer: Optimization algorithm + noise_schedule: Noise scheduler for diffusion process + input_config: Configuration for input data, including keys, shapes and conditioning inputs + rngs: Random number generator keys + unconditional_prob: Probability of training with unconditional samples + name: Name of this trainer + model_output_transform: Transform for model predictions + autoencoder: Optional autoencoder for latent diffusion + native_resolution: Native resolution of the data + frames_per_sample: Number of frames per video sample (for video only) + **kwargs: Additional arguments for parent class + """ + # Initialize with parent DiffusionTrainer but without encoder parameter + input_shapes = input_config.get_input_shapes( + autoencoder=autoencoder, + ) + self.input_config = input_config + + if wandb_config is not None: + # If input_config is not in wandb_config, add it + if 'input_config' not in wandb_config['config']: + wandb_config['config']['input_config'] = input_config.serialize() + # If model is not in wandb_config, add it + if 'model' not in wandb_config['config']: + wandb_config['config']['model'] = serialize_model(model) + if 'autoencoder' not in wandb_config['config'] and autoencoder is not None: + wandb_config['config']['autoencoder'] = autoencoder.name + wandb_config['config']['autoencoder_opts'] = json.dumps(autoencoder.serialize()) + + # Generate a model name based on the configuration + modelname = generate_modelname( + dataset_name=wandb_config['config']['arguments']['dataset'], + noise_schedule_name=wandb_config['config']['arguments']['noise_schedule'], + architecture_name=wandb_config['config']['arguments']['architecture'], + model=model, + input_config=input_config, + autoencoder=autoencoder, + frames_per_sample=frames_per_sample, + ) + print("Model name:", modelname) + self.modelname = modelname + wandb_config['config']['modelname'] = modelname + + super().__init__( + model=model, + input_shapes=input_shapes, + optimizer=optimizer, + noise_schedule=noise_schedule, + unconditional_prob=unconditional_prob, + autoencoder=autoencoder, + model_output_transform=model_output_transform, + rngs=rngs, + name=name, + native_resolution=native_resolution, + encoder=None, # Don't use the default encoder from the parent class + wandb_config=wandb_config, + **kwargs + ) + + # Store video-specific parameters + self.frames_per_sample = frames_per_sample + + # List of conditional inputs + self.conditional_inputs = input_config.conditions + # Determine if we're working with video or images + self.is_video = self._is_video_data() + + def _is_video_data(self): + sample_data_shape = self.input_config.sample_data_shape + return len(sample_data_shape) == 5 + + def _define_train_step(self, batch_size): + """ + Define the training step function for both image and video diffusion. + Optimized for efficient sharding and JIT compilation. + """ + # Access class variables once for JIT optimization + noise_schedule = self.noise_schedule + model = self.model + model_output_transform = self.model_output_transform + loss_fn = self.loss_fn + distributed_training = self.distributed_training + autoencoder = self.autoencoder + unconditional_prob = self.unconditional_prob + + input_config = self.input_config + sample_data_key = input_config.sample_data_key + + # JIT-optimized function for processing conditional inputs + # @functools.partial(jax.jit, static_argnums=(2,)) + def process_conditioning(batch, uncond_mask): + return input_config.process_conditioning( + batch, + uncond_mask=uncond_mask, + ) + + # Main training step function - optimized for JIT compilation and sharding + def train_step(train_state: TrainState, rng_state: RandomMarkovState, batch, local_device_index): + """Training step optimized for distributed execution.""" + # Random key handling + rng_state, key_fold = rng_state.get_random_key() + folded_key = jax.random.fold_in(key_fold, local_device_index.reshape()) + local_rng_state = RandomMarkovState(folded_key) + + # Extract and normalize data (works for both images and videos) + data = batch[sample_data_key] + local_batch_size = data.shape[0] + data = (jnp.asarray(data, dtype=jnp.float32) - 127.5) / 127.5 + + # Autoencoder step (handles both image and video data) + if autoencoder is not None: + local_rng_state, enc_key = local_rng_state.get_random_key() + data = autoencoder.encode(data, enc_key) + + # Determine number of unconditional samples per mini batch randomly + local_rng_state, uncond_key = local_rng_state.get_random_key() + # Determine unconditional samples + uncond_mask = jax.random.bernoulli( + uncond_key, + shape=(local_batch_size,), + p=unconditional_prob + ) + + # Process conditioning + all_conditional_inputs = process_conditioning(batch, uncond_mask) + + # Generate diffusion timesteps + noise_level, local_rng_state = noise_schedule.generate_timesteps(local_batch_size, local_rng_state) + + # Generate noise + local_rng_state, noise_key = local_rng_state.get_random_key() + noise = jax.random.normal(noise_key, shape=data.shape, dtype=jnp.float32) + + # Forward diffusion process + rates = noise_schedule.get_rates(noise_level, get_coeff_shapes_tuple(data)) + noisy_data, c_in, expected_output = model_output_transform.forward_diffusion(data, noise, rates) + + # Loss function + def model_loss(params): + # Apply model + inputs = noise_schedule.transform_inputs(noisy_data * c_in, noise_level) + preds = model.apply(params, *inputs, *all_conditional_inputs) + + # Transform predictions and calculate loss + preds = model_output_transform.pred_transform(noisy_data, preds, rates) + sample_losses = loss_fn(preds, expected_output) + + # Apply loss weighting + weights = noise_schedule.get_weights(noise_level, get_coeff_shapes_tuple(sample_losses)) + weighted_loss = sample_losses * weights + + return jnp.mean(weighted_loss) + + # Compute gradients and apply updates + if train_state.dynamic_scale is not None: + # Mixed precision training with dynamic scale + grad_fn = train_state.dynamic_scale.value_and_grad(model_loss, axis_name="data") + dynamic_scale, is_finite, loss, grads = grad_fn(train_state.params) + + train_state = train_state.replace(dynamic_scale=dynamic_scale) + new_state = train_state.apply_gradients(grads=grads) + + # Handle NaN/Inf gradients + select_fn = functools.partial(jnp.where, is_finite) + new_state = new_state.replace( + opt_state=jax.tree_map(select_fn, new_state.opt_state, train_state.opt_state), + params=jax.tree_map(select_fn, new_state.params, train_state.params) + ) + else: + # Standard gradient computation + grad_fn = jax.value_and_grad(model_loss) + loss, grads = grad_fn(train_state.params) + + if distributed_training: + grads = jax.lax.pmean(grads, axis_name="data") + + new_state = train_state.apply_gradients(grads=grads) + + # Apply EMA update + new_state = new_state.apply_ema(self.ema_decay) + + # Average loss across devices if distributed + if distributed_training: + loss = jax.lax.pmean(loss, axis_name="data") + + return new_state, loss, rng_state + + # Apply sharding for distributed training + if distributed_training: + train_step = shard_map( + train_step, + mesh=self.mesh, + in_specs=(P(), P(), P('data'), P('data')), + out_specs=(P(), P(), P()), + ) + + # Apply JIT compilation + train_step = jax.jit(train_step, donate_argnums=(2)) + return train_step + + def _define_validation_step(self, sampler_class: Type[DiffusionSampler]=DDIMSampler, sampling_noise_schedule: NoiseScheduler=None): + """ + Define the validation step for both image and video diffusion models. + """ + # Setup for validation + model = self.model + autoencoder = self.autoencoder + input_config = self.input_config + conditional_inputs = self.conditional_inputs + is_video = self.is_video + + # Get necessary parameters + image_size = self._get_image_size() + + # Get sequence length only for video data + sequence_length = self._get_sequence_length() if is_video else None + + # Initialize the sampler + sampler = sampler_class( + model=model, + noise_schedule=self.noise_schedule if sampling_noise_schedule is None else sampling_noise_schedule, + model_output_transform=self.model_output_transform, + input_config=input_config, + autoencoder=autoencoder, + guidance_scale=3.0, + ) + + def generate_samples( + val_state: TrainState, + batch, + sampler: DiffusionSampler, + diffusion_steps: int, + ): + # Process all conditional inputs + model_conditioning_inputs = [cond_input(batch) for cond_input in conditional_inputs] + + # Determine batch size + batch_size = len(model_conditioning_inputs[0]) if model_conditioning_inputs else 4 + + # Generate samples - works for both images and videos + return sampler.generate_samples( + params=val_state.ema_params, + resolution=image_size, + num_samples=batch_size, + sequence_length=sequence_length, # Will be None for images + diffusion_steps=diffusion_steps, + start_step=1000, + end_step=0, + priors=None, + model_conditioning_inputs=tuple(model_conditioning_inputs), + ) + + return sampler, generate_samples + + def _get_image_size(self): + """Helper to determine image size from available information.""" + if self.native_resolution is not None: + return self.native_resolution + + sample_data_shape = self.input_config.sample_data_shape + return sample_data_shape[-2] # Assuming [..., H, W, C] format + + def _get_sequence_length(self): + """Helper to determine sequence length for video generation.""" + if not self.is_video: + return None + + sample_data_shape = self.input_config.sample_data_shape + return sample_data_shape[1] # Assuming [B,T,H,W,C] format + + def validation_loop( + self, + val_state: SimpleTrainState, + val_step_fn: Callable, + val_ds, + val_steps_per_epoch, + current_step, + diffusion_steps=200, + ): + """ + Run validation and log samples for both image and video diffusion. + """ + sampler, generate_samples = val_step_fn + val_ds = iter(val_ds()) if val_ds else None + + try: + # Generate samples + samples = generate_samples( + val_state, + next(val_ds), + sampler, + diffusion_steps, + ) + + # Log samples to wandb + if getattr(self, 'wandb', None) is not None and self.wandb: + import numpy as np + + # Process samples differently based on dimensionality + if len(samples.shape) == 5: # [B,T,H,W,C] - Video data + self._log_video_samples(samples, current_step) + else: # [B,H,W,C] - Image data + self._log_image_samples(samples, current_step) + + except Exception as e: + print("Error in validation loop:", e) + import traceback + traceback.print_exc() + + def _log_video_samples(self, samples, current_step): + """Helper to log video samples to wandb.""" + import numpy as np + from wandb import Video as wandbVideo + + for i in range(samples.shape[0]): + # Convert to numpy, denormalize and clip + sample = np.array(samples[i]) + sample = (sample + 1) * 127.5 + sample = np.clip(sample, 0, 255).astype(np.uint8) + + # Log as video + self.wandb.log({ + f"video_sample_{i}": wandbVideo( + sample, + fps=10, + caption=f"Video Sample {i} at step {current_step}" + ) + }, step=current_step) + + def _log_image_samples(self, samples, current_step): + """Helper to log image samples to wandb.""" + import numpy as np + from wandb import Image as wandbImage + + for i in range(samples.shape[0]): + # Convert to numpy, denormalize and clip + sample = np.array(samples[i]) + sample = (sample + 1) * 127.5 + sample = np.clip(sample, 0, 255).astype(np.uint8) + + # Log as image + self.wandb.log({ + f"sample_{i}": wandbImage( + sample, + caption=f"Sample {i} at step {current_step}" + ) + }, step=current_step) + + def push_to_registry( + self, + registry_name: str = 'wandb-registry-model', + ): + """ + Push the model to wandb registry. + Args: + registry_name: Name of the model registry. + """ + if self.wandb is None: + raise ValueError("Wandb is not initialized. Cannot push to registry.") + + modelname = self.modelname + if hasattr(self, "wandb_sweep"): + modelname = f"{modelname}-sweep-{self.wandb_sweep.id}" + + latest_checkpoint_path = get_latest_checkpoint(self.checkpoint_path()) + logged_artifact = self.wandb.log_artifact( + artifact_or_path=latest_checkpoint_path, + name=modelname, + type="model", + ) + + target_path = f"{registry_name}/{modelname}" + + self.wandb.link_artifact( + artifact=logged_artifact, + target_path=target_path, + ) + print(f"Model pushed to registry at {target_path}") + return logged_artifact + + def __get_best_sweep_runs__( + self, + metric: str = "train/best_loss", + top_k: int = 5, + ): + """ + Get the best runs from a wandb sweep. + Args: + metric: Metric to sort by. + top_k: Number of top runs to return. + """ + if self.wandb is None: + raise ValueError("Wandb is not initialized. Cannot get best runs.") + + if not hasattr(self, "wandb_sweep"): + raise ValueError("Wandb sweep is not initialized. Cannot get best runs.") + + # Get the sweep runs + runs = sorted(self.wandb_sweep.runs, key=lambda x: x.summary.get(metric, float('inf'))) + best_runs = runs[:top_k] + lower_bound = best_runs[-1].summary.get(metric, float('inf')) + upper_bound = best_runs[0].summary.get(metric, float('inf')) + print(f"Best runs from sweep {self.wandb_sweep.id}:") + for run in best_runs: + print(f"\t\tRun ID: {run.id}, Metric: {run.summary.get(metric, float('inf'))}") + return best_runs, (min(lower_bound, upper_bound), max(lower_bound, upper_bound)) + + def __compare_run_against_best__(self, top_k=2, metric="train/best_loss"): + # Get best runs + best_runs, bounds = self.__get_best_sweep_runs__(metric=metric, top_k=top_k) + + # Determine if lower or higher values are better (for loss, lower is better) + is_lower_better = "loss" in metric.lower() + + # Check if current run is one of the best + current_run_metric = self.wandb.summary.get(metric, float('inf') if is_lower_better else float('-inf')) + + # Direct check if current run is in best runs + for run in best_runs: + if run.id == self.wandb.id: + print(f"Current run {self.wandb.id} is one of the best runs.") + return True + + # Backup check based on metric value + if (is_lower_better and current_run_metric < bounds[1]) or (not is_lower_better and current_run_metric > bounds[0]): + print(f"Current run {self.wandb.id} meets performance criteria.") + return True + + return False + + def save(self, epoch=0, step=0, state=None, rngstate=None): + super().save(epoch=epoch, step=step, state=state, rngstate=rngstate) + + if self.wandb is not None and hasattr(self, "wandb_sweep"): + checkpoint = get_latest_checkpoint(self.checkpoint_path()) + try: + if self.__compare_run_against_best__(top_k=5, metric="train/best_loss"): + self.push_to_registry() + print("Model pushed to registry successfully") + else: + print("Current run is not one of the best runs. Not saving model.") + + # Only delete after successful registry push + shutil.rmtree(checkpoint, ignore_errors=True) + print(f"Checkpoint deleted at {checkpoint}") + except Exception as e: + print(f"Error during registry operations: {e}") + print(f"Checkpoint preserved at {checkpoint}") diff --git a/flaxdiff/trainer/simple_trainer.py b/flaxdiff/trainer/simple_trainer.py index a748444..8729886 100644 --- a/flaxdiff/trainer/simple_trainer.py +++ b/flaxdiff/trainer/simple_trainer.py @@ -25,6 +25,8 @@ from flax.training.dynamic_scale import DynamicScale from flaxdiff.utils import RandomMarkovState from flax.training import dynamic_scale as dynamic_scale_lib +from dataclasses import dataclass +import gc PROCESS_COLOR_MAP = { 0: "green", @@ -71,6 +73,7 @@ class SimpleTrainState(train_state.TrainState): metrics: Metrics dynamic_scale: dynamic_scale_lib.DynamicScale +@dataclass class SimpleTrainer: state: SimpleTrainState best_state: SimpleTrainState @@ -86,7 +89,6 @@ def __init__(self, train_state: SimpleTrainState = None, name: str = "Simple", load_from_checkpoint: str = None, - checkpoint_suffix: str = "", loss_fn=optax.l2_loss, param_transforms: Callable = None, wandb_config: Dict[str, Any] = None, @@ -94,6 +96,7 @@ def __init__(self, checkpoint_base_path: str = "./checkpoints", checkpoint_step: int = None, use_dynamic_scale: bool = False, + max_checkpoints_to_keep: int = 2, ): if distributed_training is None or distributed_training is True: # Auto-detect if we are running on multiple devices @@ -109,10 +112,9 @@ def __init__(self, self.input_shapes = input_shapes self.checkpoint_base_path = checkpoint_base_path - if wandb_config is not None and jax.process_index() == 0: import wandb - run = wandb.init(**wandb_config) + run = wandb.init(resume='allow', **wandb_config) self.wandb = run # define our custom x axis metric @@ -126,13 +128,18 @@ def __init__(self, self.wandb.define_metric("train/avg_loss", step_metric="train/epoch") self.wandb.define_metric("train/best_loss", step_metric="train/epoch") + if self.wandb.sweep_id: + api = wandb.Api() + self.wandb_sweep = api.sweep(f"{self.wandb.entity}/{self.wandb.project}/{self.wandb.sweep_id}") + print(f"Running sweep {self.wandb_sweep.id} with id {self.wandb.sweep_id}") + # checkpointer = orbax.checkpoint.PyTreeCheckpointer() async_checkpointer = orbax.checkpoint.AsyncCheckpointer(orbax.checkpoint.PyTreeCheckpointHandler(), timeout_secs=60) options = orbax.checkpoint.CheckpointManagerOptions( - max_to_keep=4, create=True) + max_to_keep=max_checkpoints_to_keep, create=True) self.checkpointer = orbax.checkpoint.CheckpointManager( - self.checkpoint_path() + checkpoint_suffix, async_checkpointer, options) + self.checkpoint_path(), async_checkpointer, options) if load_from_checkpoint is not None: latest_epoch, latest_step, old_state, old_best_state, rngstate = self.load(load_from_checkpoint, checkpoint_step) @@ -159,7 +166,7 @@ def __init__(self, self.best_loss = 1e9 def get_input_ones(self): - return {k: jnp.ones((1, *v), dtype=self.model.dtype) for k, v in self.input_shapes.items()} + return {k: jnp.ones((1, *v)) for k, v in self.input_shapes.items()} def generate_states( self, @@ -248,6 +255,10 @@ def load(self, checkpoint_path=None, checkpoint_step=None): step = checkpoint_step print("Loading model from checkpoint at step ", step) + loaded_checkpoint_path = os.path.join( + checkpoint_path if checkpoint_path else self.checkpoint_path(), + f"{step}") + self.loaded_checkpoint_path = loaded_checkpoint_path ckpt = checkpointer.restore(step) state = ckpt['state'] best_state = ckpt['best_state'] @@ -311,7 +322,7 @@ def model_loss(params): train_step = jax.pmap(train_step) return train_step - def _define_vaidation_step(self): + def _define_validation_step(self): model = self.model loss_fn = self.loss_fn distributed_training = self.distributed_training @@ -418,8 +429,8 @@ def train_loop( for i in range(train_steps_per_epoch): batch = next(train_ds) - if i == 0: - print(f"First batch loaded at step {current_step}") + # if i == 0: + # print(f"First batch loaded at step {current_step}") if self.distributed_training and global_device_count > 1: # # Convert the local device batches to a unified global jax.Array @@ -433,34 +444,40 @@ def train_loop( # loss = jax.experimental.multihost_utils.process_allgather(loss) loss = jnp.mean(loss) # Just to make sure its a scaler value - if loss <= 1e-8: - # If the loss is too low, we can assume the model has diverged - print(colored(f"Loss too low at step {current_step} => {loss}", 'red')) - # Reset the model to the old state - # if self.best_state is not None: - # print(colored(f"Resetting model to best state", 'red')) - # train_state = self.best_state - # loss = self.best_loss - # else: - # exit(1) + if loss <= 1e-8 or jnp.isnan(loss) or jnp.isinf(loss): + # If the loss is too low or NaN/Inf, log the issue and attempt recovery + print(colored(f"Abnormal loss at step {current_step}: {loss}", 'red')) - # Check if there are any NaN/inf values in the train_state.params + # Check model parameters for NaN/Inf values params = train_state.params + has_nan_or_inf = False + if isinstance(params, dict): for key, value in params.items(): if isinstance(value, jnp.ndarray): if jnp.isnan(value).any() or jnp.isinf(value).any(): - print(colored(f"NaN/inf values found in params at step {current_step}", 'red')) - # Reset the model to the old state - # train_state = self.best_state - # loss = self.best_loss - # break - else: - print(colored(f"Params are fine at step {current_step}", 'green')) - else: - print(colored(f"Params are not a dict at step {current_step}", 'red')) + print(colored(f"NaN/inf values found in params[{key}] at step {current_step}", 'red')) + has_nan_or_inf = True + break + + if not has_nan_or_inf: + print(colored(f"Model parameters seem valid despite abnormal loss", 'yellow')) - exit(1) + # Try to recover - clear JAX caches and collect garbage + gc.collect() + if hasattr(jax, "clear_caches"): + jax.clear_caches() + + # If we have a best state and the loss is truly invalid, consider restoring + if (loss <= 1e-8 or jnp.isnan(loss) or jnp.isinf(loss)) and self.best_state is not None: + print(colored(f"Attempting recovery by resetting model to last best state", 'yellow')) + train_state = self.best_state + loss = self.best_loss + else: + # If we can't recover, skip this step but continue training + print(colored(f"Unable to recover - continuing with current state", 'yellow')) + if loss <= 1e-8: + loss = 1.0 # Set to a reasonable default to continue training epoch_loss += loss current_step += 1 @@ -489,7 +506,7 @@ def train_loop( def fit(self, data, train_steps_per_epoch, epochs, train_step_args={}, val_steps_per_epoch=5, validation_step_args={}): train_ds = iter(data['train']()) train_step = self._define_train_step(**train_step_args) - val_step = self._define_vaidation_step(**validation_step_args) + val_step = self._define_validation_step(**validation_step_args) train_state = self.state rng_state = self.rngstate process_index = jax.process_index() diff --git a/flaxdiff/trainer/video_diffusion_trainer.py b/flaxdiff/trainer/video_diffusion_trainer.py deleted file mode 100644 index e5f72ba..0000000 --- a/flaxdiff/trainer/video_diffusion_trainer.py +++ /dev/null @@ -1,62 +0,0 @@ -import flax -from flax import linen as nn -import jax -from typing import Callable -from dataclasses import field -import jax.numpy as jnp -import optax -import functools -from jax.sharding import Mesh, PartitionSpec as P -from jax.experimental.shard_map import shard_map -from typing import Dict, Callable, Sequence, Any, Union, Tuple - -from ..schedulers import NoiseScheduler -from ..predictors import DiffusionPredictionTransform, EpsilonPredictionTransform - -from flaxdiff.utils import RandomMarkovState - -from .simple_trainer import SimpleTrainer, SimpleTrainState, Metrics - -from flaxdiff.models.autoencoder.autoencoder import AutoEncoder -from flax.training import dynamic_scale as dynamic_scale_lib - -class TrainState(SimpleTrainState): - rngs: jax.random.PRNGKey - ema_params: dict - - def apply_ema(self, decay: float = 0.999): - new_ema_params = jax.tree_util.tree_map( - lambda ema, param: decay * ema + (1 - decay) * param, - self.ema_params, - self.params, - ) - return self.replace(ema_params=new_ema_params) - -from flaxdiff.models.autoencoder.autoencoder import AutoEncoder -from flaxdiff.trainer.diffusion_trainer import DiffusionTrainer - -class SimpleVideoDiffusionTrainer(DiffusionTrainer): - def __init__(self, - model: nn.Module, - input_shapes: Dict[str, Tuple[int]], - optimizer: optax.GradientTransformation, - noise_schedule: NoiseScheduler, - rngs: jax.random.PRNGKey, - unconditional_prob: float = 0.12, - name: str = "SimpleVideoDiffusion", - model_output_transform: DiffusionPredictionTransform = EpsilonPredictionTransform(), - autoencoder: AutoEncoder = None, - **kwargs - ): - super().__init__( - model=model, - input_shapes=input_shapes, - optimizer=optimizer, - noise_schedule=noise_schedule, - unconditional_prob=unconditional_prob, - autoencoder=autoencoder, - model_output_transform=model_output_transform, - rngs=rngs, - name=name, - **kwargs - ) diff --git a/flaxdiff/utils.py b/flaxdiff/utils.py index 8a85e4e..b1263b0 100644 --- a/flaxdiff/utils.py +++ b/flaxdiff/utils.py @@ -2,26 +2,145 @@ import jax.numpy as jnp import flax.struct as struct import flax.linen as nn -from typing import Any, Callable -from dataclasses import dataclass +from typing import Any from functools import partial import numpy as np +import os from jax.sharding import Mesh, PartitionSpec as P -from abc import ABC, abstractmethod +from flaxdiff.inputs import TextEncoder, CLIPTextEncoder + +# Setup mappings for dtype, precision, and activation +DTYPE_MAP = { + 'bfloat16': jnp.bfloat16, + 'float32': jnp.float32, + 'jax.numpy.float32': jnp.float32, + 'jax.numpy.bfloat16': jnp.bfloat16, + 'None': None, + None: None, +} + +PRECISION_MAP = { + 'high': jax.lax.Precision.HIGH, + 'HIGH': jax.lax.Precision.HIGH, + 'default': jax.lax.Precision.DEFAULT, + 'DEFAULT': jax.lax.Precision.DEFAULT, + 'highest': jax.lax.Precision.HIGHEST, + 'HIGHEST': jax.lax.Precision.HIGHEST, + 'None': None, + None: None, +} + +ACTIVATION_MAP = { + 'swish': jax.nn.swish, + 'silu': jax.nn.silu, + 'jax._src.nn.functions.silu': jax.nn.silu, + 'mish': jax.nn.mish, +} + +def map_nested_config(config): + new_config = {} + for key, value in config.items(): + if isinstance(value, dict): + new_config[key] = map_nested_config(value) + elif isinstance(value, str): + if value in DTYPE_MAP: + new_config[key] = DTYPE_MAP[value] + elif value in PRECISION_MAP: + new_config[key] = PRECISION_MAP[value] + elif value in ACTIVATION_MAP: + new_config[key] = ACTIVATION_MAP[value] + elif value == 'None': + new_config[key] = None + elif '.' in value: + # Ignore any other string that contains a dot + print( + f"Ignoring key {key} with value {value} as it contains a dot.") + return new_config + +def serialize_model(model: nn.Module): + """ + Serializes the model to a dictionary format. + """ + model_dict = model.__dict__ + model_dict = {k: v for k, v in model_dict.items() if not k.startswith('_')} + # Convert all callable attributes to their string representation + def map(model_dict): + for k, v in model_dict.items(): + if isinstance(v, dict): + # Recursively serialize nested dictionaries + model_dict[k] = map(v) + elif isinstance(v, list): + # Recursively serialize lists + [map(item) if isinstance(item, dict) else item for item in v] + elif callable(v): + # If the attribute has __name__, use that as the key + if hasattr(v, '__name__'): + model_dict[k] = v.__name__ + else: + model_dict[k] = str(v).split('.')[-1] + map(model_dict) + return model_dict + +def get_latest_checkpoint(checkpoint_path): + checkpoint_files = os.listdir(checkpoint_path) + # Sort files by step number + checkpoint_files = sorted([int(i) for i in checkpoint_files]) + latest_step = checkpoint_files[-1] + latest_checkpoint = os.path.join(checkpoint_path, str(latest_step)) + return latest_checkpoint class MarkovState(struct.PyTreeNode): pass class RandomMarkovState(MarkovState): rng: jax.random.PRNGKey - def get_random_key(self): rng, subkey = jax.random.split(self.rng) return RandomMarkovState(rng), subkey def clip_images(images, clip_min=-1, clip_max=1): + """Clip image values to a specified range. + + Args: + images: Images to clip + clip_min: Minimum value + clip_max: Maximum value + + Returns: + Clipped images + """ return jnp.clip(images, clip_min, clip_max) +def denormalize_images(images, target_type=jnp.uint8, source_range=(-1, 1), target_range=(0, 255)): + """Convert images from normalized range (e.g. [-1, 1]) to target range (e.g. [0, 255]). + + Args: + images: Normalized images + target_type: Target dtype (e.g. jnp.uint8 for standard images) + source_range: Tuple of (min, max) for the source normalization range + target_range: Tuple of (min, max) for the target range + + Returns: + Denormalized images in the target dtype + """ + src_min, src_max = source_range + tgt_min, tgt_max = target_range + + # First clip to ensure we're in the expected source range + images = clip_images(images, src_min, src_max) + + # Scale to [0, 1] + images = (images - src_min) / (src_max - src_min) + + # Scale to target range + images = images * (tgt_max - tgt_min) + tgt_min + + # Convert to target dtype if needed + if target_type is not None: + images = images.astype(target_type) + + return images + def _build_global_shape_and_sharding( local_shape: tuple[int, ...], global_mesh: Mesh ) -> tuple[tuple[int, ...], jax.sharding.NamedSharding]: @@ -117,45 +236,6 @@ def _normalize( y = mul * x return jnp.asarray(y, dtype) -@dataclass -class ConditioningEncoder(ABC): - model: nn.Module - tokenizer: Callable - - def __call__(self, data): - tokens = self.tokenize(data) - outputs = self.encode_from_tokens(tokens) - return outputs - - def encode_from_tokens(self, tokens): - outputs = self.model(input_ids=tokens['input_ids'], - attention_mask=tokens['attention_mask']) - last_hidden_state = outputs.last_hidden_state - return last_hidden_state - - def tokenize(self, data): - tokens = self.tokenizer(data, padding="max_length", - max_length=self.tokenizer.model_max_length, truncation=True, return_tensors="np") - return tokens - -@dataclass -class TextEncoder(ConditioningEncoder): - # def __call__(self, data): - # tokens = self.tokenize(data) - # outputs = self.encode_from_tokens(tokens) - # return outputs - - # def encode_from_tokens(self, tokens): - # outputs = self.model(input_ids=tokens['input_ids'], - # attention_mask=tokens['attention_mask']) - # last_hidden_state = outputs.last_hidden_state - # # pooler_output = outputs.pooler_output # pooled (EOS token) states - # # embed_pooled = pooler_output # .astype(jnp.float16) - # embed_labels_full = last_hidden_state # .astype(jnp.float16) - - # return embed_labels_full - pass - class AutoTextTokenizer: def __init__(self, tensor_type="pt", modelname="openai/clip-vit-large-patch14"): from transformers import AutoTokenizer @@ -175,18 +255,9 @@ def __call__(self, inputs): def __repr__(self): return self.__class__.__name__ + '()' + +# class AutoAudioTokenizer: -def defaultTextEncodeModel(backend="jax"): - from transformers import ( - CLIPTextModel, - FlaxCLIPTextModel, - AutoTokenizer, - ) - modelname = "openai/clip-vit-large-patch14" - if backend == "jax": - model = FlaxCLIPTextModel.from_pretrained( - modelname, dtype=jnp.bfloat16) - else: - model = CLIPTextModel.from_pretrained(modelname) - tokenizer = AutoTokenizer.from_pretrained(modelname, dtype=jnp.float16) - return TextEncoder(model, tokenizer) +def defaultTextEncodeModel(modelname = "openai/clip-vit-large-patch14", backend="jax"): + """Default text encoder model.""" + return CLIPTextEncoder.from_modelname(modelname=modelname, backend=backend) \ No newline at end of file diff --git a/inference_prototype.ipynb b/inference_prototype.ipynb new file mode 100644 index 0000000..653a96f --- /dev/null +++ b/inference_prototype.ipynb @@ -0,0 +1,824 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f5d63ccf", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/torch_xla/__init__.py:251: UserWarning: `tensorflow` can conflict with `torch-xla`. Prefer `tensorflow-cpu` when using PyTorch/XLA. To silence this warning, `pip uninstall -y tensorflow && pip install tensorflow-cpu`. If you are in a notebook environment such as Colab or Kaggle, restart your notebook runtime afterwards.\n", + " warnings.warn(\n", + "WARNING:root:libtpu.so and TPU device found. Setting PJRT_DEVICE=TPU.\n", + "2025-04-19 20:40:11.988308: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1745095212.011454 2066084 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1745095212.018579 2066084 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1745095212.035785 2066084 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1745095212.035804 2066084 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1745095212.035806 2066084 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1745095212.035809 2066084 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n" + ] + } + ], + "source": [ + "# Set JAX_PLATFORMS=''\n", + "import os\n", + "# os.environ[\"JAX_PLATFORMS\"] = \"\"\n", + "\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import flax\n", + "import flax.linen as nn\n", + "import json\n", + "import wandb\n", + "from dataclasses import dataclass, field\n", + "from typing import Optional, Dict, Any, Union, Callable, List, Tuple, Type\n", + "\n", + "from flaxdiff.trainer import (\n", + " SimpleTrainer,\n", + " SimpleTrainState,\n", + " TrainState,\n", + " DiffusionTrainer,\n", + ")\n", + "from flaxdiff.samplers import (\n", + " DiffusionSampler,\n", + ")\n", + "from flaxdiff.schedulers import (\n", + " NoiseScheduler,\n", + " EDMNoiseScheduler,\n", + " CosineNoiseScheduler,\n", + " KarrasVENoiseScheduler,\n", + ")\n", + "from flaxdiff.predictors import (\n", + " DiffusionPredictionTransform,\n", + " EpsilonPredictionTransform,\n", + " DirectPredictionTransform,\n", + " VPredictionTransform,\n", + " KarrasPredictionTransform,\n", + ")\n", + "from flaxdiff.models.common import kernel_init\n", + "from flaxdiff.models.simple_unet import Unet\n", + "from flaxdiff.models.simple_vit import UViT\n", + "from flaxdiff.models.general import BCHWModelWrapper\n", + "from flaxdiff.models.autoencoder import AutoEncoder\n", + "from flaxdiff.models.autoencoder.diffusers import StableDiffusionVAE\n", + "from flaxdiff.inputs import DiffusionInputConfig, ConditionalInputConfig\n", + "from flaxdiff.utils import defaultTextEncodeModel, RandomMarkovState\n", + "from flaxdiff.samplers.euler import EulerAncestralSampler, EulerSampler\n", + "from diffusers import FlaxUNet2DConditionModel\n", + "\n", + "import orbax.checkpoint\n", + "from orbax.checkpoint import CheckpointManager, CheckpointManagerOptions, PyTreeCheckpointer\n", + "\n", + "from functools import partial\n", + "import warnings\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bf2c55cd", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def normalizeImage(x): return jax.nn.standardize(x, mean=[127.5], std=[127.5])\n", + "def denormalizeImage(x): return (x + 1.0) * 127.5\n", + "\n", + "\n", + "def plotImages(imgs, fig_size=(8, 8), dpi=100):\n", + " fig = plt.figure(figsize=fig_size, dpi=dpi)\n", + " imglen = imgs.shape[0]\n", + " for i in range(imglen):\n", + " plt.subplot(fig_size[0], fig_size[1], i + 1)\n", + " plt.imshow(jnp.astype(denormalizeImage(imgs[i, :, :, :]), jnp.uint8))\n", + " plt.axis(\"off\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e5b3b72c", + "metadata": {}, + "outputs": [], + "source": [ + "def get_wandb_run(wandb_run: str, project, entity):\n", + " \"\"\"\n", + " Try to get the wandb run for the given experiment name and project.\n", + " Return None if not found.\n", + " \"\"\"\n", + " import wandb\n", + " wandb_api = wandb.Api()\n", + " # First try to get the run by treating wandb_run as a run ID\n", + " try:\n", + " run = wandb_api.run(f\"{entity}/{project}/{wandb_run}\")\n", + " print(f\"Found run: {run.name} ({run.id})\")\n", + " return run\n", + " except wandb.Error as e:\n", + " print(f\"Run not found by ID: {e}\")\n", + " # If that fails, try to get the run by treating wandb_run as a display name\n", + " # This is a bit of a hack, but it works for now.\n", + " # Note: this will return all runs with the same display name, so be careful.\n", + " print(f\"Trying to get run by display name: {wandb_run}\")\n", + " runs = wandb_api.runs(path=f\"{entity}/{project}\", filters={\"displayName\": wandb_run})\n", + " for run in runs:\n", + " print(f\"Found run: {run.name} ({run.id})\")\n", + " return run\n", + " return None\n", + "\n", + "def parse_config(config, overrides=None):\n", + " \"\"\"Parse configuration for inference pipeline.\n", + " \n", + " Args:\n", + " config: Configuration dictionary from wandb run\n", + " overrides: Optional dictionary of overrides for config parameters\n", + " \n", + " Returns:\n", + " Dictionary containing model, sampler, scheduler, and other required components\n", + " including DiffusionInputConfig for the general diffusion framework\n", + " \"\"\"\n", + " warnings.filterwarnings(\"ignore\")\n", + " \n", + " # Merge config with overrides if provided\n", + " if overrides is not None:\n", + " # Create a deep copy of config to avoid modifying the original\n", + " merged_config = dict(config)\n", + " # Update arguments with overrides\n", + " if 'arguments' in merged_config:\n", + " merged_config['arguments'] = {**merged_config['arguments'], **overrides}\n", + " # Also update top-level config for key parameters\n", + " for key in overrides:\n", + " if key in merged_config:\n", + " merged_config[key] = overrides[key]\n", + " else:\n", + " merged_config = config\n", + " \n", + " # Parse configuration from config dict\n", + " conf = merged_config\n", + " \n", + " # Setup mappings for dtype, precision, and activation\n", + " DTYPE_MAP = {\n", + " 'bfloat16': jnp.bfloat16,\n", + " 'float32': jnp.float32,\n", + " 'jax.numpy.float32': jnp.float32,\n", + " 'jax.numpy.bfloat16': jnp.bfloat16,\n", + " 'None': None,\n", + " None: None,\n", + " }\n", + " \n", + " PRECISION_MAP = {\n", + " 'high': jax.lax.Precision.HIGH,\n", + " 'HIGH': jax.lax.Precision.HIGH,\n", + " 'default': jax.lax.Precision.DEFAULT,\n", + " 'DEFAULT': jax.lax.Precision.DEFAULT,\n", + " 'highest': jax.lax.Precision.HIGHEST,\n", + " 'HIGHEST': jax.lax.Precision.HIGHEST,\n", + " 'None': None,\n", + " None: None,\n", + " }\n", + " \n", + " ACTIVATION_MAP = {\n", + " 'swish': jax.nn.swish,\n", + " 'silu': jax.nn.silu,\n", + " 'jax._src.nn.functions.silu': jax.nn.silu,\n", + " 'mish': jax.nn.mish,\n", + " }\n", + " \n", + " # Get model class based on architecture\n", + " MODEL_CLASSES = {\n", + " 'unet': Unet,\n", + " 'uvit': UViT,\n", + " 'diffusers_unet_simple': FlaxUNet2DConditionModel\n", + " }\n", + " \n", + " # Map all the leaves of the model config, converting strings to appropriate types\n", + " def map_nested_config(config):\n", + " new_config = {}\n", + " for key, value in config.items():\n", + " if isinstance(value, dict):\n", + " new_config[key] = map_nested_config(value)\n", + " elif isinstance(value, list):\n", + " new_config[key] = [map_nested_config(item) if isinstance(item, dict) else item for item in value]\n", + " elif isinstance(value, str):\n", + " if value in DTYPE_MAP:\n", + " new_config[key] = DTYPE_MAP[value]\n", + " elif value in PRECISION_MAP:\n", + " new_config[key] = PRECISION_MAP[value]\n", + " elif value in ACTIVATION_MAP:\n", + " new_config[key] = ACTIVATION_MAP[value]\n", + " elif value == 'None':\n", + " new_config[key] = None\n", + " elif '.'in value:\n", + " # Ignore any other string that contains a dot\n", + " print(f\"Ignoring key {key} with value {value} as it contains a dot.\")\n", + " else:\n", + " new_config[key] = value\n", + " else:\n", + " new_config[key] = value\n", + " return new_config\n", + "\n", + " # Parse architecture and model config\n", + " model_config = conf['model']\n", + " \n", + " # Get architecture type\n", + " architecture = conf.get('architecture', conf.get('arguments', {}).get('architecture', 'unet'))\n", + " \n", + " # Handle autoencoder\n", + " autoencoder_name = conf.get('autoencoder', conf.get('arguments', {}).get('autoencoder'))\n", + " autoencoder_opts_str = conf.get('autoencoder_opts', conf.get('arguments', {}).get('autoencoder_opts', '{}'))\n", + " autoencoder = None\n", + " autoencoder_opts = None\n", + " \n", + " if autoencoder_name:\n", + " print(f\"Using autoencoder: {autoencoder_name}\")\n", + " if isinstance(autoencoder_opts_str, str):\n", + " autoencoder_opts = json.loads(autoencoder_opts_str)\n", + " else:\n", + " autoencoder_opts = autoencoder_opts_str\n", + " \n", + " if autoencoder_name == 'stable_diffusion':\n", + " print(\"Using Stable Diffusion Autoencoder for Latent Diffusion Modeling\")\n", + " autoencoder_opts = map_nested_config(autoencoder_opts)\n", + " autoencoder = StableDiffusionVAE(**autoencoder_opts)\n", + " \n", + " input_config = conf.get('input_config', None)\n", + " \n", + " # If not provided, create one based on the older format (backward compatibility)\n", + " if input_config is None:\n", + " # Warn if input_config is not provided\n", + " print(\"No input_config provided, creating a default one.\")\n", + " image_size = conf['arguments'].get('image_size', 128)\n", + " image_channels = 3 # Default number of channels\n", + " # Create text encoder\n", + " text_encoder = defaultTextEncodeModel()\n", + " # Create a conditional input config for text conditioning\n", + " text_conditional_config = ConditionalInputConfig(\n", + " encoder=text_encoder,\n", + " conditioning_data_key='text',\n", + " pretokenized=True,\n", + " unconditional_input=\"\",\n", + " model_key_override=\"textcontext\"\n", + " )\n", + " \n", + " # Create the main input config\n", + " input_config = DiffusionInputConfig(\n", + " sample_data_key='image',\n", + " sample_data_shape=(image_size, image_size, image_channels),\n", + " conditions=[text_conditional_config]\n", + " )\n", + " else:\n", + " # Deserialize the input config if it's a string\n", + " input_config = DiffusionInputConfig.deserialize(input_config)\n", + " \n", + " model_kwargs = map_nested_config(model_config)\n", + " \n", + " print(f\"Model kwargs after mapping: {model_kwargs}\")\n", + " \n", + " model_class = MODEL_CLASSES.get(architecture)\n", + " if not model_class:\n", + " raise ValueError(f\"Unknown architecture: {architecture}. Supported architectures: {', '.join(MODEL_CLASSES.keys())}\")\n", + " \n", + " # Instantiate the model\n", + " model = model_class(**model_kwargs)\n", + " \n", + " # If using diffusers UNet, wrap it for consistent interface\n", + " if 'diffusers' in architecture:\n", + " model = BCHWModelWrapper(model)\n", + " \n", + " # Create noise scheduler based on configuration\n", + " noise_schedule_type = conf.get('noise_schedule', conf.get('arguments', {}).get('noise_schedule', 'edm'))\n", + " if noise_schedule_type in ['edm', 'karras']:\n", + " # For both EDM and karras, we use the karras scheduler for inference\n", + " noise_schedule = KarrasVENoiseScheduler(1, sigma_max=80, rho=7, sigma_data=0.5)\n", + " prediction_transform = KarrasPredictionTransform(sigma_data=noise_schedule.sigma_data)\n", + " elif noise_schedule_type == 'cosine':\n", + " noise_schedule = CosineNoiseScheduler(1000, beta_end=1)\n", + " prediction_transform = VPredictionTransform()\n", + " else:\n", + " raise ValueError(f\"Unknown noise schedule: {noise_schedule_type}\")\n", + " \n", + " # Prepare return dictionary with all components\n", + " result = {\n", + " 'model': model,\n", + " 'model_config': model_kwargs,\n", + " 'architecture': architecture,\n", + " 'autoencoder': autoencoder,\n", + " 'noise_schedule': noise_schedule,\n", + " 'prediction_transform': prediction_transform,\n", + " 'input_config': input_config,\n", + " 'raw_config': conf,\n", + " }\n", + " \n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "54cd1d74", + "metadata": {}, + "outputs": [], + "source": [ + "@dataclass\n", + "class InferencePipeline:\n", + " \"\"\"Inference pipeline for a general model.\"\"\"\n", + " model: nn.Module = None\n", + " state: SimpleTrainState = None\n", + " best_state: SimpleTrainState = None\n", + " \n", + " def from_wandb(\n", + " self,\n", + " wandb_run: str,\n", + " wandb_project: str,\n", + " wandb_entity: str,\n", + " ):\n", + " raise NotImplementedError(\"InferencePipeline does not support from_wandb.\") \n", + " \n", + "def get_latest_checkpoint(checkpoint_path):\n", + " checkpoint_files = os.listdir(checkpoint_path)\n", + " # Sort files by step number\n", + " checkpoint_files = sorted([int(i) for i in checkpoint_files])\n", + " latest_step = checkpoint_files[-1]\n", + " latest_checkpoint = os.path.join(checkpoint_path, str(latest_step))\n", + " return latest_checkpoint\n", + "\n", + "def load_from_checkpoint(\n", + " checkpoint_dir: str,\n", + "):\n", + " try:\n", + " checkpointer = PyTreeCheckpointer()\n", + " options = CheckpointManagerOptions(create=False)\n", + " # Convert checkpoint_dir to absolute path\n", + " checkpoint_dir = os.path.abspath(checkpoint_dir)\n", + " manager = CheckpointManager(checkpoint_dir, checkpointer, options)\n", + " ckpt = manager.restore(checkpoint_dir)\n", + " # Extract as above\n", + " state, best_state = None, None\n", + " if 'state' in ckpt:\n", + " state = ckpt['state']\n", + " if 'best_state' in ckpt:\n", + " best_state = ckpt['best_state']\n", + " print(f\"Loaded checkpoint from local dir {checkpoint_dir}\")\n", + " return state, best_state\n", + " except Exception as e:\n", + " print(f\"Warning: Failed to load checkpoint from local dir: {e}\")\n", + " return None, None\n", + " \n", + "def load_from_wandb_run(\n", + " run,\n", + " project: str,\n", + " entity: str = None,\n", + "):\n", + " \"\"\"\n", + " Loads model from wandb model registry.\n", + " \"\"\"\n", + " # Get the model version from wandb\n", + " states = None\n", + " config = None\n", + " try:\n", + " if isinstance(run, str):\n", + " run = get_wandb_run(run, project, entity)\n", + " # Search for model artifact\n", + " models = [i for i in run.logged_artifacts() if i.type == 'model']\n", + " if len(models) == 0:\n", + " raise ValueError(f\"No model artifacts found in run {run.id}\")\n", + " # Pick out any model artifact\n", + " highest_version = max([{'version':int(i.version[1:]), 'name': i.qualified_name} for i in models], key=lambda x: x['version'])\n", + " wandb_modelname = highest_version['name']\n", + " \n", + " print(f\"Loading model from wandb: {wandb_modelname} out of versions {[i.version for i in models]}\")\n", + " artifact = run.use_artifact(wandb.Api().artifact(wandb_modelname))\n", + " ckpt_dir = artifact.download()\n", + " print(f\"Loaded model from wandb: {wandb_modelname} at path {ckpt_dir}\")\n", + " # Load the model from the checkpoint directory\n", + " states = load_from_checkpoint(ckpt_dir)\n", + " config = run.config\n", + " except Exception as e:\n", + " print(f\"Warning: Failed to load model from wandb: {e}\")\n", + " return states, config\n", + "\n", + "def load_from_wandb_registry(\n", + " modelname: str,\n", + " project: str,\n", + " entity: str = None,\n", + " version: str = 'latest',\n", + " registry: str = 'wandb-registry-model',\n", + "):\n", + " \"\"\"\n", + " Loads model from wandb model registry.\n", + " \"\"\"\n", + " # Get the model version from wandb\n", + " states = None\n", + " config = None\n", + " try:\n", + " artifact = wandb.Api().artifact(f\"{registry}/{modelname}:{version}\")\n", + " ckpt_dir = artifact.download()\n", + " print(f\"Loaded model from wandb registry: {modelname} at path {ckpt_dir}\")\n", + " # Load the model from the checkpoint directory\n", + " states = load_from_checkpoint(ckpt_dir)\n", + " run = artifact.logged_by()\n", + " config = run.config\n", + " except Exception as e:\n", + " print(f\"Warning: Failed to load model from wandb: {e}\")\n", + " return states, config" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "526cfa69", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "@dataclass\n", + "class DiffusionInferencePipeline(InferencePipeline):\n", + " \"\"\"Inference pipeline for diffusion models.\n", + " \n", + " This pipeline handles loading models from wandb and generating samples using the\n", + " DiffusionSampler from FlaxDiff.\n", + " \"\"\"\n", + " state: TrainState = None\n", + " best_state: TrainState = None\n", + " rngstate: Optional[RandomMarkovState] = None\n", + " noise_schedule: NoiseScheduler = None\n", + " model_output_transform: DiffusionPredictionTransform = None\n", + " autoencoder: AutoEncoder = None\n", + " input_config: DiffusionInputConfig = None\n", + " samplers: Dict[Type[DiffusionSampler], Dict[float, DiffusionSampler]] = field(default_factory=dict)\n", + " config: Dict[str, Any] = field(default_factory=dict)\n", + " \n", + " @classmethod\n", + " def from_wandb_run(\n", + " cls,\n", + " wandb_run: str,\n", + " project: str,\n", + " entity: str,\n", + " ):\n", + " \"\"\"Create an inference pipeline from a wandb run.\n", + " \n", + " Args:\n", + " wandb_run: Run ID or display name\n", + " project: Wandb project name\n", + " entity: Wandb entity name\n", + " wandb_modelname: Model name in wandb registry (if None, loads from checkpoint)\n", + " checkpoint_step: Specific checkpoint step to load (if None, loads latest)\n", + " config_overrides: Optional dictionary to override config values\n", + " checkpoint_base_path: Base path for checkpoint storage\n", + " \n", + " Returns:\n", + " DiffusionInferencePipeline instance\n", + " \"\"\"\n", + " states, config = load_from_wandb_run(\n", + " wandb_run,\n", + " project=project,\n", + " entity=entity,\n", + " )\n", + " \n", + " if states is None:\n", + " raise ValueError(\"Failed to load model parameters from wandb.\")\n", + " \n", + " state, best_state = states\n", + " parsed_config = parse_config(config)\n", + " \n", + " # Create the pipeline\n", + " pipeline = cls.create(\n", + " config=parsed_config,\n", + " state=state,\n", + " best_state=best_state,\n", + " rngstate=RandomMarkovState(jax.random.PRNGKey(42)),\n", + " )\n", + " return pipeline\n", + " \n", + " @classmethod\n", + " def from_wandb_registry(\n", + " cls,\n", + " modelname: str,\n", + " project: str,\n", + " entity: str = None,\n", + " version: str = 'latest',\n", + " registry: str = 'wandb-registry-model',\n", + " ):\n", + " \"\"\"Create an inference pipeline from a wandb model registry.\n", + " \n", + " Args:\n", + " modelname: Model name in wandb registry\n", + " project: Wandb project name\n", + " entity: Wandb entity name\n", + " version: Version of the model to load (default is 'latest')\n", + " registry: Registry name (default is 'wandb-registry-model')\n", + " \n", + " Returns:\n", + " DiffusionInferencePipeline instance\n", + " \"\"\"\n", + " states, config = load_from_wandb_registry(\n", + " modelname=modelname,\n", + " project=project,\n", + " entity=entity,\n", + " version=version,\n", + " registry=registry,\n", + " )\n", + " \n", + " if states is None:\n", + " raise ValueError(\"Failed to load model parameters from wandb.\")\n", + " \n", + " state, best_state = states\n", + " parsed_config = parse_config(config)\n", + " \n", + " # Create the pipeline\n", + " pipeline = cls.create(\n", + " config=parsed_config,\n", + " state=state,\n", + " best_state=best_state,\n", + " rngstate=RandomMarkovState(jax.random.PRNGKey(42)),\n", + " )\n", + " return pipeline\n", + " \n", + " @classmethod\n", + " def create(\n", + " cls,\n", + " config: Dict[str, Any],\n", + " state: Dict[str, Any],\n", + " best_state: Optional[Dict[str, Any]] = None,\n", + " rngstate: Optional[RandomMarkovState] = None,\n", + " ):\n", + " if rngstate is None:\n", + " rngstate = RandomMarkovState(jax.random.PRNGKey(42))\n", + " # Build and return pipeline\n", + " return cls(\n", + " model=config['model'],\n", + " state=state,\n", + " best_state=best_state,\n", + " rngstate=rngstate,\n", + " noise_schedule=config['noise_schedule'],\n", + " model_output_transform=config['prediction_transform'],\n", + " autoencoder=config['autoencoder'],\n", + " input_config=config['input_config'],\n", + " config=config,\n", + " )\n", + " \n", + " def get_sampler(\n", + " self, \n", + " guidance_scale: float = 3.0,\n", + " sampler_class=EulerAncestralSampler, \n", + " ) -> DiffusionSampler:\n", + " \"\"\"Get (or create) a sampler for generating samples.\n", + " \n", + " This method caches samplers by their class and guidance scale for reuse.\n", + " \n", + " Args:\n", + " sampler_class: Class for the diffusion sampler\n", + " guidance_scale: Classifier-free guidance scale (0.0 to disable)\n", + " \n", + " Returns:\n", + " DiffusionSampler instance\n", + " \"\"\"\n", + " # Get or create dictionary for this sampler class\n", + " if sampler_class not in self.samplers:\n", + " self.samplers[sampler_class] = {}\n", + " \n", + " # Check if we already have a sampler with this guidance scale\n", + " if guidance_scale not in self.samplers[sampler_class]:\n", + " # Create unconditional embeddings if using guidance\n", + " null_embeddings = None\n", + " if guidance_scale > 0.0:\n", + " null_text = self.input_config.conditions[0].get_unconditional()\n", + " null_embeddings = null_text\n", + " print(f\"Created null embeddings for guidance with shape {null_embeddings.shape}\")\n", + " \n", + " # Create and cache the sampler\n", + " self.samplers[sampler_class][guidance_scale] = sampler_class(\n", + " model=self.model,\n", + " noise_schedule=self.noise_schedule,\n", + " model_output_transform=self.model_output_transform,\n", + " guidance_scale=guidance_scale,\n", + " input_config=self.input_config,\n", + " autoencoder=self.autoencoder,\n", + " )\n", + " \n", + " return self.samplers[sampler_class][guidance_scale]\n", + " \n", + " def generate_samples(\n", + " self,\n", + " num_samples: int,\n", + " resolution: int,\n", + " conditioning_data: Optional[List[Union[Tuple, Dict]]] = None, # one list per modality or list of tuples\n", + " sequence_length: Optional[int] = None,\n", + " diffusion_steps: int = 50,\n", + " guidance_scale: float = 1.0,\n", + " sampler_class=EulerAncestralSampler,\n", + " timestep_spacing: str = 'linear',\n", + " seed: Optional[int] = None,\n", + " start_step: Optional[int] = None,\n", + " end_step: int = 0,\n", + " steps_override=None,\n", + " priors=None,\n", + " use_best_params: bool = False,\n", + " use_ema: bool = False,\n", + " ):\n", + " # Setup RNG\n", + " rngstate = self.rngstate or RandomMarkovState(jax.random.PRNGKey(seed or 0))\n", + " \n", + " # Get cached or new sampler\n", + " sampler = self.get_sampler(\n", + " guidance_scale=guidance_scale,\n", + " sampler_class=sampler_class,\n", + " )\n", + " if hasattr(sampler, 'timestep_spacing'):\n", + " sampler.timestep_spacing = timestep_spacing\n", + " print(f\"Generating samples: steps={diffusion_steps}, num_samples={num_samples}, guidance={guidance_scale}\")\n", + " \n", + " if use_best_params:\n", + " state = self.best_state\n", + " else:\n", + " state = self.state\n", + " \n", + " if use_ema:\n", + " params = state['ema_params']\n", + " else:\n", + " params = state['params']\n", + " \n", + " \n", + " return sampler.generate_samples(\n", + " params=params,\n", + " num_samples=num_samples,\n", + " resolution=resolution,\n", + " sequence_length=sequence_length,\n", + " diffusion_steps=diffusion_steps,\n", + " start_step=start_step,\n", + " end_step=end_step,\n", + " steps_override=steps_override,\n", + " priors=priors,\n", + " rngstate=rngstate,\n", + " conditioning=conditioning_data\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0cc86369", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Using wandb-core as the SDK backend. Please refer to https://wandb.me/wandb-core for more information.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Downloading large artifact diffusion-oxford_flowers102-res256:latest, 1049.57MB. 14 files... \n", + "\u001b[34m\u001b[1mwandb\u001b[0m: 14 of 14 files downloaded. \n", + "Done. 0:0:1.1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded model from wandb registry: diffusion-oxford_flowers102-res256 at path /home/mrwhite0racle/persist/FlaxDiff/artifacts/diffusion-oxford_flowers102-res256:v0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:Configured `CheckpointManager` using deprecated legacy API. Please follow the instructions at https://orbax.readthedocs.io/en/latest/api_refactor.html to migrate.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loaded checkpoint from local dir /home/mrwhite0racle/persist/FlaxDiff/artifacts/diffusion-oxford_flowers102-res256:v0\n", + "Using autoencoder: stable_diffusion\n", + "Using Stable Diffusion Autoencoder for Latent Diffusion Modeling\n", + "Ignoring key dtype with value as it contains a dot.\n", + "Scaling factor: 0.18215\n", + "Calculating downscale factor...\n", + "Downscale factor: 8\n", + "Latent channels: 4\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Some weights of the model checkpoint at openai/clip-vit-large-patch14 were not used when initializing FlaxCLIPTextModel: {('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'bias'), ('text_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'pre_layrnorm', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'pre_layrnorm', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'bias'), ('vision_model', 'post_layernorm', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'kernel'), ('logit_scale',), ('vision_model', 'embeddings', 'class_embedding'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'scale'), ('vision_model', 'embeddings', 'patch_embedding', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'bias'), ('vision_model', 'embeddings', 'position_embedding', 'embedding'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'post_layernorm', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'bias'), ('visual_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'bias')}\n", + "- This IS expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model kwargs after mapping: {'name': None, 'dtype': , 'precision': None, 'activation': >, 'named_norms': False, 'norm_groups': 8, 'emb_features': 256, 'feature_depths': [64, 64, 128, 256, 512], 'num_res_blocks': 2, 'output_channels': 4, 'attention_configs': [None, {'dtype': , 'heads': 8, 'use_projection': False, 'flash_attention': False, 'use_self_and_cross': True}, {'dtype': , 'heads': 8, 'use_projection': False, 'flash_attention': False, 'use_self_and_cross': True}, {'dtype': , 'heads': 8, 'use_projection': False, 'flash_attention': False, 'use_self_and_cross': True}, {'dtype': , 'heads': 8, 'use_projection': False, 'flash_attention': False, 'use_self_and_cross': False}], 'num_middle_res_blocks': 1}\n" + ] + } + ], + "source": [ + "pipeline = DiffusionInferencePipeline.from_wandb_registry(\n", + " modelname='diffusion-oxford_flowers102-res256',\n", + " project='mlops-msml605-project',\n", + " entity='umd-projects',\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5e4737f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Created null embeddings for guidance with shape (1, 77, 768)\n", + "Using classifier-free guidance\n", + "Generating samples: steps=100, num_samples=8, guidance=3.0\n", + "Processing raw conditioning inputs to generate model conditioning inputs\n" + ] + } + ], + "source": [ + "prompts = [\n", + " 'water tulip',\n", + " 'a water lily',\n", + " 'a water lily',\n", + " 'a photo of a rose',\n", + " 'a photo of a rose',\n", + " 'a water lily',\n", + " 'a water lily',\n", + " 'a photo of a marigold',\n", + "]\n", + "\n", + "samples = pipeline.generate_samples(\n", + " num_samples=len(prompts),\n", + " resolution=256,\n", + " diffusion_steps=100,\n", + " guidance_scale=3.0,\n", + " start_step=1000,\n", + " conditioning_data=prompts,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ae137be8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plotImages(samples, dpi=500)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84498dc6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaxdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/preprocess b/preprocess index 8ac4831..365b52d 160000 --- a/preprocess +++ b/preprocess @@ -1 +1 @@ -Subproject commit 8ac4831a59e307f35a71ac515dd2fec4fa419abf +Subproject commit 365b52d7b44c9e59e18970b2ab5394ed2349bacc diff --git a/prototype_general_pipeline.ipynb b/prototype_general_pipeline.ipynb new file mode 100644 index 0000000..6017ad7 --- /dev/null +++ b/prototype_general_pipeline.ipynb @@ -0,0 +1,1458 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "from flaxdiff.schedulers import EDMNoiseScheduler, KarrasVENoiseScheduler\n", + "from flaxdiff.predictors import KarrasPredictionTransform\n", + "from flaxdiff.models.simple_unet import Unet\n", + "from flaxdiff.trainer.general_diffusion_trainer import GeneralDiffusionTrainer, ConditionalInputConfig\n", + "from flaxdiff.data.dataloaders import get_dataset_grain\n", + "from flaxdiff.utils import defaultTextEncodeModel, get_latest_checkpoint\n", + "from flaxdiff.models.autoencoder.diffusers import StableDiffusionVAE\n", + "from flaxdiff.samplers.euler import EulerAncestralSampler\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import optax\n", + "from datetime import datetime\n", + "import argparse\n", + "import os\n", + "\n", + "BATCH_SIZE = 16\n", + "IMAGE_SIZE = 256" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-04-19 19:46:43.910069: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1745092003.933578 2058403 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1745092003.940782 2058403 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1745092003.957749 2058403 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1745092003.957772 2058403 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1745092003.957774 2058403 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1745092003.957776 2058403 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "Some weights of the model checkpoint at openai/clip-vit-large-patch14 were not used when initializing FlaxCLIPTextModel: {('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'bias'), ('visual_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'embeddings', 'position_embedding', 'embedding'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'embeddings', 'class_embedding'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'post_layernorm', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'kernel'), ('logit_scale',), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'post_layernorm', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'scale'), ('text_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'embeddings', 'patch_embedding', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'pre_layrnorm', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'pre_layrnorm', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'bias')}\n", + "- This IS expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/torch_xla/__init__.py:251: UserWarning: `tensorflow` can conflict with `torch-xla`. Prefer `tensorflow-cpu` when using PyTorch/XLA. To silence this warning, `pip uninstall -y tensorflow && pip install tensorflow-cpu`. If you are in a notebook environment such as Colab or Kaggle, restart your notebook runtime afterwards.\n", + " warnings.warn(\n", + "WARNING:root:libtpu.so and TPU device found. Setting PJRT_DEVICE=TPU.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scaling factor: 0.18215\n", + "Calculating downscale factor...\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "data = get_dataset_grain(\n", + " \"oxford_flowers102\", batch_size=BATCH_SIZE, image_scale=IMAGE_SIZE)\n", + "datalen = data['train_len']\n", + "batches = datalen // BATCH_SIZE\n", + "\n", + "text_encoder = defaultTextEncodeModel()\n", + "autoencoder = StableDiffusionVAE(**{\"modelname\": \"pcuenq/sd-vae-ft-mse-flax\"})\n", + "\n", + "# Construct a validation set by the prompts\n", + "val_prompts = ['water tulip', ' a water lily', ' a water lily', ' a photo of a rose', ' a photo of a rose', ' a water lily', ' a water lily', ' a photo of a marigold', ' a photo of a marigold', ' a photo of a marigold', ' a water lily', ' a photo of a sunflower', ' a photo of a lotus', ' columbine', ' columbine', ' an orchid', ' an orchid', ' an orchid', ' a water lily', ' a water lily', ' a water lily', ' columbine', ' columbine', ' a photo of a sunflower', ' a photo of a sunflower', ' a photo of a sunflower', ' a photo of a lotus', ' a photo of a lotus', ' a photo of a marigold', ' a photo of a marigold', ' a photo of a rose', ' a photo of a rose', ' a photo of a rose',\n", + " ' orange dahlia', ' orange dahlia', ' a lenten rose', ' a lenten rose', ' a water lily', ' a water lily', ' a water lily', ' a water lily', ' an orchid', ' an orchid', ' an orchid', ' hard-leaved pocket orchid', ' bird of paradise', ' bird of paradise', ' a photo of a lovely rose', ' a photo of a lovely rose', ' a photo of a globe-flower', ' a photo of a globe-flower', ' a photo of a lovely rose', ' a photo of a lovely rose', ' a photo of a ruby-lipped cattleya', ' a photo of a ruby-lipped cattleya', ' a photo of a lovely rose', ' a water lily', ' a osteospermum', ' a osteospermum', ' a water lily', ' a water lily', ' a water lily', ' a red rose', ' a red rose']\n", + "\n", + "\n", + "def get_val_dataset(batch_size=8):\n", + " for i in range(0, len(val_prompts), batch_size):\n", + " prompts = val_prompts[i:i + batch_size]\n", + " tokens = text_encoder.tokenize(prompts)\n", + " yield {\"text\": tokens}\n", + "\n", + "\n", + "data['test'] = get_val_dataset\n", + "data['test_len'] = len(val_prompts)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated input shapes: {'x': (32, 32, 4), 'temb': (), 'textcontext': (77, 768)}\n" + ] + } + ], + "source": [ + "from flax import linen as nn\n", + "from diffusers import FlaxUNet2DConditionModel\n", + "from flaxdiff.inputs import DiffusionInputConfig, ConditionalInputConfig\n", + "\n", + "input_config = DiffusionInputConfig(\n", + " sample_data_key='image',\n", + " sample_data_shape=(IMAGE_SIZE, IMAGE_SIZE, 3),\n", + " conditions=[\n", + " ConditionalInputConfig(\n", + " encoder=text_encoder,\n", + " conditioning_data_key='text',\n", + " pretokenized=True,\n", + " unconditional_input=\"\",\n", + " model_key_override=\"textcontext\",\n", + " )\n", + " ],\n", + ")\n", + "\n", + "input_shapes = input_config.get_input_shapes(\n", + " autoencoder=autoencoder,\n", + ")\n", + "\n", + "unet_model = FlaxUNet2DConditionModel(\n", + " sample_size=input_shapes[\"x\"][1], # the target image resolution\n", + " # the number of input channels, 3 for RGB images\n", + " in_channels=input_shapes[\"x\"][2],\n", + " out_channels=input_shapes[\"x\"][2], # the number of output channels\n", + " layers_per_block=2, # how many ResNet layers to use per UNet block\n", + " # the number of output channels for each UNet block\n", + " block_out_channels=(64, 128, 256, 512),\n", + " cross_attention_dim=512, # the size of the cross-attention layers\n", + " dtype=jnp.bfloat16,\n", + " use_memory_efficient_attention=True,\n", + ")\n", + "\n", + "\n", + "class BCHWModelWrapper(nn.Module):\n", + " model: nn.Module\n", + "\n", + " @nn.compact\n", + " def __call__(self, x, temb, textcontext):\n", + " # Reshape the input to BCHW format from BHWC\n", + " x = jnp.transpose(x, (0, 3, 1, 2))\n", + " # Pass the input through the UNet model\n", + " out = self.model(\n", + " sample=x,\n", + " timesteps=temb,\n", + " encoder_hidden_states=textcontext,\n", + " )\n", + " # Reshape the output back to BHWC format\n", + " out = jnp.transpose(out.sample, (0, 2, 3, 1))\n", + " return out\n", + " \n", + " @property\n", + " def __dict__(self):\n", + " return self.model.__dict__\n", + "\n", + "unet = BCHWModelWrapper(unet_model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated input shapes: {'x': (32, 32, 4), 'temb': (), 'textcontext': (77, 768)}\n" + ] + } + ], + "source": [ + "from flaxdiff.inputs import DiffusionInputConfig, ConditionalInputConfig\n", + "\n", + "input_config = DiffusionInputConfig(\n", + " sample_data_key='image',\n", + " sample_data_shape=(IMAGE_SIZE, IMAGE_SIZE, 3),\n", + " conditions=[\n", + " ConditionalInputConfig(\n", + " encoder=text_encoder,\n", + " conditioning_data_key='text',\n", + " pretokenized=True,\n", + " unconditional_input=\"\",\n", + " model_key_override=\"textcontext\",\n", + " )\n", + " ]\n", + ")\n", + "\n", + "input_shapes = input_config.get_input_shapes(\n", + " autoencoder=autoencoder,\n", + ")\n", + "\n", + "unet = Unet(emb_features=256,\n", + " feature_depths=[64, 64, 128, 256, 512],\n", + " attention_configs=[\n", + " None,\n", + " {\"heads\": 8, \"dtype\": jnp.float32, \"flash_attention\": False,\n", + " \"use_projection\": False, \"use_self_and_cross\": True},\n", + " {\"heads\": 8, \"dtype\": jnp.float32, \"flash_attention\": False,\n", + " \"use_projection\": False, \"use_self_and_cross\": True},\n", + " {\"heads\": 8, \"dtype\": jnp.float32, \"flash_attention\": False,\n", + " \"use_projection\": False, \"use_self_and_cross\": True},\n", + " {\"heads\": 8, \"dtype\": jnp.float32, \"flash_attention\": False,\n", + " \"use_projection\": False, \"use_self_and_cross\": False}\n", + " ],\n", + " num_res_blocks=2,\n", + " num_middle_res_blocks=1,\n", + " dtype=jnp.bfloat16,\n", + " output_channels=input_shapes[\"x\"][2],\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated input shapes: {'x': (32, 32, 4), 'temb': (), 'textcontext': (77, 768)}\n", + "Model name: diffusion-oxford_flowers102-res256\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Using wandb-core as the SDK backend. Please refer to https://wandb.me/wandb-core for more information.\n", + "\u001b[34m\u001b[1mwandb\u001b[0m: Currently logged in as: \u001b[33mashishkumar4\u001b[0m to \u001b[32mhttps://api.wandb.ai\u001b[0m. Use \u001b[1m`wandb login --relogin`\u001b[0m to force relogin\n" + ] + }, + { + "data": { + "text/html": [ + "Tracking run with wandb version 0.19.9" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Run data is saved locally in /home/mrwhite0racle/persist/FlaxDiff/wandb/run-20250419_153720-4b2mer47" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "Syncing run General_Diffusion_demo_for_inference2 to Weights & Biases (docs)
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View project at https://wandb.ai/umd-projects/mlops-msml605-project" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + " View run at https://wandb.ai/umd-projects/mlops-msml605-project/runs/4b2mer47" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:absl:Configured `CheckpointManager` using deprecated legacy API. Please follow the instructions at https://orbax.readthedocs.io/en/latest/api_refactor.html to migrate.\n", + "WARNING:absl:Configured `CheckpointManager` using deprecated legacy API. Please follow the instructions at https://orbax.readthedocs.io/en/latest/api_refactor.html to migrate.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading model from checkpoint at step 411355\n", + "Loaded model from checkpoint at epoch 804 step 411355 0.4702588\n", + "Generating states for DiffusionTrainer\n" + ] + } + ], + "source": [ + "# Define noise scheduler\n", + "edm_schedule = EDMNoiseScheduler(1, sigma_max=80, rho=7, sigma_data=0.5)\n", + "karas_ve_schedule = KarrasVENoiseScheduler(\n", + " 1, sigma_max=80, rho=7, sigma_data=0.5)\n", + "# Define model\n", + "\n", + "# Define optimizer\n", + "solver = optax.adam(2e-4)\n", + "\n", + "# Create the GeneralDiffusionTrainer\n", + "experiment_name = \"General_Diffusion_2025-04-18_06:34:50\"#f\"General_Diffusion_{datetime.now().strftime('%Y-%m-%d_%H:%M:%S')}\"\n", + "\n", + "trainer = GeneralDiffusionTrainer(\n", + " unet,\n", + " optimizer=solver,\n", + " noise_schedule=edm_schedule,\n", + " autoencoder=autoencoder,\n", + " input_config=input_config,\n", + " rngs=jax.random.PRNGKey(42),\n", + " name=experiment_name,\n", + " model_output_transform=KarrasPredictionTransform(\n", + " sigma_data=edm_schedule.sigma_data),\n", + " # data_key='image', # Specify the key for image data in batches\n", + " distributed_training=True,\n", + " wandb_config={\n", + " \"project\": 'mlops-msml605-project',\n", + " \"entity\": 'umd-projects',\n", + " \"name\": experiment_name,\n", + " \"id\": \"bdw4ebqf\",\n", + " \"config\": {\n", + " \"batch_size\": BATCH_SIZE,\n", + " \"image_size\": IMAGE_SIZE,\n", + " \"arguments\": {\n", + " \"architecture\": \"unet\",\n", + " \"dataset\": \"oxford_flowers102\",\n", + " \"noise_schedule\": \"edm\",\n", + " }\n", + " }\n", + " },\n", + " native_resolution=IMAGE_SIZE,\n", + " # Path to the checkpoint\n", + " load_from_checkpoint=\"/home/mrwhite0racle/persist/FlaxDiff/checkpoints/general_diffusion_2025-04-18_06:34:50\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 897: 600step [00:31, 19.01step/s, loss=0.4680] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mEpoch done on index 0 => 897 Loss: 0.47235533595085144\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 897 completed. Avg Loss: 0.47235533595085144, Time: 31.57s, Best Loss: 0.47025880217552185\u001b[0m\n", + "Validation started for process index 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 200/200 [00:01<00:00, 105.60it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mValidation done on process index 0\u001b[0m\n", + "\n", + "Epoch 898/2000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 898: 0%| | 0/511 [00:00 898 Loss: 0.4722280502319336\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 898 completed. Avg Loss: 0.4722280502319336, Time: 30.52s, Best Loss: 0.47025880217552185\u001b[0m\n", + "Validation started for process index 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 200/200 [00:01<00:00, 104.79it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mValidation done on process index 0\u001b[0m\n", + "\n", + "Epoch 899/2000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 899: 0%| | 0/511 [00:00 899 Loss: 0.473550945520401\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 899 completed. Avg Loss: 0.473550945520401, Time: 30.75s, Best Loss: 0.47025880217552185\u001b[0m\n", + "Validation started for process index 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 200/200 [00:01<00:00, 104.55it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mValidation done on process index 0\u001b[0m\n", + "\n", + "Epoch 900/2000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 900: 0%| | 0/511 [00:00 900 Loss: 0.47377240657806396\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 900 completed. Avg Loss: 0.47377240657806396, Time: 30.48s, Best Loss: 0.47025880217552185\u001b[0m\n", + "Validation started for process index 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 200/200 [00:01<00:00, 101.77it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mValidation done on process index 0\u001b[0m\n", + "\n", + "Epoch 901/2000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 901: 0%| | 0/511 [00:00 901 Loss: 0.47391751408576965\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 901 completed. Avg Loss: 0.47391751408576965, Time: 31.45s, Best Loss: 0.47025880217552185\u001b[0m\n", + "Validation started for process index 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 200/200 [00:01<00:00, 100.14it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mValidation done on process index 0\u001b[0m\n", + "\n", + "Epoch 902/2000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 902: 0%| | 0/511 [00:00 902 Loss: 0.47201600670814514\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 902 completed. Avg Loss: 0.47201600670814514, Time: 31.75s, Best Loss: 0.47025880217552185\u001b[0m\n", + "Validation started for process index 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "100%|██████████| 200/200 [00:01<00:00, 100.31it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32mValidation done on process index 0\u001b[0m\n", + "\n", + "Epoch 903/2000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 903: 0%| | 0/511 [00:00\n", + " fn = lambda r: (record.Record(r.metadata, transform.map(r.data)), True)\n", + " ^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/persist/FlaxDiff/flaxdiff/data/sources/images.py\", line 159, in map\n", + " results = self.tokenize(caption)\n", + " ^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/persist/FlaxDiff/flaxdiff/utils.py\", line 166, in __call__\n", + " tokens = self.tokenizer(inputs, padding=\"max_length\", max_length=self.tokenizer.model_max_length,\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/transformers/tokenization_utils_base.py\", line 2887, in __call__\n", + " encodings = self._call_one(text=text, text_pair=text_pair, **all_kwargs)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/transformers/tokenization_utils_base.py\", line 2997, in _call_one\n", + " return self.encode_plus(\n", + " ^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/transformers/tokenization_utils_base.py\", line 3073, in encode_plus\n", + " return self._encode_plus(\n", + " ^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/transformers/tokenization_utils_fast.py\", line 613, in _encode_plus\n", + " batched_output = self._batch_encode_plus(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/transformers/tokenization_utils_fast.py\", line 539, in _batch_encode_plus\n", + " encodings = self._tokenizer.encode_batch(\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/grain/_src/python/grain_pool.py\", line 236, in _worker_loop\n", + " if not multiprocessing_common.add_element_to_queue( # pytype: disable=wrong-arg-types\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/grain/_src/python/multiprocessing_common.py\", line 54, in add_element_to_queue\n", + " elements_queue.put(element, timeout=_QUEUE_WAIT_TIMEOUT_SECONDS)\n", + "KeyboardInterrupt\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/multiprocessing/queues.py\", line 89, in put\n", + " if not self._sem.acquire(block, timeout):\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/multiprocessing/process.py\", line 314, in _bootstrap\n", + " self.run()\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/multiprocessing/process.py\", line 108, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/grain/_src/python/grain_pool.py\", line 236, in _worker_loop\n", + " if not multiprocessing_common.add_element_to_queue( # pytype: disable=wrong-arg-types\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/grain/_src/python/multiprocessing_common.py\", line 54, in add_element_to_queue\n", + " elements_queue.put(element, timeout=_QUEUE_WAIT_TIMEOUT_SECONDS)\n", + " File \"/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/multiprocessing/queues.py\", line 89, in put\n", + " if not self._sem.acquire(block, timeout):\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + "KeyboardInterrupt\n" + ] + }, + { + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# Train the model\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m final_state = \u001b[43mtrainer\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbatches\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m2000\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msampler_class\u001b[49m\u001b[43m=\u001b[49m\u001b[43mEulerAncestralSampler\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msampling_noise_schedule\u001b[49m\u001b[43m=\u001b[49m\u001b[43mkaras_ve_schedule\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/trainer/diffusion_trainer.py:361\u001b[39m, in \u001b[36mDiffusionTrainer.fit\u001b[39m\u001b[34m(self, data, training_steps_per_epoch, epochs, val_steps_per_epoch, sampler_class, sampling_noise_schedule)\u001b[39m\n\u001b[32m 356\u001b[39m local_batch_size = data[\u001b[33m'\u001b[39m\u001b[33mlocal_batch_size\u001b[39m\u001b[33m'\u001b[39m]\n\u001b[32m 357\u001b[39m validation_step_args = {\n\u001b[32m 358\u001b[39m \u001b[33m\"\u001b[39m\u001b[33msampler_class\u001b[39m\u001b[33m\"\u001b[39m: sampler_class,\n\u001b[32m 359\u001b[39m \u001b[33m\"\u001b[39m\u001b[33msampling_noise_schedule\u001b[39m\u001b[33m\"\u001b[39m: sampling_noise_schedule,\n\u001b[32m 360\u001b[39m }\n\u001b[32m--> \u001b[39m\u001b[32m361\u001b[39m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m.\u001b[49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 362\u001b[39m \u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 363\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_steps_per_epoch\u001b[49m\u001b[43m=\u001b[49m\u001b[43mtraining_steps_per_epoch\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 364\u001b[39m \u001b[43m \u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mepochs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 365\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_step_args\u001b[49m\u001b[43m=\u001b[49m\u001b[43m{\u001b[49m\u001b[33;43m\"\u001b[39;49m\u001b[33;43mbatch_size\u001b[39;49m\u001b[33;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mlocal_batch_size\u001b[49m\u001b[43m}\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 366\u001b[39m \u001b[43m \u001b[49m\u001b[43mval_steps_per_epoch\u001b[49m\u001b[43m=\u001b[49m\u001b[43mval_steps_per_epoch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 367\u001b[39m \u001b[43m \u001b[49m\u001b[43mvalidation_step_args\u001b[49m\u001b[43m=\u001b[49m\u001b[43mvalidation_step_args\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 368\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/trainer/simple_trainer.py:526\u001b[39m, in \u001b[36mSimpleTrainer.fit\u001b[39m\u001b[34m(self, data, train_steps_per_epoch, epochs, train_step_args, val_steps_per_epoch, validation_step_args)\u001b[39m\n\u001b[32m 523\u001b[39m start_time = time.time()\n\u001b[32m 524\u001b[39m epoch_loss = \u001b[32m0\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m526\u001b[39m epoch_loss, current_step, train_state, rng_state = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mtrain_loop\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 527\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_state\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 528\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_step\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 529\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_ds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 530\u001b[39m \u001b[43m \u001b[49m\u001b[43mtrain_steps_per_epoch\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 531\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mlatest_step\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 532\u001b[39m \u001b[43m \u001b[49m\u001b[43mrng_state\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 533\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 534\u001b[39m \u001b[38;5;28mprint\u001b[39m(colored(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mEpoch done on process index \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mprocess_index\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m, PROCESS_COLOR_MAP[process_index]))\n\u001b[32m 536\u001b[39m \u001b[38;5;28mself\u001b[39m.latest_step = current_step\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/trainer/simple_trainer.py:438\u001b[39m, in \u001b[36mSimpleTrainer.train_loop\u001b[39m\u001b[34m(self, train_state, train_step_fn, train_ds, train_steps_per_epoch, current_step, rng_state)\u001b[39m\n\u001b[32m 434\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mTraining started for process index \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mprocess_index\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m at step \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcurrent_step\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m 436\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.distributed_training:\n\u001b[32m 437\u001b[39m \u001b[38;5;66;03m# loss = jax.experimental.multihost_utils.process_allgather(loss)\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m438\u001b[39m loss = \u001b[43mjnp\u001b[49m\u001b[43m.\u001b[49m\u001b[43mmean\u001b[49m\u001b[43m(\u001b[49m\u001b[43mloss\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;66;03m# Just to make sure its a scaler value\u001b[39;00m\n\u001b[32m 440\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m loss <= \u001b[32m1e-8\u001b[39m \u001b[38;5;129;01mor\u001b[39;00m jnp.isnan(loss) \u001b[38;5;129;01mor\u001b[39;00m jnp.isinf(loss):\n\u001b[32m 441\u001b[39m \u001b[38;5;66;03m# If the loss is too low or NaN/Inf, log the issue and attempt recovery\u001b[39;00m\n\u001b[32m 442\u001b[39m \u001b[38;5;28mprint\u001b[39m(colored(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mAbnormal loss at step \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mcurrent_step\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mloss\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m, \u001b[33m'\u001b[39m\u001b[33mred\u001b[39m\u001b[33m'\u001b[39m))\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/jax/_src/numpy/reductions.py:803\u001b[39m, in \u001b[36mmean\u001b[39m\u001b[34m(a, axis, dtype, out, keepdims, where)\u001b[39m\n\u001b[32m 799\u001b[39m size *= maybe_named_axis(a, \u001b[38;5;28;01mlambda\u001b[39;00m i: a_shape[i], \u001b[38;5;28;01mlambda\u001b[39;00m name: lax.psum(\u001b[32m1\u001b[39m, name))\n\u001b[32m 800\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m size\n\u001b[32m--> \u001b[39m\u001b[32m803\u001b[39m \u001b[38;5;129m@export\u001b[39m\n\u001b[32m 804\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mmean\u001b[39m(a: ArrayLike, axis: Axis = \u001b[38;5;28;01mNone\u001b[39;00m, dtype: DTypeLike | \u001b[38;5;28;01mNone\u001b[39;00m = \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m 805\u001b[39m out: \u001b[38;5;28;01mNone\u001b[39;00m = \u001b[38;5;28;01mNone\u001b[39;00m, keepdims: \u001b[38;5;28mbool\u001b[39m = \u001b[38;5;28;01mFalse\u001b[39;00m, *,\n\u001b[32m 806\u001b[39m where: ArrayLike | \u001b[38;5;28;01mNone\u001b[39;00m = \u001b[38;5;28;01mNone\u001b[39;00m) -> Array:\n\u001b[32m 807\u001b[39m \u001b[38;5;250m \u001b[39m\u001b[33mr\u001b[39m\u001b[33;03m\"\"\"Return the mean of array elements along a given axis.\u001b[39;00m\n\u001b[32m 808\u001b[39m \n\u001b[32m 809\u001b[39m \u001b[33;03m JAX implementation of :func:`numpy.mean`.\u001b[39;00m\n\u001b[32m (...)\u001b[39m\u001b[32m 865\u001b[39m \u001b[33;03m [6. ]], dtype=float32)\u001b[39;00m\n\u001b[32m 866\u001b[39m \u001b[33;03m \"\"\"\u001b[39;00m\n\u001b[32m 867\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m _mean(a, _ensure_optional_axes(axis), dtype, out, keepdims,\n\u001b[32m 868\u001b[39m where=where, upcast_f16_for_computation=(dtype \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m))\n", + "\u001b[31mKeyboardInterrupt\u001b[39m: " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error in callback > (for post_run_cell), with arguments args ( result=None>,),kwargs {}:\n" + ] + }, + { + "ename": "MailboxClosedError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mMailboxClosedError\u001b[39m Traceback (most recent call last)", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/wandb_init.py:543\u001b[39m, in \u001b[36m_WandbInit._pause_backend\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 541\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.notebook.save_ipynb(): \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[32m 542\u001b[39m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m.run \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m543\u001b[39m res = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mrun\u001b[49m\u001b[43m.\u001b[49m\u001b[43mlog_code\u001b[49m\u001b[43m(\u001b[49m\u001b[43mroot\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[32m 544\u001b[39m \u001b[38;5;28mself\u001b[39m._logger.info(\u001b[33m\"\u001b[39m\u001b[33msaved code: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[33m\"\u001b[39m, res) \u001b[38;5;66;03m# type: ignore\u001b[39;00m\n\u001b[32m 545\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.backend.interface \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:435\u001b[39m, in \u001b[36m_run_decorator._noop_on_finish..decorator_fn..wrapper_fn\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 432\u001b[39m \u001b[38;5;129m@functools\u001b[39m.wraps(func)\n\u001b[32m 433\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mwrapper_fn\u001b[39m(\u001b[38;5;28mself\u001b[39m: \u001b[38;5;28mtype\u001b[39m[Run], *args: Any, **kwargs: Any) -> Any:\n\u001b[32m 434\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mgetattr\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[33m\"\u001b[39m\u001b[33m_is_finished\u001b[39m\u001b[33m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m):\n\u001b[32m--> \u001b[39m\u001b[32m435\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 437\u001b[39m default_message = (\n\u001b[32m 438\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mRun (\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.id\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m) is finished. The call to `\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfunc.\u001b[34m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m` will be ignored. \u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 439\u001b[39m \u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mPlease make sure that you are using an active run.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 440\u001b[39m )\n\u001b[32m 441\u001b[39m resolved_message = message \u001b[38;5;129;01mor\u001b[39;00m default_message\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:387\u001b[39m, in \u001b[36m_log_to_run..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 384\u001b[39m run_id = \u001b[38;5;28mself\u001b[39m._attach_id\n\u001b[32m 386\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m wb_logging.log_to_run(run_id):\n\u001b[32m--> \u001b[39m\u001b[32m387\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:425\u001b[39m, in \u001b[36m_run_decorator._attach..wrapper\u001b[39m\u001b[34m(self, *args, **kwargs)\u001b[39m\n\u001b[32m 423\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m e\n\u001b[32m 424\u001b[39m \u001b[38;5;28mcls\u001b[39m._is_attaching = \u001b[33m\"\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m--> \u001b[39m\u001b[32m425\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m*\u001b[49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:1147\u001b[39m, in \u001b[36mRun.log_code\u001b[39m\u001b[34m(self, root, name, include_fn, exclude_fn)\u001b[39m\n\u001b[32m 1142\u001b[39m wandb.termwarn(\n\u001b[32m 1143\u001b[39m \u001b[33m\"\u001b[39m\u001b[33mNo relevant files were detected in the specified directory. No code will be logged to your run.\u001b[39m\u001b[33m\"\u001b[39m\n\u001b[32m 1144\u001b[39m )\n\u001b[32m 1145\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m-> \u001b[39m\u001b[32m1147\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_log_artifact\u001b[49m\u001b[43m(\u001b[49m\u001b[43mart\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/wandb_run.py:3351\u001b[39m, in \u001b[36mRun._log_artifact\u001b[39m\u001b[34m(self, artifact_or_path, name, type, aliases, tags, distributed_id, finalize, is_user_created, use_after_commit)\u001b[39m\n\u001b[32m 3349\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backend \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m._backend.interface:\n\u001b[32m 3350\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m._settings._offline:\n\u001b[32m-> \u001b[39m\u001b[32m3351\u001b[39m handle = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_backend\u001b[49m\u001b[43m.\u001b[49m\u001b[43minterface\u001b[49m\u001b[43m.\u001b[49m\u001b[43mdeliver_artifact\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 3352\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 3353\u001b[39m \u001b[43m \u001b[49m\u001b[43martifact\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3354\u001b[39m \u001b[43m \u001b[49m\u001b[43maliases\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3355\u001b[39m \u001b[43m \u001b[49m\u001b[43mtags\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3356\u001b[39m \u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mstep\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3357\u001b[39m \u001b[43m \u001b[49m\u001b[43mfinalize\u001b[49m\u001b[43m=\u001b[49m\u001b[43mfinalize\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3358\u001b[39m \u001b[43m \u001b[49m\u001b[43mis_user_created\u001b[49m\u001b[43m=\u001b[49m\u001b[43mis_user_created\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3359\u001b[39m \u001b[43m \u001b[49m\u001b[43muse_after_commit\u001b[49m\u001b[43m=\u001b[49m\u001b[43muse_after_commit\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 3360\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 3361\u001b[39m artifact._set_save_handle(handle, \u001b[38;5;28mself\u001b[39m._public_api().client)\n\u001b[32m 3362\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/interface/interface.py:589\u001b[39m, in \u001b[36mInterfaceBase.deliver_artifact\u001b[39m\u001b[34m(self, run, artifact, aliases, tags, history_step, is_user_created, use_after_commit, finalize)\u001b[39m\n\u001b[32m 587\u001b[39m log_artifact.history_step = history_step\n\u001b[32m 588\u001b[39m log_artifact.staging_dir = get_staging_dir()\n\u001b[32m--> \u001b[39m\u001b[32m589\u001b[39m resp = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_deliver_artifact\u001b[49m\u001b[43m(\u001b[49m\u001b[43mlog_artifact\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 590\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m resp\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/interface/interface_shared.py:339\u001b[39m, in \u001b[36mInterfaceShared._deliver_artifact\u001b[39m\u001b[34m(self, log_artifact)\u001b[39m\n\u001b[32m 334\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_deliver_artifact\u001b[39m(\n\u001b[32m 335\u001b[39m \u001b[38;5;28mself\u001b[39m,\n\u001b[32m 336\u001b[39m log_artifact: pb.LogArtifactRequest,\n\u001b[32m 337\u001b[39m ) -> MailboxHandle[pb.Result]:\n\u001b[32m 338\u001b[39m rec = \u001b[38;5;28mself\u001b[39m._make_request(log_artifact=log_artifact)\n\u001b[32m--> \u001b[39m\u001b[32m339\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43m_deliver_record\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrec\u001b[49m\u001b[43m)\u001b[49m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/interface/interface_shared.py:389\u001b[39m, in \u001b[36mInterfaceShared._deliver_record\u001b[39m\u001b[34m(self, record)\u001b[39m\n\u001b[32m 386\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34m_deliver_record\u001b[39m(\u001b[38;5;28mself\u001b[39m, record: pb.Record) -> MailboxHandle[pb.Result]:\n\u001b[32m 387\u001b[39m mailbox = \u001b[38;5;28mself\u001b[39m._get_mailbox()\n\u001b[32m--> \u001b[39m\u001b[32m389\u001b[39m handle = \u001b[43mmailbox\u001b[49m\u001b[43m.\u001b[49m\u001b[43mrequire_response\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrecord\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 390\u001b[39m \u001b[38;5;28mself\u001b[39m._publish(record)\n\u001b[32m 392\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m handle.map(\u001b[38;5;28;01mlambda\u001b[39;00m resp: resp.result_communicate)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/wandb/sdk/mailbox/mailbox.py:68\u001b[39m, in \u001b[36mMailbox.require_response\u001b[39m\u001b[34m(self, request)\u001b[39m\n\u001b[32m 66\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m._handles_lock:\n\u001b[32m 67\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m._closed:\n\u001b[32m---> \u001b[39m\u001b[32m68\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m MailboxClosedError()\n\u001b[32m 70\u001b[39m handle = MailboxResponseHandle(address)\n\u001b[32m 71\u001b[39m \u001b[38;5;28mself\u001b[39m._handles[address] = handle\n", + "\u001b[31mMailboxClosedError\u001b[39m: " + ] + } + ], + "source": [ + "# Train the model\n", + "final_state = trainer.fit(data, batches, epochs=2000,\n", + " sampler_class=EulerAncestralSampler, sampling_noise_schedule=karas_ve_schedule)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def normalizeImage(x): return jax.nn.standardize(x, mean=[127.5], std=[127.5])\n", + "def denormalizeImage(x): return (x + 1.0) * 127.5\n", + "\n", + "\n", + "def plotImages(imgs, fig_size=(8, 8), dpi=100):\n", + " fig = plt.figure(figsize=fig_size, dpi=dpi)\n", + " imglen = imgs.shape[0]\n", + " for i in range(imglen):\n", + " plt.subplot(fig_size[0], fig_size[1], i + 1)\n", + " plt.imshow(jnp.astype(denormalizeImage(imgs[i, :, :, :]), jnp.uint8))\n", + " plt.axis(\"off\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using classifier-free guidance\n" + ] + } + ], + "source": [ + "sampler = EulerAncestralSampler(\n", + " model=trainer.model,\n", + " noise_schedule=karas_ve_schedule,\n", + " model_output_transform=KarrasPredictionTransform(\n", + " sigma_data=karas_ve_schedule.sigma_data),\n", + " autoencoder=trainer.autoencoder,\n", + " input_config=trainer.input_config,\n", + " guidance_scale=3,\n", + " timestep_spacing=\"linear\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing raw conditioning inputs to generate model conditioning inputs\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 200/200 [00:15<00:00, 13.01it/s]\n" + ] + } + ], + "source": [ + "prompts = [\n", + " 'water tulip',\n", + " 'a water lily',\n", + " 'a water lily',\n", + " 'a photo of a rose',\n", + " 'a photo of a rose',\n", + " 'a water lily',\n", + " 'a water lily',\n", + " 'a photo of a marigold',\n", + "]\n", + "images = sampler.generate_samples(\n", + " params=trainer.best_state.params,\n", + " resolution=IMAGE_SIZE,\n", + " num_samples=len(prompts),\n", + " sequence_length=None,\n", + " diffusion_steps=200,\n", + " start_step=1000,\n", + " end_step=0,\n", + " conditioning=prompts,\n", + " # model_conditioning_inputs=(encoded,)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'plotImages' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[5]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mplotImages\u001b[49m(images, dpi=\u001b[32m500\u001b[39m)\n", + "\u001b[31mNameError\u001b[39m: name 'plotImages' is not defined" + ] + } + ], + "source": [ + "plotImages(images, dpi=500)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/home/mrwhite0racle/persist/FlaxDiff/checkpoints/general_diffusion_demo_for_inference'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer.checkpoint_path()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34m\u001b[1mwandb\u001b[0m: Adding directory to artifact (/home/mrwhite0racle/persist/FlaxDiff/checkpoints/general_diffusion_demo_for_inference2/411355)... Done. 8.9s\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model pushed to registry at wandb-registry-model/diffusion-oxford_flowers102-res256\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer.push_to_registry()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'trainer' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m \u001b[43mtrainer\u001b[49m.wandb.run\n", + "\u001b[31mNameError\u001b[39m: name 'trainer' is not defined" + ] + } + ], + "source": [ + "trainer.wandb.run" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaxdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/prototype_pipeline.ipynb b/prototype_pipeline.ipynb index 4b376fc..b3dced9 100644 --- a/prototype_pipeline.ipynb +++ b/prototype_pipeline.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -28,12 +28,12 @@ "from datetime import datetime\n", "\n", "BATCH_SIZE = 16\n", - "IMAGE_SIZE = 128" + "IMAGE_SIZE = 256" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -45,22 +45,22 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "2025-04-10 15:23:13.709672: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "2025-04-11 03:05:29.785067: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "E0000 00:00:1744298593.733614 2309744 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "E0000 00:00:1744298593.741021 2309744 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "W0000 00:00:1744298593.758653 2309744 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1744298593.758673 2309744 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1744298593.758675 2309744 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "W0000 00:00:1744298593.758677 2309744 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", - "Some weights of the model checkpoint at openai/clip-vit-large-patch14 were not used when initializing FlaxCLIPTextModel: {('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'bias'), ('visual_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'bias'), ('logit_scale',), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'kernel'), ('vision_model', 'embeddings', 'position_embedding', 'embedding'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'bias'), ('vision_model', 'embeddings', 'patch_embedding', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'post_layernorm', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'kernel'), ('vision_model', 'pre_layrnorm', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'post_layernorm', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'pre_layrnorm', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'bias'), ('text_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'embeddings', 'class_embedding'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'kernel')}\n", + "E0000 00:00:1744340729.809380 2662861 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1744340729.816702 2662861 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1744340729.834348 2662861 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1744340729.834376 2662861 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1744340729.834378 2662861 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1744340729.834380 2662861 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "Some weights of the model checkpoint at openai/clip-vit-large-patch14 were not used when initializing FlaxCLIPTextModel: {('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'bias'), ('vision_model', 'post_layernorm', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'pre_layrnorm', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'kernel'), ('logit_scale',), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'kernel'), ('text_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'bias'), ('vision_model', 'post_layernorm', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'bias'), ('vision_model', 'embeddings', 'class_embedding'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'kernel'), ('vision_model', 'pre_layrnorm', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'embeddings', 'patch_embedding', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'embeddings', 'position_embedding', 'embedding'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'bias'), ('visual_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'bias')}\n", "- This IS expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", "- This IS NOT expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n" ] @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -109,7 +109,8 @@ "from diffusers import FlaxUNet2DConditionModel\n", "\n", "input_shapes = {\n", - " \"x\": (IMAGE_SIZE, IMAGE_SIZE, 3),\n", + " # \"x\": (IMAGE_SIZE, IMAGE_SIZE, 3),\n", + " \"x\": (IMAGE_SIZE//8, IMAGE_SIZE//8, 4),\n", " \"temb\": (),\n", " \"textcontext\": (77, 768)\n", "}\n", @@ -122,9 +123,9 @@ "# Write a wrapper model around FlaxUNet2DConditionModel \n", "\n", "unet_model = FlaxUNet2DConditionModel(\n", - " sample_size=IMAGE_SIZE, # the target image resolution\n", - " in_channels=3, # the number of input channels, 3 for RGB images\n", - " out_channels=3, # the number of output channels\n", + " sample_size=input_shapes[\"x\"][1], # the target image resolution\n", + " in_channels=input_shapes[\"x\"][2], # the number of input channels, 3 for RGB images\n", + " out_channels=input_shapes[\"x\"][2], # the number of output channels\n", " layers_per_block=2, # how many ResNet layers to use per UNet block\n", " block_out_channels=(64, 128, 256, 512), # the number of output channels for each UNet block\n", " cross_attention_dim=512, # the size of the cross-attention layers\n", @@ -154,12 +155,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "input_shapes = {\n", - " \"x\": (IMAGE_SIZE, IMAGE_SIZE, 3),\n", + " \"x\": (IMAGE_SIZE//8, IMAGE_SIZE//8, 4),\n", " \"temb\": (),\n", " \"textcontext\": (77, 768)\n", "}\n", @@ -176,13 +177,22 @@ " num_res_blocks=2,\n", " num_middle_res_blocks=1,\n", " dtype=jnp.bfloat16,\n", - " \n", + " output_channels=input_shapes[\"x\"][2],\n", ")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from flaxdiff.models.autoencoder.diffusers import StableDiffusionVAE" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { @@ -208,7 +218,7 @@ { "data": { "text/html": [ - "Run data is saved locally in /home/mrwhite0racle/persist/FlaxDiff/wandb/run-20250410_152327-lqhfkv5j" + "Run data is saved locally in /home/mrwhite0racle/persist/FlaxDiff/wandb/run-20250411_030547-97zfganj" ], "text/plain": [ "" @@ -220,7 +230,7 @@ { "data": { "text/html": [ - "Syncing run prototype-2025-04-10_15:23:26 to Weights & Biases (docs)
" + "Syncing run prototype-2025-04-11_03:05:45 to Weights & Biases (docs)
" ], "text/plain": [ "" @@ -244,7 +254,7 @@ { "data": { "text/html": [ - " View run at https://wandb.ai/ashishkumar4/mlops-msml605-project/runs/lqhfkv5j" + " View run at https://wandb.ai/ashishkumar4/mlops-msml605-project/runs/97zfganj" ], "text/plain": [ "" @@ -271,17 +281,20 @@ "source": [ "# Define noise scheduler\n", "edm_schedule = EDMNoiseScheduler(1, sigma_max=80, rho=7, sigma_data=0.5)\n", - "karas_ve_schedule = KarrasVENoiseScheduler(1, sigma_max=80, rho=7, sigma_data=0.5)\n", + "karras_ve_schedule = KarrasVENoiseScheduler(1, sigma_max=80, rho=7, sigma_data=0.5)\n", "# Define model\n", "\n", "# Define optimizer\n", "solver = optax.adam(2e-4)\n", "\n", + "autoencoder = StableDiffusionVAE(**{\"modelname\":\"pcuenq/sd-vae-ft-mse-flax\"})\n", + "\n", "# Create trainer\n", "trainer = DiffusionTrainer(\n", " unet, optimizer=solver, \n", " input_shapes=input_shapes,\n", " noise_schedule=edm_schedule,\n", + " autoencoder=autoencoder,\n", " rngs=jax.random.PRNGKey(4), \n", " name=\"Diffusion_SDE_VE_\" + datetime.now().strftime(\"%Y-%m-%d_%H:%M:%S\"),\n", " model_output_transform=KarrasPredictionTransform(sigma_data=edm_schedule.sigma_data),\n", @@ -290,7 +303,8 @@ " wandb_config = {\n", " \"project\": 'mlops-msml605-project',\n", " \"name\": f\"prototype-{datetime.now().strftime('%Y-%m-%d_%H:%M:%S')}\",\n", - " }\n", + " },\n", + " native_resolution=IMAGE_SIZE\n", ")\n" ] }, @@ -299,54 +313,9537 @@ "execution_count": null, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\t\tEpoch 683: 600step [01:07, 8.91step/s, loss=0.6253] " + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Using classifier-free guidance\n", - "Validation run for sanity check for process index 0\n" + "\u001b[32mEpoch done on index 0 => 683 Loss: 0.6746714115142822\u001b[0m\n", + "\u001b[32mEpoch done on process index 0\u001b[0m\n", + "\u001b[32m\n", + "\tEpoch 683 completed. Avg Loss: 0.6746714115142822, Time: 67.36s, Best Loss: 0.47083213925361633\u001b[0m\n", + "Validation started for process index 0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 200/200 [00:26<00:00, 7.65it/s]\n" + "\n", + "100%|██████████| 200/200 [00:06<00:00, 32.03it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "\u001b[32mSanity Validation done on process index 0\u001b[0m\n", + "\u001b[32mValidation done on process index 0\u001b[0m\n", "\n", - "Epoch 0/2\n" + "Epoch 684/2000\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\t\tEpoch 0: 0%| | 0/511 [00:00 - -for tpu-v4-32 - -python3 training.py --dataset=combined_online --dataset_path='/home/mrwhite0racle/gcs_mount/'\ - --checkpoint_dir='flaxdiff-datasets-regional/checkpoints/' --checkpoint_fs='gcs'\ - --epochs=40 --batch_size=256 --image_size=512 \ - --learning_rate=9e-5 --num_res_blocks=3 --emb_features 512 \ - --use_self_and_cross=False --precision=default --dtype=bfloat16 --attention_heads=16\ - --experiment_name='dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-32_ldm_data-online_big'\ - --optimizer=adamw --feature_depths 128 256 512 512 --autoencoder=stable_diffusion \ - --norm_groups 0 --clip_grads 0.5 --only_pure_attention=True - -python3 training.py --dataset=combined_online --dataset_path='/home/mrwhite0racle/gcs_mount/'\ - --checkpoint_dir='flaxdiff-datasets-regional/checkpoints/' --checkpoint_fs='gcs'\ - --epochs=40 --batch_size=256 --image_size=128 \ - --learning_rate=1e-4 --num_res_blocks=3 --emb_features 512 \ - --use_self_and_cross=False --precision=default --dtype=bfloat16 --attention_heads=16\ - --experiment_name='dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-32_data-online'\ - --optimizer=adamw --feature_depths 128 256 512 512 \ - --norm_groups 0 --clip_grads 0.5 --only_pure_attention=True - -for tpu-v4-16 - -python3 training.py --dataset=combined_30m --dataset_path='/home/mrwhite0racle/gcs_mount/'\ - --checkpoint_dir='flaxdiff-datasets-regional/checkpoints/' --checkpoint_fs='gcs'\ - --epochs=40 --batch_size=128 --image_size=128 \ - --learning_rate=4e-5 --num_res_blocks=3 \ - --use_self_and_cross=False --dtype=bfloat16 --precision=default --attention_heads=8\ - --experiment_name='dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-16_flaxdiff-0-1-9_light_combined_30m_1'\ - --optimizer=adamw --use_dynamic_scale=True --norm_groups 0 --only_pure_attention=False \ - --load_from_checkpoint='gs://flaxdiff-datasets-regional/checkpoints/dataset-combined_30m/image_size-128/batch-128-v4-16_flaxdiff-0-1-9_light_combined_30m_ldm_1' - ----------------------------------------------------------------------------------------------------------------------------- -Old --> - -for tpu-v4-64 - -python3 training.py --dataset=combined_online --dataset_path='/home/mrwhite0racle/gcs_mount/'\ - --checkpoint_dir='flaxdiff-datasets-regional/checkpoints/' --checkpoint_fs='gcs'\ - --epochs=40 --batch_size=512 --image_size=512 --learning_rate=9e-5 \ - --architecture=uvit --num_layers=12 --emb_features=768 --norm_groups 0 --num_heads=12 \ - --dtype=bfloat16 --precision=default \ - --experiment_name='dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-64_uvit_ldm_combined_online'\ - --optimizer=adamw --clip_grads 0.5 --autoencoder=stable_diffusion \ - --learning_rate_schedule=cosine --learning_rate_peak=2.7e-4 --learning_rate_end=4e-5 --learning_rate_warmup_steps=10000 --learning_rate_decay_epochs=2\ - - - --load_from_checkpoint='gs://flaxdiff-datasets-regional/checkpoints/dataset-combined_30m/image_size-512/batch-512-v4-64_flaxdiff-0-1-8_ldm_dyn_scale_NEW_ARCH_combined_30' - - - --learning_rate_schedule=cosine --learning_rate_peak=4e-5 --learning_rate_end=9e-6 --learning_rate_warmup_steps=5000 --learning_rate_decay_epochs=2\ - - -python3 training.py --dataset=combined_online --dataset_path=/home/mrwhite0racle/gcs_mount/ \ - --checkpoint_dir=flaxdiff-datasets-regional/checkpoints/ --checkpoint_fs=gcs \ - --epochs=40 --batch_size=512 --image_size=256 --learning_rate=4e-5 \ - --architecture=uvit --num_layers=12 --emb_features=768 --norm_groups 0 --num_heads=12 \ - --dtype=bfloat16 --precision=default \ - --experiment_name=dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-64_uvit_combined_online-larger_residualout \ - --optimizer=adamw --clip_grads 1 --add_residualblock_output=True - -for tpu-v4-32 - -python3 training.py --dataset=combined_online --dataset_path=/home/mrwhite0racle/gcs_mount/ --checkpoint_dir=flaxdiff-datasets-regional/checkpoints/ \ - --checkpoint_fs=gcs --epochs=40 --batch_size=512 --image_size=256 --learning_rate=8e-5 \ - --num_res_blocks=3 --emb_features 512 --use_self_and_cross=False \ - --precision=default --dtype=bfloat16 --attention_heads=16 \ - --experiment_name=dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-64-_combined_online-finetuned-more-biggerdata \ - --optimizer=adamw --feature_depths 128 256 512 512 --only_pure_attention=True --named_norms=True --norm_groups=0 \ - --clip_grads=1 --load_from_checkpoint=gs://flaxdiff-datasets-regional/checkpoints/dataset-combined_online/image_size-256/batch-512-v4-64-_combined_online-finetuned-more - -for tpu-v4-16 - -python3 training.py --dataset=combined_aesthetic --dataset_path='/home/mrwhite0racle/gcs_mount/'\ - --checkpoint_dir='flaxdiff-datasets-regional/checkpoints/' --checkpoint_fs='gcs'\ - --epochs=40 --batch_size=128 --image_size=512 \ - --learning_rate=8e-5 --num_res_blocks=3 \ - --use_self_and_cross=False --precision=default --attention_heads=16\ - --experiment_name='dataset-{dataset}/image_size-{image_size}/batch-{batch_size}-v4-16_flaxdiff-0-1-8_new-combined_ldm_1'\ - --learning_rate_schedule=cosine --learning_rate_peak=1e-4 --learning_rate_end=4e-5 --learning_rate_warmup_steps=5000 --learning_rate_decay_epochs=1\ - --optimizer=adamw --autoencoder=stable_diffusion --use_dynamic_scale=True\ - --load_from_checkpoint='gs://flaxdiff-datasets-regional/checkpoints/dataset-combined_aesthetic/image_size-512/batch-128-v4-16_flaxdiff-0-1-8__ldm_1' -""" +""" \ No newline at end of file diff --git a/video_diffusion_example.ipynb b/video_diffusion_example.ipynb new file mode 100644 index 0000000..5dc5b71 --- /dev/null +++ b/video_diffusion_example.ipynb @@ -0,0 +1,872 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3f95b1a3", + "metadata": {}, + "source": [ + "# Video Diffusion with FlaxUNet3DConditionModel\n", + "\n", + "This notebook demonstrates how to use the FlaxUNet3DConditionModel for video diffusion tasks." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2788e6f2", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], + "source": [ + "from flaxdiff.schedulers import EDMNoiseScheduler, KarrasVENoiseScheduler\n", + "from flaxdiff.predictors import KarrasPredictionTransform\n", + "from flaxdiff.models.simple_unet import Unet\n", + "from flaxdiff.trainer.general_diffusion_trainer import GeneralDiffusionTrainer, ConditionalInputConfig\n", + "from flaxdiff.data.datasets import get_dataset_grain, get_media_dataset_grain\n", + "from flaxdiff.utils import defaultTextEncodeModel\n", + "from flaxdiff.models.autoencoder.diffusers import StableDiffusionVAE\n", + "from flaxdiff.samplers.euler import EulerAncestralSampler\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import optax\n", + "from datetime import datetime\n", + "import argparse\n", + "import os\n", + "\n", + "BATCH_SIZE = 16\n", + "IMAGE_SIZE = 256" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ee5dbbd", + "metadata": {}, + "outputs": [], + "source": [ + "# Load dataset\n", + "data = get_media_dataset_grain(\"ucf101\", batch_size=BATCH_SIZE, media_scale=IMAGE_SIZE)\n", + "datalen = data['train_len']\n", + "batches = datalen // BATCH_SIZE" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "02327607", + "metadata": {}, + "outputs": [], + "source": [ + "dataiter = iter(data['train']())\n", + "batch = next(dataiter)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b83da25", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4381abec", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-04-13 14:55:42.973940: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:467] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", + "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", + "E0000 00:00:1744556142.998162 192486 cuda_dnn.cc:8579] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", + "E0000 00:00:1744556143.005274 192486 cuda_blas.cc:1407] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", + "W0000 00:00:1744556143.022849 192486 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1744556143.022872 192486 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1744556143.022874 192486 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "W0000 00:00:1744556143.022876 192486 computation_placer.cc:177] computation placer already registered. Please check linkage and avoid linking the same target more than once.\n", + "Some weights of the model checkpoint at openai/clip-vit-large-patch14 were not used when initializing FlaxCLIPTextModel: {('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'bias'), ('vision_model', 'pre_layrnorm', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'scale'), ('vision_model', 'embeddings', 'patch_embedding', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'bias'), ('logit_scale',), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc1', 'kernel'), ('vision_model', 'post_layernorm', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'embeddings', 'class_embedding'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '18', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '14', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'kernel'), ('vision_model', 'pre_layrnorm', 'scale'), ('visual_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '14', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '9', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'k_proj', 'kernel'), ('text_projection', 'kernel'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '12', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '11', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '12', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '23', 'layer_norm2', 'bias'), ('vision_model', 'embeddings', 'position_embedding', 'embedding'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '23', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '7', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '22', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '17', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '17', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '2', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '7', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '13', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '22', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '20', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '18', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc1', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc1', 'kernel'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '1', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '0', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '5', 'layer_norm2', 'bias'), ('vision_model', 'encoder', 'layers', '16', 'self_attn', 'q_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'post_layernorm', 'scale'), ('vision_model', 'encoder', 'layers', '19', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '3', 'self_attn', 'k_proj', 'bias'), ('vision_model', 'encoder', 'layers', '6', 'self_attn', 'k_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '10', 'layer_norm1', 'scale'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm1', 'bias'), ('vision_model', 'encoder', 'layers', '15', 'self_attn', 'out_proj', 'bias'), ('vision_model', 'encoder', 'layers', '19', 'self_attn', 'v_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '9', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '2', 'self_attn', 'out_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '4', 'mlp', 'fc2', 'bias'), ('vision_model', 'encoder', 'layers', '8', 'layer_norm2', 'scale'), ('vision_model', 'encoder', 'layers', '21', 'self_attn', 'v_proj', 'bias'), ('vision_model', 'encoder', 'layers', '10', 'mlp', 'fc2', 'kernel'), ('vision_model', 'encoder', 'layers', '14', 'self_attn', 'q_proj', 'kernel'), ('vision_model', 'encoder', 'layers', '3', 'mlp', 'fc2', 'kernel')}\n", + "- This IS expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n", + "- This IS NOT expected if you are initializing FlaxCLIPTextModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\n", + "/home/mrwhite0racle/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/torch_xla/__init__.py:251: UserWarning: `tensorflow` can conflict with `torch-xla`. Prefer `tensorflow-cpu` when using PyTorch/XLA. To silence this warning, `pip uninstall -y tensorflow && pip install tensorflow-cpu`. If you are in a notebook environment such as Colab or Kaggle, restart your notebook runtime afterwards.\n", + " warnings.warn(\n", + "WARNING:root:libtpu.so and TPU device found. Setting PJRT_DEVICE=TPU.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scaling factor: 0.18215\n", + "Calculating downscale factor...\n", + "Downscale factor: 8\n", + "Latent channels: 4\n" + ] + } + ], + "source": [ + "# Load dataset\n", + "data = get_dataset_grain(\"oxford_flowers102\", batch_size=BATCH_SIZE, image_scale=IMAGE_SIZE)\n", + "datalen = data['train_len']\n", + "batches = datalen // BATCH_SIZE\n", + "\n", + "text_encoder = defaultTextEncodeModel()\n", + "autoencoder = StableDiffusionVAE(**{\"modelname\": \"pcuenq/sd-vae-ft-mse-flax\"})\n", + "\n", + "# Construct a validation set by the prompts\n", + "val_prompts = ['water tulip', ' a water lily', ' a water lily', ' a photo of a rose', ' a photo of a rose', ' a water lily', ' a water lily', ' a photo of a marigold', ' a photo of a marigold', ' a photo of a marigold', ' a water lily', ' a photo of a sunflower', ' a photo of a lotus', ' columbine', ' columbine', ' an orchid', ' an orchid', ' an orchid', ' a water lily', ' a water lily', ' a water lily', ' columbine', ' columbine', ' a photo of a sunflower', ' a photo of a sunflower', ' a photo of a sunflower', ' a photo of a lotus', ' a photo of a lotus', ' a photo of a marigold', ' a photo of a marigold', ' a photo of a rose', ' a photo of a rose', ' a photo of a rose', ' orange dahlia', ' orange dahlia', ' a lenten rose', ' a lenten rose', ' a water lily', ' a water lily', ' a water lily', ' a water lily', ' an orchid', ' an orchid', ' an orchid', ' hard-leaved pocket orchid', ' bird of paradise', ' bird of paradise', ' a photo of a lovely rose', ' a photo of a lovely rose', ' a photo of a globe-flower', ' a photo of a globe-flower', ' a photo of a lovely rose', ' a photo of a lovely rose', ' a photo of a ruby-lipped cattleya', ' a photo of a ruby-lipped cattleya', ' a photo of a lovely rose', ' a water lily', ' a osteospermum', ' a osteospermum', ' a water lily', ' a water lily', ' a water lily', ' a red rose', ' a red rose']\n", + "\n", + "def get_val_dataset(batch_size=8):\n", + " for i in range(0, len(val_prompts), batch_size):\n", + " prompts = val_prompts[i:i + batch_size]\n", + " tokens = text_encoder.tokenize(prompts)\n", + " yield {\"text\": tokens}\n", + "\n", + "data['test'] = get_val_dataset\n", + "data['test_len'] = len(val_prompts)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e11399d7", + "metadata": {}, + "outputs": [], + "source": [ + "dataiter = iter(data['train']())\n", + "batch = next(dataiter)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "706c7ac0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(16, 256, 256, 3)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch['image'].shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4de21008", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1ac8daf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01ffd1ad", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c374389e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model initialized with 20,027,236 parameters\n" + ] + } + ], + "source": [ + "def create_model(rng):\n", + " num_frames = 8\n", + " model = FlaxUNet3DConditionModel(\n", + " sample_size=(num_frames, 32, 32),\n", + " in_channels=4,\n", + " out_channels=4,\n", + " down_block_types=(\n", + " \"CrossAttnDownBlock3D\",\n", + " \"CrossAttnDownBlock3D\",\n", + " \"CrossAttnDownBlock3D\",\n", + " \"DownBlock3D\",\n", + " ),\n", + " up_block_types=(\n", + " \"UpBlock3D\",\n", + " \"CrossAttnUpBlock3D\",\n", + " \"CrossAttnUpBlock3D\",\n", + " \"CrossAttnUpBlock3D\",\n", + " ),\n", + " block_out_channels=(32, 64, 128, 256),\n", + " layers_per_block=1,\n", + " cross_attention_dim=64,\n", + " attention_head_dim=8,\n", + " dropout=0.0,\n", + " dtype=jnp.bfloat16\n", + " )\n", + " \n", + " # Create dummy inputs for initialization\n", + " batch_size = 1\n", + " sample = jax.random.normal(\n", + " rng, \n", + " shape=(batch_size, num_frames, 32, 32, 4),\n", + " dtype=jnp.bfloat16\n", + " )\n", + " \n", + " timestep = jnp.array([0], dtype=jnp.int32)\n", + " \n", + " # Create dummy text embeddings\n", + " encoder_hidden_states = jax.random.normal(\n", + " rng, \n", + " shape=(batch_size, 77, 64), # 77 is standard for CLIP text tokens\n", + " dtype=jnp.bfloat16\n", + " )\n", + " \n", + " # Initialize the model\n", + " params = model.init(rng, sample, timestep, encoder_hidden_states)\n", + " \n", + " # Print model summary\n", + " param_count = sum(p.size for p in jax.tree_util.tree_leaves(params))\n", + " print(f\"Model initialized with {param_count:,} parameters\")\n", + " \n", + " return model, params\n", + "\n", + "rng = jax.random.PRNGKey(42)\n", + "rng, model_rng = jax.random.split(rng)\n", + "model, params = create_model(model_rng)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d4065755", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2, 8, 32, 32, 4)\n" + ] + } + ], + "source": [ + "sample_video = np.random.rand(2, 8, 32, 32, 4).astype(np.float32)\n", + "sample_video = jnp.array(sample_video)\n", + "timestep = jnp.ones((2,), dtype=jnp.int32) * 0\n", + " \n", + "# Create dummy text embeddings\n", + "encoder_hidden_states = jax.random.normal(\n", + " rng, \n", + " shape=(2, 77, 64), # 77 is standard for CLIP text tokens\n", + " dtype=jnp.bfloat16\n", + ")\n", + "\n", + "out = model.apply(\n", + " params,\n", + " sample_video,\n", + " timestep,\n", + " encoder_hidden_states,\n", + " return_dict=True\n", + ")\n", + "print(out.shape) # Should be (2, 8, 32, 32, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bc70490", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "3c9960cf", + "metadata": {}, + "source": [ + "## 2. Set up the Diffusion Process\n", + "\n", + "Now we'll set up the noise scheduler and sampler for our diffusion process." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a052fe8f", + "metadata": {}, + "outputs": [], + "source": [ + "# Create a noise scheduler\n", + "noise_scheduler = EDMNoiseScheduler(1, sigma_min=0.002, sigma_max=80.0, rho=7.0)\n", + "\n", + "# Create a prediction transform\n", + "model_output_transform = EpsilonPredictionTransform()\n", + "\n", + "# Create a sampler\n", + "sampler = EulerSampler(\n", + " model=model,\n", + " params=params,\n", + " noise_schedule=noise_scheduler,\n", + " model_output_transform=model_output_transform,\n", + " guidance_scale=0\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ca53a402", + "metadata": {}, + "source": [ + "## 3. Generate a Simple Video\n", + "\n", + "Let's generate a simple random video using our model. For a real application, you would use a text encoder like CLIP to encode prompts." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b1420622", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generating 8 frames with 20 diffusion steps...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/20 [00:00 \u001b[39m\u001b[32m29\u001b[39m video = \u001b[43mgenerate_video\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnum_frames\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m8\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msteps\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m20\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[6]\u001b[39m\u001b[32m, line 15\u001b[39m, in \u001b[36mgenerate_video\u001b[39m\u001b[34m(num_frames, height, width, steps)\u001b[39m\n\u001b[32m 13\u001b[39m \u001b[38;5;66;03m# Generate video frames\u001b[39;00m\n\u001b[32m 14\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[33mGenerating \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnum_frames\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m frames with \u001b[39m\u001b[38;5;132;01m{\u001b[39;00msteps\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m diffusion steps...\u001b[39m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m15\u001b[39m video = \u001b[43msampler\u001b[49m\u001b[43m.\u001b[49m\u001b[43mgenerate_images\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 16\u001b[39m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m=\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 17\u001b[39m \u001b[43m \u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m=\u001b[49m\u001b[43mbatch_size\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 18\u001b[39m \u001b[43m \u001b[49m\u001b[43msequence_length\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnum_frames\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 19\u001b[39m \u001b[43m \u001b[49m\u001b[43mdiffusion_steps\u001b[49m\u001b[43m=\u001b[49m\u001b[43msteps\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 20\u001b[39m \u001b[43m \u001b[49m\u001b[43mstart_step\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m1000\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 21\u001b[39m \u001b[43m \u001b[49m\u001b[43mend_step\u001b[49m\u001b[43m=\u001b[49m\u001b[32;43m0\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[32m 22\u001b[39m \u001b[43m \u001b[49m\u001b[43mpriors\u001b[49m\u001b[43m=\u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m,\u001b[49m\n\u001b[32m 23\u001b[39m \u001b[43m \u001b[49m\u001b[43mmodel_conditioning_inputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43m(\u001b[49m\u001b[43mencoder_hidden_states\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 24\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 26\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m video\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/samplers/common.py:335\u001b[39m, in \u001b[36mDiffusionSampler.generate_samples\u001b[39m\u001b[34m(self, params, batch_size, sequence_length, diffusion_steps, start_step, end_step, steps_override, priors, rngstate, model_conditioning_inputs)\u001b[39m\n\u001b[32m 332\u001b[39m next_step = \u001b[38;5;28mself\u001b[39m.scale_steps(steps[i+\u001b[32m1\u001b[39m] \u001b[38;5;28;01mif\u001b[39;00m i+\u001b[32m1\u001b[39m < \u001b[38;5;28mlen\u001b[39m(steps) \u001b[38;5;28;01melse\u001b[39;00m \u001b[32m0\u001b[39m)\n\u001b[32m 334\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m i != \u001b[38;5;28mlen\u001b[39m(steps) - \u001b[32m1\u001b[39m:\n\u001b[32m--> \u001b[39m\u001b[32m335\u001b[39m samples, rngstate = \u001b[43msample_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 336\u001b[39m \u001b[43m \u001b[49m\u001b[43msample_model_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrngstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msamples\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcurrent_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnext_step\u001b[49m\n\u001b[32m 337\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 338\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 339\u001b[39m step_ones = jnp.ones((samples.shape[\u001b[32m0\u001b[39m],), dtype=jnp.int32)\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/samplers/common.py:312\u001b[39m, in \u001b[36mDiffusionSampler.generate_samples..sample_step\u001b[39m\u001b[34m(sample_model_fn, state, samples, current_step, next_step)\u001b[39m\n\u001b[32m 311\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34msample_step\u001b[39m(sample_model_fn, state: RandomMarkovState, samples, current_step, next_step):\n\u001b[32m--> \u001b[39m\u001b[32m312\u001b[39m samples, state = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43msample_step\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 313\u001b[39m \u001b[43m \u001b[49m\u001b[43msample_model_fn\u001b[49m\u001b[43m=\u001b[49m\u001b[43msample_model_fn\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 314\u001b[39m \u001b[43m \u001b[49m\u001b[43mcurrent_samples\u001b[49m\u001b[43m=\u001b[49m\u001b[43msamples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 315\u001b[39m \u001b[43m \u001b[49m\u001b[43mcurrent_step\u001b[49m\u001b[43m=\u001b[49m\u001b[43mcurrent_step\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 316\u001b[39m \u001b[43m \u001b[49m\u001b[43mmodel_conditioning_inputs\u001b[49m\u001b[43m=\u001b[49m\u001b[43mmodel_conditioning_inputs\u001b[49m\u001b[43m,\u001b[49m\n\u001b[32m 317\u001b[39m \u001b[43m \u001b[49m\u001b[43mstate\u001b[49m\u001b[43m=\u001b[49m\u001b[43mstate\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 318\u001b[39m \u001b[43m \u001b[49m\u001b[43mnext_step\u001b[49m\u001b[43m=\u001b[49m\u001b[43mnext_step\u001b[49m\n\u001b[32m 319\u001b[39m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 320\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m samples, state\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/samplers/common.py:141\u001b[39m, in \u001b[36mDiffusionSampler.sample_step\u001b[39m\u001b[34m(self, sample_model_fn, current_samples, current_step, model_conditioning_inputs, next_step, state)\u001b[39m\n\u001b[32m 138\u001b[39m current_step = step_ones * current_step\n\u001b[32m 139\u001b[39m next_step = step_ones * next_step\n\u001b[32m--> \u001b[39m\u001b[32m141\u001b[39m pred_images, pred_noise, _ = \u001b[43msample_model_fn\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 142\u001b[39m \u001b[43m \u001b[49m\u001b[43mcurrent_samples\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcurrent_step\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43mmodel_conditioning_inputs\u001b[49m\n\u001b[32m 143\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 145\u001b[39m new_samples, state = \u001b[38;5;28mself\u001b[39m.take_next_step(\n\u001b[32m 146\u001b[39m current_samples=current_samples,\n\u001b[32m 147\u001b[39m reconstructed_samples=pred_images,\n\u001b[32m (...)\u001b[39m\u001b[32m 153\u001b[39m sample_model_fn=sample_model_fn,\n\u001b[32m 154\u001b[39m )\n\u001b[32m 155\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m new_samples, state\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/samplers/common.py:309\u001b[39m, in \u001b[36mDiffusionSampler.generate_samples..sample_model_fn\u001b[39m\u001b[34m(x_t, t, *additional_inputs)\u001b[39m\n\u001b[32m 308\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34msample_model_fn\u001b[39m(x_t, t, *additional_inputs):\n\u001b[32m--> \u001b[39m\u001b[32m309\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43msample_model\u001b[49m\u001b[43m(\u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mx_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43madditional_inputs\u001b[49m\u001b[43m)\u001b[49m\n", + " \u001b[31m[... skipping hidden 14 frame]\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/samplers/common.py:95\u001b[39m, in \u001b[36mDiffusionSampler.__init__..sample_model\u001b[39m\u001b[34m(params, x_t, t, *additional_inputs)\u001b[39m\n\u001b[32m 93\u001b[39m rates = \u001b[38;5;28mself\u001b[39m.noise_schedule.get_rates(t)\n\u001b[32m 94\u001b[39m c_in = \u001b[38;5;28mself\u001b[39m.model_output_transform.get_input_scale(rates)\n\u001b[32m---> \u001b[39m\u001b[32m95\u001b[39m model_output = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mmodel\u001b[49m\u001b[43m.\u001b[49m\u001b[43mapply\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 96\u001b[39m \u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 97\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mnoise_schedule\u001b[49m\u001b[43m.\u001b[49m\u001b[43mtransform_inputs\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx_t\u001b[49m\u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43m \u001b[49m\u001b[43mc_in\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mt\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\n\u001b[32m 98\u001b[39m \u001b[43m \u001b[49m\u001b[43m*\u001b[49m\u001b[43madditional_inputs\u001b[49m\n\u001b[32m 99\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 100\u001b[39m x_0, eps = \u001b[38;5;28mself\u001b[39m.model_output_transform(x_t, model_output, t, \u001b[38;5;28mself\u001b[39m.noise_schedule)\n\u001b[32m 101\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m x_0, eps, model_output\n", + " \u001b[31m[... skipping hidden 6 frame]\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/persist/FlaxDiff/flaxdiff/models/unet_3d.py:346\u001b[39m, in \u001b[36mFlaxUNet3DConditionModel.__call__\u001b[39m\u001b[34m(self, sample, timesteps, encoder_hidden_states, frame_encoder_hidden_states, added_cond_kwargs, down_block_additional_residuals, mid_block_additional_residual, return_dict, train)\u001b[39m\n\u001b[32m 344\u001b[39m \u001b[38;5;66;03m# 2. Pre-process input - reshape from [B, F, H, W, C] to [B*F, H, W, C] for 2D operations\u001b[39;00m\n\u001b[32m 345\u001b[39m sample = sample.reshape(batch * num_frames, height, width, channels)\n\u001b[32m--> \u001b[39m\u001b[32m346\u001b[39m sample = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mconv_in\u001b[49m\u001b[43m(\u001b[49m\u001b[43msample\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 348\u001b[39m \u001b[38;5;66;03m# Process encoder hidden states - repeat for each frame and combine with frame-specific conditioning if provided\u001b[39;00m\n\u001b[32m 349\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m encoder_hidden_states \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 350\u001b[39m \u001b[38;5;66;03m# Repeat video-wide conditioning for each frame: (B, S, X) -> (B*F, S, X)\u001b[39;00m\n", + " \u001b[31m[... skipping hidden 2 frame]\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/flax/linen/linear.py:662\u001b[39m, in \u001b[36m_Conv.__call__\u001b[39m\u001b[34m(self, inputs)\u001b[39m\n\u001b[32m 656\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.mask \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mself\u001b[39m.mask.shape != kernel_shape:\n\u001b[32m 657\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[32m 658\u001b[39m \u001b[33m'\u001b[39m\u001b[33mMask needs to have the same shape as weights. \u001b[39m\u001b[33m'\u001b[39m\n\u001b[32m 659\u001b[39m \u001b[33mf\u001b[39m\u001b[33m'\u001b[39m\u001b[33mShapes are: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m.mask.shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m, \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkernel_shape\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m'\u001b[39m\n\u001b[32m 660\u001b[39m )\n\u001b[32m--> \u001b[39m\u001b[32m662\u001b[39m kernel = \u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mparam\u001b[49m\u001b[43m(\u001b[49m\n\u001b[32m 663\u001b[39m \u001b[43m \u001b[49m\u001b[33;43m'\u001b[39;49m\u001b[33;43mkernel\u001b[39;49m\u001b[33;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mkernel_init\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkernel_shape\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m.\u001b[49m\u001b[43mparam_dtype\u001b[49m\n\u001b[32m 664\u001b[39m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 666\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m.mask \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m 667\u001b[39m kernel *= \u001b[38;5;28mself\u001b[39m.mask\n", + " \u001b[31m[... skipping hidden 1 frame]\u001b[39m\n", + "\u001b[36mFile \u001b[39m\u001b[32m~/miniconda3/envs/flaxdiff/lib/python3.11/site-packages/flax/core/scope.py:960\u001b[39m, in \u001b[36mScope.param\u001b[39m\u001b[34m(self, name, init_fn, unbox, *init_args, **init_kwargs)\u001b[39m\n\u001b[32m 955\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m val, abs_val \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(value_flat, abs_value_flat):\n\u001b[32m 956\u001b[39m \u001b[38;5;66;03m# NOTE: We could check dtype consistency here as well but it's\u001b[39;00m\n\u001b[32m 957\u001b[39m \u001b[38;5;66;03m# usefuleness is less obvious. We might intentionally change the dtype\u001b[39;00m\n\u001b[32m 958\u001b[39m \u001b[38;5;66;03m# for inference to a half float type for example.\u001b[39;00m\n\u001b[32m 959\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m np.shape(val) != np.shape(abs_val):\n\u001b[32m--> \u001b[39m\u001b[32m960\u001b[39m \u001b[38;5;28;01mraise\u001b[39;00m errors.ScopeParamShapeError(\n\u001b[32m 961\u001b[39m name, \u001b[38;5;28mself\u001b[39m.path_text, np.shape(abs_val), np.shape(val)\n\u001b[32m 962\u001b[39m )\n\u001b[32m 963\u001b[39m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[32m 964\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28mself\u001b[39m.is_mutable_collection(\u001b[33m'\u001b[39m\u001b[33mparams\u001b[39m\u001b[33m'\u001b[39m):\n", + "\u001b[31mScopeParamShapeError\u001b[39m: Initializer expected to generate shape (3, 3, 3, 4, 32) but got shape (3, 3, 3, 3, 32) instead for parameter \"kernel\" in \"/conv_in\". (https://flax.readthedocs.io/en/latest/api_reference/flax.errors.html#flax.errors.ScopeParamShapeError)" + ] + } + ], + "source": [ + "def generate_video(num_frames=8, height=32, width=32, steps=20):\n", + " # Create mock text embeddings (in a real scenario, you'd use a text encoder like CLIP)\n", + " batch_size = 1\n", + " rng_gen = jax.random.PRNGKey(123) # Using a different seed\n", + " \n", + " # Generate random text embeddings\n", + " encoder_hidden_states = jax.random.normal(\n", + " rng_gen, \n", + " shape=(batch_size, 77, 64),\n", + " dtype=jnp.float32\n", + " )\n", + " \n", + " # Generate video frames\n", + " print(f\"Generating {num_frames} frames with {steps} diffusion steps...\")\n", + " video = sampler.generate_images(\n", + " params=params,\n", + " batch_size=batch_size,\n", + " sequence_length=num_frames,\n", + " diffusion_steps=steps,\n", + " start_step=1000,\n", + " end_step=0,\n", + " priors=None,\n", + " model_conditioning_inputs=(encoder_hidden_states,),\n", + " )\n", + " \n", + " return video\n", + "\n", + "# Generate video\n", + "video = generate_video(num_frames=8, steps=20)" + ] + }, + { + "cell_type": "markdown", + "id": "09bf7f9d", + "metadata": {}, + "source": [ + "## 4. Visualize the Generated Video" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd541d38", + "metadata": {}, + "outputs": [], + "source": [ + "def visualize_video(video):\n", + " # Normalize to [0, 1] range for visualization\n", + " video_clip = np.array(video[0])\n", + " video_clip = (video_clip + 1.0) / 2.0 # Assuming [-1, 1] range\n", + " video_clip = np.clip(video_clip, 0.0, 1.0)\n", + " \n", + " # Only use RGB channels (first 3) for visualization\n", + " video_clip = video_clip[:, :, :, :3]\n", + " \n", + " # Create a figure for animation\n", + " fig, ax = plt.subplots(figsize=(5, 5))\n", + " ax.axis('off')\n", + " \n", + " # Create initial frame\n", + " img = ax.imshow(video_clip[0])\n", + " \n", + " # Animation function\n", + " def animate(i):\n", + " img.set_array(video_clip[i])\n", + " return [img]\n", + " \n", + " # Create animation\n", + " anim = animation.FuncAnimation(\n", + " fig, animate, frames=len(video_clip), interval=200, blit=True\n", + " )\n", + " \n", + " # Display the animation\n", + " from IPython.display import HTML\n", + " HTML(anim.to_jshtml())\n", + " \n", + " # Also display individual frames for reference\n", + " fig, axes = plt.subplots(1, len(video_clip), figsize=(15, 3))\n", + " for i, ax in enumerate(axes):\n", + " ax.imshow(video_clip[i])\n", + " ax.set_title(f\"Frame {i}\")\n", + " ax.axis('off')\n", + " plt.tight_layout()\n", + " \n", + " return anim\n", + "\n", + "# Visualize the generated video\n", + "anim = visualize_video(video)" + ] + }, + { + "cell_type": "markdown", + "id": "b083082f", + "metadata": {}, + "source": [ + "## 5. Save the Generated Video" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfeebe17", + "metadata": {}, + "outputs": [], + "source": [ + "def save_video(video, filename='generated_video.mp4'):\n", + " video_clip = np.array(video[0])\n", + " video_clip = (video_clip + 1.0) / 2.0 # Assuming [-1, 1] range\n", + " video_clip = np.clip(video_clip, 0.0, 1.0)\n", + " \n", + " # Only use RGB channels (first 3) for saving\n", + " video_clip = video_clip[:, :, :, :3]\n", + " \n", + " # Create a figure for animation\n", + " fig, ax = plt.subplots(figsize=(5, 5))\n", + " ax.axis('off')\n", + " \n", + " # Create initial frame\n", + " img = ax.imshow(video_clip[0])\n", + " \n", + " # Animation function\n", + " def animate(i):\n", + " img.set_array(video_clip[i])\n", + " return [img]\n", + " \n", + " # Create animation\n", + " anim = animation.FuncAnimation(\n", + " fig, animate, frames=len(video_clip), interval=200, blit=True\n", + " )\n", + " \n", + " # Save the animation\n", + " anim.save(filename, writer='ffmpeg', fps=5, dpi=100)\n", + " print(f\"Video saved to {filename}\")\n", + " \n", + " # Also save individual frames\n", + " for i, frame in enumerate(video_clip):\n", + " plt.imsave(f\"frame_{i}.png\", frame)\n", + " \n", + "# Comment out if you don't have ffmpeg installed\n", + "# save_video(video)" + ] + }, + { + "cell_type": "markdown", + "id": "61e05bb7", + "metadata": {}, + "source": [ + "## 6. Experiment with Different Parameters\n", + "\n", + "Let's experiment with different guidance scales to see how they affect the generated video." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2ac61cfc", + "metadata": {}, + "outputs": [], + "source": [ + "def experiment_with_guidance_scale(guidance_scales=[1.0, 3.0, 5.0, 7.0], num_frames=8, steps=20):\n", + " results = {}\n", + " \n", + " for gs in guidance_scales:\n", + " print(f\"Generating video with guidance scale {gs}...\")\n", + " \n", + " # Create a sampler with the current guidance scale\n", + " temp_sampler = EulerSampler(\n", + " model=model,\n", + " params=params,\n", + " noise_schedule=noise_scheduler,\n", + " model_output_transform=model_output_transform,\n", + " guidance_scale=gs,\n", + " )\n", + " \n", + " # Create mock text embeddings\n", + " batch_size = 1\n", + " rng_gen = jax.random.PRNGKey(123) # Using a consistent seed for comparison\n", + " \n", + " encoder_hidden_states = jax.random.normal(\n", + " rng_gen, \n", + " shape=(batch_size, 77, 64),\n", + " dtype=jnp.float32\n", + " )\n", + " \n", + " # Generate video\n", + " video = temp_sampler.generate_images(\n", + " params=params,\n", + " num_images=batch_size,\n", + " diffusion_steps=steps,\n", + " start_step=1000,\n", + " end_step=0,\n", + " priors=None,\n", + " image_shape=(num_frames, 32, 32, 4),\n", + " model_conditioning_inputs=(encoder_hidden_states,),\n", + " )\n", + " \n", + " results[gs] = video\n", + " \n", + " return results\n", + "\n", + "# Uncomment to run the experiment\n", + "# guidance_results = experiment_with_guidance_scale()" + ] + }, + { + "cell_type": "markdown", + "id": "5d2fdb01", + "metadata": {}, + "source": [ + "## 7. Processing Existing Video\n", + "\n", + "In a real-world scenario, you might want to process existing video frames. Here's how you could do that with the UNet3D model." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f2672c2", + "metadata": {}, + "outputs": [], + "source": [ + "def process_existing_video(video_frames, noise_level=0.2):\n", + " \"\"\"\n", + " Process existing video frames with the UNet3D model.\n", + " This is a simple example that adds noise and then denoises.\n", + " \n", + " Args:\n", + " video_frames: numpy array of shape (num_frames, height, width, channels)\n", + " noise_level: Amount of noise to add (0-1)\n", + " \"\"\"\n", + " # Convert to JAX array and ensure correct shape\n", + " video_frames = jnp.array(video_frames)\n", + " batch_size = 1\n", + " num_frames, height, width, channels = video_frames.shape\n", + " \n", + " # Scale to [-1, 1] if needed\n", + " if video_frames.max() > 1.0:\n", + " video_frames = video_frames / 255.0\n", + " if video_frames.max() <= 1.0 and video_frames.min() >= 0.0:\n", + " video_frames = video_frames * 2.0 - 1.0\n", + " \n", + " # Add a batch dimension\n", + " video_frames = video_frames.reshape(batch_size, num_frames, height, width, channels)\n", + " \n", + " # If channels < 4, pad with zeros\n", + " if channels < 4:\n", + " padding = jnp.zeros((batch_size, num_frames, height, width, 4 - channels))\n", + " video_frames = jnp.concatenate([video_frames, padding], axis=-1)\n", + " \n", + " # Add noise\n", + " rng_noise = jax.random.PRNGKey(456)\n", + " noise = jax.random.normal(rng_noise, video_frames.shape)\n", + " noisy_frames = video_frames + noise_level * noise\n", + " \n", + " # Create mock text embeddings \n", + " rng_text = jax.random.PRNGKey(789)\n", + " encoder_hidden_states = jax.random.normal(\n", + " rng_text, \n", + " shape=(batch_size, 77, 64),\n", + " dtype=jnp.float32\n", + " )\n", + " \n", + " # Process the video\n", + " print(\"Processing video...\")\n", + " \n", + " # For a simple demonstration, we'll just do a single denoising step\n", + " timestep = jnp.array([500], dtype=jnp.int32) # Middle of the diffusion process\n", + " output = model.apply(params, noisy_frames, timestep, encoder_hidden_states)\n", + " \n", + " # Extract the first 3 channels for visualization\n", + " processed_frames = output['sample'][0, :, :, :, :3]\n", + " original_frames = video_frames[0, :, :, :, :3]\n", + " noisy_frames = noisy_frames[0, :, :, :, :3]\n", + " \n", + " # Normalize to [0, 1] for visualization\n", + " processed_frames = (processed_frames + 1.0) / 2.0\n", + " original_frames = (original_frames + 1.0) / 2.0\n", + " noisy_frames = (noisy_frames + 1.0) / 2.0\n", + " \n", + " processed_frames = jnp.clip(processed_frames, 0.0, 1.0)\n", + " original_frames = jnp.clip(original_frames, 0.0, 1.0)\n", + " noisy_frames = jnp.clip(noisy_frames, 0.0, 1.0)\n", + " \n", + " return {\n", + " 'original': original_frames,\n", + " 'noisy': noisy_frames,\n", + " 'processed': processed_frames\n", + " }\n", + "\n", + "# Create some synthetic video frames for demonstration\n", + "def create_synthetic_video(num_frames=8, height=32, width=32):\n", + " \"\"\"Create a simple synthetic video with moving shapes\"\"\"\n", + " frames = np.zeros((num_frames, height, width, 3))\n", + " \n", + " # Add a moving circle\n", + " for i in range(num_frames):\n", + " # Create frame with a circle\n", + " frame = np.zeros((height, width, 3))\n", + " x_center = width // 2 + int(width * 0.3 * np.sin(i / num_frames * 2 * np.pi))\n", + " y_center = height // 2 + int(height * 0.3 * np.cos(i / num_frames * 2 * np.pi))\n", + " \n", + " # Draw circle\n", + " for y in range(height):\n", + " for x in range(width):\n", + " dist = np.sqrt((x - x_center)**2 + (y - y_center)**2)\n", + " if dist < 5:\n", + " frame[y, x, 0] = 1.0 # Red circle\n", + " \n", + " # Add a static square\n", + " frame[5:15, 5:15, 1] = 1.0 # Green square\n", + " \n", + " frames[i] = frame\n", + " \n", + " return frames\n", + "\n", + "# Generate synthetic video and process it\n", + "synthetic_video = create_synthetic_video()\n", + "# Uncomment to process the video\n", + "# processed_results = process_existing_video(synthetic_video, noise_level=0.3)" + ] + }, + { + "cell_type": "markdown", + "id": "ea49f699", + "metadata": {}, + "source": [ + "## 8. Using Frame-Specific Conditioning\n", + "\n", + "The UNet3D model now supports both video-wide conditioning and optional frame-specific conditioning. Let's see how to use this feature." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d0e8d436", + "metadata": {}, + "outputs": [], + "source": [ + "def generate_with_frame_conditioning(num_frames=8, height=32, width=32, steps=20):\n", + " # Create batch\n", + " batch_size = 1\n", + " rng_gen = jax.random.PRNGKey(123)\n", + " rng_gen, key1, key2 = jax.random.split(rng_gen, 3)\n", + " \n", + " # Generate random global text embeddings\n", + " encoder_hidden_states = jax.random.normal(\n", + " key1, \n", + " shape=(batch_size, 77, 64),\n", + " dtype=jnp.float32\n", + " )\n", + " \n", + " # Generate random frame-specific embeddings\n", + " frame_encoder_hidden_states = jax.random.normal(\n", + " key2, \n", + " shape=(batch_size, num_frames, 77, 64),\n", + " dtype=jnp.float32\n", + " )\n", + " \n", + " # Generate video frames - demonstrate with and without frame conditioning\n", + " print(f\"Generating {num_frames} frames with global conditioning only...\")\n", + " video_global = sampler.generate_images(\n", + " params=params,\n", + " num_images=batch_size,\n", + " diffusion_steps=steps,\n", + " start_step=1000,\n", + " end_step=0,\n", + " priors=None,\n", + " image_shape=(num_frames, height, width, 4),\n", + " model_conditioning_inputs=(encoder_hidden_states,),\n", + " )\n", + " \n", + " print(f\"Generating {num_frames} frames with global + frame-specific conditioning...\")\n", + " video_combined = sampler.generate_images(\n", + " params=params,\n", + " num_images=batch_size,\n", + " diffusion_steps=steps,\n", + " start_step=1000,\n", + " end_step=0,\n", + " priors=None,\n", + " image_shape=(num_frames, height, width, 4),\n", + " model_conditioning_inputs=(encoder_hidden_states, frame_encoder_hidden_states),\n", + " )\n", + " \n", + " return video_global, video_combined\n", + "\n", + "# Uncomment to run the experiment\n", + "# video_global, video_combined = generate_with_frame_conditioning()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cc6359d2", + "metadata": {}, + "outputs": [], + "source": [ + "def compare_videos(video1, video2, title1=\"Global Conditioning\", title2=\"Global + Frame Conditioning\"):\n", + " # Normalize both videos\n", + " def normalize_video(video):\n", + " video_clip = np.array(video[0])\n", + " video_clip = (video_clip + 1.0) / 2.0\n", + " video_clip = np.clip(video_clip, 0.0, 1.0)\n", + " video_clip = video_clip[:, :, :, :3] # RGB only\n", + " return video_clip\n", + " \n", + " video1_norm = normalize_video(video1)\n", + " video2_norm = normalize_video(video2)\n", + " \n", + " # Display side by side frames\n", + " num_frames = video1_norm.shape[0]\n", + " fig, axes = plt.subplots(2, num_frames, figsize=(num_frames*2, 4))\n", + " \n", + " # Display first video on top row\n", + " for i in range(num_frames):\n", + " axes[0, i].imshow(video1_norm[i])\n", + " axes[0, i].set_title(f\"Frame {i}\")\n", + " axes[0, i].axis('off')\n", + " axes[0, 0].set_ylabel(title1)\n", + " \n", + " # Display second video on bottom row\n", + " for i in range(num_frames):\n", + " axes[1, i].imshow(video2_norm[i])\n", + " axes[1, i].set_title(f\"Frame {i}\")\n", + " axes[1, i].axis('off')\n", + " axes[1, 0].set_ylabel(title2)\n", + " \n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "# Uncomment to compare the videos\n", + "# if 'video_global' in locals() and 'video_combined' in locals():\n", + "# compare_videos(video_global, video_combined)" + ] + }, + { + "cell_type": "markdown", + "id": "e7057ecb", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "In this notebook, we've demonstrated:\n", + "1. How to initialize and use the FlaxUNet3DConditionModel\n", + "2. How to generate new videos from random noise\n", + "3. How to modify existing videos using the model\n", + "4. How to use frame-specific conditioning for more detailed control\n", + "\n", + "The FlaxUNet3DConditionModel provides a powerful tool for video diffusion tasks, offering the performance benefits of JAX and Flax while maintaining compatibility with diffusers-style APIs." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaxdiff", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}