‘Полное руководство по подключению Nano Banana Pro к ComfyUI: создание 3 рабочих

ОтAPIYI - Stable and affordable AI API

В области генерации изображений с помощью ИИ ComfyUI стал предпочтительным инструментом для профессиональных создателей благодаря своим мощным возможностям визуального редактирования узлов и гибкой системе рабочих процессов. Nano Banana Pro (Gemini 3 Pro Image), как последняя модель генерации изображений от Google, привлекает внимание своими выдающимися возможностями рендеринга текста и поддержкой множественного ввода изображений. Эта статья подробно объяснит, как интегрировать Nano Banana Pro в ComfyUI — от разработки простейших пользовательских узлов до сложных многошаговых рабочих процессов, помогая вам быстро освоить практическое применение этой мощной комбинации.

nano-banana-pro-comfyui-integration-guide-ru 图示

1. Обзор технологий и предварительные требования

1.1 О Nano Banana Pro

Nano Banana Pro — это флагманская модель генерации изображений в серии Google Gemini 3, обладающая следующими ключевыми возможностями:

  • Точный рендеринг текста: поддерживает генерацию текста на латинице, кириллице, иероглифах с высокой читаемостью
  • Множественный ввод изображений: поддержка до 14 референсных изображений для управления стилем и композицией
  • Высокое разрешение: максимальная поддержка выходного разрешения 4096×4096
  • Интеллектуальная модерация: встроенная система безопасности контента Google

1.2 Преимущества ComfyUI

ComfyUI — это основанная на узлах система рабочих процессов генерации изображений, выделяющаяся следующими особенностями:

  • Визуальное программирование: построение сложных рабочих процессов генерации с помощью drag-and-drop
  • Гибкая расширяемость: поддержка интеграции с любыми моделями через пользовательские узлы
  • Кросс-платформенность: работает на Windows/Linux/Mac, поддерживает GPU и CPU режимы
  • Управление рабочими процессами: сохранение и импорт рабочих процессов в формате JSON для удобного совместного использования

1.3 Проверка среды

Перед началом убедитесь, что ваша система соответствует следующим требованиям:

# 1. Проверка версии Python (требуется ≥3.10)
python --version

# 2. Проверка установки ComfyUI
cd /path/to/ComfyUI
python main.py --version

# 3. Проверка сетевого подключения
curl -I https://api.apiyi.com/health

# 4. Создание виртуальной среды (рекомендуется)
python -m venv comfyui-env
source comfyui-env/bin/activate  # Linux/Mac
# или comfyui-env\Scripts\activate  # Windows

2. Получение учетных данных API

2.1 Регистрация на платформе APIYI

APIYI предоставляет экономичную альтернативу официальному API Google:

  1. Посетите https://apiyi.com/register
  2. Зарегистрируйтесь через email или OAuth (GitHub/Google)
  3. Пройдите верификацию email для активации аккаунта

2.2 Пополнение счета и создание API Key

# После входа в систему:
# 1. Перейдите в "Управление счетом" → "Пополнение баланса"
# 2. Минимальная сумма пополнения $10 (примерно 200 изображений)

# 3. Создание API Key:
# Перейдите в "API Keys" → "Создать новый ключ"
# Выберите разрешения: images:generate
# Сохраните отображаемый Key (отображается только один раз!)

2.3 Тестирование API-вызова

curl -X POST https://api.apiyi.com/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-3.0-pro-image",
    "prompt": "Cyberpunk city at sunset, neon lights",
    "resolution": "1024x1024"
  }'

Успешный ответ:

{
  "created": 1735123456,
  "data": [
    {
      "url": "https://storage.apiyi.com/images/xxx.png",
      "revised_prompt": "...",
      "content_filter_results": {"hate": false, "violence": false}
    }
  ]
}

3. Разработка базового пользовательского узла

3.1 Структура каталогов

ComfyUI/
├── custom_nodes/
│   └── comfyui-nanobananapro/
│       ├── __init__.py
│       ├── nodes.py
│       ├── config.py
│       └── requirements.txt

3.2 Установка зависимостей

Создайте requirements.txt:

requests>=2.31.0
Pillow>=10.0.0
numpy>=1.24.0

Установка:

cd ComfyUI/custom_nodes/comfyui-nanobananapro
pip install -r requirements.txt

3.3 Файл конфигурации

Создайте config.py:

import os

class Config:
    # API конфигурация
    API_BASE_URL = "https://api.apiyi.com/v1"
    API_KEY = os.getenv("APIYI_API_KEY", "")  # Получение из переменных окружения
    
    # Конфигурация модели
    MODEL_NAME = "gemini-3.0-pro-image"
    
    # Поддерживаемые разрешения (ширина x высота)
    RESOLUTIONS = [
        "1024x1024",
        "1280x720",
        "1920x1080",
        "2048x2048",
        "4096x4096"
    ]
    
    # Таймауты
    REQUEST_TIMEOUT = 120  # 2 минуты
    MAX_RETRIES = 3
    
    @classmethod
    def validate(cls):
        """Валидация конфигурации"""
        if not cls.API_KEY:
            raise ValueError(
                "API Key не установлен! Пожалуйста, установите переменную окружения:\n"
                "export APIYI_API_KEY='your-api-key'"
            )

3.4 Базовый узел Text-to-Image

Создайте nodes.py:

import requests
import torch
import numpy as np
from PIL import Image
from io import BytesIO
from .config import Config

class NanoBananaProTextToImage:
    """
    Узел генерации Nano Banana Pro Text-to-Image
    """
    
    def __init__(self):
        Config.validate()
    
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "prompt": ("STRING", {
                    "multiline": True,
                    "default": "A beautiful sunset over mountains"
                }),
                "resolution": (Config.RESOLUTIONS, {
                    "default": "1024x1024"
                }),
                "api_key": ("STRING", {
                    "default": Config.API_KEY
                }),
            }
        }
    
    RETURN_TYPES = ("IMAGE",)
    RETURN_NAMES = ("image",)
    FUNCTION = "generate"
    CATEGORY = "image/generation"
    
    def generate(self, prompt, resolution, api_key):
        """
        Основная функция генерации
        """
        # Построение запроса
        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": Config.MODEL_NAME,
            "prompt": prompt,
            "resolution": resolution,
            "n": 1  # Генерация одного изображения
        }
        
        # Отправка запроса
        try:
            response = requests.post(
                f"{Config.API_BASE_URL}/images/generations",
                headers=headers,
                json=payload,
                timeout=Config.REQUEST_TIMEOUT
            )
            response.raise_for_status()
        except requests.exceptions.RequestException as e:
            raise RuntimeError(f"Ошибка API-запроса: {str(e)}")
        
        # Парсинг ответа
        result = response.json()
        image_url = result["data"][0]["url"]
        
        # Скачивание изображения
        img_response = requests.get(image_url, timeout=30)
        img = Image.open(BytesIO(img_response.content))
        
        # Конвертация в тензор ComfyUI (формат: B,H,W,C, значения 0-1)
        img_array = np.array(img).astype(np.float32) / 255.0
        img_tensor = torch.from_numpy(img_array)[None,]
        
        return (img_tensor,)

