Премини към основното съдържание
Български— Изберете език
Меню

Комбиниране на генерирането на изображения с други API инструменти

Урок 10 от 12 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Комбиниране на генерирането на изображения с други API инструменти
  2. Използване на езиков модел за написване на подканата
  3. Илюстриране на статия от начало до край
  4. Описване на изображение за различното му регенериране
  5. Обработка на големи обеми на партиди
  6. Директно публикуване в хранилище
  7. Какво поддържа една верига стабилна

Актуализация от 2 ноември 2026 г. — Модели за изображения. gpt-image-1, моделът, за който първоначално беше написан този курс, беше спрян на 23 октомври 2026 г.. gpt-image-1.5, gpt-image-1-mini и chatgpt-image-latest ще бъдат оттеглени на 1 декември 2026 г.. Примерите сега използват gpt-image-2.5-sunburst, който предлага най-висока прецизност при редактиране; gpt-image-2.5-flare е по-бърз за стандартно генериране. И двата модела поддържат и настройки за качество xhigh и max. Моделите GPT Image винаги връщат изображения в base64: параметърът response_format от по-старите модели на DALL·E не се поддържа и е премахнат от кода. Източник: Image generation (OpenAI).

Комбиниране на генерирането на изображения с други API инструменти

Като изолиран процес, генерирането на изображения е занаятчийски инструмент: пишете подкана (prompt) и получавате файл. Истинската му сила се разкрива, когато стане една стъпка в автоматизирана верига – езиков модел, който пише подканата, анализ на зрението, който описва референтно изображение, или хранилище, което публикува резултата. Този урок Ви показва как да свържете тези части заедно.

Използване на езиков модел за написване на подканата

