ComfyUI и генеративные изображения: промптинг, фишки и custom nodes

Введение в ComfyUI: интерфейс, графы и базовый пайплайн

ComfyUI — это интерфейс для генерации изображений, где процесс сборки изображения оформляется как граф из узлов (nodes). Такой подход делает пайплайн прозрачным: вы явно видите, что и в каком порядке происходит, можете переиспользовать куски графа и постепенно усложнять систему (вплоть до собственных custom nodes).

В этой статье вы:

Поймёте логику графов в ComfyUI

Разберёте основные части интерфейса

Соберёте базовый пайплайн text-to-image из стандартных узлов

Научитесь читать граф и отлаживать типичные ошибки

> В следующих статьях мы будем углубляться в промптинг, приёмы управления стилем и качеством, а затем перейдём к расширениям и custom nodes — но фундаментом всегда останется понимание базового графа.

Что такое ComfyUI и почему он «про граф»

Ключевая идея: граф вычислений

В ComfyUI генерация — это граф, где:

Узел (node) выполняет одну операцию (например, кодирует текст в эмбеддинги или делает один проход сэмплирования).

Порт (вход/выход) — типизированный канал данных (например, MODEL, CONDITIONING, LATENT, IMAGE).

Ребро (соединение) — передача результата одного узла в другой.

Практический смысл:

Вы видите всю цепочку преобразований от текста до итогового изображения.

Вы можете заменять отдельные шаги (другой сэмплер, другая модель, другая VAE) без «магии внутри кнопки».

Вы можете собирать сложные системы: img2img, inpaint, ControlNet, LoRA-миксы, многопроходные апскейлы — как конструктор.

!Упрощённая схема базового графа text-to-image

Что ComfyUI не делает «вместо вас»

ComfyUI специально оставляет вам контроль. Это означает:

Вам нужно понимать, что такое модель (checkpoint), VAE, латентное пространство, сэмплирование.

Ошибки вида «не тот тип на входе» — нормальная часть работы, потому что вы собираете пайплайн руками.

Хорошая новость: базовых понятий немного, и после первого пайплайна всё становится намного проще.

Интерфейс ComfyUI: что где находится

Интерфейс может немного отличаться в зависимости от сборки и расширений, но логика обычно одна.

Полотно графа (canvas)

Это рабочая область, где вы:

Добавляете узлы

Соединяете их линиями

Группируете и переносите блоки

Полезные привычки:

Держать граф «слева направо»: загрузка модели → подготовка условий → сэмплер → декодирование → сохранение.

Давать себе визуальные подсказки: располагать positive над negative, а выходы вести строго вправо.

Узлы и их поиск

ComfyUI ориентирован на добавление узлов через меню поиска (обычно через контекстное меню на полотне). Вы быстро находите нужное по названию, а затем соединяете порты.

Совет по мышлению:

Если вы понимаете, какой тип данных нужен следующему узлу (MODEL? LATENT? IMAGE?), вы почти всегда быстро находите узел-источник.

Очередь (Queue) и выполнение

ComfyUI обычно работает через очередь задач:

Вы отправляете текущий граф на выполнение (один или несколько запусков).

ComfyUI выполняет граф и сохраняет результаты.

Важная идея:

Граф — это описание вычислений, а кнопка запуска — исполнение этого описания.

Сохранение и загрузка графов

ComfyUI позволяет сохранять граф, чтобы:

Вернуться к нему позже

Делать версии («v1», «v2», «эксперимент с другим сэмплером»)

Отправлять граф коллегам/ученикам

Официальный репозиторий ComfyUI: ComfyUI на GitHub

Базовые сущности, которые нужно понимать

Checkpoint (модель)

Checkpoint — файл весов модели (например, семейство Stable Diffusion). Он определяет «что модель умеет» и её общий визуальный характер.

CLIP и conditioning

Текстовый промпт не отправляется в модель напрямую. Обычно он:

Преобразуется текстовым энкодером (часто это CLIP) в числовое представление

Это представление называется conditioning (условие генерации)

В ComfyUI вы часто видите два условия:

Positive: что вы хотите видеть

Negative: чего вы хотите избежать

Latent (латент)

Многие модели генерируют изображение не сразу в пикселях, а в сжатом латентном пространстве.

Упрощённо:

Сэмплер «рисует» в латенте

Потом VAE декодирует латент в картинку

VAE

VAE (Variational Autoencoder) — часть системы, которая переводит:

изображение → латент (для задач вроде img2img)

латент → изображение (для вывода результата)

Собираем базовый пайплайн text-to-image

Ниже — минимальный рабочий граф, который превращает текст в изображение.

Набор узлов

Для базового text-to-image обычно используются:

Checkpoint Loader (или аналогичный загрузчик модели)

CLIP Text Encode для positive

CLIP Text Encode для negative

Empty Latent Image (задаёт размер латента)

KSampler (ядро генерации)

VAE Decode (латент → изображение)

Save Image (сохранение результата)

Логика соединений

Соединяется это обычно так:

Из Checkpoint Loader выходят:

1. MODEL → в KSampler 2. CLIP → в оба CLIP Text Encode 3. VAE → в VAE Decode

Из CLIP Text Encode (positive) выходит CONDITIONING → в KSampler (positive)

Из CLIP Text Encode (negative) выходит CONDITIONING → в KSampler (negative)

Empty Latent Image даёт LATENT → в KSampler (latent_image)

KSampler выдаёт LATENT → в VAE Decode

VAE Decode выдаёт IMAGE → в Save Image

Если вы мыслите типами данных, граф становится очевидным:

KSampler всегда хочет MODEL, CONDITIONING и LATENT

VAE Decode всегда хочет VAE и LATENT

Save Image всегда хочет IMAGE

Пример промптов для первого запуска

Positive (пример):

portrait photo of a young woman, soft studio light, 85mm lens, high detail, natural skin texture

Negative (пример):

lowres, blurry, bad anatomy, extra fingers, watermark, text

Важно:

На первом шаге не пытайтесь «выжать шедевр». Цель — убедиться, что пайплайн работает стабильно.

Ключевой узел: KSampler и его параметры

KSampler управляет тем, как из шума получается итоговый латент.

Ниже — параметры, которые важнее всего на старте.

| Параметр | Что делает | Как думать новичку | |---|---|---| | seed | Инициализирует случайность | Одинаковый seed при одинаковых настройках даёт повторяемый результат | | steps | Количество итераций сэмплирования | Больше шагов обычно даёт больше деталей, но медленнее | | cfg | Сила следования промпту (Classifier-Free Guidance) | Слишком мало — «не слушает промпт», слишком много — артефакты/пережатый стиль | | sampler_name | Алгоритм сэмплирования | Влияет на характер результата и скорость | | scheduler | Расписание шумов по шагам | Влияет на стабильность и стиль, часто связка важнее, чем кажется | | denoise | Сила перерисовки (особенно для img2img) | Для чистого text-to-image обычно 1.0 |

Практическая стартовая настройка:

steps: 20–30

cfg: 5–8

seed: фиксируйте, если сравниваете изменения

Что такое «базовый пайплайн» в терминах данных

Полезно уметь проговаривать пайплайн как цепочку преобразований:

Текст → (CLIP Text Encode) → conditioning

Пустой латент заданного размера → (KSampler + conditioning + model) → сгенерированный латент

Латент → (VAE Decode) → изображение

Изображение → (Save Image) → файл на диске

Если где-то ошибка, вы ищете разрыв именно в этой логике: какой тип ожидался и что реально подано.

Типичные проблемы новичка и как их диагностировать

«Нельзя соединить узлы» или «несовместимые типы»

Причина почти всегда одна:

Вы пытаетесь подать на вход узла данные другого типа (например, IMAGE вместо LATENT).

Что делать:

Посмотреть подписи портов (MODEL, VAE, CLIP, LATENT, IMAGE, CONDITIONING).

Найти узел, который делает нужное преобразование (например, VAE Decode для перехода LATENT → IMAGE).

«Генерация идёт, но результат странный»

Проверьте по порядку:

Правильный ли checkpoint загружен

Не перепутаны ли positive и negative

Не слишком ли высок cfg

Достаточно ли steps

«Ничего не меняется между запусками»

Самая частая причина:

У вас фиксированный seed, и вы меняете параметры, которые мало влияют в выбранной конфигурации.

Что делать:

Для проверки разнообразия поменять seed.

Для сравнения качества наоборот зафиксировать seed и менять один параметр за раз.

Как работать с ComfyUI в стиле «инженера графов»

Чтобы быстро расти в ComfyUI, полезен простой рабочий метод:

Меняйте только один параметр за раз и фиксируйте seed.

