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

Оптимизиране на разходите

Урок 11 от 12 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Оптимизиране на разходите
  2. Разбиране на структурата на разходите
  3. Прототипиране в ниско качество, доставка във високо
  4. Никога не плащайте два пъти за едно и също изображение
  5. Оразмеряване с прецизност
  6. Редактиране вместо регенериране
  7. Знайте къде отиват парите
  8. Откъде да започнете

Обновено на 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).

Оптимизиране на разходите

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

Разбиране на структурата на разходите

Разходите за генериране зависят от три фактора.

ФакторВърху разходите
Качество (low, medium, high)Директен множител
Резолюция (1024, 1536)По-голяма = по-скъпо
Брой изображения (n)Линейни разходи (n × единична цена)

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

from openai import OpenAI

client = OpenAI()

# Compare costs: same prompt, different parameters
configs = [
    {"quality": "low", "size": "1024x1024", "label": "Low / 1024"},
    {"quality": "medium", "size": "1024x1024", "label": "Medium / 1024"},
    {"quality": "high", "size": "1024x1024", "label": "High / 1024"},
    {"quality": "medium", "size": "1536x1024", "label": "Medium / 1536"},
    {"quality": "high", "size": "1536x1024", "label": "High / 1536"},
]

print("Configuration         | Usage (estimated)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Check your OpenAI dashboard")

Прототипиране в ниско качество, доставка във високо

Това е далеч най-рентабилната стратегия и най-лесната за внедряване. По време на фазата на проучване Вие не оценявате финеса на градиент: Вие оценявате композицията, кадрирането и цялостното настроение, всички от които са перфектно видими при quality: low. Преминаването към high има смисъл само за изображението, което действително възнамерявате да публикувате. Работният поток по-долу формализира тази последователност, като произвежда пет икономични чернови, последвани от един единствен финален рендер, с допълнителното предимство на превключване към пейзажен формат (1536×1024) за окончателната версия. При пет опита и една доставка, спестяванията, цитирани в края на скрипта, са около 60% в сравнение с проучване, проведено изцяло в high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Two-phase workflow:
    1. Fast drafts in low quality
    2. Final render in high quality
    """
    # Phase 1: Fast exploration
    print("Phase 1: fast drafts (low quality)")
    drafts = []
    for i in range(n_drafts):
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="low",
        )

        path = f"draft_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        drafts.append(path)
        print(f"  Draft {i+1}: {path}")

    # Phase 2: Final render (after human selection of the best draft)
    print("\nPhase 2: final render (high quality)")
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1536x1024",
        quality="high",
    )

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

    # Summary: 5 low + 1 high instead of 5 high
    print(f"\nSummary: {n_drafts} low drafts + 1 final high")
    print("Estimated savings: ~60% compared to all-high exploration")


economical_workflow(
    "Illustration of a green tech campus with solar panels, architectural style",
    "campus_final.png"
)

Никога не плащайте два пъти за едно и също изображение

В реално приложение един и същ промпт се връща много по-често, отколкото бихте очаквали: потребител опреснява страницата, скрипт за изграждане преизпълнява генериране или икона се използва повторно в три страници. Всеки от тези случаи представлява ненужно таксуване. Кешът по-долу ги елиминира, като изчислява SHA-256 хеш на тройката (промпт, размер, качество) — трите елемента, които определят фактурирания резултат — и съкращава този хеш до шестнадесет знака, за да създаде управляемо име на файл. Обърнете внимание на проверката os.path.exists: индексът може да знае за запис, чийто файл е бил изтрит от диска, в който случай кодът регенерира изображението, вместо да върне мъртъв път.

import hashlib
import json
import os
from openai import OpenAI
import base64

client = OpenAI()

CACHE_DIR = "image_cache"
CACHE_INDEX = os.path.join(CACHE_DIR, "index.json")

def load_cache() -> dict:
    """Loads the cache index."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Saves the cache index."""
    os.makedirs(CACHE_DIR, exist_ok=True)
    with open(CACHE_INDEX, "w") as f:
        json.dump(cache, f, indent=2, ensure_ascii=False)

def generate_with_cache(
    prompt: str,
    size: str = "1024x1024",
    quality: str = "medium"
) -> str:
    """Generates an image or returns the cached result."""
    # Create a unique key based on parameters
    key_data = f"{prompt}|{size}|{quality}"
    cache_key = hashlib.sha256(key_data.encode()).hexdigest()[:16]

    cache = load_cache()

    if cache_key in cache:
        cached_path = cache[cache_key]["path"]
        if os.path.exists(cached_path):
            print(f"Cache hit: {cached_path}")
            return cached_path
        else:
            print("Cache expired, regenerating...")

    # Not in cache: generate
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=size,
        quality=quality,
    )

    path = os.path.join(CACHE_DIR, f"{cache_key}.png")
    os.makedirs(CACHE_DIR, exist_ok=True)
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)

    cache[cache_key] = {
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "path": path
    }
    save_cache(cache)

    print(f"Generated and cached: {path}")
    return path


# First generation: API call
path1 = generate_with_cache("Minimalist logo for a tech startup, blue and white")
# Second identical call: served from cache
path2 = generate_with_cache("Minimalist logo for a tech startup, blue and white")

Оразмеряване с прецизност