Вашите потребители или колеги не пишат визуални подкани; те пишат задания (briefs). „Трябва ми изображение за статия за изкуствения интелект в здравеопазването, футуристично, но човешко“ не съдържа композиция, осветление или палитра. Вместо да ги карате да учат речника от предишния урок, включете езиков модел, който да се справи с превода. Възложете му ролята на арт директор в системното съобщение и изискайте то да произведе конкретните слоеве на подканата, със строги инструкции да не извежда нищо друго. В противен случай ще получите любезно обяснение, което след това ще трябва да изпратите на GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Двустъпков процес:
    1. LLM генерира оптималната визуална подкана
    2. GPT Image създава изображението
    """
    # Стъпка 1: Генериране на визуалната подкана с LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert art director. "
                    "Based on a brief, generate a detailed prompt for an "
                    "image generation model. Include: subject, composition, lighting, "
                    "style, perspective, color palette. "
                    "Respond only with the prompt, no explanation."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Generated prompt: {visual_prompt[:100]}...")

    # Стъпка 2: Генериране на изображението
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Image generated: {output}")
    return visual_prompt


prompt = text_to_image(
    "I need an image for an article on artificial intelligence "
    "in healthcare. Futuristic but human.",
    "ai_health.png"
)

Илюстриране на статия от начало до край

Една основна статия се нуждае от корица и по една илюстрация за всеки раздел. Тези изображения трябва да изглеждат сплотени, без да са идентични. Функцията illustrate_article прилага тази логика, като повторно въвежда стила във всяка подкана и повтаря заглавието на статията всеки път, осигурявайки тематично единство на целия набор. Два детайла за икономия на разходи заслужават внимание: корицата се генерира с качество high, защото всеки я вижда и често се споделя, докато илюстрациите на разделите остават на medium, тъй като се показват по-малки и по-ниско на страницата. За петте раздела в този пример за ИИ в набирането на персонал, този компромис намалява сметката, без читателят да забележи каквото и да е.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Генерира илюстрация за заглавката + по една за всеки раздел.
    """
    results = []

    # Изображение за корицата
    header_prompt = (
        f"Cover image for an article titled \"{title}\", "
        f"{style} style, panoramic composition, "
        "no text in the image, professional"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Header: {path}")

    # Илюстрации за разделите
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration for the section \"{section}\" "
            f"of an article on \"{title}\", "
            f"{style} style, rectangular format, "
            "conceptual illustration without text"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
        f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Section {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Ways AI Is Transforming Recruitment",
    sections=[
        "Automatic CV Screening",
        "AI-Analyzed Video Interviews",
        "Smart Candidate-Job Matching",
        "Reducing Recruitment Bias",
        "Personalized Onboarding",
    ],
    style="3D isometric illustration, blue and violet tones",
    output_dir="."
)

Описване на изображение за различното му регенериране

Как получавате зимна версия на летен пейзаж, когато разполагате само с файла, без маска и без инструменти за редактиране? Чрез езика. Зрението на модела анализира изображението и създава описание, достатъчно точно, за да послужи като подкана за реконструкция – обект, композиция, осветление, цветове, стил, перспектива, настроение. След това конкатенирате Вашата инструкция за модификация към това описание. Моделът за генериране получава пълна текстова подкана, в която е променен само сезонът, и получавате изображение, кохерентно с оригинала, а не нещо несвързано. Това е и най-надеждният начин за възпроизвеждане на визуалната идентичност на референтно изображение, което не можете да редактирате директно.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Анализира изображение с GPT Vision
    2. Генерира вариант въз основа на анализа
    """
    # Стъпка 1: Анализиране на изображението
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Describe this image in detail so an image "
                            "generation model can reproduce it faithfully. "
                            "Include: subject, composition, lighting, colors, style, "
                            "perspective, mood. Be very precise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Analysis: {description[:150]}...")

    # Стъпка 2: Генериране на модифициран вариант
    variant_prompt = f"{description}. Requested modification: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Variant generated: {output}")


analyze_and_vary(
    "original_landscape.png",
    "Change the season from summer to winter, with snow on roofs and trees",
    "winter_landscape.png"
)

Обработка на големи обеми на партиди

Генерирането на пет визуализации на продукти последователно отнема минути; генерирането на петстотин последователно отнема цяла нощ и се прекъсва при първия мрежов проблем. Настройката по-долу решава и двата проблема. Всяка задача е самодостатъчен речник, носещ своя ID, подкана, изходен файл и настройки. Функцията worker обгръща извикването в блок try, който връща статус вместо да срива цялата партида: отхвърлено генериране вече не сваля другите четиристотин деветдесет и девет. ThreadPoolExecutor след това паралелизира изпълнението, но с умишлено нисък max_workers – три в този пример – защото тясното място не е Вашата машина, а API квотите. Крайният отчет брои успехите и грешките, за да знаете какво да повторите.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Генерира едно изображение от задача."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Изпълнява партида от генерирания с контролиран паралелизъм."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Отчет
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")

    return results


# Дефиниране на партида от задачи
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-commerce product photo: {product}, white background, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rose gold watch",
        "aviator sunglasses",
        "braided leather bracelet",
        "solitaire diamond ring",
        "cultured pearl necklace",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Директно публикуване в хранилище

Записването на PNG файла на диска на машината, която изпълнява скрипта, има смисъл само при разработка. В производствена среда изображението трябва да попадне там, откъдето Вашият сайт ще го извлече, а отклонението през локалната файлова система се превръща в ненужна точка на отказ. Форматът b64_json подхожда добре за това премахване: декодираните байтове се обгръщат в обект BytesIO и се изпращат директно в кофата (bucket), с изричен ContentType – без който браузърите биха предложили изтегляне вместо показване на изображението. Функцията връща публичния URL, от който всъщност се нуждае Вашата CMS.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Генерира изображение и го качва директно в S3."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    image_data = base64.b64decode(response.data[0].b64_json)

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Image stored on S3: {url}")
    return url


# Пример
url = generate_and_store_s3(
    "Mobile app icon: open book with stars, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

Какво поддържа една верига стабилна

Петте вериги в този урок споделят една и съща хигиена на изграждане. Всяка стъпка прави едно нещо, което Ви позволява да замените писането на подкани или съхранението, без да пипате останалото. Всяка стъпка обработва собствените си грешки; в противен случай отказ от модериране по средата на партида срива цялата верига – точно това предотвратява try блокът в generate_one_image. Паралелизмът остава ограничен, за да се спазват лимитите на честотата, и в това отношение предпазливостта струва по-малко от възстановяването след временно блокиране.

Остават два по-малко видими, но еднакво решаващи навика. Регистрирайте действително изпратените подкани, особено когато са написани от езиков модел: без този дневник едно изображение, което харесвате, става невъзпроизводимо при второто изпълнение. И кешувайте резултатите, когато една и съща подкана може да се върне, което следващият урок формализира в пълна система.

Сега сглобете собствената си пълна верига: тя приема заглавие на статия като вход, иска от езиков модел три описания на подходящи визуализации, генерира трите изображения паралелно и произвежда обобщаващ JSON, свързващ всяка подкана с нейния файл. След това ще разполагате с всичко необходимо, за да илюстрирате цял блог без намеса на човек.