Datasets:

introvoyz045
/

V3Cell

License:

Migrated from GitHub

a44124f verified 11 days ago

7.65 kB

#!/usr/bin/env python3
"""
V3Cell video generation (inference) script.
Loads a trained V3CellGenerator checkpoint and generates organoid development
videos unconditionally (noise → MotionRNN → R3GAN → frames).
Usage:
    python scripts/generate.py \\
        --checkpoint checkpoints/outputs/v3cell/checkpoint_002000.pt \\
        --r3gan_ckpt checkpoints/training-runs/00002-frames-256-gpus3-batch96/network-snapshot-000000580.pkl \\
        --n_videos 10 \\
        --n_frames 16 \\
        --output_dir outputs/generated
"""

import argparse
import sys
from pathlib import Path

project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

import torch
from tqdm import tqdm

from models import V3CellGenerator
from utils import load_config, set_seed, save_video_as_gif


def parse_args():
    parser = argparse.ArgumentParser(description='Generate videos with V3Cell')

    # Required arguments
    parser.add_argument('--checkpoint', type=str, required=True,
                        help='Path to V3Cell checkpoint (.pt)')
    parser.add_argument('--r3gan_ckpt', type=str, required=True,
                        help='Path to R3GAN checkpoint (.pkl)')

    # Optional paths
    parser.add_argument('--config', type=str, default='configs/default.yaml',
                        help='Path to YAML config file')
    parser.add_argument('--output_dir', type=str, default='outputs/generated',
                        help='Output directory for generated videos')
    parser.add_argument('--r3gan_path', type=str, default=None,
                        help='Path to external R3GAN source (usually not needed)')

    # Generation parameters
    parser.add_argument('--n_videos', type=int, default=10,
                        help='Total number of videos to generate')
    parser.add_argument('--n_frames', type=int, default=16,
                        help='Number of frames per video')
    parser.add_argument('--class_idx', type=int, default=None,
                        help='Class index to generate (None = generate all classes)')
    parser.add_argument('--batch_size', type=int, default=4,
                        help='Batch size for generation')

    # Output format
    parser.add_argument('--format', type=str, default='gif',
                        choices=['gif', 'mp4', 'png'],
                        help='Output format: gif, mp4, or png (frame sequence)')
    parser.add_argument('--fps', type=int, default=10,
                        help='Frames per second for video output')

    parser.add_argument('--seed', type=int, default=42)
    parser.add_argument('--gpu', type=int, default=0)

    # Architecture flags — must match the settings used to train --checkpoint
    # (see scripts/train_conditional.py, which defaults to content-motion
    # separation with content_dim=32; inference.py hardcodes the same values).
    parser.add_argument('--use_content_motion', action='store_true', default=True,
                        help='Build the generator with MoCoGAN-style content/motion latent separation')
    parser.add_argument('--no_content_motion', action='store_true',
                        help='Disable content-motion separation (use a single shared z_dim)')
    parser.add_argument('--content_dim', type=int, default=32,
                        help='Content latent dimension (only used if content-motion separation is enabled)')

    return parser.parse_args()