Дублируйте узлы, если сравниваете варианты (например, два KSampler с разными samplers).

Делайте «чистый базовый граф», от которого вы ответвляетесь экспериментами.

Что дальше по курсу

Дальше мы будем наращивать этот базовый граф:

Улучшать промптинг (структура промпта, приоритеты, негативный промпт)

Разбирать приёмы качества (детализация, стиль, борьба с артефактами)

Подключать дополнительные узлы и расширения

Переходить к custom nodes: зачем они нужны, как устроены, и как реализовать свои «фишки» внутри ComfyUI

Основа останется той же: понятные типы данных, ясные связи и воспроизводимый пайплайн.

Модели и ресурсы: checkpoints, VAE, LoRA, embeddings

В предыдущей статье вы собрали базовый граф text-to-image и увидели, что узлы в ComfyUI оперируют типами данных вроде MODEL, CLIP, VAE, CONDITIONING, LATENT, IMAGE. Теперь разберём, откуда берутся ключевые ресурсы, что именно они меняют и как мыслить ими инженерно: чтобы не «настраивать наугад», а понимать причинно-следственные связи.

Эта тема критична для всего курса:

Промптинг работает внутри возможностей выбранного checkpoint и CLIP.

Качество и цвет часто зависят от VAE.

Быстрые стили и персонажи обычно делаются через LoRA.

Локальные правки понятиями чаще всего делаются embeddings.

!Картинка показывает, где в базовом графе участвуют checkpoint, VAE, LoRA и embeddings

Что считается ресурсом в ComfyUI

В рамках ComfyUI под ресурсами обычно понимают файлы, которые вы скачиваете отдельно и подключаете в граф:

Checkpoint: основной файл модели (веса генератора, а часто и текстового энкодера).

VAE: модуль кодирования/декодирования между пикселями и латентом.

LoRA: компактная надстройка, меняющая поведение модели.

Embeddings: небольшие векторы для текстового энкодера, добавляющие понятие или стиль по «токену».

Практическая мысль: checkpoint определяет базовые способности, а остальные ресурсы чаще всего дают управляемые смещения и исправления.

Checkpoint: что это и как он влияет на результат

Что такое checkpoint

Checkpoint — это файл весов диффузионной модели. Он определяет:

общую «эстетику по умолчанию»;

диапазон сцен и объектов, которые получаются легко или сложно;

то, насколько модель послушна промпту;

совместимость со стилями дообучений (LoRA) и некоторыми embeddings.

Где смотреть:

Модели часто распространяются как .safetensors.

Источники: Hugging Face и Civitai.

Практическая классификация checkpoints

Полезно делить модели не по названиям, а по назначению:

универсальные: для широкого спектра сюжетов;

фотореалистичные: лучше лица, свет, оптика;

иллюстративные/аниме: лучше плоские заливки, контуры, стилизацию;

нишевые: заточены под конкретные темы.

Ошибка новичка: пытаться «додавить промптом» то, что базовая модель делает плохо. В таких случаях чаще нужно сменить checkpoint или добавить LoRA.

Что конкретно приходит из Checkpoint Loader в базовый граф

В базовой схеме ComfyUI загрузчик чекпойнта обычно отдаёт несколько выходов:

MODEL: то, что будет использовать KSampler.

CLIP: то, что будет кодировать текст в conditioning.

VAE: иногда встроенный VAE (не всегда лучший).

Понимание этого помогает диагностировать проблемы:

если «модель не слушает промпт», проверяйте checkpoint и CLIP;

если «цвета грязные или лицо мыльное», проверяйте VAE;

если «стиль не применяется», проверяйте, что LoRA подключена к правильному MODEL.

VAE: почему “декодер” меняет цвета и детали

Что такое VAE

VAE (Variational Autoencoder) — это модуль, который переводит данные между:

LATENT: внутреннее представление (то, что рисует KSampler);

IMAGE: пиксельная картинка.

В text-to-image вы чаще видите VAE на шаге VAE Decode.

Как VAE влияет на итог

Хотя VAE не отвечает за «смысл сцены», он заметно влияет на:

насыщенность и баланс цвета;

контраст и ощущение резкости;

характер мелких текстур;

появление или исчезновение некоторых артефактов.

Практическое правило:

Если результат «в целом правильный», но неприятный по цвету или “пластиковый”, попробуйте другой VAE раньше, чем менять промпт.

Встроенный и внешний VAE

У некоторых checkpoint VAE встроен, но его качество может быть средним. Поэтому VAE часто подменяют отдельным файлом.

Важно: VAE должен быть совместим с семейством модели. Если взять VAE «не от той базы», вы можете получить странные оттенки, падение качества или нестабильность.

LoRA: быстрые стили и персонажи без замены модели

Что такое LoRA

LoRA (Low-Rank Adaptation) — компактный набор параметров, который модифицирует поведение базовой модели.

Что LoRA обычно даёт:

стиль (например, «комикс», «кинематографичный свет»);

конкретный персонаж;

тип одежды/объекта;

художественный приём (линия, штрих, материал).

LoRA не заменяет checkpoint, а работает как «насадка»: базовая модель остаётся той же, но ответы смещаются.

Вес LoRA и что означает “сила”

У LoRA почти всегда есть параметр weight (вес). Его смысл простой:

малый вес: эффект едва заметен;

средний вес: характер LoRA устойчиво проявляется;

большой вес: эффект доминирует, но растёт риск артефактов и потери адекватности.

Практический подход:

фиксируйте seed;

меняйте вес LoRA маленькими шагами;

оценивайте не один кадр, а серию из нескольких.

Совместимость LoRA

Совместимость определяется базой, на которой LoRA обучали:

LoRA под конкретное семейство моделей обычно работает предсказуемо;

«кросс-база» иногда даёт странные формы, шум, неверный стиль.

Если LoRA “не включается”, проверяйте:

подключена ли она к MODEL (а не к IMAGE или LATENT);

подходит ли LoRA к вашему checkpoint;

не перекрывает ли её эффект другой LoRA.

Embeddings: “токены”, которые добавляют понятия

Что такое embeddings

Embeddings (в контексте Stable Diffusion это часто называют textual inversion) — это добавленные в словарь текстового энкодера векторы, которые активируются при использовании специального слова или короткого токена в промпте.

Отличие от LoRA:

LoRA меняет поведение модели генерации.

Embedding меняет представление текста на входе (conditioning).

Проще думать так:

LoRA влияет на то, как модель рисует.

Embedding влияет на то, что именно “подразумевается” под словом в промпте.

Как использовать embeddings в промпте

Обычно embedding используется как отдельный токен в positive (иногда и в negative). Примеры формата зависят от конкретного embedding и того, как он назван.

Практический смысл embeddings:

быстро получить специфический стиль/артефакт-исправление;

зафиксировать уникальную «концепцию», которую сложно описать словами.

Ограничение:

embedding часто очень чувствителен к конкретной базе (checkpoint и CLIP). Если «не работает», это часто вопрос совместимости.

Где лежат файлы в ComfyUI и как не утонуть в версиях

ComfyUI хранит ресурсы в папке models внутри директории проекта. Точные подпапки зависят от сборки, но обычно логика такая:

models/checkpoints: checkpoint файлы.

models/vae: VAE файлы.

models/loras: LoRA файлы.

models/embeddings: embeddings.

Официальный репозиторий ComfyUI: ComfyUI на GitHub

Практика, которая экономит время:

называйте файлы понятно (модель, версия, база);

держите рядом текстовый файл с заметками: для какой модели подходит LoRA, какие веса работают;

не смешивайте всё в одну папку, иначе вы начнёте «перебирать на глаз».

Типичные симптомы и быстрые проверки

Симптом: “сцена правильная, но цвета странные”

Частые причины:

неподходящий VAE;

неудачная комбинация checkpoint и VAE.

Быстрая проверка:

оставьте всё как есть, замените только VAE и сравните при одинаковом seed.

Симптом: “LoRA не чувствуется”

Частые причины:

LoRA несовместима с базой;

слишком маленький вес;

промпт конкурирует (вы просите противоположное стилю LoRA).

Быстрая проверка:

отключите сложные стилевые слова в промпте;

поднимите вес LoRA умеренно;

проверьте, что LoRA именно на MODEL ветке.

Симптом: “embedding даёт мусор или ничего”

Частые причины:

embedding не для вашей базы;

токен в промпте написан не так, как ожидается.

Быстрая проверка:

убедитесь, что embedding лежит в models/embeddings;

проверьте точное имя токена;

попробуйте другой checkpoint той же базы, под которую делали embedding.

Как связывать ресурсы с промптингом

В следующих материалах по промптингу и «фишкам» держите в голове простую связку:

checkpoint задаёт «вселенную возможного»;

LoRA добавляет узкий, но сильный “уклон”;

embeddings добавляют конкретные понятия через текст;

VAE влияет на визуальную «проявку» результата.

Если вы выстроите привычку менять одну вещь за раз (seed фиксирован, меняем только VAE или только LoRA), ComfyUI становится предсказуемым инструментом, а не лотереей.

Промптинг для diffusion: структура, веса, негатив, стили

Промптинг в diffusion-моделях — это управление генерацией через текстовое условие (conditioning), которое вы создаёте в узлах CLIP Text Encode и подаёте в KSampler.

Из предыдущих статей важно помнить две опоры:

В ComfyUI вы явно видите, куда именно попадает промпт: текст → CLIP → CONDITIONING → KSampler.

Возможности промптинга ограничены выбранными ресурсами: checkpoint задаёт «вселенную возможного», LoRA и embeddings добавляют управляемые смещения, VAE влияет на финальную «проявку» цветов и деталей.

Цель этой статьи — дать рабочую систему: как строить промпт, как усиливать/ослаблять части текста, как думать про negative и как воспроизводимо получать стили.

!Куда именно попадает промпт в графе ComfyUI и почему positive/negative — это два разных conditioning

Как diffusion «понимает» промпт

Модель не читает ваш текст «как человек». Она получает числовое представление текста от текстового энкодера (часто это семейство CLIP). Поэтому важны:

слова и устойчивые фразы, которые встречались в обучающих данных;

порядок и акценты (веса, emphasis);

конфликты между требованиями в одном промпте;

соответствие текста выбранной базе (checkpoint, LoRA, embeddings).

Практическое следствие: один и тот же промпт на разных checkpoint может давать заметно разные результаты.

Структура промпта: удобный «скелет», который масштабируется

Чтобы промпт был управляемым, собирайте его из блоков. Самый практичный порядок — от смысла к оформлению:

Субъект: кто/что в кадре.

Действие и контекст: что происходит и где.

Композиция и камера: крупность, ракурс, оптика.

Свет и цвет: тип освещения, палитра.

Материалы и детали: фактуры, одежда, окружение.

Стиль: медиум, художественная манера, эпоха.

Качество: осторожные «quality»-якоря.

Минимальный шаблон (стартовая версия)

subject: кто в кадре

scene: где и что происходит

composition: ракурс/план

lighting: свет

style: стиль

Пример (positive):

portrait of a woman, autumn park, half body, eye-level, soft overcast light, natural colors, 35mm photo

Эта версия специально короткая: она даёт пространство для точечных правок.

Как добавлять детали, чтобы промпт не «ломался»

Рабочее правило: добавляйте детали слоями и тестируйте при фиксированном seed.

Сначала добейтесь правильного сюжета (субъект, сцена, действие).

Затем зафиксируйте композицию (ракурс, план, фон).

Потом добавляйте свет/цвет.

В конце — стиль и полировка качества.

Если вы меняете всё сразу, вы не понимаете, что именно повлияло на результат.

Веса и emphasis: как «подсветить» важное

Под весом в промптинге обычно понимают приём: сделать часть промпта более (или менее) значимой для conditioning.

В большинстве workflow вокруг Stable Diffusion используются такие формы:

(...) — усиление фрагмента

[...] — ослабление фрагмента

(фраза:1.2) — явный вес (например, 1.2)

Практический диапазон весов

Чаще всего разумно оставаться в диапазоне:

0.8–0.95 для мягкого ослабления

1.05–1.3 для умеренного усиления

Слишком большие веса часто приводят к побочным эффектам:

«пережатый» стиль (всё становится одинаково стилизованным)

артефакты (особенно на лицах и руках)

потеря глобальной композиции (модель «цепляется» за одно требование)

Что имеет смысл усиливать

Хорошие кандидаты на усиление:

уникальная сущность: персонаж, ключевой объект

важная композиция: close-up, wide shot, top-down

критичный признак: red dress, bald head, two characters

То, что часто лучше не усиливать без необходимости:

общие слова качества (best quality, highres)

слишком широкие стили (cinematic, masterpiece)

Пример: тот же промпт, но с акцентами

Positive:

portrait photo of (a woman:1.2), (red dress:1.15), autumn park, half body, eye-level, soft overcast light, natural colors, 35mm

Здесь веса помогают модели «не забыть» ключевой объект и атрибут, не разрушая остальное.

Negative prompt: не «что плохо», а «что мешает цели»

Negative prompt — это отдельное conditioning, которое говорит модели, в какую сторону не идти. В ComfyUI это второй узел CLIP Text Encode, подключённый в negative вход KSampler.

Базовый negative-набор (универсальный)

Этот набор полезен как стартовая страховка, но его нужно адаптировать под задачу:

lowres, blurry, jpeg artifacts, watermark, text, logo

bad anatomy, extra fingers, deformed hands, crossed eyes

Важно: слишком агрессивный negative может «убить» стиль или полезные детали. Например, жёсткое подавление skin texture иногда делает кожу пластиковой.

Как проектировать negative под конкретную задачу

Думайте от симптома к причине:

Если портрет «мылит» лицо: добавляйте blurry, out of focus.

Если лезут надписи: добавляйте text, watermark, signature, logo.

Если ломаются руки: добавляйте bad hands, extra fingers, missing fingers.

И так же тестируйте по одному изменению за раз.

Частая ошибка: противоречить positive

Если в positive вы просите film grain, а в negative запрещаете noise, результат будет нестабилен. Модель получает два конфликтующих сигнала.

Стили: как получать повторяемый «вид» изображения

Под стилем мы будем понимать устойчивую комбинацию:

визуального медиума (photo, oil painting, 3d render)

световой постановки (cinematic lighting, studio light)

палитры (pastel colors, muted tones)

характера деталей (clean lines, highly detailed)

Три уровня стилевого управления

Слова стиля в промпте: самый простой способ, но самый «плавающий».

LoRA: лучше для повторяемого стиля/персонажа, если LoRA совместима с checkpoint.

Смена checkpoint: радикальная смена эстетики и поведения.

Связь со второй статьёй курса прямая: если вы не можете получить нужную стилизацию словами, чаще правильнее подключить LoRA или сменить checkpoint, чем бесконечно усложнять промпт.

Практические «стилевые пакеты» (как стартовые пресеты)

| Задача | Positive-слова стиля (пример) | Риски | |---|---|---| | Фотореалистичный портрет | photo, 35mm, natural skin texture, soft light | легко получить «паспортное фото» без характера | | Кинематографичный кадр | cinematic, film still, dramatic lighting, color grading | может добавлять шум/переконтраст | | Иллюстрация | illustration, digital painting, brush strokes | иногда теряются мелкие реалистичные детали | | 3D-рендер | 3d render, octane render, global illumination | может «пластиковать» материалы |

Используйте эти пакеты как модуль, который вы подставляете в конец промпта после смысла сцены.

Порядок слов, «перегруз» и конфликт требований

Даже без формальных весов у промпта есть две инженерные проблемы: перегруз и конфликт.

Перегруз

Слишком длинный список требований часто даёт обратный эффект:

модель «усредняет» всё

часть требований игнорируется

появляются случайные артефакты

Лечение:

сокращайте промпт до минимума, который даёт правильную сцену

возвращайте детали по одной

Конфликт

Конфликт — это когда вы просите несовместимые вещи:

wide shot и macro

flat lighting и dramatic rim light одновременно

minimalist background и busy city street одновременно

Лечение:

выбирайте главное и убирайте альтернативы

усиливайте важное весом, но только после того, как убрали противоречия

Практика в ComfyUI: как работать с промптами воспроизводимо

Чтобы промптинг не превращался в лотерею, закрепите три привычки из первого материала про базовый пайплайн:

фиксируйте seed, когда сравниваете правки текста

меняйте одну вещь за раз (одно слово, один вес, один блок стиля)

сохраняйте версии графа или хотя бы текст промпта (например, v1_scene, v2_lighting)

Минимальный «лабораторный» цикл:

Зафиксировать seed, steps, cfg.

Сделать базовый positive (скелет) + базовый negative.

Добавить один акцент весом.

Добавить один стилевой пакет.

Если стиль не держится — перейти к LoRA или другому checkpoint.

Связка промптинг ↔ ресурсы: быстрые решения типичных проблем

Если промпт «не слушается»: вероятно, дело в checkpoint (и его CLIP), а не в словах.

Если стиль «не фиксируется» словами: подключайте LoRA под вашу базу.

Если картинка «в целом та», но цвета/контраст неприятные: пробуйте другой VAE.

