Add inference endpoint code for image enhancer

README.md

@@ -0,0 +1,41 @@
+# Finegrain Image Enhancer - Inference Endpoint
+
+This repository contains the Inference Endpoint version of the Finegrain Image Enhancer.
+
+## Usage
+
+Send a POST request to the endpoint with:
+
+```json
+{
+  "image": "base64_encoded_image_data",
+  "prompt": "masterpiece, best quality, highres",
+  "upscale_factor": 2.0,
+  "seed": 42
+}
+```
+
+Returns:
+```json
+{
+  "enhanced_image": "base64_encoded_enhanced_image",
+  "original_size": [width, height],
+  "enhanced_size": [width, height]
+}
+```
+
+## Parameters
+
+- `image` (required): Base64 encoded input image
+- `prompt` (optional): Enhancement prompt (default: "masterpiece, best quality, highres")
+- `negative_prompt` (optional): Negative prompt (default: "worst quality, low quality, normal quality")
+- `seed` (optional): Random seed (default: 42)
+- `upscale_factor` (optional): Upscale factor 1-4 (default: 2.0)
+- `controlnet_scale` (optional): ControlNet scale 0-1.5 (default: 0.6)
+- `controlnet_decay` (optional): ControlNet decay 0.5-1 (default: 1.0)
+- `condition_scale` (optional): Condition scale 2-20 (default: 6)
+- `tile_width` (optional): Tile width 64-200 (default: 112)
+- `tile_height` (optional): Tile height 64-200 (default: 144)
+- `denoise_strength` (optional): Denoise strength 0-1 (default: 0.35)
+- `num_inference_steps` (optional): Number of steps 1-30 (default: 18)
+- `solver` (optional): Solver type "DDIM" or "DPMSolver" (default: "DDIM")

client_example.py

@@ -0,0 +1,76 @@
+import base64
+import requests
+from PIL import Image
+import io
+
+def enhance_image_via_endpoint(
+    image_path: str,
+    endpoint_url: str,
+    hf_token: str,
+    prompt: str = "masterpiece, best quality, highres",
+    upscale_factor: float = 2.0
+):
+    """
+    Call the Hugging Face Inference Endpoint to enhance an image
+    """
+    
+    # Load and encode image
+    with open(image_path, "rb") as f:
+        image_bytes = f.read()
+    
+    image_base64 = base64.b64encode(image_bytes).decode('utf-8')
+    
+    # Prepare request
+    headers = {
+        "Authorization": f"Bearer {hf_token}",
+        "Content-Type": "application/json"
+    }
+    
+    payload = {
+        "image": image_base64,
+        "prompt": prompt,
+        "upscale_factor": upscale_factor,
+        "seed": 42
+    }
+    
+    # Make request
+    response = requests.post(endpoint_url, headers=headers, json=payload)
+    
+    if response.status_code == 200:
+        result = response.json()
+        
+        if "error" in result:
+            raise Exception(f"Enhancement failed: {result['error']}")
+        
+        # Decode enhanced image
+        enhanced_base64 = result["enhanced_image"]
+        enhanced_bytes = base64.b64decode(enhanced_base64)
+        enhanced_image = Image.open(io.BytesIO(enhanced_bytes))
+        
+        print(f"Original size: {result.get('original_size')}")
+        print(f"Enhanced size: {result.get('enhanced_size')}")
+        
+        return enhanced_image
+    else:
+        raise Exception(f"API call failed: {response.status_code} - {response.text}")
+
+# Example usage
+if __name__ == "__main__":
+    # Replace with your values
+    ENDPOINT_URL = "https://YOUR_ENDPOINT_ID.us-east-1.aws.endpoints.huggingface.cloud"
+    HF_TOKEN = "hf_YOUR_TOKEN_HERE"
+    
+    try:
+        enhanced = enhance_image_via_endpoint(
+            image_path="input.jpg",
+            endpoint_url=ENDPOINT_URL,
+            hf_token=HF_TOKEN,
+            prompt="masterpiece, best quality, highres, sharp details",
+            upscale_factor=2.0
+        )
+        
+        enhanced.save("enhanced_output.png")
+        print("Image enhanced and saved!")
+        
+    except Exception as e:
+        print(f"Error: {e}")