def main():
    args = parse_args()

    device = torch.device(f'cuda:{args.gpu}' if torch.cuda.is_available() else 'cpu')
    print(f"Using device: {device}")

    set_seed(args.seed)

    # Load configuration.
    config_path = project_root / args.config
    if config_path.exists():
        config = load_config(config_path)
    else:
        print(f"Config not found at {config_path} — using built-in defaults.")
        config = {
            'model': {
                'z_dim': 64,
                'c_dim': 3,
                'img_resolution': 256,
                'motion_rnn': {
                    'hidden_dim': 384,
                    'num_layers': 2,
                    'dropout': 0.1,
                    'residual_weight': 0.2,
                },
            },
        }

    model_cfg = config['model']

    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    # Build and load model.
    use_content_motion = args.use_content_motion and not args.no_content_motion
    print("Loading V3Cell model...")
    print(f"  Content-motion separation: {use_content_motion} (content_dim={args.content_dim})")
    generator = V3CellGenerator(
        r3gan_checkpoint=args.r3gan_ckpt,
        z_dim=model_cfg['z_dim'],
        c_dim=model_cfg['c_dim'],
        motion_hidden_dim=model_cfg['motion_rnn']['hidden_dim'],
        motion_num_layers=model_cfg['motion_rnn']['num_layers'],
        motion_dropout=model_cfg['motion_rnn']['dropout'],
        residual_weight=model_cfg['motion_rnn']['residual_weight'],
        use_content_motion=use_content_motion,
        content_dim=args.content_dim,
        freeze_r3gan=True,
        r3gan_path=args.r3gan_path,
    )

    checkpoint = torch.load(args.checkpoint, map_location='cpu')
    generator.load_trainable_state_dict(checkpoint['generator'])
    generator = generator.to(device).eval()

    print(f"Loaded checkpoint: {args.checkpoint}")

    # Determine which classes to generate.
    class_indices = [args.class_idx] if args.class_idx is not None \
        else list(range(model_cfg['c_dim']))

    print(f"\nGenerating {args.n_videos} videos × {args.n_frames} frames "
          f"for classes {class_indices} ...")

    video_idx = 0
    with torch.no_grad():
        for class_idx in class_indices:
            # Distribute n_videos evenly across classes.
            n_class_videos = args.n_videos // len(class_indices)
            if class_idx < args.n_videos % len(class_indices):
                n_class_videos += 1

            print(f"\nClass {class_idx}: generating {n_class_videos} videos")

            for batch_start in tqdm(range(0, n_class_videos, args.batch_size)):
                batch_size = min(args.batch_size, n_class_videos - batch_start)

                z = generator.sample_z(batch_size, device)
                c = generator.sample_c(batch_size, device, class_idx=class_idx)

                # Generate and rescale from [-1, 1] to [0, 1].
                videos = generator(z, c, args.n_frames)
                videos = ((videos + 1) / 2).clamp(0, 1)

                for i, video in enumerate(videos):
                    if args.format == 'gif':
                        save_path = output_dir / f"video_{video_idx:04d}_class{class_idx}.gif"
                        save_video_as_gif(video, save_path, fps=args.fps)

                    elif args.format == 'mp4':
                        from utils.misc import save_video_as_mp4
                        save_path = output_dir / f"video_{video_idx:04d}_class{class_idx}.mp4"
                        save_video_as_mp4(video, save_path, fps=args.fps)

                    elif args.format == 'png':
                        # Save each frame as a separate PNG.
                        vid_dir = output_dir / f"video_{video_idx:04d}_class{class_idx}"
                        vid_dir.mkdir(exist_ok=True)
                        for t, frame in enumerate(video):
                            from torchvision.utils import save_image
                            save_image(frame, vid_dir / f"frame_{t:04d}.png")

                    video_idx += 1

    print(f"\nGenerated {video_idx} videos → {output_dir}")