Это продолжает инженерную линию курса: промпт — важен, но он работает внутри конкретной модели и её ресурсов.

Что дальше

Следующий шаг — перейти от «текст как есть» к фишкам управления условием в графе: смешивание conditioning, несколько промптов на разные части процесса, контроль композиции через дополнительные узлы. Это станет мостом к теме расширений и custom nodes, где подобные приёмы можно упаковывать в удобные компоненты.

Полезные источники для ориентира в терминах:

ComfyUI на GitHub

CLIP: Learning Transferable Visual Models From Natural Language Supervision (arXiv)

Контроль генерации: sampler, CFG, seed, разрешение и upscale

В предыдущих статьях вы разобрали базовый граф text-to-image, научились выбирать ресурсы (checkpoint, VAE, LoRA, embeddings) и строить промпты. Теперь добавим следующий слой управления: параметры, которые определяют как именно модель приходит к изображению и в каком разрешении вы получаете результат.

Эта тема связывает всё пройденное:

Промпт и ресурсы задают цель и возможности.

Sampler, scheduler, steps, CFG и seed определяют траекторию поиска изображения.

Разрешение и upscale определяют детализацию, скорость, стоимость по VRAM и то, насколько хорошо сохраняется композиция.

Где эти параметры живут в графе ComfyUI

В базовой схеме (из первой статьи) ключевой узел управления генерацией — KSampler. Именно в нём вы управляете:

sampler_name и scheduler

steps

cfg

seed

denoise

А параметры разрешения чаще всего задаются узлом Empty Latent Image (для text-to-image) или настройками, которые создают/масштабируют латент при двухпроходной генерации.

Метод работы, который делает результат предсказуемым

Чтобы понимать причинно-следственные связи, придерживайтесь простого лабораторного цикла:

Фиксируйте seed, когда сравниваете изменения.

Меняйте один фактор за раз: либо sampler, либо CFG, либо steps, либо промпт.

Сравнивайте не один кадр: берите 3–6 разных seed, если проверяете устойчивость настройки.

Это продолжает инженерный подход из первых статей: ComfyUI удобен тем, что вы можете собирать управляемые эксперименты прямо в графе.

Sampler и scheduler: как модель проходит путь от шума к изображению

Что такое sampler

Sampler — это алгоритм, который решает, как на каждом шаге уменьшать шум и приближаться к изображению. Он влияет на:

характер деталей (резкость, микротекстуры)

стабильность (насколько часто «ломает» лица/руки)

скорость при тех же шагах

ComfyUI использует набор сэмплеров, широко распространённых в экосистеме Stable Diffusion. Источник исторически связан с реализациями семейства k-diffusion: k-diffusion на GitHub.

Что такое scheduler

Scheduler — это то, как распределяются уровни шума по шагам. Проще думать так:

sampler — как делаем шаг

scheduler — как меняем «громкость шума» от шага к шагу

Одна и та же пара sampler + steps может вести себя по-разному при разных scheduler.

Практические ориентиры по выбору

Нет «лучшего навсегда» варианта, но есть рабочие стартовые сочетания:

Для универсального качества: DPM++-семейство (часто даёт аккуратные детали и стабильность).

Для быстрых черновиков: более простые варианты с меньшим числом шагов.

Для художественной “неровности” и большего разнообразия: варианты с более «шумным» характером.

Главная мысль: выбирайте связку под задачу и фиксируйте её как часть пресета, как вы фиксируете checkpoint.

Steps: когда шаги помогают, а когда нет

Steps — число итераций. Больше шагов:

обычно повышает проработку деталей

повышает время генерации

после некоторого порога даёт убывающую отдачу

Практический диапазон для старта (часто работает как база для сравнения):

15–25 steps для быстрых тестов

25–40 steps для «финальных» кадров

Если изображение «грязное» или недоделанное, прибавьте steps. Если изображение уже хорошее, но «не слушается промпт» или рушится стиль — проблема часто не в шагах (а в CFG, промпте, ресурсе или несовместимой LoRA).

CFG: сила следования промпту

Что означает CFG

CFG (Classifier-Free Guidance) — параметр, который регулирует, насколько сильно модель следует positive по сравнению с базовой “свободной” генерацией. Концептуальную основу описывает работа про classifier-free guidance: Classifier-Free Diffusion Guidance (arXiv).

Как это проявляется на практике:

низкий CFG: изображение более естественное, но модель может «не услышать» детали промпта

высокий CFG: детали промпта усиливаются, но растут риски артефактов и «пережатого» вида

Типичные симптомы неправильного CFG

CFG слишком низкий:

- теряются конкретные атрибуты (red dress становится “просто платьем”) - стиль “плавает”

CFG слишком высокий:

- кожа становится пластиковой или “перешарпленной” - фон начинает ломаться - появляются странные контуры и артефакты

Рабочие диапазоны

Стартовая зона, которую удобно брать как “норму”:

4–8 для многих задач

Но это не правило, а точка отсчёта. CFG нужно подбирать вместе с:

промптом (особенно с весами и перегрузом)

выбранным checkpoint

LoRA (сильная LoRA + высокий CFG часто дают перебор)

Seed: управляемая случайность и воспроизводимость

Что такое seed

Seed — это число, из которого инициализируется генератор случайности. В контексте диффузии это влияет на начальный шум и, как следствие, на итоговую композицию и детали.

Практические правила:

Один и тот же seed при одинаковых настройках даёт воспроизводимый результат.

Если вы меняете sampler, CFG, steps, промпт или LoRA, фиксированный seed помогает честно сравнивать изменения.

Если вы хотите разнообразие, меняйте seed, а не переписывайте промпт “в надежде”.

Seed как инструмент контроля вариативности

Удобная стратегия в работе:

Сначала найдите удачный seed, где композиция “в целом правильная”.

Потом фиксируйте seed и полируйте: промпт, CFG, steps, LoRA, VAE.

Затем проверяйте устойчивость на нескольких других seed.

Разрешение: качество, композиция, VRAM и скорость

Где задаётся разрешение

В text-to-image разрешение обычно задаётся в Empty Latent Image. Это важно: модель на самом деле генерирует латент, и стоимость по памяти/времени растёт вместе с размером латента.

Как разрешение влияет на результат

Разрешение меняет не только детализацию, но и поведение композиции:

Малое разрешение:

- быстрее - проще держать целостную композицию - меньше микродеталей

Большое разрешение:

- больше деталей - выше риск “расползания” (особенно если промпт перегружен) - резко растут требования к VRAM

База модели и “родные” размеры

Разные семейства моделей “любят” разные масштабы. Практически полезно помнить:

SD 1.5 чаще комфортно чувствует себя около 512 по короткой стороне.

SDXL обычно рассчитан на более высокие базовые размеры.

Если вы генерируете сильно выше «родного» диапазона, вы часто платите качеством (или стабильностью), даже если VRAM позволяет.

Соотношение сторон как часть промптинга

Соотношение сторон — это скрытая часть композиции. Для дисциплины полезно выбирать его осознанно:

портрет: вертикальные форматы

пейзаж/кино: широкие форматы

товарка/каталог: ближе к квадрату или умеренному прямоугольнику

Если вы просите wide shot cinematic frame, но генерируете квадрат, модель будет “бороться” между текстом и геометрией.

Upscale: как получать высокое разрешение без потери управляемости

Многие новички сразу увеличивают размер в Empty Latent Image и получают:

медленную генерацию

меньше устойчивости

больше артефактов

Чаще профессиональный подход — делать upscale в 1–2 этапа.

Стратегия A: апскейл уже готового изображения

Смысл: сначала сгенерировать картинку, затем увеличить её алгоритмом апскейла.

Плюсы:

быстро и экономно по VRAM

композиция сохраняется максимально

Минусы:

апскейл повышает резкость и размер, но не всегда добавляет “настоящую” новую деталь

Эта стратегия хороша, если изображение уже достаточно детализировано и вам нужно больше пикселей для печати/верстки.

Стратегия B: двухпроходная генерация (hires-подход)

Смысл: сначала получить хорошую композицию в меньшем размере, затем увеличить латент или изображение и доделать детали вторым проходом с небольшим denoise.

!Диаграмма показывает, как делается upscale через второй проход сэмплирования

Ключевой параметр здесь — denoise во втором KSampler:

denoise около 0.2–0.35:

- композиция почти не меняется - добавляется аккуратная детализация

denoise около 0.4–0.6:

- деталей больше - растёт риск заметно изменить лицо, позу, одежду

Практический смысл denoise: это “сколько свободы” вы даёте модели перерисовать изображение на втором проходе.

Как не испортить результат при upscale

Проверяйте типичные проблемы и решения:

Детализация выросла, но лицо “поехало”:

- уменьшите denoise во втором проходе - уменьшите CFG во втором проходе

Появился шум/перешарп:

- уменьшите CFG - попробуйте другую связку sampler/scheduler - проверьте VAE (иногда смена VAE влияет сильнее, чем кажется)

Стиль “сломался” после upscale:

- убедитесь, что LoRA и промпт одинаково поданы в оба прохода - уменьшите вес LoRA на втором проходе, если она слишком доминирует

Практические пресеты для старта

Таблица ниже — не «истина», а удобные отправные точки для экспериментов при фиксированном seed.

| Задача | Базовое разрешение | Steps | CFG | Upscale-подход | |---|---:|---:|---:|---| | Быстрый поиск идеи | 512 по короткой стороне | 15–20 | 4–7 | без upscale | | Портрет с аккуратной кожей | 512–768 по короткой стороне | 25–35 | 4–7 | 2 прохода, denoise 0.2–0.35 | | Иллюстрация с текстурами | 512–768 по короткой стороне | 25–40 | 5–8 | 2 прохода, denoise 0.25–0.45 | | Большой кадр для верстки | меньшее базовое | 20–35 | 4–7 | сначала стабильная композиция, затем upscale |

Частые ошибки и быстрые диагностики

Ошибка: “кручу всё сразу и не понимаю, что помогло”.

- Решение: фиксируйте seed и меняйте один параметр.

Ошибка: “ставлю огромное разрешение, чтобы было детально”.

- Решение: сначала композиция на меньшем размере, затем upscale и второй проход.

Ошибка: “повышаю CFG, чтобы модель слушалась”.

- Решение: сначала уберите конфликты в промпте и перегруз; затем добавляйте веса точечно.

Что дальше по курсу

Теперь у вас есть базовые ручки управления процессом генерации: sampler/scheduler, steps, CFG, seed, разрешение и upscale. Следующий логичный шаг — графовые фишки управления условием: смешивание conditioning, разные промпты на разные этапы, управление композицией через дополнительные узлы.

Это станет мостом к custom nodes: многие “фишки” в ComfyUI — это просто удачно упакованные куски графа, которые можно превратить в переиспользуемый компонент.

Полезные источники:

ComfyUI на GitHub

Classifier-Free Diffusion Guidance (arXiv)

k-diffusion на GitHub

Управление композицией: ControlNet, IP-Adapter, reference-подходы

В прошлых статьях вы научились собирать базовый граф text-to-image, выбирать ресурсы (checkpoint, VAE, LoRA, embeddings), писать управляемые промпты и контролировать сэмплирование (sampler, CFG, seed, разрешение, upscale). Но у diffusion есть фундаментальное ограничение: промпт хорошо задаёт идею и стиль, но плохо фиксирует геометрию кадра.

Когда вам нужно, чтобы:

персонаж стоял в конкретной позе;

композиция повторяла референс;

объект был строго в нужном месте;

стиль и палитра совпадали с примером;

одного текста обычно недостаточно. Здесь появляются три практических инструмента для композиционного контроля в ComfyUI:

ControlNet: фиксирует структуру (позу, контуры, глубину, линии, сегментацию).

IP-Adapter: переносит смысл и визуальные признаки из референса (стиль, персонажность, материалы), часто без жёсткой геометрии.

Reference-подходы: набор паттернов графа (img2img с малым denoise, двухпроходка, извлечение структуры из референса), которые комбинируют контроль и вариативность.

!Карта методов управления композицией и что именно каждый метод контролирует

Зачем композиционный контроль, если есть промпт и seed

Даже при фиксированном seed текст задаёт скорее направление, чем чертёж. Причины:

Текстовое conditioning не содержит точной геометрии.

Модель выбирает позу, перспективу и расположение объектов как часть «творческого» решения.

Чем выше вариативность (seed, denoise, некоторые sampler), тем сильнее плавает композиция.

Композиционный контроль добавляет в граф ещё один вид условий, который обычно сильнее фиксирует форму, чем слова.

ControlNet: «скелет» и структура кадра

Что такое ControlNet

ControlNet — это метод, который подключает к генерации дополнительный сигнал управления, полученный из изображения: например, поза (OpenPose), контуры (Canny), глубина (Depth), сегментация. В итоге модель следует не только тексту, но и структурной подсказке.

Рекомендуемые первоисточники:

ControlNet на arXiv

Репозиторий ControlNet

Как это выглядит в графе ComfyUI

Типовой паттерн (названия узлов могут чуть отличаться в разных сборках и наборах расширений, но типы данных и логика одинаковы):

Load Image загружает референс.

Препроцессор (например, Canny/OpenPose/Depth) превращает изображение в control image.

ControlNet Loader загружает веса ControlNet под выбранный тип контроля.

Узел применения ControlNet добавляет управление к вашему CONDITIONING.

Обновлённый conditioning идёт в KSampler.

!Базовый граф text-to-image с добавленной веткой ControlNet

Какие виды контроля бывают и что выбирать

| Тип ControlNet | Что фиксирует | Когда применять | Типичные риски | |---|---|---|---| | Pose (OpenPose) | позы людей, расположение суставов | позирование, сцены с персонажами | «манекенность», если слишком жёстко | | Canny/Lineart | контуры и границы объектов | повтор формы, предметка, иллюстрации | чрезмерная «обводка», потеря реализма | | Depth | перспективу и объём | интерьер/экстерьер, 3D-ощущение | иногда упрощает мелкие детали | | Segmentation | области (небо/земля/человек и т.д.) | управляемая композиция крупных масс | может делать кадр слишком «плоским» |

Практический выбор простой:

нужно повторить позу человека: берите Pose;

нужно повторить форму объекта: берите Canny/Lineart;

нужно повторить перспективу сцены: берите Depth;

нужно разложить сцену на крупные зоны: берите Segmentation.

Главные ручки ControlNet и как ими мыслить

У ControlNet обычно есть несколько ключевых параметров (они могут называться по-разному, но смысл одинаковый):

weight/strength: сила контроля.

- меньше: больше свободы у модели, композиция может «плыть»; - больше: точнее повтор структуры, но выше риск «зажать» изображение.

start/end или start_percent/end_percent: на каком участке сэмплирования ControlNet действует.

- действие только в начале чаще фиксирует композицию, оставляя свободу деталям; - действие до конца делает следование структуре максимально жёстким.

preprocessor resolution: разрешение карты контроля.

- выше: точнее геометрия и мелкие элементы; - ниже: более грубая форма, меньше «дрожания линий».

Инженерная стратегия настройки:

Зафиксируйте seed.

Подберите тип ControlNet и адекватный препроцессор.

Настройте weight так, чтобы поза/контуры держались.

Если стало «деревянно», уменьшите weight или ограничьте действие ControlNet по шагам (start/end).

Типичные ошибки с ControlNet

Ошибка: использовать неподходящий тип контроля.

- Пример: пытаться повторить позу через Canny. - Решение: Pose/OpenPose.

Ошибка: слишком большой weight.

- Симптом: «как раскраска по линиям», теряется естественность. - Решение: снизить weight или закончить действие ControlNet раньше.

Ошибка: пытаться одной ControlNet решить и позу, и стиль.

- Решение: поза через ControlNet, стиль через промпт, LoRA или IP-Adapter.

IP-Adapter: референс как «визуальный промпт»

Что такое IP-Adapter

IP-Adapter — подход, который позволяет подать в генерацию изображение-референс так, чтобы модель переняла из него визуальные признаки. В отличие от ControlNet, это обычно не «карта структуры», а семантика и визуальная идентичность, извлечённые энкодером изображений.

Первоисточники:

IP-Adapter на arXiv

Репозиторий IP-Adapter

Когда IP-Adapter лучше ControlNet

IP-Adapter особенно полезен, когда вы хотите:

перенести стиль, палитру, материалы;

удержать «похожесть» на персонажа или объект по референсу;

получить близкий визуальный характер без жёсткой привязки к контурам.

Если ваша задача звучит как «сделай в похожей манере» или «похоже на этого персонажа, но в другой сцене», IP-Adapter чаще оказывается проще, чем ControlNet.

Общая логика узлов в ComfyUI

Концептуально пайплайн выглядит так:

Load Image загружает референс.

Узел визуального энкодера превращает референс в image conditioning.

Этот сигнал смешивается с вашим текстовым CONDITIONING.

Итог идёт в KSampler.

!Как IP-Adapter добавляет изображение-референс как дополнительное условие

Главные параметры IP-Adapter

В большинстве реализаций вам встретятся параметры с таким смыслом:

weight/strength: насколько сильно референс влияет.

