Spaces:
Running on Zero
Running on Zero
Download gen.py from INTERNETCON/AI-KING-Studio: direct link, hf CLI and curl.
- Browser
- Download file 10 kB
-
https://huggingface.co/spaces/INTERNETCON/AI-KING-Studio/resolve/main/gen.py
- Command line
-
hf download hf://spaces/INTERNETCON/AI-KING-Studio/gen.py
-
curl -L -o gen.py https://huggingface.co/spaces/INTERNETCON/AI-KING-Studio/resolve/main/gen.py
10 kB
| """AI KINGยฉ๏ธ generators on ZeroGPU (open models only, no paid inference). | |
| - Text โ Image and Image โ Image: FLUX.1 [schnell] (Apache-2.0), 4-step distilled. | |
| - Text/Image โ Video + seamless loops: LTX-Video 0.9.5 (2B, LTXV Open Weights License, | |
| free for companies under $10M annual revenue). Shares FLUX's T5-XXL text encoder | |
| (byte-identical weights) so both fit in one ZeroGPU slot. | |
| Set AIKING_NO_MODELS=1 to run the UI without loading models (local design work). | |
| """ | |
| from __future__ import annotations | |
| import math, os, random, tempfile, time, traceback | |
| import numpy as np | |
| from PIL import Image, ImageOps | |
| try: | |
| import spaces # ZeroGPU | |
| except Exception: # local / non-Spaces | |
| class _S: | |
| def GPU(*a, **k): | |
| if a and callable(a[0]): | |
| return a[0] | |
| return lambda f: f | |
| spaces = _S() | |
| NO_MODELS = os.environ.get("AIKING_NO_MODELS") == "1" | |
| HUB_TOKEN = os.environ.get("AIKING_HUB_TOKEN") or None | |
| FLUX_ID = "black-forest-labs/FLUX.1-schnell" | |
| LTX_ID = "Lightricks/LTX-Video-0.9.5" | |
| OUT_DIR = os.path.join(tempfile.gettempdir(), "aiking_out") | |
| os.makedirs(OUT_DIR, exist_ok=True) | |
| STATUS = {"image": "off", "video": "off"} | |
| ERRORS: dict[str, str] = {} | |
| t2i = i2i = ltx = None | |
| LTXVideoCondition = None | |
| STYLES = { | |
| "None": "", | |
| "๐ฌ ARRI ALEXA 35": "cinematic film still shot on ARRI ALEXA 35, anamorphic lens, shallow depth of field, natural film grain, hyperrealistic skin texture, dramatic motivated lighting", | |
| "๐ฟ Album Cover": "premium album cover art, bold centered composition, iconic silhouette, luxury finish, high contrast, crisp detail", | |
| "๐ Royal Gold": "black and gold luxury aesthetic, regal, glossy reflections, crown motifs, studio rim light, hyperdetailed", | |
| "๐ Neon Lofi": "cozy lofi aesthetic, neon city at night, rain on glass, soft bloom, warm desk lamp, cinematic anime-inspired color", | |
| "๐ Intergalactic": "cosmic nebula backdrop, starfield, iridescent rim light, epic sci-fi scale, glossy chrome accents", | |
| "๐ธ Editorial": "luxury fashion editorial photograph, softbox key light, magazine cover quality, clean background", | |
| "๐งธ 3D Toy": "glossy 3D render, collectible vinyl toy style, soft global illumination, studio backdrop", | |
| "๐ฎ Game Cinematic": "AAA video game cinematic key art, unreal engine 5 render, volumetric light, epic composition", | |
| } | |
| ASPECTS = {"9:16 Story": (768, 1344), "1:1 Square": (1024, 1024), "4:5 Portrait": (896, 1120), "16:9 Cinema": (1344, 768)} | |
| VIDEO_ASPECTS = {"9:16 Story": (480, 832), "1:1 Square": (640, 640), "16:9 Cinema": (832, 480)} | |
| VIDEO_NEG = "worst quality, inconsistent motion, blurry, jittery, distorted face, morphing, warped hands, text, watermark, logo" | |
| def _load(): | |
| global t2i, i2i, ltx, LTXVideoCondition | |
| import torch | |
| from huggingface_hub import snapshot_download | |
| from diffusers import FluxImg2ImgPipeline, FluxPipeline | |
| flux_dir = snapshot_download(FLUX_ID, token=HUB_TOKEN, allow_patterns=[ | |
| "model_index.json", "scheduler/*", "text_encoder/*", "text_encoder_2/*", | |
| "tokenizer/*", "tokenizer_2/*", "transformer/*", "vae/*"]) | |
| t2i = FluxPipeline.from_pretrained(flux_dir, dtype=torch.bfloat16).to("cuda") | |
| i2i = FluxImg2ImgPipeline.from_pipe(t2i, dtype=torch.bfloat16) # from_pipe defaults to fp32! | |
| STATUS["image"] = "ready" | |
| try: | |
| from diffusers import (AutoencoderKLLTXVideo, FlowMatchEulerDiscreteScheduler, | |
| LTXConditionPipeline, LTXVideoTransformer3DModel) | |
| from diffusers.pipelines.ltx.pipeline_ltx_condition import LTXVideoCondition as _C | |
| LTXVideoCondition = _C | |
| ltx_dir = snapshot_download(LTX_ID, token=HUB_TOKEN, allow_patterns=[ | |
| "model_index.json", "scheduler/*", "transformer/*", "vae/*", "tokenizer/*"]) | |
| ltx = LTXConditionPipeline( | |
| scheduler=FlowMatchEulerDiscreteScheduler.from_pretrained(ltx_dir, subfolder="scheduler"), | |
| vae=AutoencoderKLLTXVideo.from_pretrained(ltx_dir, subfolder="vae", dtype=torch.bfloat16), | |
| text_encoder=t2i.text_encoder_2, # identical T5-XXL v1.1 weights | |
| tokenizer=t2i.tokenizer_2, | |
| transformer=LTXVideoTransformer3DModel.from_pretrained(ltx_dir, subfolder="transformer", dtype=torch.bfloat16), | |
| ).to("cuda") | |
| STATUS["video"] = "ready" | |
| except Exception as e: # keep images working even if video can't load | |
| ERRORS["video"] = f"{type(e).__name__}: {e}"[:500] | |
| STATUS["video"] = "error" | |
| traceback.print_exc() | |
| if not NO_MODELS: | |
| try: | |
| _load() | |
| except Exception as e: | |
| ERRORS["image"] = f"{type(e).__name__}: {e}"[:500] | |
| STATUS["image"] = STATUS["image"] if STATUS["image"] == "ready" else "error" | |
| traceback.print_exc() | |
| class GenError(RuntimeError): | |
| pass | |
| def _seed(seed): | |
| try: | |
| s = int(seed) | |
| except Exception: | |
| s = -1 | |
| return random.randint(0, 2**31 - 1) if s < 0 else s | |
| CLEAN = "original unbranded design, plain clothing and products without any brand logos or third-party trademarks, no watermark" | |
| def style_prompt(prompt: str, style: str) -> str: | |
| extra = STYLES.get(style, "") | |
| p = (prompt or "").strip().rstrip(".") | |
| p = f"{p}, {extra}" if extra else p | |
| return f"{p}, {CLEAN}" | |
| def _save_png(img: Image.Image, tag: str) -> str: | |
| path = os.path.join(OUT_DIR, f"aiking-{tag}-{int(time.time()*1000)}-{random.randint(100,999)}.png") | |
| img.save(path) | |
| return path | |
| def _fit16(img: Image.Image, max_side=1024) -> Image.Image: | |
| img = ImageOps.exif_transpose(img).convert("RGB") | |
| w, h = img.size | |
| s = min(1.0, max_side / max(w, h)) | |
| w, h = max(256, int(w * s) // 16 * 16), max(256, int(h * s) // 16 * 16) | |
| return img.resize((w, h), Image.LANCZOS) | |
| def _cover(img: Image.Image, w: int, h: int) -> Image.Image: | |
| return ImageOps.fit(ImageOps.exif_transpose(img).convert("RGB"), (w, h), Image.LANCZOS) | |
| def _need(kind): | |
| if STATUS.get(kind) != "ready": | |
| msg = ERRORS.get(kind) or ("models are disabled in this preview" if NO_MODELS else "model is still loading, try again in a minute") | |
| raise GenError(f"{'Image' if kind == 'image' else 'Video'} engine not ready ({msg}).") | |
| # ---------------- GPU functions ---------------- | |
| def _t2i_dur(prompt, style, aspect, n, seed): | |
| return min(90, 20 + 8 * int(n or 1)) | |
| def text_to_image(prompt, style, aspect, n, seed): | |
| import torch | |
| _need("image") | |
| w, h = ASPECTS.get(aspect, (1024, 1024)) | |
| s = _seed(seed) | |
| imgs = t2i(prompt=style_prompt(prompt, style), width=w, height=h, num_inference_steps=4, guidance_scale=0.0, | |
| num_images_per_prompt=int(n or 1), max_sequence_length=256, | |
| generator=torch.Generator("cpu").manual_seed(s)).images | |
| return [_save_png(im, "img") for im in imgs], s | |
| def _i2i_dur(image_path, prompt, style, strength, seed): | |
| return 40 | |
| def image_to_image(image_path, prompt, style, strength, seed): | |
| import torch | |
| _need("image") | |
| src = _fit16(Image.open(image_path)) | |
| st = float(strength) | |
| steps = max(4, math.ceil(4 / max(st, 0.05))) | |
| s = _seed(seed) | |
| img = i2i(prompt=style_prompt(prompt, style), image=src, strength=st, width=src.width, height=src.height, | |
| num_inference_steps=min(steps, 16), guidance_scale=0.0, max_sequence_length=256, | |
| generator=torch.Generator("cpu").manual_seed(s)).images[0] | |
| return _save_png(img, "edit"), s | |
| def _frames(seconds: float) -> int: | |
| n = int(round(float(seconds) * 24 / 8)) * 8 + 1 | |
| return max(25, min(n, 129)) | |
| def _vid_dur(prompt, image_path, mode, seconds, aspect, steps, seed): | |
| return int(min(170, 35 + int(steps) * (_frames(seconds) / 97) * 2.2)) | |
| def _write_mp4(frames, fps=24) -> str: | |
| import imageio.v2 as imageio | |
| path = os.path.join(OUT_DIR, f"aiking-video-{int(time.time()*1000)}.mp4") | |
| arr = (np.clip(np.asarray(frames), 0, 1) * 255).astype(np.uint8) if np.asarray(frames).dtype != np.uint8 else np.asarray(frames) | |
| with imageio.get_writer(path, fps=fps, codec="libx264", quality=8, pixelformat="yuv420p", macro_block_size=16, | |
| ffmpeg_params=["-movflags", "+faststart"]) as wr: | |
| for f in arr: | |
| wr.append_data(f) | |
| return path | |
| def make_video(prompt, image_path, mode, seconds, aspect, steps, seed): | |
| """mode: 'Text โ Video', 'Image โ Video', 'Seamless Loop'.""" | |
| import torch | |
| _need("video") | |
| w, h = VIDEO_ASPECTS.get(aspect, (832, 480)) | |
| n = _frames(seconds) | |
| s = _seed(seed) | |
| gen = torch.Generator("cpu").manual_seed(s) | |
| keyframe = None | |
| if image_path: | |
| keyframe = _cover(Image.open(image_path), w, h) | |
| elif mode != "Text โ Video" or STATUS["image"] == "ready": | |
| # cinematic keyframe from FLUX first: sharper, more on-brand than raw text-to-video | |
| _need("image") | |
| kw, kh = (w * 2 // 16 * 16, h * 2 // 16 * 16) | |
| k = t2i(prompt=style_prompt(prompt, "๐ฌ ARRI ALEXA 35"), width=kw, height=kh, num_inference_steps=4, | |
| guidance_scale=0.0, max_sequence_length=256, generator=torch.Generator("cpu").manual_seed(s)).images[0] | |
| keyframe = k.resize((w, h), Image.LANCZOS) | |
| conds = None | |
| if keyframe is not None: | |
| conds = [LTXVideoCondition(image=keyframe, frame_index=0)] | |
| if mode == "Seamless Loop": | |
| conds.append(LTXVideoCondition(image=keyframe, frame_index=n - 1)) | |
| motion = (prompt or "").strip().rstrip(".") + ". Smooth natural motion, cinematic camera, consistent identity and lighting, high detail." | |
| out = ltx(conditions=conds, prompt=motion, negative_prompt=VIDEO_NEG, width=w, height=h, num_frames=n, | |
| num_inference_steps=int(steps), guidance_scale=3.0, decode_timestep=0.05, decode_noise_scale=0.025, | |
| generator=gen, output_type="np").frames[0] | |
| return _write_mp4(out), s | |