InstantID

Generieren Sie Bilder mit jeder Gesichtsidentität aus einem Referenzfoto

Erzeuge Bilder mit jeder Gesichtsidentität nur anhand eines Referenzfotos.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Mieten auf CLORE.AI

1. Besuchen Sie CLORE.AI Marketplace

2. Nach GPU-Typ, VRAM und Preis filtern

3. Wählen On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfigurieren Sie Ihre Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Umgebungsvariablen bei Bedarf hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf Bereitstellung warten

Zugriff auf Ihren Server

• Verbindungsdetails finden Sie in Meine Bestellungen

• Webschnittstellen: Verwenden Sie die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist InstantID?

InstantID bewahrt die Gesichtsidentität:

• Beliebiges Referenzgesicht verwenden

• Zero-Shot - kein Training erforderlich

• Funktioniert mit jedem Stil/Prompt

• Besser als LoRA-Training

Anforderungen

Modus	VRAM	Empfohlen
Basic	12GB	RTX 4080
Hohe Qualität	16GB	RTX 4090
Mit Pose	16GB+	RTX 4090

Schnelle Bereitstellung

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

pip install diffusers transformers accelerate opencv-python insightface onnxruntime-gpu && \
huggingface-cli download InstantX/InstantID --local-dir ./checkpoints && \
python instantid_app.py

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Installation

pip install diffusers transformers accelerate
pip install opencv-python insightface onnxruntime-gpu
pip install huggingface_hub

# Modelle herunterladen
huggingface-cli download InstantX/InstantID --local-dir ./checkpoints

Grundlegende Verwendung

import torch
import cv2
import numpy as np
from PIL import Image
from diffusers import StableDiffusionXLPipeline, DDIMScheduler
from insightface.app import FaceAnalysis

# Initialisiere Gesichtsanalysator
app = FaceAnalysis(name='antelopev2', root='./', providers=['CUDAExecutionProvider'])
app.prepare(ctx_id=0, det_size=(640, 640))

# Lade Pipeline
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

# Lade InstantID-Komponenten
from diffusers import ControlNetModel

controlnet = ControlNetModel.from_pretrained(
    "./checkpoints/ControlNetModel",
    torch_dtype=torch.float16
)

# Lade IP-Adapter für Gesicht
pipe.load_ip_adapter(
    "./checkpoints",
    subfolder="",
    weight_name="ip-adapter.bin"
)

# Verarbeite Referenzgesicht
face_image = cv2.imread("reference_face.jpg")
faces = app.get(face_image)
face_emb = faces[0].normed_embedding

# Erzeuge mit Gesichtsidentität
image = pipe(
    prompt="portrait of a person as an astronaut, space background",
    negative_prompt="ugly, blurry, low quality",
    ip_adapter_image_embeds=[torch.tensor(face_emb).unsqueeze(0)],
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

image.save("output.png")

Verwendung der Diffusers-Pipeline

from diffusers import StableDiffusionXLInstantIDPipeline, DDIMScheduler
from insightface.app import FaceAnalysis
import torch
import cv2

# Lade Gesichtsanalysator
app = FaceAnalysis(name='antelopev2', providers=['CUDAExecutionProvider'])
app.prepare(ctx_id=0)

# Lade Pipeline
pipe = StableDiffusionXLInstantIDPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet="./checkpoints/ControlNetModel",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter_instantid("./checkpoints/ip-adapter.bin")

# Erhalte Gesichts-Embedding
face_image = cv2.imread("face.jpg")
face_info = app.get(face_image)[0]

face_emb = face_info.normed_embedding
face_kps = face_info.kps

# Generieren
image = pipe(
    prompt="watercolor portrait painting, artistic",
    face_emb=face_emb,
    face_kps=face_kps,
    num_inference_steps=30
).images[0]

image.save("portrait.png")

Stilbeispiele

Professionelles Bewerbungsfoto

prompt = "professional corporate headshot, studio lighting, gray background, business attire"
negative = "cartoon, anime, illustration, blurry"

Künstlerisches Porträt

prompt = "oil painting portrait in the style of Rembrandt, dramatic lighting, museum quality"
negative = "photo, realistic, modern"

Fantasy-Charakter

prompt = "fantasy elf character, pointed ears, magical forest background, ethereal lighting"
negative = "human ears, modern clothing, realistic"

Anime-Stil

prompt = "anime character portrait, studio ghibli style, detailed, beautiful"
negative = "realistic, photo, 3d render"

Mit Pose-Kontrolle

from diffusers.utils import load_image

# Lade Pose-Referenz
pose_image = load_image("pose_reference.jpg")

# Erzeuge mit Gesicht UND Pose
image = pipe(
    prompt="person in action pose, dynamic, high quality",
    face_emb=face_emb,
    face_kps=face_kps,
    image=pose_image,  # Pose-Referenz
    controlnet_conditioning_scale=0.8,
    num_inference_steps=30
).images[0]

Gradio-Oberfläche

import gradio as gr
import torch
import cv2
import numpy as np
from diffusers import StableDiffusionXLInstantIDPipeline
from insightface.app import FaceAnalysis

app = FaceAnalysis(name='antelopev2', providers=['CUDAExecutionProvider'])
app.prepare(ctx_id=0)

pipe = StableDiffusionXLInstantIDPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet="./checkpoints/ControlNetModel",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter_instantid("./checkpoints/ip-adapter.bin")

def generate(face_image, prompt, negative_prompt, strength, steps):
    # Konvertiere ins cv2-Format
    face_cv = cv2.cvtColor(np.array(face_image), cv2.COLOR_RGB2BGR)

    # Erhalte Gesichtsinfos
    faces = app.get(face_cv)
    if len(faces) == 0:
        return None, "Kein Gesicht erkannt!"

    face_info = faces[0]
    face_emb = face_info.normed_embedding
    face_kps = face_info.kps

    # Generieren
    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        face_emb=face_emb,
        face_kps=face_kps,
        ip_adapter_scale=strength,
        num_inference_steps=steps
    ).images[0]

    return image, "Erfolg!"

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Image(type="pil", label="Referenzgesicht"),
        gr.Textbox(label="Prompt", value="professional portrait"),
        gr.Textbox(label="Negativer Prompt", value="hässlich, verschwommen"),
        gr.Slider(0.1, 1.0, value=0.8, label="Identitätsstärke"),
        gr.Slider(10, 50, value=30, step=1, label="Schritte")
    ],
    outputs=[
        gr.Image(label="Generiertes Bild"),
        gr.Textbox(label="Status")
    ],
    title="InstantID - Identity Preserving Generation"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Batch-Gesichtstausch