enhancer.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import torch
+from PIL import Image
+from refiners.foundationals.latent_diffusion.stable_diffusion_1.multi_upscaler import (
+    MultiUpscaler,
+    UpscalerCheckpoints,
+)
+
+from esrgan_model import UpscalerESRGAN
+
+
+@dataclass(kw_only=True)
+class ESRGANUpscalerCheckpoints(UpscalerCheckpoints):
+    esrgan: Path
+
+
+class ESRGANUpscaler(MultiUpscaler):
+    def __init__(
+        self,
+        checkpoints: ESRGANUpscalerCheckpoints,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> None:
+        super().__init__(checkpoints=checkpoints, device=device, dtype=dtype)
+        self.esrgan = UpscalerESRGAN(checkpoints.esrgan, device=self.device, dtype=self.dtype)
+
+    def to(self, device: torch.device, dtype: torch.dtype):
+        self.esrgan.to(device=device, dtype=dtype)
+        self.sd = self.sd.to(device=device, dtype=dtype)
+        self.device = device
+        self.dtype = dtype
+
+    def pre_upscale(self, image: Image.Image, upscale_factor: float, **_: Any) -> Image.Image:
+        image = self.esrgan.upscale_with_tiling(image)
+        return super().pre_upscale(image=image, upscale_factor=upscale_factor / 4)

esrgan_model.py

@@ -0,0 +1,305 @@
+"""
+Modified from https://github.com/philz1337x/clarity-upscaler
+which is a copy of https://github.com/AUTOMATIC1111/stable-diffusion-webui
+which is a copy of https://github.com/victorca25/iNNfer
+which is a copy of https://github.com/xinntao/ESRGAN
+"""
+
+import math
+from pathlib import Path
+from typing import NamedTuple
+
+import numpy as np
+import numpy.typing as npt
+import torch
+import torch.nn as nn
+from PIL import Image
+
+
+def conv_block(in_nc: int, out_nc: int) -> nn.Sequential:
+    return nn.Sequential(
+        nn.Conv2d(in_nc, out_nc, kernel_size=3, padding=1),
+        nn.LeakyReLU(negative_slope=0.2, inplace=True),
+    )
+
+
+class ResidualDenseBlock_5C(nn.Module):
+    """
+    Residual Dense Block
+    The core module of paper: (Residual Dense Network for Image Super-Resolution, CVPR 18)
+    Modified options that can be used:
+        - "Partial Convolution based Padding" arXiv:1811.11718
+        - "Spectral normalization" arXiv:1802.05957
+        - "ICASSP 2020 - ESRGAN+ : Further Improving ESRGAN" N. C.
+            {Rakotonirina} and A. {Rasoanaivo}
+    """
+
+    def __init__(self, nf: int = 64, gc: int = 32) -> None:
+        super().__init__()  # type: ignore[reportUnknownMemberType]
+
+        self.conv1 = conv_block(nf, gc)
+        self.conv2 = conv_block(nf + gc, gc)
+        self.conv3 = conv_block(nf + 2 * gc, gc)
+        self.conv4 = conv_block(nf + 3 * gc, gc)
+        # Wrapped in Sequential because of key in state dict.
+        self.conv5 = nn.Sequential(nn.Conv2d(nf + 4 * gc, nf, kernel_size=3, padding=1))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x1 = self.conv1(x)
+        x2 = self.conv2(torch.cat((x, x1), 1))
+        x3 = self.conv3(torch.cat((x, x1, x2), 1))
+        x4 = self.conv4(torch.cat((x, x1, x2, x3), 1))
+        x5 = self.conv5(torch.cat((x, x1, x2, x3, x4), 1))
+        return x5 * 0.2 + x
+
+
+class RRDB(nn.Module):
+    """
+    Residual in Residual Dense Block
+    (ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks)
+    """
+
+    def __init__(self, nf: int) -> None:
+        super().__init__()  # type: ignore[reportUnknownMemberType]
+        self.RDB1 = ResidualDenseBlock_5C(nf)
+        self.RDB2 = ResidualDenseBlock_5C(nf)
+        self.RDB3 = ResidualDenseBlock_5C(nf)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        out = self.RDB1(x)
+        out = self.RDB2(out)
+        out = self.RDB3(out)
+        return out * 0.2 + x
+
+
+class Upsample2x(nn.Module):
+    """Upsample 2x."""
+
+    def __init__(self) -> None:
+        super().__init__()  # type: ignore[reportUnknownMemberType]
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return nn.functional.interpolate(x, scale_factor=2.0)  # type: ignore
+
+
+class ShortcutBlock(nn.Module):
+    """Elementwise sum the output of a submodule to its input"""
+
+    def __init__(self, submodule: nn.Module) -> None:
+        super().__init__()  # type: ignore[reportUnknownMemberType]
+        self.sub = submodule
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x + self.sub(x)
+
+
+class RRDBNet(nn.Module):
+    def __init__(self, in_nc: int, out_nc: int, nf: int, nb: int) -> None:
+        super().__init__()  # type: ignore[reportUnknownMemberType]
+        assert in_nc % 4 != 0  # in_nc is 3
+
+        self.model = nn.Sequential(
+            nn.Conv2d(in_nc, nf, kernel_size=3, padding=1),
+            ShortcutBlock(
+                nn.Sequential(
+                    *(RRDB(nf) for _ in range(nb)),
+                    nn.Conv2d(nf, nf, kernel_size=3, padding=1),
+                )
+            ),
+            Upsample2x(),
+            nn.Conv2d(nf, nf, kernel_size=3, padding=1),
+            nn.LeakyReLU(negative_slope=0.2, inplace=True),
+            Upsample2x(),
+            nn.Conv2d(nf, nf, kernel_size=3, padding=1),
+            nn.LeakyReLU(negative_slope=0.2, inplace=True),
+            nn.Conv2d(nf, nf, kernel_size=3, padding=1),
+            nn.LeakyReLU(negative_slope=0.2, inplace=True),
+            nn.Conv2d(nf, out_nc, kernel_size=3, padding=1),
+        )
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.model(x)
+
+
+def infer_params(state_dict: dict[str, torch.Tensor]) -> tuple[int, int, int, int, int]:
+    # this code is adapted from https://github.com/victorca25/iNNfer
+    scale2x = 0
+    scalemin = 6
+    n_uplayer = 0
+    out_nc = 0
+    nb = 0
+
+    for block in list(state_dict):
+        parts = block.split(".")
+        n_parts = len(parts)
+        if n_parts == 5 and parts[2] == "sub":
+            nb = int(parts[3])
+        elif n_parts == 3:
+            part_num = int(parts[1])
+            if part_num > scalemin and parts[0] == "model" and parts[2] == "weight":
+                scale2x += 1
+            if part_num > n_uplayer:
+                n_uplayer = part_num
+                out_nc = state_dict[block].shape[0]
+        assert "conv1x1" not in block  # no ESRGANPlus
+
+    nf = state_dict["model.0.weight"].shape[0]
+    in_nc = state_dict["model.0.weight"].shape[1]
+    scale = 2**scale2x
+
+    assert out_nc > 0
+    assert nb > 0
+
+    return in_nc, out_nc, nf, nb, scale  # 3, 3, 64, 23, 4
+
+
+Tile = tuple[int, int, Image.Image]
+Tiles = list[tuple[int, int, list[Tile]]]
+
+
+# https://github.com/philz1337x/clarity-upscaler/blob/e0cd797198d1e0e745400c04d8d1b98ae508c73b/modules/images.py#L64
+class Grid(NamedTuple):
+    tiles: Tiles
+    tile_w: int
+    tile_h: int
+    image_w: int
+    image_h: int
+    overlap: int
+
+
+# adapted from https://github.com/philz1337x/clarity-upscaler/blob/e0cd797198d1e0e745400c04d8d1b98ae508c73b/modules/images.py#L67
+def split_grid(image: Image.Image, tile_w: int = 512, tile_h: int = 512, overlap: int = 64) -> Grid:
+    w = image.width
+    h = image.height
+
+    non_overlap_width = tile_w - overlap
+    non_overlap_height = tile_h - overlap
+
+    cols = max(1, math.ceil((w - overlap) / non_overlap_width))
+    rows = max(1, math.ceil((h - overlap) / non_overlap_height))
+
+    dx = (w - tile_w) / (cols - 1) if cols > 1 else 0
+    dy = (h - tile_h) / (rows - 1) if rows > 1 else 0
+
+    grid = Grid([], tile_w, tile_h, w, h, overlap)
+    for row in range(rows):
+        row_images: list[Tile] = []
+        y1 = max(min(int(row * dy), h - tile_h), 0)
+        y2 = min(y1 + tile_h, h)
+        for col in range(cols):
+            x1 = max(min(int(col * dx), w - tile_w), 0)
+            x2 = min(x1 + tile_w, w)
+            tile = image.crop((x1, y1, x2, y2))
+            row_images.append((x1, tile_w, tile))
+        grid.tiles.append((y1, tile_h, row_images))
+
+    return grid
+
+
+# https://github.com/philz1337x/clarity-upscaler/blob/e0cd797198d1e0e745400c04d8d1b98ae508c73b/modules/images.py#L104
+def combine_grid(grid: Grid):
+    def make_mask_image(r: npt.NDArray[np.float32]) -> Image.Image:
+        r = r * 255 / grid.overlap
+        return Image.fromarray(r.astype(np.uint8), "L")
+
+    mask_w = make_mask_image(
+        np.arange(grid.overlap, dtype=np.float32).reshape((1, grid.overlap)).repeat(grid.tile_h, axis=0)
+    )
+    mask_h = make_mask_image(
+        np.arange(grid.overlap, dtype=np.float32).reshape((grid.overlap, 1)).repeat(grid.image_w, axis=1)
+    )
+
+    combined_image = Image.new("RGB", (grid.image_w, grid.image_h))
+    for y, h, row in grid.tiles:
+        combined_row = Image.new("RGB", (grid.image_w, h))
+        for x, w, tile in row:
+            if x == 0:
+                combined_row.paste(tile, (0, 0))
+                continue
+
+            combined_row.paste(tile.crop((0, 0, grid.overlap, h)), (x, 0), mask=mask_w)
+            combined_row.paste(tile.crop((grid.overlap, 0, w, h)), (x + grid.overlap, 0))
+
+        if y == 0:
+            combined_image.paste(combined_row, (0, 0))
+            continue
+
+        combined_image.paste(
+            combined_row.crop((0, 0, combined_row.width, grid.overlap)),
+            (0, y),
+            mask=mask_h,
+        )
+        combined_image.paste(
+            combined_row.crop((0, grid.overlap, combined_row.width, h)),
+            (0, y + grid.overlap),
+        )
+
+    return combined_image
+
+
+class UpscalerESRGAN:
+    def __init__(self, model_path: Path, device: torch.device, dtype: torch.dtype):
+        self.model_path = model_path
+        self.device = device
+        self.model = self.load_model(model_path)
+        self.to(device, dtype)
+
+    def __call__(self, img: Image.Image) -> Image.Image:
+        return self.upscale_without_tiling(img)
+
+    def to(self, device: torch.device, dtype: torch.dtype):
+        self.device = device
+        self.dtype = dtype
+        self.model.to(device=device, dtype=dtype)
+
+    def load_model(self, path: Path) -> RRDBNet:
+        filename = path
+        state_dict: dict[str, torch.Tensor] = torch.load(filename, weights_only=True, map_location=self.device)  # type: ignore
+        in_nc, out_nc, nf, nb, upscale = infer_params(state_dict)
+        assert upscale == 4, "Only 4x upscaling is supported"
+        model = RRDBNet(in_nc=in_nc, out_nc=out_nc, nf=nf, nb=nb)
+        model.load_state_dict(state_dict)
+        model.eval()
+
+        return model
+
+    def upscale_without_tiling(self, img: Image.Image) -> Image.Image:
+        img_np = np.array(img)
+        img_np = img_np[:, :, ::-1]
+        img_np = np.ascontiguousarray(np.transpose(img_np, (2, 0, 1))) / 255
+        img_t = torch.from_numpy(img_np).float()  # type: ignore
+        img_t = img_t.unsqueeze(0).to(device=self.device, dtype=self.dtype)
+        with torch.no_grad():
+            output = self.model(img_t)
+        output = output.squeeze().float().cpu().clamp_(0, 1).numpy()
+        output = 255.0 * np.moveaxis(output, 0, 2)
+        output = output.astype(np.uint8)
+        output = output[:, :, ::-1]
+        return Image.fromarray(output, "RGB")
+
+    # https://github.com/philz1337x/clarity-upscaler/blob/e0cd797198d1e0e745400c04d8d1b98ae508c73b/modules/esrgan_model.py#L208
+    def upscale_with_tiling(self, img: Image.Image) -> Image.Image:
+        img = img.convert("RGB")
+        grid = split_grid(img)
+        newtiles: Tiles = []
+        scale_factor: int = 1
+
+        for y, h, row in grid.tiles:
+            newrow: list[Tile] = []
+            for tiledata in row:
+                x, w, tile = tiledata
+                output = self.upscale_without_tiling(tile)
+                scale_factor = output.width // tile.width
+                newrow.append((x * scale_factor, w * scale_factor, output))
+            newtiles.append((y * scale_factor, h * scale_factor, newrow))
+
+        newgrid = Grid(
+            newtiles,
+            grid.tile_w * scale_factor,
+            grid.tile_h * scale_factor,
+            grid.image_w * scale_factor,
+            grid.image_h * scale_factor,
+            grid.overlap * scale_factor,
+        )
+        output = combine_grid(newgrid)
+        return output

inference.py

@@ -0,0 +1,186 @@
+import base64
+import io
+import torch
+from pathlib import Path
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from refiners.foundationals.latent_diffusion import solvers
+
+from enhancer import ESRGANUpscaler, ESRGANUpscalerCheckpoints
+
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        """Initialize the handler with model checkpoints"""
+        
+        # Download model checkpoints
+        self.checkpoints = ESRGANUpscalerCheckpoints(
+            unet=Path(
+                hf_hub_download(
+                    repo_id="refiners/juggernaut.reborn.sd1_5.unet",
+                    filename="model.safetensors",
+                    revision="347d14c3c782c4959cc4d1bb1e336d19f7dda4d2",
+                )
+            ),
+            clip_text_encoder=Path(
+                hf_hub_download(
+                    repo_id="refiners/juggernaut.reborn.sd1_5.text_encoder",
+                    filename="model.safetensors",
+                    revision="744ad6a5c0437ec02ad826df9f6ede102bb27481",
+                )
+            ),
+            lda=Path(
+                hf_hub_download(
+                    repo_id="refiners/juggernaut.reborn.sd1_5.autoencoder",
+                    filename="model.safetensors",
+                    revision="3c1aae3fc3e03e4a2b7e0fa42b62ebb64f1a4c19",
+                )
+            ),
+            controlnet_tile=Path(
+                hf_hub_download(
+                    repo_id="refiners/controlnet.sd1_5.tile",
+                    filename="model.safetensors",
+                    revision="48ced6ff8bfa873a8976fa467c3629a240643387",
+                )
+            ),
+            esrgan=Path(
+                hf_hub_download(
+                    repo_id="philz1337x/upscaler",
+                    filename="4x-UltraSharp.pth",
+                    revision="011deacac8270114eb7d2eeff4fe6fa9a837be70",
+                )
+            ),
+            negative_embedding=Path(
+                hf_hub_download(
+                    repo_id="philz1337x/embeddings",
+                    filename="JuggernautNegative-neg.pt",
+                    revision="203caa7e9cc2bc225031a4021f6ab1ded283454a",
+                )
+            ),
+            negative_embedding_key="string_to_param.*",
+            loras={
+                "more_details": Path(
+                    hf_hub_download(
+                        repo_id="philz1337x/loras",
+                        filename="more_details.safetensors",
+                        revision="a3802c0280c0d00c2ab18d37454a8744c44e474e",
+                    )
+                ),
+                "sdxl_render": Path(
+                    hf_hub_download(
+                        repo_id="philz1337x/loras",
+                        filename="SDXLrender_v2.0.safetensors",
+                        revision="a3802c0280c0d00c2ab18d37454a8744c44e474e",
+                    )
+                ),
+            },
+        )
+
+        # Initialize device and dtype
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float32
+        
+        # Initialize the enhancer
+        self.enhancer = ESRGANUpscaler(
+            checkpoints=self.checkpoints, 
+            device=self.device, 
+            dtype=self.dtype
+        )
+
+    def __call__(self, data):
+        """
+        Process the input data and return enhanced image
+        
+        Args:
+            data (dict): Input data containing:
+                - image (str): Base64 encoded input image
+                - prompt (str, optional): Enhancement prompt
+                - negative_prompt (str, optional): Negative prompt
+                - seed (int, optional): Random seed
+                - upscale_factor (float, optional): Upscale factor
+                - controlnet_scale (float, optional): ControlNet scale
+                - controlnet_decay (float, optional): ControlNet decay
+                - condition_scale (int, optional): Condition scale
+                - tile_width (int, optional): Tile width
+                - tile_height (int, optional): Tile height
+                - denoise_strength (float, optional): Denoise strength
+                - num_inference_steps (int, optional): Number of inference steps
+                - solver (str, optional): Solver type
+        
+        Returns:
+            dict: Contains enhanced image as base64 string
+        """
+        try:
+            # Extract and decode input image
+            image_data = data.get("image")
+            if not image_data:
+                return {"error": "No image provided"}
+            
+            # Decode base64 image
+            if image_data.startswith('data:image'):
+                # Remove data:image/...;base64, prefix if present
+                image_data = image_data.split(',')[1]
+            
+            image_bytes = base64.b64decode(image_data)
+            input_image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+            
+            # Extract parameters with defaults
+            prompt = data.get("prompt", "masterpiece, best quality, highres")
+            negative_prompt = data.get("negative_prompt", "worst quality, low quality, normal quality")
+            seed = data.get("seed", 42)
+            upscale_factor = data.get("upscale_factor", 2)
+            controlnet_scale = data.get("controlnet_scale", 0.6)
+            controlnet_decay = data.get("controlnet_decay", 1.0)
+            condition_scale = data.get("condition_scale", 6)
+            tile_width = data.get("tile_width", 112)
+            tile_height = data.get("tile_height", 144)
+            denoise_strength = data.get("denoise_strength", 0.35)
+            num_inference_steps = data.get("num_inference_steps", 18)
+            solver_name = data.get("solver", "DDIM")
+            
+            # Get solver type
+            solver_type = getattr(solvers, solver_name)
+            
+            # Set up generator
+            generator = torch.Generator(device=self.device)
+            generator.manual_seed(seed)
+            
+            # Resize input image if too large to avoid VRAM issues
+            side_size = min(input_image.size)
+            if side_size > 768:
+                scale = 768 / side_size
+                new_size = (int(input_image.width * scale), int(input_image.height * scale))
+                resized_image = input_image.resize(new_size, resample=Image.Resampling.LANCZOS)
+            else:
+                resized_image = input_image
+            
+            # Enhance the image
+            enhanced_image = self.enhancer.upscale(
+                image=resized_image,
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                upscale_factor=upscale_factor,
+                controlnet_scale=controlnet_scale,
+                controlnet_scale_decay=controlnet_decay,
+                condition_scale=condition_scale,
+                tile_size=(tile_height, tile_width),
+                denoise_strength=denoise_strength,
+                num_inference_steps=num_inference_steps,
+                loras_scale={"more_details": 0.5, "sdxl_render": 1.0},
+                solver_type=solver_type,
+                generator=generator,
+            )
+            
+            # Convert enhanced image to base64
+            buffered = io.BytesIO()
+            enhanced_image.save(buffered, format="PNG")
+            enhanced_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+            
+            return {
+                "enhanced_image": enhanced_base64,
+                "original_size": input_image.size,
+                "enhanced_size": enhanced_image.size
+            }
+            
+        except Exception as e:
+            return {"error": f"Enhancement failed: {str(e)}"}

requirements.txt

@@ -0,0 +1,7 @@
+git+https://github.com/finegrain-ai/refiners@cfe8b66ba4f8a906583850ac25e9e89cb83a44b9
+numpy<2.0.0
+pillow>=10.4.0
+pillow-heif>=0.18.0
+torch>=2.0.0
+transformers>=4.21.0
+huggingface-hub>=0.16.0