Spaces:
Sleeping
Sleeping
File size: 3,778 Bytes
1ba6b4e 1731700 1ba6b4e 0bcabe8 886fb78 1ba6b4e 886fb78 1ba6b4e | 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 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 | from __future__ import annotations
import io
import os
from dataclasses import dataclass
import spaces
from PIL import Image
MODEL = os.getenv("PEERPIXEL_MODEL", "black-forest-labs/FLUX.2-klein-base-4B")
PIPELINE = None
EDIT_PIPELINE = None
SAFETY = None
def gpu_duration(task: dict, source: bytes | None = None) -> int:
outputs = max(1, min(4, int(task.get("outputCount", 1))))
steps = max(1, min(50, int(task.get("steps", 16))))
return min(300, max(60, 35 + outputs * steps * 2))
def _pipeline(source: bytes | None):
global PIPELINE, EDIT_PIPELINE
if source is None and PIPELINE is not None:
return PIPELINE
import torch
from diffusers import Flux2KleinInpaintPipeline, Flux2KleinPipeline
if PIPELINE is None:
PIPELINE = Flux2KleinPipeline.from_pretrained(MODEL, torch_dtype=torch.bfloat16)
PIPELINE.to("cuda")
PIPELINE.vae.enable_tiling()
if source is not None:
if EDIT_PIPELINE is None: EDIT_PIPELINE = Flux2KleinInpaintPipeline.from_pipe(PIPELINE)
return EDIT_PIPELINE
return PIPELINE
def _classifier():
global SAFETY
if SAFETY is None:
from transformers import pipeline
SAFETY = pipeline("image-classification", model="Falconsai/nsfw_image_detection", device=-1)
return SAFETY
def _generator(seed: int):
import torch
return torch.Generator(device="cpu").manual_seed(seed)
def _jpeg(image: Image.Image) -> bytes:
output = io.BytesIO()
image.convert("RGB").save(output, "JPEG", quality=95, subsampling=0, optimize=True)
return output.getvalue()
def _evidence(image: Image.Image) -> dict:
results = _classifier()(image.convert("RGB"))
score = max((float(x["score"]) for x in results if "nsfw" in str(x.get("label", "")).lower()), default=0.0)
return {"label": "nsfw" if score > .65 else "normal", "unsafe": score > .65, "score": score}
def compose_grid(images: list[Image.Image]) -> Image.Image:
canvas = Image.new("RGB", (1024, 1024), "white")
for index, image in enumerate(images[:4]):
canvas.paste(image.convert("RGB").resize((512, 512), Image.Resampling.LANCZOS), ((index % 2) * 512, (index // 2) * 512))
return canvas
# ZeroGPU provides CUDA emulation during startup. Root-level placement lets it
# prepare the model before a real allocation instead of loading inside it.
if os.getenv("SPACE_ID"):
_pipeline(None)
@spaces.GPU(duration=gpu_duration)
def render_task(task: dict, source: bytes | None):
pipe = _pipeline(source)
count = max(1, min(4, int(task.get("outputCount", 1))))
width, height = int(task.get("width", 512)), int(task.get("height", 512))
base_seed = int(task.get("seed", 0))
source_image = Image.open(io.BytesIO(source)).convert("RGB") if source else None
images = []
for index in range(count):
kwargs = {"prompt": task["prompt"], "width": width, "height": height,
"num_inference_steps": int(task.get("steps", 16)),
"guidance_scale": float(task.get("guidance", 4.0)),
"generator": _generator(base_seed + index * 104729)}
if source_image is not None:
prepared = source_image.resize((width, height), Image.Resampling.LANCZOS)
kwargs.update(image=prepared, mask_image=Image.new("L", (width, height), 255),
strength=float(task.get("strength", .65)))
image = pipe(**kwargs).images[0]
images.append(image)
packaged = [{"bytes": _jpeg(image), "localSafety": _evidence(image)} for image in images]
grid = None
if count == 4:
composite = compose_grid(images)
grid = {"bytes": _jpeg(composite), "localSafety": _evidence(composite)}
return {"images": packaged, "grid": grid}
|