Генерирането на миниатюра с висока разделителна способност, която ще се показва в квадрат от 80 пиксела, е все едно да платите за отпечатък за изложба, само за да го пъхнете в портфейл. Лекарството е да спрете да оставяте този избор на прищявките на разработчика и вместо това да го изведете от declared usage. Речникът generate_for_usage разделя случаите на три семейства: малки уеб формати — миниатюри и аватари, които са добре с low; стандартна уеб употреба — заглавия на блогове, публикации в социалните мрежи, които изискват medium; и медии, където финесът наистина има значение — банери за герои, печат A4, портфолиа, които оправдават high. Последните два повика илюстрират разликата: една и съща котка астронавт струва кратно повече в зависимост от това дали завършва като миниатюра или като банер на начална страница.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Automatically chooses optimal resolution and quality."""
    configs = {
        # Small web usage
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standard web usage
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # High-quality usage
        "hero_banner": {"size": "1536x1024", "quality": "high"},
        "print_a4": {"size": "1024x1536", "quality": "high"},
        "portfolio": {"size": "1024x1024", "quality": "high"},
    }

    config = configs.get(usage, {"size": "1024x1024", "quality": "medium"})

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=config["size"],
        quality=config["quality"],
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Usage {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Cute cat in an astronaut suit", "thumbnail", "cat_thumb.png")
generate_for_usage("Cute cat in an astronaut suit", "hero_banner", "cat_hero.png")

Редактиране вместо регенериране

Клиентът одобрява снимката, но иска различно небе. Естественият рефлекс — повторно стартиране на пълното генериране с коригиран промпт — Ви кара да платите за цяло изображение и, което е по-лошо, Ви кара да загубите останалата част от композицията, която всички бяха одобрили. images.edit() решава тази ситуация на цената на едно редактиране: функцията edit_detail изгражда маска, която освобождава само съответния правоъгълник, тук горните 300 пиксела височина, съответстващи на небето, а промптът описва само съдържанието на тази лента. Самият пейзаж не се мести нито с пиксел.

import base64
from openai import OpenAI
from PIL import Image, ImageDraw

client = OpenAI()

# Instead of regenerating the entire image to change a detail,
# edit only the relevant area.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Edits a detail in an existing image.
    zone: (x1, y1, x2, y2) of the area to modify
    """
    source = Image.open(image_path)
    mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
    draw = ImageDraw.Draw(mask)
    draw.rectangle(zone, fill=(0, 0, 0, 0))
    mask.save("temp_mask.png")

    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open(image_path, "rb"),
        mask=open("temp_mask.png", "rb"),
        prompt=new_content
    )

    with open(output, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Detail edited: {output}")
    print("Cost: 1 edit instead of 1 full generation")


# Example: change just the sky of a photo
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Blue sky with some fluffy white clouds",
    "landscape_sky_edited.png"
)

Знайте къде отиват парите

Четирите предишни стратегии предполагат, че знаете какво консумирате, а тази видимост не идва автоматично: таблото на доставчика Ви дава обща сума, а не разбивка по проект или качество. Локален дневник запълва тази празнота за пренебрежимо малка цена за разработка. log_generation добавя ред с времеви печат за всеки повик, съкращавайки промпта до 100 знака, за да остане четим, а usage_report след това агрегира всичко по ниво на качество. Тази разбивка задейства решения: ако Вашият дневник разкрие, че 80% от Вашите изображения се генерират в high, докато мнозинството завършват в публикации в социалните мрежи, току-що сте открили Вашия източник на спестявания.

import json
import os
from datetime import datetime

USAGE_FILE = "image_usage_log.json"

def log_generation(prompt: str, size: str, quality: str, n: int = 1):
    """Logs every generation to track costs."""
    if os.path.exists(USAGE_FILE):
        with open(USAGE_FILE, "r") as f:
            log = json.load(f)
    else:
        log = []

    entry = {
        "timestamp": datetime.now().isoformat(),
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "n_images": n,
    }

    log.append(entry)

    with open(USAGE_FILE, "w") as f:
        json.dump(log, f, indent=2, ensure_ascii=False)


def usage_report():
    """Displays a consumption report."""
    if not os.path.exists(USAGE_FILE):
        print("No consumption data.")
        return

    with open(USAGE_FILE, "r") as f:
        log = json.load(f)

    total = len(log)
    by_quality = {}
    for entry in log:
        q = entry["quality"]
        by_quality[q] = by_quality.get(q, 0) + entry["n_images"]

    print(f"Total generations: {total}")
    print(f"Breakdown by quality:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} images")


usage_report()

Откъде да започнете

Не всички тези стратегии предлагат еднаква възвръщаемост на усилията и следващата таблица Ви помага да ги приоритизирате.

СтратегияОчаквани спестяванияУсилие
Ниско качество за прототипиране50-70%Минимално
Кеш на промптове10-30% (ако има повторения)Умерено
Адаптирана резолюция20-40%Минимално
Редактиране срещу регенериране30-50% (на модификация)Умерено
Проследяване на разходитеНепреки (видимост)Умерено

Два реда изпъкват ясно: прототипирането в low и адаптирането на резолюцията към употребата изискват минимално усилие за половината от възможните спестявания. Започнете с тях, след което добавете кеширане и целево редактиране, когато обемът Ви го оправдава. Самото проследяване на разходите не спестява нищо директно — но то е това, което Ви казва кои от другите четири наистина дават плодове във Вашия конкретен контекст.

Най-добрият начин да спрете да мислите за това е да капсулирате тези правила в една единствена контролна точка. Напишете обвивка около client.images.generate(), която интегрира кеширане на промптове, автоматично адаптиране на качеството и резолюцията въз основа на declared usage, и записване на всеки повик; след това я стартирайте за десет генерирания и прочетете отчета за потреблението. Оттам нататък целият Ви екип спестява пари, без да се налага да помни нищо.