- низкий вес: лёгкий стилевой оттенок; - высокий вес: сильная похожесть, но риск перетянуть детали и снизить соответствие тексту.

тип адаптера: условно «для стиля» и «для идентичности».

- некоторые варианты больше цепляются за общую манеру; - другие стараются удерживать конкретные черты объекта.

количество референсов: иногда можно смешивать несколько изображений.

Практический паттерн:

если референс начинает «ломать сцену» из промпта, снижайте weight;

если референс почти не ощущается, повышайте weight и упрощайте стилевые слова в промпте, чтобы не было конкуренции.

Reference-подходы: практические паттерны, которые работают всегда

Под reference-подходами удобно понимать не один алгоритм, а набор графовых приёмов: как использовать референс так, чтобы контролировать композицию, не превращая задачу в борьбу параметров.

Reference-подход A: img2img с малым denoise как «мягкий якорь»

Смысл:

вы берёте референс-картинку;

кодируете её в латент;

делаете KSampler с denoise меньше 1.0.

Как это работает концептуально:

denoise ближе к 0 означает «почти не менять исходник»;

denoise ближе к 1 означает «перерисовать почти как text-to-image».

Практические ориентиры:

небольшой denoise помогает сохранить композицию и позу;

повышая denoise, вы повышаете свободу для изменения стиля и деталей.

Где это полезно:

«сохрани позу, но перерисуй в другом стиле»;

«сохрани композицию кадра, но поменяй персонажа».

Ограничение:

если референс низкого качества, вы легко «тащите» в результат его дефекты.

Reference-подход B: извлечь структуру из референса и подать через ControlNet

Это часто самый стабильный подход, потому что вы отделяете:

структуру (поза/контуры/глубина) через ControlNet;

содержание и стиль через текст, LoRA, IP-Adapter.

Типовой сценарий:

из референса вытаскиваете Pose или Depth;

генерируете новую сцену с той же геометрией.

Плюс:

меньше «залипания» на пиксели референса, чем у чистого img2img.

Reference-подход C: комбинировать ControlNet и IP-Adapter

Самый практичный гибрид:

ControlNet держит позу/перспективу;

IP-Adapter переносит стиль/персонажность;

промпт задаёт сюжет и точные требования.

Рекомендация по настройке:

сначала добейтесь стабильной структуры одним ControlNet;

затем добавьте IP-Adapter с небольшим весом;

потом уже полируйте промпт, CFG и upscale.

Как выбрать инструмент: короткая карта решений

| Запрос | Что взять первым | Почему | |---|---|---| | «Нужна точно такая поза» | ControlNet Pose | это структурная задача | | «Нужны такие же контуры/силуэт» | ControlNet Canny/Lineart | это задача формы | | «Нужна похожая перспектива интерьера» | ControlNet Depth | фиксирует объём | | «Сделай в стиле этой картинки» | IP-Adapter | переносит визуальную манеру | | «Похоже на этого персонажа, но другая сцена» | IP-Adapter, затем ControlNet при необходимости | похожесть важнее контура | | «Сохрани композицию и чуть перерисуй» | img2img с малым denoise | мягкая фиксация исходника |

Практический метод работы в ComfyUI: чтобы не утонуть в параметрах

Зафиксируйте базу: checkpoint, VAE, sampler/scheduler, steps, CFG, seed.

Решите, что именно вы контролируете:

1. структуру кадра; 2. стиль и визуальные признаки; 3. или мягкую близость к референсу.

Подключите один инструмент контроля:

1. ControlNet или IP-Adapter, но не всё сразу.

Добейтесь стабильности на 1-2 seed.

Только потом добавляйте второй инструмент или двухпроходный upscale.

Эта дисциплина продолжает инженерный подход из прошлых статей: фиксируем seed, меняем один фактор, строим воспроизводимые эксперименты.

Связь с custom nodes: почему это важный мост

ControlNet, IP-Adapter и reference-паттерны в ComfyUI часто оформляются как повторяющиеся блоки графа:

загрузка и препроцессинг референса;

применение к conditioning;

набор «правильных» параметров по умолчанию.

Когда вы начнёте делать свои фишки через custom nodes, самая практичная идея будет простой: упаковать повторяющийся композиционный блок в переиспользуемый компонент, чтобы не собирать одно и то же вручную и не ошибаться в соединениях типов.

Полезные ссылки

ComfyUI на GitHub

ControlNet на arXiv

Репозиторий ControlNet

IP-Adapter на arXiv

Репозиторий IP-Adapter

Продвинутые “фишки”: inpainting, outpainting, регионы, маски, батчи

Вы уже умеете собирать базовый граф text-to-image, выбирать ресурсы (checkpoint, VAE, LoRA, embeddings), писать управляемые промпты, контролировать sampler/CFG/seed/разрешение и использовать ControlNet/IP-Adapter для композиции. Следующий шаг в практической работе — научиться делать то, что чаще всего нужно “в продакшене”:

точечно править готовое изображение (inpainting), не ломая остальное;

расширять кадр за пределы исходника (outpainting);

задавать разные промпты для разных зон (регионы) и управлять ими масками;

быстро прогонять варианты пакетно (батчи) и не утонуть в случайности.

Эти приёмы важны ещё и как мост к custom nodes: почти всё ниже — повторяемые блоки графа, которые удобно упаковывать в переиспользуемые компоненты.

!Упрощённая карта узлов для inpainting и где в графе участвует маска

Базовые определения: что именно мы контролируем

Inpainting

Inpainting — это генерация только внутри выбранной области, заданной маской. Внутри маски модель может перерисовать содержимое, снаружи — стремится сохранить исходник.

Типовые задачи:

исправить руки/глаза/лицо;

убрать надпись/логотип;

заменить один объект (например, “сделай чашку вместо стакана”).

Outpainting

Outpainting — частный случай inpainting, где маска покрывает область за пределами исходника (вы расширяете холст и дорисовываете пустые зоны).

Типовые задачи:

сделать кадр шире под баннер;

“отъехать камерой назад”, сохранив центр;

расширить фон без заметных швов.

Маска

Маска — это изображение (или матрица), которое разделяет:

где модель имеет право менять пиксели;

где нужно сохранить исходник.

Практически маска чаще всего интерпретируется так:

белое — перерисовывать;

чёрное — сохранять;

серое — мягкая зона перехода.

Важно: точная логика (белое/чёрное) может зависеть от конкретного узла/пакета узлов, поэтому всегда делайте быстрый тест на маленьком участке.

Регионы

Регионы — это приём, когда вы задаёте разные условия (conditioning) для разных областей изображения. Это помогает, когда один промпт “тянет одеяло” и мешает другой части кадра.

Примеры:

персонаж в одном стиле, фон в другом;

разные объекты в разных местах с разными приоритетами;

два персонажа с разными описаниями одежды.

Батчи

Батчи — это пакетные запуски, которые помогают:

быстро перебрать seed/параметры;

оценить устойчивость промпта/LoRA/ControlNet;

собрать набор кандидатов и уже потом делать точечные правки inpainting.

Inpainting в ComfyUI: стабильный “инженерный” паттерн

Ниже — логика, которая обычно работает предсказуемо. Названия узлов могут отличаться между сборками, но типы данных и смысл шагов одинаковы.

Какой минимум узлов нужен

| Шаг | Что делаем | Типичный смысл узла | Типы данных на вход/выход | |---|---|---|---| | Загрузка исходника | Берём картинку-основу | Load Image | выход: IMAGE | | Получение латента | Переводим изображение в LATENT | VAE Encode | вход: IMAGE+VAE, выход: LATENT | | Маска | Загружаем/рисуем маску | Load Mask или Image to Mask | выход: MASK | | Применение маски | Говорим, где можно менять | узел вида Set Latent Noise Mask | вход: LATENT+MASK, выход: LATENT | | Условие по тексту | Positive/Negative | CLIP Text Encode | выход: CONDITIONING | | Сэмплирование | Перерисовываем с denoise<1 | KSampler | вход: MODEL+CONDITIONING+LATENT, выход: LATENT | | Декод | Возврат в пиксели | VAE Decode | вход: LATENT+VAE, выход: IMAGE | | Сохранение | Пишем файл | Save Image | вход: IMAGE |

Ключевая идея: inpainting в ComfyUI почти всегда строится вокруг img2img-логики (мы стартуем не с пустого латента, а с латента, полученного из исходной картинки).

Главная ручка inpainting: denoise

Параметр denoise в KSampler определяет, насколько сильно модель “имеет право” переписать исходник.

Практические диапазоны:

0.15–0.35: точечная правка, высокий шанс сохранить лицо/позу/стиль.

0.35–0.6: более заметная замена внутри маски, риск “поплыть” выше.