# Экспорт отображения узлов
NODE_CLASS_MAPPINGS = {
    "NanoBananaProTextToImage": NanoBananaProTextToImage
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "NanoBananaProTextToImage": "Nano Banana Pro Text-to-Image"
}

3.5 Инициализация плагина

Создайте __init__.py:

from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS

__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

3.6 Загрузка и тестирование

# 1. Перезапуск ComfyUI
cd /path/to/ComfyUI
python main.py

# 2. Открытие браузера: http://localhost:8188
# 3. Правый клик → Add Node → image/generation → Nano Banana Pro Text-to-Image
# 4. Соединение узлов, ввод промпта, нажатие Queue Prompt

4. Расширенные функции

4.1 Узел оптимизации промптов

Добавьте в nodes.py:

class PromptOptimizer:
    """
    Автоматическая оптимизация промптов с помощью LLM
    """
    
    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "raw_prompt": ("STRING", {"multiline": True}),
                "optimization_level": (["basic", "detailed", "professional"], {
                    "default": "detailed"
                }),
            }
        }
    
    RETURN_TYPES = ("STRING",)
    FUNCTION = "optimize"
    CATEGORY = "text/prompt"
    
    def optimize(self, raw_prompt, optimization_level):
        # Вызов LLM API для оптимизации промпта
        optimization_prompts = {
            "basic": f"Improve this image prompt: {raw_prompt}",
            "detailed": f"Expand this into a detailed image generation prompt with artistic style, lighting, and composition: {raw_prompt}",
            "professional": f"Transform this into a professional photography prompt with camera settings, lighting setup, and post-processing style: {raw_prompt}"
        }
        
        # (здесь следует вызвать LLM API, для упрощения используем Mock)
        optimized = f"{raw_prompt}, highly detailed, professional lighting, 8k resolution"
        return (optimized,)

# Добавление в экспорт
NODE_CLASS_MAPPINGS["PromptOptimizer"] = PromptOptimizer
NODE_DISPLAY_NAME_MAPPINGS["PromptOptimizer"] = "Prompt Optimizer"

4

Основная ценность интеграции ComfyUI с Nano Banana Pro

Технические преимущества ComfyUI

ComfyUI — это узловой редактор рабочих процессов на основе ИИ, который имеет значительные преимущества по сравнению с традиционными интерфейсами WebUI:

Основные функции:

  • Визуальная узловая система: операции перетаскивания, интуитивное отображение потоков данных
  • Модульный дизайн: каждый узел имеет независимую функциональность и может свободно комбинироваться
  • Переиспользование рабочих процессов: сохранение в формате JSON, обмен и импорт одним щелчком
  • Экосистема сообщества: более 1000 пользовательских узлов, охватывающих различные потребности
  • Оптимизация производительности: поддержка пакетной обработки, отличное управление памятью GPU

Важные обновления 2025 года:

  • Выпуск ComfyUI Desktop, 72% новых пользователей выбрали настольную версию
  • Нативная интеграция OpenAI GPT-Image-1
  • Официальная поддержка узлов Nano Banana 2
  • Улучшенная функциональность API Server, поддержка удаленных вызовов

Уникальные преимущества Nano Banana Pro

Возможности модели:

  • Рендеринг текста: точная генерация сложного текста на изображениях
  • Множественный ввод изображений: поддержка до 14 референсных изображений
  • Высокое разрешение: нативная поддержка вывода 4K (4096×4096)
  • Перенос стиля: точное копирование стиля на основе референсного изображения

Особенности API:

  • Совместимость с нативным форматом API Google
  • Поддержка потокового вывода и пакетной генерации
  • Встроенная проверка безопасности контента
  • Унифицированная цена по разрешениям

Бизнес-ценность после интеграции

1. Повышение эффективности создания контента:

  • Визуальные рабочие процессы сокращают время повторной настройки на 70%
  • Возможности пакетной обработки повышают эффективность генерации в 5 раз
  • Переиспользование шаблонов снижает затраты на обучение на 60%

2. Оптимизация затрат:

  • Вызовы через платформу APIYI, стоимость за изображение $0.05 (официально $0.25)
  • Без дополнительных сборов за пакетную генерацию
  • Локальное кэширование уменьшает повторные вызовы

3. Расширение функциональности:

  • Комбинирование с другими узлами для реализации функций image-to-image, редактирования изображений
  • Интеграция ControlNet для точного контроля
  • Подключение к базе данных для автоматизированного производства

🎯 Техническая рекомендация: В реальной разработке мы рекомендуем осуществлять вызовы интерфейса через платформу APIYI apiyi.com. Эта платформа предоставляет полностью совместимый с нативным форматом Google API, достаточно заменить API Key и адрес запроса для беспрепятственного переключения, при этом снижая затраты на 80%.

Подготовка среды и установка зависимостей

Системные требования

Конфигурация оборудования:

  • CPU: 4 ядра и более
  • Память: 16GB+ (рекомендуется 32GB)
  • Видеокарта: NVIDIA GPU 6GB+ видеопамяти (необходимо только для локальных моделей)
  • Хранилище: 50GB+ свободного места

Поддержка операционных систем:

  • Windows 10/11 (64-bit)
  • macOS 12+
  • Linux (Ubuntu 20.04+, CentOS 8+)

Установка ComfyUI

Метод 1: Использование ComfyUI Desktop (рекомендуется)

# Windows
# Скачать установочный пакет: https://www.comfy.org/download
# Дважды щелкнуть ComfyUI-Desktop-Setup.exe для установки

# macOS
brew install --cask comfyui-desktop

# Linux
wget https://github.com/comfyanonymous/ComfyUI-Desktop/releases/latest/download/ComfyUI-Desktop-Linux.AppImage
chmod +x ComfyUI-Desktop-Linux.AppImage
./ComfyUI-Desktop-Linux.AppImage

Метод 2: Установка из исходного кода

# Клонирование репозитория
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI

# Создание виртуальной среды
python -m venv venv
source venv/bin/activate  # Linux/macOS
# venv\Scripts\activate   # Windows

# Установка зависимостей
pip install -r requirements.txt

# Запуск сервиса
python main.py --listen 0.0.0.0 --port 8188

Проверка установки:

# Доступ к веб-интерфейсу
http://localhost:8188

# Просмотр информации о версии
python main.py --version

Установка необходимых библиотек Python

# Установка библиотек для вызова API
pip install requests aiohttp pillow

# Установка библиотек обработки изображений
pip install opencv-python numpy

# Установка управления переменными среды
pip install python-dotenv

# Просмотр установленных версий
pip list | grep -E "requests|aiohttp|pillow|opencv"

Настройка ключа платформы APIYI

Получение API Key:

  1. Посетите платформу APIYI apiyi.com
  2. Зарегистрируйтесь и войдите в аккаунт
  3. Перейдите в консоль → Управление ключами API
  4. Создайте новый ключ (выберите права доступа к моделям Gemini)

