| |
| """ |
| Miscellaneous utility functions for V3Cell. |
| |
| Contents: |
| - load_config: Load a YAML configuration file. |
| - set_seed: Set random seeds for reproducibility. |
| - save_video_as_gif: Render a video tensor to an animated GIF. |
| - save_video_as_mp4: Render a video tensor to MP4 (requires imageio). |
| - count_parameters: Count trainable parameters in a PyTorch model. |
| - format_time: Human-readable elapsed time string. |
| - EMAModel: Exponential moving average of model weights. |
| """ |
|
|
| import os |
| import random |
| from pathlib import Path |
| from typing import Union, Optional |
|
|
| import yaml |
| import numpy as np |
| import torch |
| from PIL import Image |
|
|
|
|
| def load_config(config_path: Union[str, Path]) -> dict: |
| """ |
| Load a YAML configuration file into a Python dictionary. |
| |
| Args: |
| config_path: Path to the .yaml configuration file. |
| |
| Returns: |
| config: Nested dictionary of configuration values. |
| """ |
| with open(config_path) as f: |
| return yaml.safe_load(f) |
|
|
|
|
| def set_seed(seed: int): |
| """ |
| Set random seeds for Python, NumPy and PyTorch to ensure reproducibility. |
| |
| Also disables cuDNN's non-deterministic algorithms (slightly slower but |
| fully reproducible results). |
| |
| Args: |
| seed: Integer seed value. |
| """ |
| random.seed(seed) |
| np.random.seed(seed) |
| torch.manual_seed(seed) |
| if torch.cuda.is_available(): |
| torch.cuda.manual_seed(seed) |
| torch.cuda.manual_seed_all(seed) |
| torch.backends.cudnn.deterministic = True |
| torch.backends.cudnn.benchmark = False |
|
|
|
|
| def save_video_as_gif( |
| video: torch.Tensor, |
| path: Union[str, Path], |
| fps: int = 10, |
| loop: int = 0, |
| ): |
| """ |
| Save a video tensor as an animated GIF. |
| |
| Handles both [T, C, H, W] and [T, H, W, C] layouts and both [-1, 1] |
| and [0, 1] value ranges. |
| |
| Args: |
| video: Video frames — tensor or numpy array. |
| path: Output file path (should end in .gif). |
| fps: Frames per second of the output GIF. |
| loop: Number of times the GIF loops (0 = infinite). |
| """ |
| if isinstance(video, torch.Tensor): |
| video = video.detach().cpu().numpy() |
|
|
| |
| if video.ndim == 4 and video.shape[1] in [1, 3]: |
| video = np.transpose(video, (0, 2, 3, 1)) |
|
|
| |
| if video.min() < 0: |
| video = (video + 1) / 2 |
| video = (video * 255).clip(0, 255).astype(np.uint8) |
|
|
| |
| if video.shape[-1] == 1: |
| video = np.repeat(video, 3, axis=-1) |
|
|
| frames = [Image.fromarray(frame) for frame in video] |
| frames[0].save( |
| path, |
| save_all=True, |
| append_images=frames[1:], |
| duration=1000 // fps, |
| loop=loop, |
| ) |
|
|
|
|
| def save_video_as_mp4( |
| video: torch.Tensor, |
| path: Union[str, Path], |
| fps: int = 10, |
| ): |
| """ |
| Save a video tensor as an MP4 file (requires imageio with ffmpeg). |
| |
| Falls back to GIF if imageio is not available. |
| |
| Args: |
| video: [T, C, H, W] video tensor. |
| path: Output file path (should end in .mp4). |
| fps: Frames per second. |
| """ |
| try: |
| import imageio |
| except ImportError: |
| print("imageio not installed — saving as GIF instead.") |
| save_video_as_gif(video, str(path).replace('.mp4', '.gif'), fps) |
| return |
|
|
| if isinstance(video, torch.Tensor): |
| video = video.detach().cpu().numpy() |
|
|
| if video.ndim == 4 and video.shape[1] in [1, 3]: |
| video = np.transpose(video, (0, 2, 3, 1)) |
|
|
| if video.min() < 0: |
| video = (video + 1) / 2 |
| video = (video * 255).clip(0, 255).astype(np.uint8) |
|
|
| imageio.mimwrite(path, video, fps=fps) |
|
|
|
|
| def count_parameters(model: torch.nn.Module) -> int: |
| """ |
| Count the number of trainable parameters in a PyTorch model. |
| |
| Args: |
| model: Any torch.nn.Module. |
| |
| Returns: |
| Total number of parameters with requires_grad=True. |
| """ |
| return sum(p.numel() for p in model.parameters() if p.requires_grad) |
|
|
|
|
| def format_time(seconds: float) -> str: |
| """ |
| Format an elapsed time in seconds as a human-readable string. |
| |
| Examples: |
| 42.5 → '42.5s' |
| 125 → '2m 5s' |
| 3700 → '1h 1m' |
| |
| Args: |
| seconds: Elapsed time in seconds. |
| |
| Returns: |
| Formatted time string. |
| """ |
| if seconds < 60: |
| return f"{seconds:.1f}s" |
| elif seconds < 3600: |
| return f"{int(seconds // 60)}m {int(seconds % 60)}s" |
| else: |
| return f"{int(seconds // 3600)}h {int((seconds % 3600) // 60)}m" |
|
|
|
|
| class EMAModel: |
| """ |
| Exponential Moving Average (EMA) of model weights. |
| |
| Maintains a shadow copy of model parameters updated as: |
| shadow = decay * shadow + (1 - decay) * param |
| |
| Using EMA weights at inference time typically produces smoother, higher- |
| quality generated outputs compared to the raw training weights. |
| |
| Usage: |
| ema = EMAModel(generator, decay=0.999) |
| for step in training_loop: |
| update weights ... |
| ema.update(generator) |
| ema.apply(generator) # swap in EMA weights for evaluation |
| """ |
|
|
| def __init__( |
| self, |
| model: torch.nn.Module, |
| decay: float = 0.999, |
| device: Optional[torch.device] = None, |
| ): |
| self.decay = decay |
| self.device = device |
|
|
| self.shadow = {} |
| for name, param in model.named_parameters(): |
| if param.requires_grad: |
| self.shadow[name] = param.data.clone() |
| if device is not None: |
| self.shadow[name] = self.shadow[name].to(device) |
|
|
| def update(self, model: torch.nn.Module): |
| """Update shadow weights from the current model parameters.""" |
| with torch.no_grad(): |
| for name, param in model.named_parameters(): |
| if param.requires_grad and name in self.shadow: |
| self.shadow[name].mul_(self.decay).add_(param.data, alpha=1 - self.decay) |
|
|
| def apply(self, model: torch.nn.Module): |
| """Replace model parameters with the EMA shadow weights.""" |
| for name, param in model.named_parameters(): |
| if param.requires_grad and name in self.shadow: |
| param.data.copy_(self.shadow[name]) |
|
|
