code: def main(opt):
      seed_everything(opt.seed)
  
      config = OmegaConf.load(f"{opt.config}")
      model = load_model_from_config(config, f"{opt.ckpt}")
  
      device = (
          torch.device("cuda")
          if torch.cuda.is_available()
          else torch.device("cpu")
      )
  
      model = model.to(device)
  
      # quantize model
      if opt.use_int8:
          model = replace_module(model)
          # # to compute the model size
          # getModelSize(model)
  
      if opt.plms:
          sampler = PLMSSampler(model)
      elif opt.dpm:
          sampler = DPMSolverSampler(model)
      else:
          sampler = DDIMSampler(model)
  
      os.makedirs(opt.outdir, exist_ok=True)
      outpath = opt.outdir
  
      print(
          "Creating invisible watermark encoder (see https://github.com/ShieldMnt/invisible-watermark)..."
      )
      wm = "SDV2"
      wm_encoder = WatermarkEncoder()
      wm_encoder.set_watermark("bytes", wm.encode("utf-8"))
  
      batch_size = opt.n_samples
      n_rows = opt.n_rows if opt.n_rows > 0 else batch_size
      if not opt.from_file:
          prompt = opt.prompt
          assert prompt is not None
          data = [batch_size * [prompt]]
  
      else:
          print(f"reading prompts from {opt.from_file}")
          with open(opt.from_file, "r") as f:
              data = f.read().splitlines()
              data = [p for p in data for i in range(opt.repeat)]
              data = list(chunk(data, batch_size))
  
      sample_path = os.path.join(outpath, "samples")
      os.makedirs(sample_path, exist_ok=True)
      sample_count = 0
      base_count = len(os.listdir(sample_path))
      grid_count = len(os.listdir(outpath)) - 1
  
      start_code = None
      if opt.fixed_code:
          start_code = torch.randn(
              [opt.n_samples, opt.C, opt.H // opt.f, opt.W // opt.f],
              device=device,
          )
  
      precision_scope = (
          autocast if opt.precision == "autocast" else nullcontext
      )
      with torch.no_grad(), precision_scope("cuda"), model.ema_scope():
          all_samples = list()
          for n in trange(opt.n_iter, desc="Sampling"):
              for prompts in tqdm(data, desc="data"):
                  uc = None
                  if opt.scale != 1.0:
                      uc = model.get_learned_conditioning(
                          batch_size * [""]
                      )
                  if isinstance(prompts, tuple):
                      prompts = list(prompts)
                  c = model.get_learned_conditioning(prompts)
                  shape = [opt.C, opt.H // opt.f, opt.W // opt.f]
                  samples, _ = sampler.sample(
                      S=opt.steps,
                      conditioning=c,
                      batch_size=opt.n_samples,
                      shape=shape,
                      verbose=False,
                      unconditional_guidance_scale=opt.scale,
                      unconditional_conditioning=uc,
                      eta=opt.ddim_eta,
                      x_T=start_code,
                  )
  
                  x_samples = model.decode_first_stage(samples)
                  x_samples = torch.clamp(
                      (x_samples + 1.0) / 2.0, min=0.0, max=1.0
                  )
  
                  for x_sample in x_samples:
                      x_sample = 255.0 * rearrange(
                          x_sample.cpu().numpy(), "c h w -> h w c"
                      )
                      img = Image.fromarray(x_sample.astype(np.uint8))
                      img = put_watermark(img, wm_encoder)
                      img.save(
                          os.path.join(
                              sample_path, f"{base_count:05}.png"
                          )
                      )
                      base_count += 1
                      sample_count += 1
  
                  all_samples.append(x_samples)
  
          # additionally, save as grid
          grid = torch.stack(all_samples, 0)
          grid = rearrange(grid, "n b c h w -> (n b) c h w")
          grid = make_grid(grid, nrow=n_rows)
  
          # to image
          grid = 255.0 * rearrange(grid, "c h w -> h w c").cpu().numpy()
          grid = Image.fromarray(grid.astype(np.uint8))
          grid = put_watermark(grid, wm_encoder)
          grid.save(os.path.join(outpath, f"grid-{grid_count:04}.png"))
          grid_count += 1
  
      print(
          f"Your samples are ready and waiting for you here: \n{outpath} \n"
          f" \nEnjoy."
      )
  
imports: import argparse
  import os
  from itertools import islice
  import cv2
  import numpy
  import torch
  from einops import rearrange
  from omegaconf import OmegaConf
  from PIL import Image
  from torchvision.utils import make_grid
  from tqdm import tqdm, trange
  from contextlib import nullcontext
  from imwatermark import WatermarkEncoder
  from ldm.models.diffusion.ddim import DDIMSampler
  from ldm.models.diffusion.dpm_solver import DPMSolverSampler
  from ldm.models.diffusion.plms import PLMSSampler
  from ldm.util import instantiate_from_config
  from torch import autocast
  from utils import replace_module
label_desc: Use image node_id 5 for calling a global function with example usage: main(opt) without return types