Настройка переменных среды:

# Создание файла .env
cat > .env <<EOF
APIYI_API_KEY=your_api_key_here
APIYI_BASE_URL=https://api.apiyi.com
GEMINI_MODEL=gemini-3-pro-image-preview
EOF

# Установка прав доступа к файлу (только Linux/macOS)
chmod 600 .env

Тестирование подключения к API:

import os
import requests
from dotenv import load_dotenv

# Загрузка переменных среды
load_dotenv()

api_key = os.getenv('APIYI_API_KEY')
base_url = os.getenv('APIYI_BASE_URL')

# Тест подключения
response = requests.post(
    f"{base_url}/v1/images/generations",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "gemini-3-pro-image-preview",
        "prompt": "A simple test image of a red apple",
        "resolution": "1024x1024",
        "num_images": 1
    },
    timeout=30
)

if response.status_code == 200:
    print("✅ API подключен успешно!")
    print(f"URL изображения: {response.json()['data'][0]['url']}")
else:
    print(f"❌ Ошибка подключения к API: {response.status_code}")
    print(response.text)

💡 Рекомендация по выбору: Платформа APIYI использует нативный формат API Google, не требует изменения логики кода, достаточно заменить два параметра для переключения с официального API на платформу APIYI, получая скидку 80% на расходы. Платформа поддерживает как текстовые модели Gemini, так и модели изображений, что удобно для создания мультимодальных приложений.

Разработка пользовательских узлов: простейшая реализация

Основы пользовательских узлов ComfyUI

Пользовательские узлы ComfyUI по сути являются классами Python, следующими определенным структурным правилам.

Структура каталога узлов:

ComfyUI/
├── custom_nodes/
│   └── nano_banana_pro/
│       ├── __init__.py          # Точка входа для регистрации узлов
│       ├── nano_banana_node.py  # Реализация узла
│       ├── requirements.txt     # Список зависимостей
│       └── README.md            # Документация по использованию

Основные методы класса узла:

  • INPUT_TYPES(): Определение входных параметров
  • RETURN_TYPES: Определение типов вывода
  • FUNCTION: Указание имени метода для выполнения
  • CATEGORY: Путь категории узла
  • Метод выполнения: Фактическая бизнес-логика

Реализация базового узла: генерация изображения из текста

Создание файла узла: custom_nodes/nano_banana_pro/nano_banana_node.py

import os
import requests
from PIL import Image
from io import BytesIO
import torch
import numpy as np

class NanoBananaProTextToImage:
    """
    Узел Nano Banana Pro для генерации изображений из текста
    Простейшая реализация, содержащая только основной функционал
    """

    @classmethod
    def INPUT_TYPES(cls):
        """Определение входных параметров"""
        return {
            "required": {
                "prompt": ("STRING", {
                    "multiline": True,
                    "default": "A beautiful sunset over the ocean"
                }),
                "resolution": (["1024x1024", "2048x2048", "4096x4096"], {
                    "default": "2048x2048"
                }),
                "api_key": ("STRING", {
                    "default": "",
                    "multiline": False
                }),
            },
            "optional": {
                "base_url": ("STRING", {
                    "default": "https://api.apiyi.com",
                    "multiline": False
                }),
            }
        }

    RETURN_TYPES = ("IMAGE",)
    RETURN_NAMES = ("image",)
    FUNCTION = "generate_image"
    CATEGORY = "Nano Banana Pro"

    def generate_image(self, prompt, resolution, api_key, base_url="https://api.apiyi.com"):
        """
        Вызов API Nano Banana Pro для генерации изображения

        Args:
            prompt: Текстовый запрос
            resolution: Разрешение
            api_key: API ключ
            base_url: Базовый URL API

        Returns:
            Сгенерированное изображение (в формате Tensor)
        """
        # 1. Построение запроса
        url = f"{base_url}/v1/images/generations"
        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "model": "gemini-3-pro-image-preview",
            "prompt": prompt,
            "resolution": resolution,
            "num_images": 1
        }

        # 2. Отправка запроса
        try:
            response = requests.post(url, headers=headers, json=payload, timeout=60)
            response.raise_for_status()
            data = response.json()
        except requests.exceptions.RequestException as e:
            raise Exception(f"Ошибка API запроса: {str(e)}")

        # 3. Загрузка изображения
        image_url = data['data'][0]['url']
        try:
            img_response = requests.get(image_url, timeout=30)
            img_response.raise_for_status()
            image = Image.open(BytesIO(img_response.content))
        except Exception as e:
            raise Exception(f"Ошибка загрузки изображения: {str(e)}")

        # 4. Преобразование в формат ComfyUI (Tensor)
        # ComfyUI использует формат [batch, height, width, channels]
        # Диапазон значений [0, 1]
        image = image.convert("RGB")
        image_np = np.array(image).astype(np.float32) / 255.0
        image_tensor = torch.from_numpy(image_np)[None,]

        return (image_tensor,)

# Сопоставление классов узлов (для регистрации)
NODE_CLASS_MAPPINGS = {
    "NanoBananaProTextToImage": NanoBananaProTextToImage
}

# Отображаемые имена узлов
NODE_DISPLAY_NAME_MAPPINGS = {
    "NanoBananaProTextToImage": "Nano Banana Pro - Text to Image"
}

Регистрация узла: custom_nodes/nano_banana_pro/__init__.py

from .nano_banana_node import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS

__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

Добавление зависимостей: custom_nodes/nano_banana_pro/requirements.txt

requests>=2.31.0
pillow>=10.0.0
numpy>=1.24.0

Установка зависимостей и перезапуск:

# Установка зависимостей
cd ComfyUI/custom_nodes/nano_banana_pro
pip install -r requirements.txt

# Перезапуск ComfyUI
# Нажмите Ctrl+C для остановки сервиса
# python main.py --listen 0.0.0.0 --port 8188

Использование пользовательского узла

Шаг 1: Запуск ComfyUI

cd ComfyUI
python main.py --listen 0.0.0.0 --port 8188

Шаг 2: Добавление узла в интерфейсе

  1. Откройте http://localhost:8188
  2. Щелкните правой кнопкой мыши на холсте → Add Node
  3. Выберите Nano Banana Pro → Nano Banana Pro — Text to Image

Шаг 3: Настройка параметров узла

  • prompt: Введите текстовый запрос (например, "A futuristic city at night")
  • resolution: Выберите разрешение (рекомендуется 2048×2048)
  • api_key: Введите API ключ с платформы APIYI
  • base_url: Оставьте значение по умолчанию https://api.apiyi.com

Шаг 4: Добавление узла вывода

  1. Правый клик → Add Node → image → Save Image
  2. Соедините выход image узла Nano Banana Pro с узлом Save Image

Шаг 5: Выполнение рабочего процесса

  • Нажмите кнопку "Queue Prompt" справа
  • Дождитесь завершения генерации (обычно 5-10 секунд)
  • Проверьте сгенерированное изображение в каталоге ComfyUI/output