if __name__ == '__main__':
    main()

	#!/usr/bin/env python3
	"""
	V3Cell video generation (inference) script.

	Loads a trained V3CellGenerator checkpoint and generates organoid development
	videos unconditionally (noise → MotionRNN → R3GAN → frames).

	Usage:
	python scripts/generate.py \\
	--checkpoint checkpoints/outputs/v3cell/checkpoint_002000.pt \\
	--r3gan_ckpt checkpoints/training-runs/00002-frames-256-gpus3-batch96/network-snapshot-000000580.pkl \\
	--n_videos 10 \\
	--n_frames 16 \\
	--output_dir outputs/generated
	"""

	import argparse
	import sys
	from pathlib import Path

	project_root = Path(__file__).parent.parent
	sys.path.insert(0, str(project_root))

	import torch
	from tqdm import tqdm

	from models import V3CellGenerator
	from utils import load_config, set_seed, save_video_as_gif


	def parse_args():
	parser = argparse.ArgumentParser(description='Generate videos with V3Cell')

	# Required arguments
	parser.add_argument('--checkpoint', type=str, required=True,
	help='Path to V3Cell checkpoint (.pt)')
	parser.add_argument('--r3gan_ckpt', type=str, required=True,
	help='Path to R3GAN checkpoint (.pkl)')

	# Optional paths
	parser.add_argument('--config', type=str, default='configs/default.yaml',
	help='Path to YAML config file')
	parser.add_argument('--output_dir', type=str, default='outputs/generated',
	help='Output directory for generated videos')
	parser.add_argument('--r3gan_path', type=str, default=None,
	help='Path to external R3GAN source (usually not needed)')

	# Generation parameters
	parser.add_argument('--n_videos', type=int, default=10,
	help='Total number of videos to generate')
	parser.add_argument('--n_frames', type=int, default=16,
	help='Number of frames per video')
	parser.add_argument('--class_idx', type=int, default=None,
	help='Class index to generate (None = generate all classes)')
	parser.add_argument('--batch_size', type=int, default=4,
	help='Batch size for generation')

	# Output format
	parser.add_argument('--format', type=str, default='gif',
	choices=['gif', 'mp4', 'png'],
	help='Output format: gif, mp4, or png (frame sequence)')
	parser.add_argument('--fps', type=int, default=10,
	help='Frames per second for video output')

	parser.add_argument('--seed', type=int, default=42)
	parser.add_argument('--gpu', type=int, default=0)

	# Architecture flags — must match the settings used to train --checkpoint
	# (see scripts/train_conditional.py, which defaults to content-motion
	# separation with content_dim=32; inference.py hardcodes the same values).
	parser.add_argument('--use_content_motion', action='store_true', default=True,
	help='Build the generator with MoCoGAN-style content/motion latent separation')
	parser.add_argument('--no_content_motion', action='store_true',
	help='Disable content-motion separation (use a single shared z_dim)')
	parser.add_argument('--content_dim', type=int, default=32,
	help='Content latent dimension (only used if content-motion separation is enabled)')

	return parser.parse_args()


	def main():
	args = parse_args()

	device = torch.device(f'cuda:{args.gpu}' if torch.cuda.is_available() else 'cpu')
	print(f"Using device: {device}")

	set_seed(args.seed)

	# Load configuration.
	config_path = project_root / args.config
	if config_path.exists():
	config = load_config(config_path)
	else:
	print(f"Config not found at {config_path} — using built-in defaults.")
	config = {
	'model': {
	'z_dim': 64,
	'c_dim': 3,
	'img_resolution': 256,
	'motion_rnn': {
	'hidden_dim': 384,
	'num_layers': 2,
	'dropout': 0.1,
	'residual_weight': 0.2,
	},
	},
	}

	model_cfg = config['model']

	output_dir = Path(args.output_dir)
	output_dir.mkdir(parents=True, exist_ok=True)

	# Build and load model.
	use_content_motion = args.use_content_motion and not args.no_content_motion
	print("Loading V3Cell model...")
	print(f" Content-motion separation: {use_content_motion} (content_dim={args.content_dim})")
	generator = V3CellGenerator(
	r3gan_checkpoint=args.r3gan_ckpt,
	z_dim=model_cfg['z_dim'],
	c_dim=model_cfg['c_dim'],
	motion_hidden_dim=model_cfg['motion_rnn']['hidden_dim'],
	motion_num_layers=model_cfg['motion_rnn']['num_layers'],
	motion_dropout=model_cfg['motion_rnn']['dropout'],
	residual_weight=model_cfg['motion_rnn']['residual_weight'],
	use_content_motion=use_content_motion,
	content_dim=args.content_dim,
	freeze_r3gan=True,
	r3gan_path=args.r3gan_path,
	)

	checkpoint = torch.load(args.checkpoint, map_location='cpu')
	generator.load_trainable_state_dict(checkpoint['generator'])
	generator = generator.to(device).eval()

	print(f"Loaded checkpoint: {args.checkpoint}")

	# Determine which classes to generate.
	class_indices = [args.class_idx] if args.class_idx is not None \
	else list(range(model_cfg['c_dim']))

	print(f"\nGenerating {args.n_videos} videos × {args.n_frames} frames "
	f"for classes {class_indices} ...")

	video_idx = 0
	with torch.no_grad():
	for class_idx in class_indices:
	# Distribute n_videos evenly across classes.
	n_class_videos = args.n_videos // len(class_indices)
	if class_idx < args.n_videos % len(class_indices):
	n_class_videos += 1

	print(f"\nClass {class_idx}: generating {n_class_videos} videos")

	for batch_start in tqdm(range(0, n_class_videos, args.batch_size)):
	batch_size = min(args.batch_size, n_class_videos - batch_start)

	z = generator.sample_z(batch_size, device)
	c = generator.sample_c(batch_size, device, class_idx=class_idx)

	# Generate and rescale from [-1, 1] to [0, 1].
	videos = generator(z, c, args.n_frames)
	videos = ((videos + 1) / 2).clamp(0, 1)

	for i, video in enumerate(videos):
	if args.format == 'gif':
	save_path = output_dir / f"video_{video_idx:04d}_class{class_idx}.gif"
	save_video_as_gif(video, save_path, fps=args.fps)

	elif args.format == 'mp4':
	from utils.misc import save_video_as_mp4
	save_path = output_dir / f"video_{video_idx:04d}_class{class_idx}.mp4"
	save_video_as_mp4(video, save_path, fps=args.fps)

	elif args.format == 'png':
	# Save each frame as a separate PNG.
	vid_dir = output_dir / f"video_{video_idx:04d}_class{class_idx}"
	vid_dir.mkdir(exist_ok=True)
	for t, frame in enumerate(video):
	from torchvision.utils import save_image
	save_image(frame, vid_dir / f"frame_{t:04d}.png")

	video_idx += 1

	print(f"\nGenerated {video_idx} videos → {output_dir}")


	if __name__ == '__main__':
	main()