Gerchegg's picture
Update app.py
c0fe752 verified
Raw History Blame Contribute Delete
35.5 kB
import gradio as gr
import numpy as np
import random
import json
import torch
from PIL import Image
import os
import time
import logging
# Опциональный импорт spaces для работы в Runpod
try:
import spaces
SPACES_AVAILABLE = True
except ImportError:
SPACES_AVAILABLE = False
from diffusers import (
DiffusionPipeline,
QwenImageImg2ImgPipeline
)
from huggingface_hub import hf_hub_download
# Настройка логирования
from io import StringIO
# Создаем буфер для логов
log_buffer = StringIO()
# Настраиваем логирование с выводом в консоль и буфер
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s | %(levelname)s | %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
handlers=[
logging.StreamHandler(), # Вывод в консоль
logging.StreamHandler(log_buffer) # Вывод в буфер для UI
]
)
logger = logging.getLogger(__name__)
# Логируем если spaces не доступен
if not SPACES_AVAILABLE:
logger.warning("⚠️ spaces module not available - running without ZeroGPU support")
def get_logs():
"""Получить накопленные логи"""
return log_buffer.getvalue()
def clear_logs():
"""Очистить буфер логов"""
global log_buffer
log_buffer = StringIO()
# Обновляем handlers
for handler in logger.handlers:
if isinstance(handler.stream, StringIO):
logger.removeHandler(handler)
new_handler = logging.StreamHandler(log_buffer)
new_handler.setFormatter(logging.Formatter('%(asctime)s | %(levelname)s | %(message)s', '%Y-%m-%d %H:%M:%S'))
logger.addHandler(new_handler)
return ""
logger.info("=" * 60)
logger.info("LOADING QWEN-SOLOBAND ADVANCED v2.1")
logger.info("With detailed logging and fixed img2img resize")
logger.info("=" * 60)
hf_token = os.environ.get("HF_TOKEN")
device = "cuda" if torch.cuda.is_available() else "cpu"
dtype = torch.bfloat16
# Логируем GPU
logger.info(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
gpu_count = torch.cuda.device_count()
logger.info(f"Number of GPUs: {gpu_count}")
for i in range(gpu_count):
logger.info(f" GPU {i}: {torch.cuda.get_device_name(i)}")
logger.info(f" Memory: {torch.cuda.get_device_properties(i).total_memory / 1024**3:.1f} GB")
else:
gpu_count = 0
logger.info("Running on CPU - no GPUs available")
# =================================================================
# ЗАГРУЗКА МОДЕЛЕЙ
# =================================================================
# 1. Базовая модель для Text-to-Image
logger.info("\n[1/3] Loading base Text2Image model...")
model_id = os.environ.get("MODEL_ID", "Gerchegg/Qwen-Soloband-Diffusers")
model_revision = os.environ.get("MODEL_REVISION", "main")
try:
start_time = time.time()
# Определяем device_map
if gpu_count > 1:
device_map = "balanced"
logger.info(f" Device map: balanced ({gpu_count} GPUs)")
else:
device_map = None
logger.info(" Device map: single GPU")
# Загружаем базовую модель
load_kwargs = {
"torch_dtype": dtype,
"device_map": device_map,
"token": hf_token,
"cache_dir": os.environ.get("HF_HOME", "/workspace/.cache/huggingface")
}
if model_revision:
load_kwargs["revision"] = model_revision
logger.info(f" Loading model: {model_id}")
logger.info(f" Device map: {device_map}")
logger.info(f" Dtype: {dtype}")
pipe_txt2img = DiffusionPipeline.from_pretrained(model_id, **load_kwargs)
if device_map is None:
pipe_txt2img.to(device)
load_time = time.time() - start_time
logger.info(f" ✓ Text2Image loaded in {load_time:.1f}s")
except Exception as e:
logger.error(f" ❌ Error loading Text2Image: {e}")
raise
# 2. Image-to-Image модель (используем те же компоненты)
logger.info("\n[2/3] Creating Image2Image pipeline...")
try:
# Создаем QwenImageImg2ImgPipeline переиспользуя компоненты Text2Image pipeline
# Это правильный способ для Qwen-Image архитектуры
pipe_img2img = QwenImageImg2ImgPipeline(
vae=pipe_txt2img.vae,
text_encoder=pipe_txt2img.text_encoder,
tokenizer=pipe_txt2img.tokenizer,
transformer=pipe_txt2img.transformer,
scheduler=pipe_txt2img.scheduler
)
logger.info(" ✓ Image2Image pipeline created (reusing components)")
except Exception as e:
logger.error(f" ❌ Error creating Image2Image: {e}")
pipe_img2img = None
# ControlNet не используется - убран для упрощения
# Оптимизации памяти
logger.info("\nApplying memory optimizations...")
for pipe in [pipe_txt2img, pipe_img2img]:
if pipe and hasattr(pipe, 'vae'):
if hasattr(pipe.vae, 'enable_tiling'):
pipe.vae.enable_tiling()
if hasattr(pipe.vae, 'enable_slicing'):
pipe.vae.enable_slicing()
logger.info(" ✓ VAE tiling and slicing enabled")
logger.info("\n" + "=" * 60)
logger.info("✓ ALL MODELS LOADED")
logger.info("=" * 60)
# =================================================================
# HELPER FUNCTIONS
# =================================================================
def resize_image(input_image, max_size=2048):
"""
Изменяет размер изображения с сохранением пропорций (кратно 16).
Если изображение меньше max_size, оставляет оригинальный размер (с округлением до 16).
"""
w, h = input_image.size
logger.info(f"[RESIZE] Входное изображение: {w}×{h}, max_size={max_size}")
# Если изображение уже меньше max_size, просто округляем до 16
if w <= max_size and h <= max_size:
new_w = w - (w % 16)
new_h = h - (h % 16)
if new_w == 0: new_w = 16
if new_h == 0: new_h = 16
if new_w != w or new_h != h:
logger.info(f"[RESIZE] Округление до кратного 16: {w}×{h} → {new_w}×{new_h}")
return input_image.resize((new_w, new_h), Image.Resampling.LANCZOS)
logger.info(f"[RESIZE] Размер уже кратен 16, изменение не требуется")
return input_image
# Определяем масштабирование с сохранением пропорций
scale = min(max_size / w, max_size / h)
new_w = int(w * scale)
new_h = int(h * scale)
logger.info(f"[RESIZE] Масштабирование: scale={scale:.3f}, промежуточный размер: {new_w}×{new_h}")
# Округляем до ближайшего кратного 16
new_w = new_w - (new_w % 16)
new_h = new_h - (new_h % 16)
# Минимальные размеры
if new_w < 16: new_w = 16
if new_h < 16: new_h = 16
logger.info(f"[RESIZE] Финальный размер после округления: {new_w}×{new_h}")
aspect_original = w / h
aspect_new = new_w / new_h
logger.info(f"[RESIZE] Соотношение сторон: {aspect_original:.3f} → {aspect_new:.3f} (разница: {abs(aspect_original - aspect_new):.3f})")
return input_image.resize((new_w, new_h), Image.Resampling.LANCZOS)
# =================================================================
# LORA FUNCTIONS
# =================================================================
# Папка для локальных LoRA
LOCAL_LORA_DIR = "/workspace/loras"
# Базовые LoRA из HuggingFace Hub (загружаются по требованию)
HUB_LORAS = {
"Realism": {
"repo": "flymy-ai/qwen-image-realism-lora",
"trigger": "Super Realism portrait of",
"weights": "pytorch_lora_weights.safetensors",
"source": "hub"
},
"Anime": {
"repo": "alfredplpl/qwen-image-modern-anime-lora",
"trigger": "Japanese modern anime style, ",
"weights": "pytorch_lora_weights.safetensors",
"source": "hub"
}
# Другие LoRA положите в /workspace/loras/ как .safetensors файлы
}
def scan_local_loras():
"""
Сканирует папку /workspace/loras на наличие .safetensors файлов
Возвращает dict с найденными LoRA
"""
local_loras = {}
if not os.path.exists(LOCAL_LORA_DIR):
logger.info(f" Local LoRA directory not found: {LOCAL_LORA_DIR}")
return local_loras
logger.info(f" Scanning local LoRA directory: {LOCAL_LORA_DIR}")
try:
for file in os.listdir(LOCAL_LORA_DIR):
if file.endswith('.safetensors'):
lora_name = os.path.splitext(file)[0] # Имя без расширения
local_path = os.path.join(LOCAL_LORA_DIR, file)
# Добавляем в список
local_loras[lora_name] = {
"path": local_path,
"trigger": "", # Без trigger word для локальных
"weights": file,
"source": "local"
}
logger.info(f" ✓ Found local LoRA: {lora_name} ({file})")
except Exception as e:
logger.warning(f" Error scanning local LoRA directory: {e}")
return local_loras
# Сканируем локальные LoRA
logger.info("\nScanning for LoRA models...")
LOCAL_LORAS = scan_local_loras()
# Объединяем Hub и локальные LoRA
AVAILABLE_LORAS = {**HUB_LORAS, **LOCAL_LORAS}
if LOCAL_LORAS:
logger.info(f" ✓ Found {len(LOCAL_LORAS)} local LoRA(s)")
logger.info(f" Total available LoRAs: {len(AVAILABLE_LORAS)}")
def load_lora_weights(pipeline, lora_name, lora_scale, hf_token):
"""
Загружает LoRA веса в pipeline (ленивая загрузка)
Hub LoRA скачиваются только при использовании
Локальные LoRA загружаются из /workspace/loras/
"""
if lora_name == "None" or lora_name not in AVAILABLE_LORAS:
logger.info(f"[LORA] Пропуск загрузки: lora_name='{lora_name}'")
return None
lora_info = AVAILABLE_LORAS[lora_name]
logger.info(f"[LORA] Начало загрузки: {lora_name}")
logger.info(f"[LORA] Source: {lora_info['source']}")
logger.info(f"[LORA] Scale: {lora_scale}")
try:
load_start = time.time()
if lora_info['source'] == 'hub':
# Ленивая загрузка с HuggingFace Hub (скачивается при первом использовании)
logger.info(f"[LORA] Загрузка из Hub: {lora_info['repo']}")
logger.info(f"[LORA] Weight file: {lora_info.get('weights', 'pytorch_lora_weights.safetensors')}")
logger.info(f"[LORA] (Скачивается если не в кэше...)")
pipeline.load_lora_weights(
lora_info['repo'],
weight_name=lora_info.get('weights', 'pytorch_lora_weights.safetensors'),
token=hf_token
)
load_time = time.time() - load_start
logger.info(f"[LORA] ✓ Hub LoRA загружена за {load_time:.2f}s (закэширована)")
else:
# Загрузка локального файла из /workspace/loras/
logger.info(f"[LORA] Загрузка локальной LoRA: {lora_info['path']}")
logger.info(f"[LORA] File: {lora_info['weights']}")
pipeline.load_lora_weights(
lora_info['path'],
adapter_name=lora_name
)
load_time = time.time() - load_start
logger.info(f"[LORA] ✓ Локальная LoRA загружена за {load_time:.2f}s")
# Устанавливаем scale
if hasattr(pipeline, 'set_adapters'):
logger.info(f"[LORA] Установка adapter scale: {lora_scale}")
pipeline.set_adapters([lora_name], adapter_weights=[lora_scale])
trigger = lora_info.get('trigger', '')
if trigger:
logger.info(f"[LORA] Trigger word: '{trigger}'")
return trigger
except Exception as e:
logger.error(f"[LORA] ❌ Ошибка загрузки {lora_name}: {e}")
import traceback
logger.error(f"[LORA] Traceback:\n{traceback.format_exc()}")
return None
# =================================================================
# GENERATION FUNCTIONS
# =================================================================
MAX_SEED = np.iinfo(np.int32).max
# Декоратор для spaces если доступен
def gpu_decorator(duration=180):
def decorator(func):
if SPACES_AVAILABLE:
return spaces.GPU(duration=duration)(func)
return func
return decorator
@gpu_decorator(duration=180)
def generate_text2img(
prompt,
negative_prompt=" ",
width=1664,
height=928,
seed=42,
randomize_seed=False,
guidance_scale=2.5,
num_inference_steps=40,
lora_name="None",
lora_scale=1.0,
progress=gr.Progress(track_tqdm=True)
):
"""Text-to-Image генерация"""
generation_start = time.time()
logger.info("\n" + "=" * 60)
logger.info("TEXT-TO-IMAGE GENERATION")
logger.info("=" * 60)
# Генерация seed
if randomize_seed:
original_seed = seed
seed = random.randint(0, MAX_SEED)
logger.info(f"[SEED] Random seed: {original_seed} → {seed}")
else:
logger.info(f"[SEED] Fixed seed: {seed}")
# Логирование параметров
logger.info(f"[PARAMS] Prompt length: {len(prompt)} chars")
logger.info(f"[PARAMS] Prompt: {prompt[:150]}{'...' if len(prompt) > 150 else ''}")
if negative_prompt and negative_prompt != " ":
logger.info(f"[PARAMS] Negative prompt: {negative_prompt[:100]}{'...' if len(negative_prompt) > 100 else ''}")
logger.info(f"[PARAMS] Resolution: {width}×{height} = {width*height:,} pixels")
logger.info(f"[PARAMS] Steps: {num_inference_steps}")
logger.info(f"[PARAMS] CFG Scale: {guidance_scale}")
logger.info(f"[PARAMS] LoRA: {lora_name} (scale: {lora_scale})")
try:
# Загружаем LoRA если выбрана
trigger_word = None
original_prompt = prompt
if lora_name != "None":
logger.info(f"[T2I STAGE 1/3] Загрузка LoRA...")
lora_start = time.time()
trigger_word = load_lora_weights(pipe_txt2img, lora_name, lora_scale, hf_token)
lora_time = time.time() - lora_start
logger.info(f"[T2I STAGE 1/3] ✓ LoRA загружена за {lora_time:.2f}s")
# Добавляем trigger word если есть
if trigger_word:
prompt = trigger_word + prompt
logger.info(f"[PROMPT] Добавлен trigger: '{trigger_word}'")
logger.info(f"[PROMPT] Финальный промпт: {prompt[:150]}...")
else:
logger.info(f"[T2I STAGE 1/3] LoRA не используется")
# Создание генератора
logger.info(f"[T2I STAGE 2/3] Подготовка генератора...")
generator = torch.Generator(device=device).manual_seed(seed)
logger.info(f"[T2I STAGE 2/3] ✓ Generator готов на устройстве: {device}")
# Генерация изображения
logger.info(f"[T2I STAGE 3/3] Начало генерации изображения...")
logger.info(f"[T2I STAGE 3/3] Pipeline: DiffusionPipeline (Text2Img)")
logger.info(f"[T2I STAGE 3/3] Ожидаемое время: ~{num_inference_steps * 0.9:.1f}s")
gen_start = time.time()
image = pipe_txt2img(
prompt=prompt,
negative_prompt=negative_prompt,
width=width,
height=height,
num_inference_steps=num_inference_steps,
true_cfg_scale=guidance_scale,
generator=generator
).images[0]
gen_time = time.time() - gen_start
logger.info(f"[T2I STAGE 3/3] ✓ Изображение сгенерировано за {gen_time:.2f}s")
logger.info(f"[T2I STAGE 3/3] Скорость: {gen_time/num_inference_steps:.3f}s на шаг")
# Выгружаем LoRA после генерации
if lora_name != "None":
logger.info(f"[CLEANUP] Выгрузка LoRA...")
unload_start = time.time()
pipe_txt2img.unload_lora_weights()
unload_time = time.time() - unload_start
logger.info(f"[CLEANUP] ✓ LoRA выгружена за {unload_time:.2f}s")
# Итоговая статистика
total_time = time.time() - generation_start
logger.info(f"[РЕЗУЛЬТАТ] Финальное изображение: {image.size[0]}×{image.size[1]}")
logger.info(f"[РЕЗУЛЬТАТ] Использованный seed: {seed}")
logger.info(f"[РЕЗУЛЬТАТ] Общее время генерации: {total_time:.2f}s")
logger.info("=" * 60)
logger.info("✓ TEXT-TO-IMAGE ЗАВЕРШЕНА УСПЕШНО")
logger.info("=" * 60 + "\n")
return image, seed, get_logs()
except Exception as e:
logger.error(f"[ERROR] ❌ Ошибка при генерации: {e}")
import traceback
logger.error(f"[ERROR] Traceback:\n{traceback.format_exc()}")
raise gr.Error(f"Ошибка генерации: {e}")
@gpu_decorator(duration=180)
def generate_img2img(
input_image,
prompt,
negative_prompt=" ",
strength=0.75,
seed=42,
randomize_seed=False,
guidance_scale=2.5,
num_inference_steps=40,
lora_name="None",
lora_scale=1.0,
progress=gr.Progress(track_tqdm=True)
):
"""Image-to-Image генерация"""
generation_start = time.time()
logger.info("\n" + "=" * 60)
logger.info("IMAGE-TO-IMAGE GENERATION")
logger.info("=" * 60)
# Проверка входного изображения
if input_image is None:
logger.error("[ERROR] Входное изображение отсутствует!")
raise gr.Error("Please upload an input image")
# КРИТИЧНО: Сохраняем оригинальные размеры ДО любых преобразований
original_width, original_height = input_image.size
logger.info(f"[INPUT] ОРИГИНАЛЬНОЕ изображение: {original_width}×{original_height}")
logger.info(f"[INPUT] Формат: {input_image.format if hasattr(input_image, 'format') else 'N/A'}")
logger.info(f"[INPUT] Режим: {input_image.mode}")
logger.info(f"[INPUT] Соотношение сторон: {original_width/original_height:.3f}")
# Генерация seed
if randomize_seed:
original_seed = seed
seed = random.randint(0, MAX_SEED)
logger.info(f"[SEED] Random seed: {original_seed} → {seed}")
else:
logger.info(f"[SEED] Fixed seed: {seed}")
# Изменяем размер изображения (max 3072 для поддержки больших изображений)
logger.info(f"[I2I STAGE 1/4] Предобработка изображения...")
resize_start = time.time()
resized = resize_image(input_image, max_size=3072)
resize_time = time.time() - resize_start
logger.info(f"[I2I STAGE 1/4] ✓ Изображение подготовлено за {resize_time:.2f}s")
# Логирование параметров
logger.info(f"[PARAMS] Prompt length: {len(prompt)} chars")
logger.info(f"[PARAMS] Prompt: {prompt[:150]}{'...' if len(prompt) > 150 else ''}")
if negative_prompt and negative_prompt != " ":
logger.info(f"[PARAMS] Negative prompt: {negative_prompt[:100]}{'...' if len(negative_prompt) > 100 else ''}")
logger.info(f"[PARAMS] Strength: {strength} (0=оригинал, 1=полная перерисовка)")
logger.info(f"[PARAMS] Effective steps: {int(num_inference_steps * strength)} из {num_inference_steps}")
logger.info(f"[PARAMS] CFG Scale: {guidance_scale}")
logger.info(f"[PARAMS] LoRA: {lora_name} (scale: {lora_scale})")
try:
if pipe_img2img is None:
logger.error("[ERROR] Image2Image pipeline не доступен!")
raise gr.Error("Image2Image pipeline not available")
# Загружаем LoRA если выбрана
trigger_word = None
original_prompt = prompt
if lora_name != "None":
logger.info(f"[I2I STAGE 2/4] Загрузка LoRA...")
lora_start = time.time()
trigger_word = load_lora_weights(pipe_img2img, lora_name, lora_scale, hf_token)
lora_time = time.time() - lora_start
logger.info(f"[I2I STAGE 2/4] ✓ LoRA загружена за {lora_time:.2f}s")
# Добавляем trigger word если есть
if trigger_word:
prompt = trigger_word + prompt
logger.info(f"[PROMPT] Добавлен trigger: '{trigger_word}'")
logger.info(f"[PROMPT] Финальный промпт: {prompt[:150]}...")
else:
logger.info(f"[I2I STAGE 2/4] LoRA не используется")
# Создание генератора
logger.info(f"[I2I STAGE 3/4] Подготовка генератора...")
generator = torch.Generator(device=device).manual_seed(seed)
logger.info(f"[I2I STAGE 3/4] ✓ Generator готов на устройстве: {device}")
# КРИТИЧНО: Передаем width и height явно, иначе пайплайн использует дефолтные 1024x1024!
img_width, img_height = resized.size
logger.info(f"[I2I STAGE 3/4] Финальное разрешение для генерации: {img_width}×{img_height}")
logger.info(f"[I2I STAGE 3/4] Соотношение сторон: {img_width/img_height:.3f}")
# Генерация изображения
logger.info(f"[I2I STAGE 4/4] Начало генерации изображения...")
logger.info(f"[I2I STAGE 4/4] Pipeline: QwenImageImg2ImgPipeline")
effective_steps = int(num_inference_steps * strength)
logger.info(f"[I2I STAGE 4/4] Реальных шагов денойзинга: {effective_steps}")
logger.info(f"[I2I STAGE 4/4] Ожидаемое время: ~{effective_steps * 0.9:.1f}s")
logger.info(f"[DEBUG] 🔍 ПЕРЕДАЕМ В PIPELINE: width={img_width}, height={img_height}")
gen_start = time.time()
image = pipe_img2img(
prompt=prompt,
negative_prompt=negative_prompt,
image=resized,
width=img_width,
height=img_height,
strength=strength,
num_inference_steps=num_inference_steps,
true_cfg_scale=guidance_scale,
generator=generator
).images[0]
gen_time = time.time() - gen_start
# КРИТИЧНО: Проверяем финальный размер результата
final_width, final_height = image.size
logger.info(f"[DEBUG] 🔍 ПОЛУЧИЛИ ИЗ PIPELINE: width={final_width}, height={final_height}")
if final_width != img_width or final_height != img_height:
logger.error(f"[BUG] ⚠️⚠️⚠️ РАЗМЕР ИЗМЕНИЛСЯ! ⚠️⚠️⚠️")
logger.error(f"[BUG] Ожидалось: {img_width}×{img_height}")
logger.error(f"[BUG] Получено: {final_width}×{final_height}")
logger.error(f"[BUG] Соотношение: {final_width/final_height:.3f}")
logger.error(f"[BUG] Это указывает на проблему в pipeline или diffusers!")
else:
logger.info(f"[I2I STAGE 4/4] ✓ Размер результата корректен: {final_width}×{final_height}")
logger.info(f"[I2I STAGE 4/4] ✓ Изображение сгенерировано за {gen_time:.2f}s")
logger.info(f"[I2I STAGE 4/4] Скорость: {gen_time/effective_steps:.3f}s на шаг")
# Выгружаем LoRA
if lora_name != "None":
logger.info(f"[CLEANUP] Выгрузка LoRA...")
unload_start = time.time()
pipe_img2img.unload_lora_weights()
unload_time = time.time() - unload_start
logger.info(f"[CLEANUP] ✓ LoRA выгружена за {unload_time:.2f}s")
# Итоговая статистика
total_time = time.time() - generation_start
logger.info(f"[РЕЗУЛЬТАТ] Финальное изображение: {image.size[0]}×{image.size[1]}")
logger.info(f"[РЕЗУЛЬТАТ] Использованный seed: {seed}")
logger.info(f"[РЕЗУЛЬТАТ] Общее время генерации: {total_time:.2f}s")
logger.info(f"[РЕЗУЛЬТАТ] Разбивка времени:")
logger.info(f"[РЕЗУЛЬТАТ] - Ресайз: {resize_time:.2f}s ({resize_time/total_time*100:.1f}%)")
logger.info(f"[РЕЗУЛЬТАТ] - Генерация: {gen_time:.2f}s ({gen_time/total_time*100:.1f}%)")
logger.info("=" * 60)
logger.info("✓ IMAGE-TO-IMAGE ЗАВЕРШЕНА УСПЕШНО")
logger.info("=" * 60 + "\n")
return image, seed, get_logs()
except Exception as e:
logger.error(f"[ERROR] ❌ Ошибка при генерации: {e}")
import traceback
logger.error(f"[ERROR] Traceback:\n{traceback.format_exc()}")
raise gr.Error(f"Ошибка генерации: {e}")
# ControlNet функция убрана - не используется
# =================================================================
# GRADIO INTERFACE
# =================================================================
MAX_SEED = np.iinfo(np.int32).max
css = """
#col-container {
margin: 0 auto;
max-width: 1400px;
}
"""
with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
lora_choices = ["None"] + list(AVAILABLE_LORAS.keys())
gr.Markdown(f"""
# 🎨 Qwen Soloband - Image2Image + LoRA v2.2
**Продвинутая модель генерации** с поддержкой Text-to-Image, Image-to-Image и LoRA стилей.
### ✨ Возможности:
- 🖼️ **Text-to-Image** - Генерация из текста, разрешения до 2048×2048
- 🔄 **Image-to-Image** - Модификация изображений с контролем strength (0.0-1.0, до 3072×3072)
- 🎭 **LoRA Support** - {len(AVAILABLE_LORAS)} доступных стилей (Hub + локальные)
- 🔌 **Full API** - Все функции доступны через API
- ⚡ **Optimized** - VAE tiling/slicing, правильный QwenImageImg2ImgPipeline
- 📋 **Detailed Logs** - Подробное логирование всех этапов генерации
**Модель**: [Gerchegg/Qwen-Soloband-Diffusers](https://huggingface.co/Gerchegg/Qwen-Soloband-Diffusers)
💡 **Local LoRAs**: Положите .safetensors файлы в `/workspace/loras/` - они появятся автоматически!
""")
with gr.Tabs() as tabs:
# TAB 1: Text-to-Image
with gr.Tab("📝 Text-to-Image"):
with gr.Row():
with gr.Column(scale=1):
t2i_prompt = gr.Text(
label="Prompt",
placeholder="SB_AI, a beautiful landscape...",
lines=3
)
t2i_run = gr.Button("Generate", variant="primary")
with gr.Accordion("Advanced Settings", open=False):
t2i_negative = gr.Text(label="Negative Prompt", value="blurry, low quality")
with gr.Row():
t2i_width = gr.Slider(label="Width", minimum=512, maximum=2048, step=64, value=1664)
t2i_height = gr.Slider(label="Height", minimum=512, maximum=2048, step=64, value=928)
with gr.Row():
t2i_steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=40)
t2i_cfg = gr.Slider(label="CFG", minimum=0.0, maximum=7.5, step=0.1, value=2.5)
with gr.Row():
t2i_seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
t2i_random_seed = gr.Checkbox(label="Random", value=True)
t2i_lora = gr.Radio(
label="LoRA Style",
choices=lora_choices,
value="None",
info=f"Hub: {len(HUB_LORAS)}, Local: {len(LOCAL_LORAS)}"
)
t2i_lora_scale = gr.Slider(label="LoRA Strength", minimum=0.0, maximum=2.0, step=0.1, value=1.0)
with gr.Column(scale=1):
t2i_output = gr.Image(label="Generated Image")
t2i_seed_output = gr.Number(label="Used Seed")
# TAB 2: Image-to-Image
with gr.Tab("🔄 Image-to-Image"):
with gr.Row():
with gr.Column(scale=1):
i2i_input = gr.Image(type="pil", label="Input Image")
i2i_prompt = gr.Text(
label="Prompt",
placeholder="Transform this image into...",
lines=3
)
i2i_strength = gr.Slider(
label="Denoising Strength",
info="0.0 = original image, 1.0 = complete redraw",
minimum=0.0,
maximum=1.0,
step=0.05,
value=0.75
)
i2i_run = gr.Button("Generate", variant="primary")
with gr.Accordion("Advanced Settings", open=False):
i2i_negative = gr.Text(label="Negative Prompt", value="blurry, low quality")
with gr.Row():
i2i_steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=40)
i2i_cfg = gr.Slider(label="CFG", minimum=0.0, maximum=7.5, step=0.1, value=2.5)
with gr.Row():
i2i_seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
i2i_random_seed = gr.Checkbox(label="Random", value=True)
i2i_lora = gr.Radio(
label="LoRA Style",
choices=lora_choices,
value="None",
info=f"Hub: {len(HUB_LORAS)}, Local: {len(LOCAL_LORAS)}"
)
i2i_lora_scale = gr.Slider(label="LoRA Strength", minimum=0.0, maximum=2.0, step=0.1, value=1.0)
with gr.Column(scale=1):
i2i_output = gr.Image(label="Generated Image")
i2i_seed_output = gr.Number(label="Used Seed")
# TAB 3: Logs
with gr.Tab("📋 Logs"):
gr.Markdown("""
## 📋 Логи генерации
Здесь отображаются подробные логи последней генерации:
- 🔍 Параметры запроса (prompt, size, seed, etc.)
- ⚙️ Этапы обработки (resize, LoRA loading, generation)
- ⏱️ Время выполнения каждого этапа
- 📊 Финальная статистика и разбивка времени
💡 Логи автоматически обновляются после каждой генерации
""")
log_output = gr.Textbox(
label="Логи",
lines=25,
max_lines=50,
show_copy_button=True,
interactive=False,
placeholder="Логи появятся после первой генерации..."
)
with gr.Row():
refresh_logs_btn = gr.Button("🔄 Обновить логи", size="sm")
clear_logs_btn = gr.Button("🗑️ Очистить логи", size="sm", variant="stop")
# Кнопка обновления логов
refresh_logs_btn.click(
fn=get_logs,
inputs=None,
outputs=log_output
)
# Кнопка очистки логов
clear_logs_btn.click(
fn=clear_logs,
inputs=None,
outputs=log_output
)
# Event handlers
t2i_run.click(
fn=generate_text2img,
inputs=[
t2i_prompt, t2i_negative, t2i_width, t2i_height,
t2i_seed, t2i_random_seed, t2i_cfg, t2i_steps,
t2i_lora, t2i_lora_scale
],
outputs=[t2i_output, t2i_seed_output, log_output],
api_name="text2img"
)
i2i_run.click(
fn=generate_img2img,
inputs=[
i2i_input, i2i_prompt, i2i_negative, i2i_strength,
i2i_seed, i2i_random_seed, i2i_cfg, i2i_steps,
i2i_lora, i2i_lora_scale
],
outputs=[i2i_output, i2i_seed_output, log_output],
api_name="img2img"
)
if __name__ == "__main__":
demo.launch(
show_api=True,
share=False,
show_error=True # Показывать подробные ошибки в API
)