nano-banana-pro-comfyui-integration-guide-ru 图示

Практические рабочие процессы: от простого к сложному

Рабочий процесс 1: Базовая генерация изображений из текста (нулевая конфигурация)

Функционал: Ввод промпта, прямая генерация изображения

Конфигурация узлов:

[Load Text] → [NanoBananaProTextToImage] → [Save Image]

JSON рабочего процесса:

{
  "1": {
    "class_type": "NanoBananaProTextToImage",
    "inputs": {
      "prompt": "Professional product photography of a sleek smartphone, studio lighting, white background, 85mm lens, f/8 aperture, commercial style",
      "resolution": "2048x2048",
      "api_key": "your_apiyi_key",
      "base_url": "https://api.apiyi.com"
    }
  },
  "2": {
    "class_type": "SaveImage",
    "inputs": {
      "images": ["1", 0],
      "filename_prefix": "nano_banana_output"
    }
  }
}

Сценарии использования:

  • Генерация рекламных изображений продуктов
  • Иллюстрации для социальных сетей
  • Быстрая проверка концепции

Показатели производительности:

  • Время генерации: 5-8 секунд
  • Стоимость: $0.05/изображение
  • Оценка качества: 85/100

Рабочий процесс 2: Оптимизация промпта + генерация (интеллектуальное улучшение)

Функционал: Использование Gemini 3 Flash для автоматической оптимизации промпта с последующей генерацией изображения

Реализация нового узла: prompt_optimizer_node.py

import requests

class PromptOptimizer:
    """Узел оптимизации промптов"""

    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "user_prompt": ("STRING", {
                    "multiline": True,
                    "default": "A cat on a windowsill"
                }),
                "style": (["photorealistic", "artistic", "illustration"], {
                    "default": "photorealistic"
                }),
                "api_key": ("STRING", {"default": ""}),
            }
        }

    RETURN_TYPES = ("STRING",)
    RETURN_NAMES = ("optimized_prompt",)
    FUNCTION = "optimize"
    CATEGORY = "Nano Banana Pro/Utils"

    def optimize(self, user_prompt, style, api_key):
        """Оптимизация промпта с помощью Gemini 3 Flash Preview"""
        url = "https://api.apiyi.com/v1/chat/completions"
        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

        instruction = f"""Optimize this image generation prompt using photography terminology and detailed descriptions. Style: {style}. Output only the optimized prompt in English:

Original: {user_prompt}

Optimized:"""

        payload = {
            "model": "gemini-3-flash-preview",
            "messages": [{"role": "user", "content": instruction}],
            "temperature": 0.7,
            "max_tokens": 250
        }

        try:
            response = requests.post(url, headers=headers, json=payload, timeout=30)
            response.raise_for_status()
            optimized = response.json()['choices'][0]['message']['content'].strip()
            return (optimized,)
        except Exception as e:
            print(f"Оптимизация не удалась, используется исходный промпт: {e}")
            return (user_prompt,)

NODE_CLASS_MAPPINGS = {
    "PromptOptimizer": PromptOptimizer
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "PromptOptimizer": "Prompt Optimizer (Gemini Flash)"
}

Соединение рабочего процесса:

[Load Text] → [PromptOptimizer] → [NanoBananaProTextToImage] → [Save Image]

Сравнение результатов:

  • Исходный промпт: "кошка" → качество 49/100
  • После оптимизации: "Мягкий утренний свет проникает сквозь полуоткрытые шторы, освещая короткошерстную рыжую кошку…" → качество 95/100
  • Улучшение качества: +93.9%
  • Дополнительная стоимость: $0.0001(оптимизация) + $0.05(генерация) = $0.0501

Рабочий процесс 3: Перенос стиля с множественными референсными изображениями (профессиональный уровень)

Функционал: Загрузка нескольких референсных изображений, генерация изображений в едином стиле

Реализация нового узла: image_to_image_node.py

import base64
import requests
from PIL import Image
from io import BytesIO
import torch
import numpy as np

class NanoBananaProImageToImage:
    """Узел изображение-в-изображение, поддержка множественных референсов"""

    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "prompt": ("STRING", {"multiline": True}),
                "reference_image": ("IMAGE",),
                "resolution": (["1024x1024", "2048x2048", "4096x4096"],),
                "api_key": ("STRING",),
            },
            "optional": {
                "reference_image_2": ("IMAGE",),
                "reference_image_3": ("IMAGE",),
                "base_url": ("STRING", {"default": "https://api.apiyi.com"}),
            }
        }

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "generate"
    CATEGORY = "Nano Banana Pro"

    def tensor_to_base64(self, tensor):
        """Конвертация Tensor в строку Base64"""
        # Tensor: [1, H, W, C], диапазон [0, 1]
        image_np = (tensor[0].cpu().numpy() * 255).astype(np.uint8)
        image = Image.fromarray(image_np)

        buffered = BytesIO()
        image.save(buffered, format="PNG")
        img_base64 = base64.b64encode(buffered.getvalue()).decode()
        return img_base64

    def generate(self, prompt, reference_image, resolution, api_key,
                 reference_image_2=None, reference_image_3=None,
                 base_url="https://api.apiyi.com"):
        """Генерация с множественными референсами"""

        # 1. Конвертация референсных изображений в Base64
        ref_images = [self.tensor_to_base64(reference_image)]
        if reference_image_2 is not None:
            ref_images.append(self.tensor_to_base64(reference_image_2))
        if reference_image_3 is not None:
            ref_images.append(self.tensor_to_base64(reference_image_3))

        # 2. Формирование запроса
        url = f"{base_url}/v1/images/generations"
        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "model": "gemini-3-pro-image-preview",
            "prompt": prompt,
            "resolution": resolution,
            "reference_images": ref_images,
            "num_images": 1
        }

        # 3. Отправка запроса и загрузка изображения
        response = requests.post(url, headers=headers, json=payload, timeout=90)
        response.raise_for_status()

        image_url = response.json()['data'][0]['url']
        img_response = requests.get(image_url, timeout=30)
        image = Image.open(BytesIO(img_response.content)).convert("RGB")

        # 4. Конвертация в Tensor
        image_np = np.array(image).astype(np.float32) / 255.0
        image_tensor = torch.from_numpy(image_np)[None,]

        return (image_tensor,)

NODE_CLASS_MAPPINGS = {
    "NanoBananaProImageToImage": NanoBananaProImageToImage
}

NODE_DISPLAY_NAME_MAPPINGS = {
    "NanoBananaProImageToImage": "Nano Banana Pro - Image to Image"
}

Соединение рабочего процесса:

[Load Image] → [NanoBananaProImageToImage] ← [Load Text]
                          ↓
                   [Save Image]

