Sanaで画像の生成を試す（Windows+CUDA、要VRAM 12GB）

cd \aiwork
git clone https://github.com/NVlabs/Sana

cd Sana
python -m venv venv
venv\Scripts\activate
python -m pip install --upgrade pip

pip install -U xformers==0.0.27.post2 --index-url https://download.pytorch.org/whl/cu121

pip install https://github.com/woct0rdho/triton-windows/releases/download/v3.1.0-windows.post5/triton-3.0.0-cp310-cp310-win_amd64.whl

pip install -e .

import fcntl
↓
import msvcrt

class ULockFile:
    def __init__(self, path):
        self.path = path
        self.file = None
    def __enter__(self):
        try:
            self.file = open(self.path, "w")
            msvcrt.locking(self.file.fileno(), msvcrt.LK_LOCK, os.path.getsize(self.path) or 1)
            return self
        except Exception as e:
            if self.file:
                self.file.close()
            raise e
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            try:
                msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, os.path.getsize(self.path) or 1)
            finally:
                self.file.close()
                try:
                    os.unlink(self.path)
                except FileNotFoundError:
                    pass

import fcntl
↓
import msvcrt

def keep_while_reading(fname, fd, phase, delay=0.0):
    assert delay == 0.0, "delay not implemented"
    if fd < 0 or fname is None:
        return
    try:
        file_size = os.path.getsize(fname) or 1
        if phase == "start":
            msvcrt.locking(fd, msvcrt.LK_LOCK, file_size)
        elif phase == "end":
            try:
                msvcrt.locking(fd, msvcrt.LK_NBLCK, file_size)
                os.unlink(fname)
            except (PermissionError, BlockingIOError):
                pass
        else:
            raise ValueError(f"Unknown phase {phase}")
    except Exception as e:
        print(f"Error occurred during file locking: {e}")

log_file = "/dev/null"
↓
log_file = "sana_log.txt"

import os
import torch
from app.sana_pipeline import SanaPipeline
from torchvision.transforms.functional import to_pil_image
from torchvision.transforms.functional import adjust_gamma
from datetime import datetime
from PIL import PngImagePlugin

# Device configuration
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# Create output folder
output_dir = "output"
os.makedirs(output_dir, exist_ok=True)

# Set up the pipeline
model_directory = "checkpoints/"
checkpoint_name = "Sana_1600M_1024px.pth"
sana = SanaPipeline("configs/sana_config/1024ms/Sana_1600M_img1024.yaml")
sana.from_pretrained(f"{model_directory}{checkpoint_name}")

# Number of images to generate
num_images = 5

# Generation parameters
prompt = '''A cheerful kawaii kitten sitting under a pastel pink cherry blossom tree, with a glowing rainbow sign that sparkles with the name "Sana" in cute bubble letters. The kitten has big adorable eyes and is wearing a tiny flower crown, surrounded by floating hearts and stars'''
negative_prompt = ''
guidance_scale = 5.0 # 1-[5]-10
pag_guidance_scale = 2.0 # 1-[2]-4
num_inference_steps = 18 # 5-[18]-40

# Image generation loop
for i in range(num_images):
    # Generate a seed
    seed = torch.seed()
    generator = torch.Generator(device=device).manual_seed(seed)

    # Generate an image
    image_tensor = sana(
        prompt=prompt,
        negative_prompt=negative_prompt,
        height=1024,
        width=1024,
        guidance_scale=guidance_scale,
        pag_guidance_scale=pag_guidance_scale,
        num_inference_steps=num_inference_steps,
        generator=generator,
    )

    # Histogram stretching
    #min_val = image_tensor.min()
    min_val = -1.51
    #max_val = image_tensor.max()
    max_val = 1.51
    #print(f"min_val={min_val} max_val={max_val} ")
    stretched = (image_tensor - min_val) / (max_val - min_val + 1e-5)

    # Contrast enhancement
    contrast_factor = 1.5 # n < [1.0] < m
    adjusted = 0.5 + contrast_factor * (stretched - 0.5)
    # Re-clamp pixel values
    image_tensor = adjusted.clamp(0, 1)

    # Gamma correction
    gamma = 0.8 # 0.2 < [1.0] < n
    image_tensor = image_tensor.clamp(0, 1)
    image_tensor = adjust_gamma(image_tensor, gamma)

    # Convert Tensor to Pillow image
    image_tensor = image_tensor.to(torch.float32)
    image = to_pil_image(image_tensor.squeeze().clamp(0, 1))

    # Get current timestamp and create a filename
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{output_dir}/{timestamp}-{seed}-sana.png"

    # Set metadata
    img_parameters = (
        f"{prompt} \n"
        f"Negative prompt: {negative_prompt} \n"
        f"Steps: {num_inference_steps}, "
        f"Guidance Scale: {guidance_scale}, "
        f"PAG Guidance Scale: {pag_guidance_scale}, "
        f"Seed: {seed}, "
        f"Model: {checkpoint_name}"
    )
    metadata = PngImagePlugin.PngInfo()
    metadata.add_text("parameters", img_parameters)

    # Save an image
    image.save(filename, "PNG", pnginfo=metadata)
    print(f"Saved: {filename} with metadata.")

cd \aiwork\Sana
venv\Scripts\activate

python sana_test.py