0.6–0.9: уже похоже на “перерисуй почти заново в этой области”.

Если правка должна быть локальной, чаще выигрывает меньше denoise + аккуратная маска + точный промпт.

Как писать промпт для inpainting, чтобы не ломать исходник

Полезный принцип: описывайте только то, что меняете, а не переписывайте весь исходный промпт.

Пример:

Было: портрет, всё в целом хорошо, но нужно исправить руки.

Inpaint positive: natural hand, five fingers, correct anatomy, realistic skin texture

Inpaint negative: extra fingers, deformed hand, bad anatomy

Так вы снижаете конкуренцию между “пересобрать сцену целиком” и “исправить локальную деталь”.

Мягкие края маски

Жёсткая маска часто даёт “шов” на границе. Поэтому в практических пайплайнах почти всегда используют:

размытие края (feather/blur);

небольшое расширение или сжатие маски (grow/shrink).

Инженерный смысл:

blur делает переход “естественным”;

grow помогает заменить проблемную область полностью;

shrink помогает не задеть соседние детали.

Если у вас “ореол” вокруг правки, почти всегда проблема в границе маски, а не в промпте.

Частые сбои и быстрые исправления

Снаружи маски всё равно меняется

1. Проверьте, что вы применяете маску именно к LATENT (а не к IMAGE), и что это inpaint-маска, а не “просто картинка”. 2. Уменьшите denoise. 3. Зафиксируйте seed и сравните 2 прогона: с маской и без маски.

Внутри маски “не слушается” промпт

1. Увеличьте denoise в небольшом диапазоне. 2. Упростите positive до 1–2 ключевых требований. 3. Проверьте CFG: слишком высокий CFG в inpaint иногда даёт артефакты и “пережим”.

Шов по границе

1. Добавьте blur на маску. 2. Попробуйте небольшой grow маски. 3. Снизьте резкие стилевые слова в inpaint-промпте.

Outpainting: расширение холста без “коллажа”

Outpainting удобнее мыслить как трёхшаговый процесс:

Увеличить холст

1. Создайте новое изображение большего размера. 2. Поместите исходник на новый холст (центр/лево/право — по задаче).

Сделать маску на пустые области

1. Маска должна покрывать зоны, где “пусто” и нужно дорисовать. 2. Края рядом с исходником лучше делать с мягким переходом.

Сэмплировать как inpainting

1. Denoise обычно держат умеренным, чтобы продолжение было согласованным.

Практические советы:

Сначала добейтесь правильной геометрии outpainting (чтобы фон “продолжался”), и только потом добавляйте детали.

Если модель дорисовывает “новые объекты”, которых вы не хотите, сделайте промпт более описательным для фона: empty wall, plain background, continuous texture.

Для интерьеров/экстерьеров outpainting хорошо сочетается с ControlNet Depth из прошлой статьи: глубина помогает продолжить перспективу.

!Иллюстрация идеи outpainting: расширяем холст и дорисовываем только пустые зоны

Регионы: разные промпты для разных частей изображения

Когда один промпт не справляется, часто помогает разделить задачу на области.

Региональный промптинг через “область действия” conditioning

Во многих наборах узлов для ComfyUI есть идея: ограничить conditioning прямоугольной областью (по координатам или в процентах), а затем смешать несколько conditioning в одно.

Концептуально это выглядит так:

Вы делаете несколько positive-conditioning:

1. персонаж; 2. фон; 3. объект справа.

Каждому conditioning задаёте область действия.

Объединяете их.

Подаёте в KSampler.

Практические плюсы:

меньше конфликтов в одном тексте;

проще управлять “кто где находится” без жёсткого ControlNet;

удобно для постеров, сцен “персонаж + продукт”, двух персонажей.

Практические ограничения:

прямоугольные регионы не повторяют сложные формы;

при больших denoise/высокой вариативности регионы могут “перетекать” друг в друга.

Регионы через маски и inpainting как более жёсткий вариант

Если прямоугольников мало, или область сложной формы, часто проще сделать так:

Сгенерировать базовую композицию.

Дальше дорабатывать части кадра inpainting-ом разными промптами и разными масками.

Это медленнее, но обычно стабильнее и ближе к “контроль в продакшене”.

Как выбирать: регионы или ControlNet/IP-Adapter

| Задача | Что пробовать первым | Почему | |---|---|---| | “Два объекта в разных местах с разными описаниями” | Регионы | текстовый контроль по областям часто достаточно | | “Нужна точная поза/контур” | ControlNet | это структурная геометрия | | “Нужна похожесть на персонажа/стиль с картинки” | IP-Adapter | это перенос визуальных признаков | | “Нужно заменить только одну деталь” | Inpainting | локальная правка без пересборки |

Маски как универсальный язык контроля

Маска появляется не только в inpainting/outpainting. Это универсальная “ручка”, которой удобно управлять:

где усиливать эффект LoRA/стиля (через локальную перерисовку);

где делать дополнительную детализацию вторым проходом;

где менять материал/цвет, сохранив форму.

Практика рисования масок

Полезные правила:

Маска должна быть чуть больше проблемного места, чем “впритык”.

Граница почти всегда должна быть мягкой.

Если вам нужно сохранить мелкий контур (например, край губ), делайте shrink, а потом blur.

Батчи: как быстро находить варианты и проверять устойчивость

Батчи удобны, когда вы не уверены:

в промпте;

в весе LoRA;

в CFG/steps;

в том, “держится ли” ваша композиция.

Три практических режима батчинга

Batch size внутри одного запуска

1. Вы генерируете сразу несколько изображений за один прогон. 2. Это удобно для “сетки вариантов”, но требует больше VRAM.

Множественные seed через очередь

1. Вы запускаете один и тот же граф много раз, меняя seed. 2. Это часто экономнее по памяти и проще в контроле.

Батч параметров как эксперимент

1. Дублируете ветки KSampler с разными CFG/steps/sampler. 2. Сравниваете при фиксированном seed.

Главная дисциплина из прошлых статей сохраняется:

если сравниваете качество и соответствие промпту, фиксируйте seed;

если ищете идею и композицию, гоняйте много seed;

меняйте один фактор за раз, иначе выводы будут случайными.

Мини-процесс “от батча к финалу”

Батч на 8–16 seed в небольшом разрешении.

Выбор 1–2 кандидатов с хорошей композицией.

Полировка:

1. лёгкий upscale или двухпроходка; 2. точечный inpainting проблемных мест; 3. финальный outpainting, если нужен формат.

Такой пайплайн почти всегда быстрее, чем пытаться “сразу попасть в идеал” одним запуском.

Как это связано с custom nodes

Все приёмы из этой статьи повторяются блоками:

загрузка изображения и маски;

преобразование маски (grow/shrink/blur);

применение маски к латенту;

типовые наборы настроек denoise/CFG для inpainting;

шаблон outpainting с расширением холста;

региональные conditioning-блоки.

Когда вы начнёте делать собственные custom nodes, самый практичный путь — упаковать эти блоки в единый узел или мини-набор узлов, чтобы:

не ошибаться в типах портов;

меньше копировать одно и то же;

быстрее собирать стабильные production-графы.

Полезные источники

ComfyUI на GitHub

Stable Diffusion (Latent Diffusion Models) на arXiv

ControlNet на arXiv

IP-Adapter на arXiv

Custom nodes в ComfyUI: разработка, отладка и упаковка под продакшен

ComfyUI хорош тем, что любой пайплайн прозрачен: вы видите граф, типы данных и связи. Но по мере роста проектов появляется новая боль: одни и те же блоки приходится собирать снова и снова.

В прошлых статьях курса вы уже видели повторяющиеся паттерны:

базовый text-to-image граф;

двухпроходный upscale;

ControlNet/IP-Adapter ветки;

inpainting/outpainting с масками;

батчи для перебора seed.

Custom nodes — это способ упаковать такие паттерны в переиспользуемые строительные блоки, чтобы:

уменьшить количество ошибок соединения типов;

стандартизировать «правильные» параметры (например, inpaint denoise по умолчанию);

ускорить сборку продакшен-графов;

добавлять функции, которых нет в стандартных узлах.

!Зачем custom nodes: превращаем повторяющиеся куски графа в единые компоненты

Что такое custom node в терминах ComfyUI

Custom node в ComfyUI — это Python-код, который добавляет в интерфейс новые узлы. Каждый узел описывает:

какие входы он принимает (и их типы);

какие выходы он возвращает (и их типы);

какую функцию выполняет при запуске графа.

Важно связать это с тем, что вы уже знаете из курса:

в базовом пайплайне типы данных были ключом к пониманию графа (MODEL, CLIP, VAE, CONDITIONING, LATENT, IMAGE);