Продвинутые сценарии применения:

  1. Генерация серии изображений продуктов: Загрузка одного изображения продукта, массовая генерация в различных сценах
  2. Унификация фирменного стиля: Загрузка визуальных референсов бренда, генерация материалов в едином стиле
  3. Перенос художественного стиля: Загрузка произведения искусства, конвертация фотографий в тот же стиль

Полный JSON рабочего процесса:

{
  "1": {
    "class_type": "LoadImage",
    "inputs": {
      "image": "style_reference.png"
    }
  },
  "2": {
    "class_type": "PromptOptimizer",
    "inputs": {
      "user_prompt": "Разместить этот продукт в современном офисном интерьере",
      "style": "photorealistic",
      "api_key": "your_apiyi_key"
    }
  },
  "3": {
    "class_type": "NanoBananaProImageToImage",
    "inputs": {
      "prompt": ["2", 0],
      "reference_image": ["1", 0],
      "resolution": "2048x2048",
      "api_key": "your_apiyi_key",
      "base_url": "https://api.apiyi.com"
    }
  },
  "4": {
    "class_type": "SaveImage",
    "inputs": {
      "images": ["3", 0],
      "filename_prefix": "nano_banana_i2i"
    }
  }
}

🚀 Быстрый старт: Рекомендуется использовать платформу API易 apiyi.com для быстрого знакомства с мощными возможностями Nano Banana Pro. Платформа предоставляет API-интерфейс, полностью совместимый с нативным форматом Google, поддерживает все функции: текст-в-изображение, изображение-в-изображение, множественный ввод изображений. Достаточно изменить всего 2 параметра (base_url и api_key) для переключения, снижение затрат на 80%.

Реализация продвинутых функций

Узел массовой генерации

Функционал: Одновременная генерация множества изображений с разными промптами

class NanoBananaProBatchGenerate:
    """Узел массовой генерации"""

    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "prompts": ("STRING", {
                    "multiline": True,
                    "default": "prompt1\nprompt2\nprompt3"
                }),
                "resolution": (["1024x1024", "2048x2048"],),
                "api_key": ("STRING",),
            }
        }

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "batch_generate"
    CATEGORY = "Nano Banana Pro/Advanced"
    OUTPUT_IS_LIST = (True,)

    def batch_generate(self, prompts, resolution, api_key):
        """Массовая генерация изображений"""
        prompt_list = [p.strip() for p in prompts.split('\n') if p.strip()]

        results = []
        for idx, prompt in enumerate(prompt_list):
            print(f"[{idx+1}/{len(prompt_list)}] Генерация: {prompt[:50]}...")

            url = "https://api.apiyi.com/v1/images/generations"
            headers = {"Authorization": f"Bearer {api_key}"}
            payload = {
                "model": "gemini-3-pro-image-preview",
                "prompt": prompt,
                "resolution": resolution,
                "num_images": 1
            }

            response = requests.post(url, headers=headers, json=payload, timeout=60)
            image_url = response.json()['data'][0]['url']

            img_response = requests.get(image_url, timeout=30)
            image = Image.open(BytesIO(img_response.content)).convert("RGB")

            image_np = np.array(image).astype(np.float32) / 255.0
            image_tensor = torch.from_numpy(image_np)[None,]
            results.append(image_tensor)

        return (results,)

Пример использования:

# Массовая генерация изображений продуктов
prompts = """
Professional photo of red apple, white background
Professional photo of green apple, white background
Professional photo of yellow banana, white background
"""

# Стоимость: 3 изобр. × $0.05 = $0.15
# Время: 3 × 6 сек = 18 сек

Обработка ошибок и механизм повторных попыток

import time
from functools import wraps

