Download app.py from Gerchegg/Qwen-Image-Sampler-Advanced: direct link, hf CLI and curl.
- Browser
- Download file 35.5 kB
-
https://huggingface.co/spaces/Gerchegg/Qwen-Image-Sampler-Advanced/resolve/main/app.py
- Command line
-
hf download hf://spaces/Gerchegg/Qwen-Image-Sampler-Advanced/app.py
-
curl -L -o app.py https://huggingface.co/spaces/Gerchegg/Qwen-Image-Sampler-Advanced/resolve/main/app.py
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 | |
| 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}") | |
| 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 | |
| ) | |