custom node — это просто узел, который честно объявляет эти типы на своих портах и выполняет действие.

Когда custom nodes действительно нужны

Custom nodes имеют смысл, когда вы упираетесь в повторяемость и стандартизацию.

Маркерные признаки, что пора упаковывать:

вы часто копируете один и тот же блок узлов в разные графы;

у команды «плавает» качество из-за разных дефолтов (CFG, steps, denoise, веса LoRA);

новички в проекте регулярно ошибаются в соединениях типов;

нужно сделать сервисный узел: сборка промпта, валидация параметров, автонейминг файлов, логирование метаданных.

Когда не стоит начинать с custom nodes:

вы ещё не стабилизировали процесс и не понимаете, какие блоки повторяются;

вы решаете задачу, которая уже закрыта распространённым пакетом узлов;

вы хотите «ускорить» генерацию без понимания, где реально узкое место.

Как ComfyUI подключает custom nodes

ComfyUI загружает пользовательские узлы из папки custom_nodes внутри директории ComfyUI.

Типовая структура пакета:

ComfyUI/

custom_nodes/

my_nodes/

__init__.py

nodes.py или несколько файлов с узлами

requirements.txt при необходимости внешних зависимостей

!Минимальная структура репозитория custom nodes

Ключевой момент: ComfyUI должен увидеть Python-модуль, в котором объявлены маппинги узлов.

Минимальная анатомия узла

Узел в ComfyUI обычно описывается Python-классом с несколькими обязательными элементами.

INPUT_TYPES: входы узла

INPUT_TYPES — это описание входных портов и параметров.

Порты с типами вроде MODEL, IMAGE, LATENT задают соединения между узлами.

Примитивные типы вроде INT, FLOAT, STRING, BOOLEAN обычно задаются как параметры в UI.

RETURN_TYPES и RETURN_NAMES: выходы узла

RETURN_TYPES — список типов на выходе.

RETURN_NAMES — человекочитаемые имена выходов.

FUNCTION: что запускать

FUNCTION указывает имя метода класса, который будет выполнен при запуске графа.

CATEGORY: где узел появится в меню

CATEGORY задаёт группу в поиске/меню узлов, чтобы ваш пакет не превращался в хаос.

Минимальный пример: узел-сборщик промпта

Задача из практики курса: мы постоянно собираем промпт из блоков (субъект, сцена, камера, свет, стиль, качество) и хотим стандартизировать формат.

Этот узел делает одну вещь: собирает строку промпта и отдаёт её как STRING, чтобы подключать к CLIP Text Encode.

Как это использовать в графе:

выход text узла Prompt Assembler подключаете к входу text узла CLIP Text Encode;

дальше всё как в базовом пайплайне из первой статьи: CLIP Text Encode → KSampler.

Это маленький узел, но он уже решает продакшен-проблему: единый формат промпта и меньше ручных ошибок.

Типы данных: как не сломать граф

В ComfyUI порты типизированы. Если тип не совпадает, соединение либо не даст сделать, либо граф упадёт при выполнении.

Практическая карта типов, с которыми вы чаще всего столкнётесь при разработке:

STRING, INT, FLOAT, BOOLEAN: параметры и текст.

MODEL, CLIP, VAE: «ресурсы выполнения» (из загрузчика checkpoint).

CONDITIONING: результат CLIP Text Encode и подобных узлов.

LATENT: то, что обрабатывает KSampler.

IMAGE: пиксельное изображение после VAE Decode.

MASK: маски для inpainting/outpainting и других локальных операций.

Инженерное правило из первых статей продолжает работать: думайте входами и выходами как типами данных.

Отладка custom nodes: что делать, когда «не работает»

Где смотреть ошибки

Ошибки custom nodes почти всегда видны в консоли, где запущен ComfyUI (терминал).

Порядок диагностики:

Узел не появился в списке.

Узел появился, но граф падает при запуске.

Узел запускается, но результат «странный».

Узел не появился

Частые причины:

код лежит не в custom_nodes;

в модуле нет NODE_CLASS_MAPPINGS;

Python-ошибка при импорте (опечатка, отсутствует зависимость);

вы не перезапустили ComfyUI после изменения файлов.

Минимальная проверка:

убедитесь, что файл импортируется без ошибок;

начните с одного узла и одного файла, а потом усложняйте.

Узел падает при запуске графа

Частые причины:

неправильная сигнатура метода (не совпадает с входами);

метод возвращает не то количество значений, что задано в RETURN_TYPES;

возвращается не тот тип (например, ожидается STRING, а возвращаете dict).

Полезная привычка: в первых версиях узла добавляйте простую проверку входов и аккуратные ошибки.

Узел работает, но результат «не тот»

Здесь действуют те же правила экспериментов, что в статьях про промптинг и контроль генерации:

фиксируйте seed и сравнивайте честно;

меняйте один фактор за раз;

делайте минимальный тест: вход → ваш узел → сохранение результата.

Если узел влияет на промпт, проверяйте это прямо:

временно отправьте результат узла в Save (Text)-аналог, если он есть в сборке;

или просто распечатайте строку в консоль через print(prompt).

Валидация и UX: как сделать узел удобным

Продакшен-узел отличается от «черновика» тем, что он защищает пользователя от ошибок.

Что обычно добавляют:

разумные значения по умолчанию;

ограничения диапазонов для INT и FLOAT;

понятные названия входов и выходов;

предсказуемую категорию CATEGORY.

Например, для числовых параметров часто задают диапазон:

Это не «косметика». Это снижает риск случайных значений, которые ломают качество (как слишком высокий CFG из статьи про контроль генерации).

Производительность: как не сделать узел «тормозом»

Custom nodes легко превратить в узкое место, если не следить за простыми вещами.

Практические правила:

избегайте лишних конверсий CPU↔GPU, если работаете с IMAGE или LATENT;

не делайте тяжёлые операции в Python-циклах по пикселям;

если используете внешние модели, грузите их один раз и переиспользуйте;

не добавляйте зависимости «на всякий случай».

Если ваш узел делает только строковую обработку (как PromptAssembler), он практически бесплатен.

Упаковка под продакшен: как превратить узел в продукт

Репозиторий и структура

Минимально полезный пакет custom nodes обычно включает:

код узлов;

README.md с установкой и примерами;

информацию о совместимости (какая версия ComfyUI тестировалась);

лицензию.

Зависимости

Если нужны зависимости, обычно кладут requirements.txt. В продакшене важно:

фиксировать версии зависимостей, чтобы завтра всё не сломалось;

избегать конфликтов с тем, что уже использует ComfyUI.

Версионирование

Практика, которая экономит часы:

используйте теги релизов в GitHub;

меняйте версию при изменении поведения узла или типов портов;

не ломайте старые графы без необходимости.

Документация и примеры

Сильный пакет узлов почти всегда содержит:

скриншот или краткое описание, что делает каждый узел;

пример графа (или хотя бы список: какие узлы подключить и куда);

рекомендации по параметрам по умолчанию.

Распространение и установка

Самый распространённый путь в экосистеме ComfyUI:

установка пакета как репозитория в custom_nodes;

управление установками через ComfyUI-Manager.

Ссылки:

ComfyUI на GitHub

ComfyUI-Manager на GitHub

Продакшен-эксплуатация: стабильность и безопасность

Custom nodes — это исполняемый код. В продакшене важно относиться к этому как к инженерному компоненту.

Рекомендации:

фиксируйте ревизии: используйте конкретные коммиты или теги, а не «последнюю версию»;

ведите список установленных пакетов узлов и их версий;

проверяйте источники: ставьте узлы только из доверенных репозиториев;

тестируйте на копии окружения перед обновлением.

Как связать custom nodes с темами курса

Custom nodes лучше всего проектировать как продолжение уже изученных паттернов:

из статьи про промптинг: узлы для сборки промпта, пресеты стилей, шаблоны negative;

из статьи про контроль генерации: узлы-пресеты параметров (steps/CFG/denoise) под разные режимы;

из статьи про композицию: упаковка повторяемых блоков ControlNet/IP-Adapter в один компонент;

из статьи про inpainting/outpainting: узел, который стандартизирует маску (blur/grow) и выставляет безопасный denoise.

Главная идея: сначала вы понимаете граф как инженер, потом упаковываете стабильные куски в компоненты.

Что дальше

После этой статьи вы готовы к практическому уровню: сделать собственный набор узлов под ваш рабочий процесс.

В домашних заданиях вы закрепите:

как устроен минимальный custom node;

как диагностировать проблемы загрузки и выполнения;

как думать о типах данных и совместимости;

какие требования важны для продакшен-упаковки.