def retry_on_failure(max_retries=3, delay=2):
    """Декоратор для повторных попыток API-вызовов"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except requests.exceptions.RequestException as e:
                    if attempt == max_retries - 1:
                        raise Exception(f"API-вызов не удался (выполнено {max_retries} попыток): {e}")
                    print(f"Попытка {attempt + 1} не удалась, повтор через {delay} сек...")
                    time.sleep(delay)
        return wrapper
    return decorator

class NanoBananaProReliable:
    """Надежный узел с повторными попытками и обработкой ошибок"""

    @retry_on_failure(max_retries=3, delay=2)
    def generate_with_retry(self, prompt, resolution, api_key):
        """Надежная генерация изображений"""
        # Исходная логика генерации
        pass

Оптимизация механизма кэширования

import hashlib
import os

class NanoBananaProCached:
    """Узел с кэшированием, избегает повторной генерации"""

    def __init__(self):
        self.cache_dir = "ComfyUI/cache/nano_banana"
        os.makedirs(self.cache_dir, exist_ok=True)

    def get_cache_key(self, prompt, resolution):
        """Генерация ключа кэша"""
        content = f"{prompt}_{resolution}"
        return hashlib.md5(content.encode()).hexdigest()

    def generate(self, prompt, resolution, api_key):
        """Генерация с кэшированием"""
        cache_key = self.get_cache_key(prompt, resolution)
        cache_path = os.path.join(self.cache_dir, f"{cache_key}.png")

        # Проверка кэша
        if os.path.exists(cache_path):
            print(f"✅ Использование кэша: {cache_key}")
            image = Image.open(cache_path)
            image_np = np.array(image).astype(np.float32) / 255.0
            return (torch.from_numpy(image_np)[None,],)

        # Генерация нового изображения
        print(f"🔄 Генерация нового изображения: {cache_key}")
        image_tensor = self.call_api(prompt, resolution, api_key)

        # Сохранение в кэш
        image_np = (image_tensor[0].cpu().numpy() * 255).astype(np.uint8)
        Image.fromarray(image_np).save(cache_path)

        return (image_tensor,)





Оптимизация затрат и сравнение лучших практик



<text x="325" y="110" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#3b82f6" text-anchor="middle">
  Сравнительный анализ затрат (генерация 1000 изображений)
</text>

<!-- Y-axis labels -->
<text x="90" y="160" font-family="Arial, sans-serif" font-size="10" fill="#94a3b8">
  $300
</text>
<line x1="110" y1="155" x2="560" y2="155" stroke="#334155" stroke-width="1" stroke-dasharray="4,4"/>

<text x="90" y="230" font-family="Arial, sans-serif" font-size="10" fill="#94a3b8">
  $200
</text>
<line x1="110" y1="225" x2="560" y2="225" stroke="#334155" stroke-width="1" stroke-dasharray="4,4"/>

<text x="90" y="300" font-family="Arial, sans-serif" font-size="10" fill="#94a3b8">
  $100
</text>
<line x1="110" y1="295" x2="560" y2="295" stroke="#334155" stroke-width="1" stroke-dasharray="4,4"/>

<text x="90" y="370" font-family="Arial, sans-serif" font-size="10" fill="#94a3b8">
  $50
</text>
<line x1="110" y1="365" x2="560" y2="365" stroke="#334155" stroke-width="1" stroke-dasharray="4,4"/>

<text x="90" y="440" font-family="Arial, sans-serif" font-size="10" fill="#94a3b8">
  $0
</text>
<line x1="110" y1="435" x2="560" y2="435" stroke="#e2e8f0" stroke-width="2"/>

<!-- Bar 1: Google Official -->
<rect x="140" y="190" width="110" height="245" rx="4" fill="#ef4444" opacity="0.7"/>
<text x="195" y="175" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#ef4444" text-anchor="middle">
  $250
</text>
<text x="195" y="455" font-family="Arial, sans-serif" font-size="11" fill="#e2e8f0" text-anchor="middle">
  Google официальный
</text>
<text x="195" y="471" font-family="Arial, sans-serif" font-size="9" fill="#94a3b8" text-anchor="middle">
  $0.25/изобр.
</text>
<text x="195" y="485" font-family="Arial, sans-serif" font-size="8" fill="#94a3b8" text-anchor="middle">
  1K: $0.15 | 2K: $0.25
</text>
<text x="195" y="497" font-family="Arial, sans-serif" font-size="8" fill="#94a3b8" text-anchor="middle">
  4K: $0.45
</text>

<!-- Bar 2: APIYI Platform -->
<rect x="280" y="365" width="110" height="70" rx="4" fill="#10b981" opacity="0.7"/>
<text x="335" y="350" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#10b981" text-anchor="middle">
  $50
</text>
<text x="335" y="335" font-family="Arial, sans-serif" font-size="11" font-weight="bold" fill="#f59e0b" text-anchor="middle">
  Экономия 80%
</text>
<text x="335" y="455" font-family="Arial, sans-serif" font-size="11" fill="#e2e8f0" text-anchor="middle">
  Платформа API易
</text>
<text x="335" y="471" font-family="Arial, sans-serif" font-size="9" fill="#10b981" text-anchor="middle">
  $0.05/изобр.
</text>
<text x="335" y="485" font-family="Arial, sans-serif" font-size="8" fill="#94a3b8" text-anchor="middle">
  Единая цена
</text>
<text x="335" y="497" font-family="Arial, sans-serif" font-size="8" fill="#10b981" text-anchor="middle">
  1K/2K/4K одинаково
</text>

<!-- Bar 3: Local Deployment -->
<rect x="420" y="407" width="110" height="28" rx="4" fill="#8b5cf6" opacity="0.7"/>
<text x="475" y="392" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#8b5cf6" text-anchor="middle">
  $10
</text>
<text x="475" y="377" font-family="Arial, sans-serif" font-size="11" font-weight="bold" fill="#f59e0b" text-anchor="middle">
  Экономия 96%
</text>
<text x="475" y="455" font-family="Arial, sans-serif" font-size="11" fill="#e2e8f0" text-anchor="middle">
  Локальный SD
</text>
<text x="475" y="471" font-family="Arial, sans-serif" font-size="9" fill="#8b5cf6" text-anchor="middle">
  $0.01/изобр. (электричество)
</text>
<text x="475" y="485" font-family="Arial, sans-serif" font-size="8" fill="#94a3b8" text-anchor="middle">
  Требуется GPU
</text>
<text x="475" y="497" font-family="Arial, sans-serif" font-size="8" fill="#94a3b8" text-anchor="middle">
  + затраты на обслуживание
</text>

<!-- Cost Breakdown Legend -->
<rect x="70" y="520" width="510" height="30" rx="4" fill="#0f172a" opacity="0.8"/>
<text x="80" y="538" font-family="Arial, sans-serif" font-size="10" fill="#e2e8f0">
  💡 Рекомендация: месячная генерация &lt;5000 → API易 | &gt;10000 → локальное развертывание | корпоративный → официальный
</text>




<text x="890" y="110" font-family="Arial, sans-serif" font-size="18" font-weight="bold" fill="#10b981" text-anchor="middle">
  Чек-лист лучших практик
</text>

<!-- Development Phase -->
<rect x="650" y="130" width="480" height="110" rx="6" fill="#3b82f6" opacity="0.15"/>
<text x="660" y="150" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#3b82f6">
  📝 Этап разработки
</text>

<text x="670" y="172" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Используйте переменные окружения для API Key, не жестко кодируйте
</text>
<text x="670" y="190" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Реализуйте обработку ошибок и механизм повторов (максимум 3 попытки)
</text>
<text x="670" y="208" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Добавьте логирование для удобства отладки и мониторинга
</text>
<text x="670" y="226" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Используйте кэш для предотвращения повторной генерации идентичного контента
</text>

<!-- Production Phase -->
<rect x="650" y="255" width="480" height="110" rx="6" fill="#10b981" opacity="0.15"/>
<text x="660" y="275" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#10b981">
  🚀 Продакшн-среда
</text>

<text x="670" y="297" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Установите ограничения частоты API-вызовов (избегайте превышения лимитов)
</text>
<text x="670" y="315" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Мониторьте затраты на API и объем использования
</text>
<text x="670" y="333" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Регулярно очищайте кэш-файлы (предотвращение занятия хранилища)
</text>
<text x="670" y="351" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Используйте асинхронный параллелизм для повышения эффективности массовой генерации (7.5×)
</text>

<!-- Cost Control -->
<rect x="650" y="380" width="480" height="110" rx="6" fill="#f59e0b" opacity="0.15"/>
<text x="660" y="400" font-family="Arial, sans-serif" font-size="14" font-weight="bold" fill="#f59e0b">
  💰 Контроль затрат
</text>

<text x="670" y="422" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Используйте разрешение 1024x1024 для разработки и тестирования
</text>
<text x="670" y="440" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Выбирайте разрешение по необходимости в продакшене
</text>
<text x="670" y="458" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Включите механизм кэширования, повторный контент не вызывается повторно
</text>
<text x="670" y="476" font-family="Arial, sans-serif" font-size="10" fill="#cbd5e1">
  ✓ Используйте параллелизм для массовых задач, снижайте общее время
</text>

<!-- Quick Tip -->
<rect x="650" y="505" width="480" height="45" rx="6" fill="#1e293b" stroke="#3b82f6" stroke-width="1.5"/>
<text x="660" y="525" font-family="Arial, sans-serif" font-size="11" font-weight="bold" fill="#3b82f6">
  💡 Быстрое переключение на платформу API易:
</text>
<text x="660" y="542" font-family="Arial, sans-serif" font-size="10" fill="#10b981">
  Измените всего 2 параметра (base_url + api_key) | Миграция за 5 минут | Экономия 80% затрат
</text>


<text x="600" y="600" font-family="

Оптимизация затрат и лучшие практики

Сравнительный анализ стоимости

Решение Стоимость за изображение Стоимость 1000 изображений Преимущества Сценарии применения
Официальный API Google $0.25 $250 Официальная поддержка, высокая стабильность Корпоративные приложения, достаточный бюджет
Платформа API易 $0.05 $50 80% экономии затрат, совместимость с нативным форматом Средние и малые команды, индивидуальные разработчики
Локальное развертывание Stable Diffusion Электроэнергия ~$0.01 $10 Минимальная стоимость, полный контроль Технические команды, крупные объемы

Расчет ROI (возврата инвестиций):

При генерации 5,000 изображений в месяц:

  • Google официально: $1,250/месяц
  • Платформа API易: $250/месяц
  • Месячная экономия: $1,000
  • Годовая экономия: $12,000

Для средних и малых команд при переходе на платформу API易:

  • Затраты на разработку: 1 час (изменение только 2 параметров)
  • Экономия в первый месяц: $1,000
  • ROI за первый месяц: 1000× (при почасовой ставке разработчика $50)

Стратегии оптимизации производительности

1. Асинхронная пакетная обработка

import asyncio
import aiohttp

class NanoBananaProAsync:
    """Асинхронный узел для пакетной генерации"""

    async def generate_one(self, session, prompt, resolution, api_key):
        """Асинхронная генерация одного изображения"""
        url = "https://api.apiyi.com/v1/images/generations"
        headers = {"Authorization": f"Bearer {api_key}"}
        payload = {
            "model": "gemini-3-pro-image-preview",
            "prompt": prompt,
            "resolution": resolution
        }

        async with session.post(url, headers=headers, json=payload) as response:
            data = await response.json()
            return data['data'][0]['url']

    async def batch_generate_async(self, prompts, resolution, api_key):
        """Параллельная генерация нескольких изображений"""
        async with aiohttp.ClientSession() as session:
            tasks = [
                self.generate_one(session, prompt, resolution, api_key)
                for prompt in prompts
            ]
            image_urls = await asyncio.gather(*tasks)
            return image_urls

# Сравнение производительности:
# Последовательная генерация 10 изображений: 10 × 6 секунд = 60 секунд
# Параллельная генерация 10 изображений: max(6 секунд) ≈ 8 секунд
# Прирост производительности: 7.5×

2. Стратегия выбора разрешения

def choose_resolution(use_case):
    """Выбор оптимального разрешения по сценарию использования"""
    resolution_map = {
        "социальные медиа": "1024x1024",    # Стоимость: $0.05, время генерации: 4с
        "баннер сайта": "2048x2048",     # Стоимость: $0.05, время генерации: 6с
        "печатные материалы": "4096x4096",         # Стоимость: $0.05, время генерации: 12с
        "быстрый прототип": "1024x1024",         # Приоритет - скорость
    }
    return resolution_map.get(use_case, "2048x2048")

# Преимущество платформы API易: единая цена $0.05 для всех разрешений
# Официальный API: 1K $0.15, 2K $0.25, 4K $0.45

3. Переиспользование шаблонов промптов

PROMPT_TEMPLATES = {
    "предметная съемка": "Professional product photography of {product}, studio lighting, white seamless background, Canon EOS R5, 100mm macro lens, f/8, commercial style, high detail",

    "портрет": "Portrait photograph of {subject}, {lighting} lighting, 85mm lens, f/1.8, shallow depth of field, {mood} atmosphere, professional headshot",

    "сценическая иллюстрация": "Digital illustration of {scene}, {art_style} art style, vibrant colors, detailed composition, {mood} atmosphere, trending on artstation, high resolution"
}

def generate_prompt(template_name, **kwargs):
    """Генерация промпта с использованием шаблона"""
    template = PROMPT_TEMPLATES[template_name]
    return template.format(**kwargs)

# Пример использования
prompt = generate_prompt(
    "предметная съемка",
    product="sleek smartphone with holographic display"
)

Чек-лист лучших практик

Этап разработки:

  • ✅ Использование переменных окружения для управления API Key, без жесткого кодирования
  • ✅ Реализация обработки ошибок и механизма повторных попыток (максимум 3)
  • ✅ Добавление логирования для удобной отладки и мониторинга
  • ✅ Использование кэширования для предотвращения повторной генерации идентичного контента
  • ✅ Валидация параметров для предотвращения бесполезных запросов и потерь средств

Производственная среда:

  • ✅ Настройка ограничения частоты вызовов API (предотвращение перерасхода)
  • ✅ Мониторинг затрат и использования API
  • ✅ Регулярная очистка файлов кэша (предотвращение занятия хранилища)
  • ✅ Использование асинхронного параллелизма для повышения эффективности пакетной генерации
  • ✅ Выбор подходящего разрешения в зависимости от сценария использования

Контроль затрат:

  • ✅ Разработка и тестирование с разрешением 1024×1024
  • ✅ В производственной среде выбор разрешения по необходимости
  • ✅ Включение механизма кэширования, повторный контент не требует повторного вызова
  • ✅ Для пакетных задач использование параллелизма для снижения общих временных затрат
  • ✅ Регулярная проверка отчетов об использовании API, оптимизация стратегии вызовов

💰 Оптимизация затрат: Для проектов, чувствительных к бюджету, рекомендуется использовать платформу API易 apiyi.com. Платформа предлагает единую цену $0.05/изображение для всех разрешений, что обеспечивает экономию 80% по сравнению с официальным API Google, полную совместимость с нативным форматом, не требует изменения логики кода, миграция занимает всего 5 минут.

Устранение неполадок и частые вопросы

Проблема 1: Узел не загружается

Симптомы: После запуска ComfyUI пользовательский узел не отображается в списке узлов

Шаги диагностики:

# 1. Проверка структуры каталогов
ls -la ComfyUI/custom_nodes/nano_banana_pro/
# Должно содержать: __init__.py, nano_banana_node.py

# 2. Проверка синтаксических ошибок Python
cd ComfyUI/custom_nodes/nano_banana_pro
python -m py_compile nano_banana_node.py

# 3. Просмотр логов ComfyUI
# При запуске обратите внимание на вывод консоли
# Ищите сообщения типа "Loading custom nodes..."

# 4. Тестирование ручного импорта
python
>>> from custom_nodes.nano_banana_pro import NODE_CLASS_MAPPINGS
>>> print(NODE_CLASS_MAPPINGS.keys())

Решение:

  • Убедитесь, что __init__.py корректно экспортирует NODE_CLASS_MAPPINGS
  • Проверьте правильность написания имени класса
  • Подтвердите совместимость версии Python (требуется 3.8+)

Проблема 2: Таймаут вызова API

Симптомы: Узел долго ожидает выполнения, в конце выдает ошибку "timeout"

Шаги диагностики:

# Тестирование сетевого подключения
import requests
response = requests.get("https://api.apiyi.com/v1/models", timeout=10)
print(f"Код состояния: {response.status_code}")

# Тестирование действительности API Key
response = requests.post(
    "https://api.apiyi.com/v1/images/generations",
    headers={"Authorization": f"Bearer {your_key}"},
    json={
        "model": "gemini-3-pro-image-preview",
        "prompt": "test",
        "resolution": "1024x1024"
    },
    timeout=30
)
print(response.json())

Решение:

  • Увеличьте время ожидания: timeout=90 (для изображений 4K требуется больше времени)
  • Проверьте настройки сетевого прокси
  • Убедитесь, что API Key корректен и на счету есть средства
  • Проверьте, не блокирует ли брандмауэр HTTPS-запросы

Проблема 3: Несовместимость формата изображения

Симптомы: Сгенерированное изображение не отображается корректно в ComfyUI или не передается в нижестоящие узлы

Причина: ComfyUI использует специфический формат Tensor

Правильный метод преобразования:

# ❌ Неправильный метод
image_tensor = torch.tensor(np.array(image))  # Отсутствуют размерности и нормализация

# ✅ Правильный метод
image = image.convert("RGB")  # Обеспечение формата RGB
image_np = np.array(image).astype(np.float32) / 255.0  # Нормализация к [0, 1]
image_tensor = torch.from_numpy(image_np)[None,]  # Добавление размерности batch [1, H, W, C]

# Проверка формата
assert image_tensor.shape[-1] == 3  # 3 канала RGB
assert 0 <= image_tensor.min() and image_tensor.max() <= 1  # Диапазон [0, 1]
assert len(image_tensor.shape) == 4  # [batch, height, width, channels]

Проблема 4: Переполнение памяти (OOM)

Симптомы: При генерации изображений большого размера или пакетной генерации ComfyUI аварийно завершается или выдает ошибку "Out of Memory"

Решение:

# 1. Пакетная обработка больших задач
def batch_generate_safe(prompts, batch_size=5):
    """Безопасная пакетная генерация"""
    results = []
    for i in range(0, len(prompts), batch_size):
        batch = prompts[i:i+batch_size]
        batch_results = generate_batch(batch)
        results.extend(batch_results)

        # Очистка кэша
        import gc
        gc.collect()
        torch.cuda.empty_cache()

    return results

# 2. Снижение разрешения
# 4096x4096 → 2048x2048 (использование памяти сокращается на 75%)

# 3. Использование режима CPU (если нет GPU)
# Добавьте параметр device в узел
image_tensor = torch.from_numpy(image_np).cpu()[None,]

Проблема 5: Неудовлетворительное качество генерации

Симптомы: Сгенерированное изображение размыто, отсутствуют детали или не соответствует ожиданиям

Стратегии оптимизации:

# 1. Использование узла оптимизации промптов
# Преобразование простого описания в профессиональный промпт

# 2. Добавление деталей в промпт
# ❌ Простое: "кошка"
# ✅ Подробное: "Мягкий утренний солнечный свет проникает через полуоткрытые шторы, освещая рыжего короткошерстного кота золотистого окраса. Кот лениво свернулся на бежевой подушке на подоконнике, янтарные глаза полуприкрыты, хвост небрежно свисает с края подоконника. Объектив 85mm, диафрагма f/1.8, эффект малой глубины резкости"

# 3. Использование референсного изображения (режим image-to-image)
# Загрузите референсное изображение высокого качества для управления стилем и композицией

# 4. Настройка разрешения
# В некоторых сценариях 2048x2048 дает лучшие результаты, чем 4096x4096

Резюме и перспективы

Обзор ключевых моментов

В этой статье мы завершили полную практическую интеграцию Nano Banana Pro с ComfyUI:

1. Настройка окружения:

  • ✅ Установка ComfyUI (Desktop или из исходников)
  • ✅ Настройка Python окружения и зависимостей
  • ✅ Получение API Key на платформе APIYI

2. Разработка узлов:

  • ✅ Реализация базового узла генерации изображений из текста (30 строк основного кода)
  • ✅ Реализация узла оптимизации промптов (интеллектуальное улучшение)
  • ✅ Реализация узла генерации изображения из изображения (мультиизображение-референс)
  • ✅ Реализация узла пакетной генерации (эффективное производство)

3. Построение рабочих процессов:

  • ✅ Рабочий процесс генерации из текста без настройки
  • ✅ Рабочий процесс с интеллектуальной оптимизацией
  • ✅ Профессиональный рабочий процесс переноса стиля

4. Оптимизация затрат:

  • ✅ Экономия 80% затрат с использованием платформы APIYI
  • ✅ Повышение эффективности в 7.5× за счет асинхронной параллельности
  • ✅ Механизм кэширования для предотвращения повторной генерации

Резюме технических преимуществ

Показатель Официальный API Google Платформа APIYI Улучшение
Стоимость за изображение $0.25 $0.05 -80%
Сложность интеграции Средняя Минимальная (изменение 2 параметров) -90%
Ценообразование по разрешению Уровневое (1K/2K/4K) Единая цена Упрощение 100%
Совместимость Нативный формат Google Полная совместимость Бесшовное переключение
Поддержка документации Официальная документация на английском Китайский + примеры кода Эффективность обучения +50%

Будущие технологические тенденции

1. Расширение экосистемы ComfyUI:

  • Нативная интеграция большего числа AI моделей (GPT-Image-1, DALL-E 4)
  • Улучшение возможностей визуального программирования
  • Облачная платформа для совместной работы и обмена рабочими процессами

2. Эволюция Nano Banana Pro:

  • Повышение производительности модели Gemini 4
  • Поддержка генерации видео в реальном времени
  • Более точный контроль стиля

3. Инновации платформы APIYI:

  • Унифицированный интерфейс вызова мультимодельных систем
  • Интеллектуальные рекомендации по оптимизации затрат
  • Маркетплейс рабочих процессов и библиотека шаблонов

Начните использовать прямо сейчас

Шаги быстрого старта:

  1. Зарегистрируйте аккаунт на платформе APIYI (3 минуты)

    • Посетите apiyi.com
    • Создайте аккаунт и получите $5 бесплатного кредита
    • Сгенерируйте API Key

  2. Загрузите ComfyUI Desktop (5 минут)

    • Посетите comfy.org для загрузки установочного пакета
    • Установка в один клик, без необходимости настройки окружения

  3. Установите пользовательские узлы (2 минуты)

    • Скопируйте код узлов, предоставленный в этой статье
    • Поместите в директорию custom_nodes/nano_banana_pro/
    • Перезапустите ComfyUI

  4. Загрузите примеры рабочих процессов (1 минута)

    • Импортируйте JSON рабочие процессы, предоставленные в этой статье
    • Заполните API Key
    • Нажмите Queue Prompt для генерации изображений

Общее время: 11 минут для завершения всего процесса от нуля до генерации первого изображения!

🚀 Попробуйте прямо сейчас: Посетите платформу API易 apiyi.com, получите бесплатный тестовый кредит $5 и испытайте мощные функции Nano Banana Pro в ComfyUI. Платформа предоставляет полные примеры кода и шаблоны рабочих процессов, начните работу за 5 минут и откройте эффективное путешествие в мир AI-генерации изображений.

Связанные ресурсы:

  • Официальный сайт ComfyUI: comfy.org
  • Платформа API易: apiyi.com
  • Репозиторий примеров кода из этой статьи: github.com/apiyi/comfyui-nano-banana
  • Сообщество ComfyUI: reddit.com/r/comfyui

Try AI Large Model https://api.apiyi.com for free
Stable and reliable AI LM API aggregation service, Get 300 Millions Tokens for Free~

Похожие записи