import os
from pathlib import Path

def batch_generate(face_image_path, prompts, output_dir):
    # Lade Gesicht
    face_cv = cv2.imread(face_image_path)
    face_info = app.get(face_cv)[0]
    face_emb = face_info.normed_embedding
    face_kps = face_info.kps

    os.makedirs(output_dir, exist_ok=True)

    for i, prompt in enumerate(prompts):
        print(f"Erzeuge {i+1}/{len(prompts)}: {prompt[:50]}...")

        image = pipe(
            prompt=prompt,
            negative_prompt="ugly, blurry, deformed",
            face_emb=face_emb,
            face_kps=face_kps,
            num_inference_steps=30
        ).images[0]

        image.save(f"{output_dir}/output_{i:03d}.png")

# Verwendung
prompts = [
    "astronaut in space suit, Earth background",
    "medieval knight in armor",
    "scientist in laboratory",
    "chef in restaurant kitchen",
    "athlete on sports field"
]

batch_generate("my_face.jpg", prompts, "./outputs")

Kontrolle der Identitätsstärke

# Niedrige Stärke - mehr Stil, weniger Identität
image_stylized = pipe(
    prompt=prompt,
    face_emb=face_emb,
    ip_adapter_scale=0.4,  # Niedrig
    num_inference_steps=30
).images[0]

# Hohe Stärke - mehr Identität, weniger Stil
image_faithful = pipe(
    prompt=prompt,
    face_emb=face_emb,
    ip_adapter_scale=0.9,  # Hoch
    num_inference_steps=30
).images[0]

Speicheroptimierung

# Aktivieren von Optimierungen
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# Oder verwende sequentielles Offload für sehr wenig VRAM
pipe.enable_sequential_cpu_offload()

Leistung

Modus	GPU	Zeit pro Bild
Basic	RTX 4090	~8s
Mit Pose	RTX 4090	~12s
Basic	RTX 3090	~15s
Basic	A100	~5s

Fehlerbehebung

Kein Gesicht erkannt

• Stelle sicher, dass das Gesicht deutlich sichtbar ist

• Gute Beleuchtung im Referenzbild

• Das Gesicht sollte frontal ausgerichtet sein

Identität nicht bewahrt

• Erhöhen Sie ip_adapter_scale

• Verwende ein klareres Referenzfoto

• Vermeide extreme Winkel

Stil nicht angewendet

• Verringern Sie ip_adapter_scale

• Beschreibenderer Prompt

• Erhöhe guidance_scale

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

• Verwenden Sie Spot Markt für flexible Workloads (oft 30–50% günstiger)

• Bezahlen mit CLORE Token

• Preise bei verschiedenen Anbietern vergleichen

Nächste Schritte

• IP-Adapter - Bildprompting

• Stable Diffusion WebUI - InstantID Erweiterung

• ControlNet - Pose-Kontrolle