Spaces:
Running
on
Zero
Running
on
Zero
File size: 2,060 Bytes
b213d84 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
from typing import Any, Dict, Optional
import numpy as np
import torch
import torch.nn as nn
from leffa.pipeline import LeffaPipeline
def pil_to_tensor(images):
images = np.array(images).astype(np.float32) / 255.0
images = torch.from_numpy(images.transpose(2, 0, 1))
return images
class LeffaInference(object):
def __init__(
self,
model: nn.Module,
ckpt_path: Optional[str] = None,
repaint: bool = False,
) -> None:
self.model: torch.nn.Module = model
self.device = "cuda" if torch.cuda.is_available() else "cpu"
# load model
if ckpt_path is not None:
self.model.load_state_dict(torch.load(ckpt_path, map_location="cpu"))
self.model = self.model.to(self.device)
self.model.eval()
self.pipe = LeffaPipeline(model=self.model, repaint=repaint)
def to_gpu(self, data: Dict[str, Any]) -> Dict[str, Any]:
for k, v in data.items():
if isinstance(v, torch.Tensor):
data[k] = v.to(self.device)
return data
def __call__(self, data: Dict[str, Any], **kwargs) -> Dict[str, Any]:
data = self.to_gpu(data)
num_inference_steps = kwargs.get("num_inference_steps", 50)
guidance_scale = kwargs.get("guidance_scale", 2.5)
seed = kwargs.get("seed", 42)
generator = torch.Generator(self.pipe.device).manual_seed(seed)
images = self.pipe(
src_image=data["src_image"],
ref_image=data["ref_image"],
mask=data["mask"],
densepose=data["densepose"],
num_inference_steps=num_inference_steps,
guidance_scale=guidance_scale,
generator=generator,
)[0]
# images = [pil_to_tensor(image) for image in images]
# images = torch.stack(images)
outputs = {}
outputs["src_image"] = (data["src_image"] + 1.0) / 2.0
outputs["ref_image"] = (data["ref_image"] + 1.0) / 2.0
outputs["generated_image"] = images
return outputs
|