Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Βελτιστοποίηση Κόστους

Μάθημα 11 / 12 Ενημερώθηκε 2 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Βελτιστοποίηση Κόστους
  2. Κατανόηση της Δομής Κόστους
  3. Πρωτοτυποποίηση σε Low, Παράδοση σε High
  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).

Βελτιστοποίηση Κόστους

Στην παραγωγή, η δημιουργία εικόνων παύει να είναι μια τεχνική περιέργεια και μετατρέπεται σε γραμμή προϋπολογισμού. Κάθε ομάδα που παράγει μερικές εκατοντάδες οπτικά στοιχεία τον μήνα το αντιλαμβάνεται γρήγορα. Η πρώτη αντίδραση—ο περιορισμός της χρήσης—είναι επίσης η λιγότερο έξυπνη. Αυτό το μάθημα καλύπτει πέντε στρατηγικές που μειώνουν τις δαπάνες χωρίς να compromettουν την ποιότητα των παραδοτέων σας, επειδή στοχεύουν σε αυτό που απορρίπτετε και όχι σε αυτό που κρατάτε.

Κατανόηση της Δομής Κόστους

Το κόστος δημιουργίας εξαρτάται από τρεις παράγοντες.

ΠαράγονταςΕπίπτωση στο Κόστος
Ποιότητα (low, medium, high)Άμεσος πολλαπλασιαστής
Ανάλυση (1024, 1536)Μεγαλύτερη = πιο ακριβή
Αριθμός εικόνων (n)Γραμμικό κόστος (n × τιμή μονάδας)

Αυτοί οι τρεις παράγοντες πολλαπλασιάζονται μεταξύ τους, γεγονός που εξηγεί γιατί η α disiplined εξερεύνηση κοστίζει μια τάξη μεγέθους περισσότερο από την ίδια εξερεύνηση που διεξάγεται με πειθαρχία. Το παρακάτω σενάριο παραθέτει τους πέντε συνδυασμούς που θα συναντήσετε συχνότερα στην παραγωγή. Ενώ τα ακριβή ποσά εμφανίζονται στον πίνακα ελέγχου (dashboard) του OpenAI, η σειρά των γραμμών δείχνει ήδη την κλίμακα των συμβιβασμών.

from openai import OpenAI

client = OpenAI()

# Σύγκριση κόστους: ίδιο prompt, διαφορετικές παράμετροι
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("Διαμόρφωση            | Χρήση (εκτιμώμενη)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Ελέγξτε το dashboard του OpenAI")

Πρωτοτυποποίηση σε Low, Παράδοση σε High

Αυτή είναι μακράν η πιο αποδοτική στρατηγική όσον αφορά το κόστος και η πιο απλή στην υιοθέτηση. Κατά τη φάση εξερεύνησης, δεν κρίνετε τη λεπτομέρεια μιας διαβάθμισης: κρίνετε τη σύνθεση, το κάδρο και τη γενική διάθεση, όλα τα οποία είναι απολύτως ορατά στο quality: low. Η μετάβαση στο high έχει νόημα μόνο για την εικόνα που σκοπεύετε πραγματικά να δημοσιεύσετε. Η ροή εργασίας παρακάτω τυποποιεί αυτή τη sequence παράγοντας πέντε οικονομικά προσχέδια ακολουθούμενα από μια μοναδική τελική απόδοση, με το επιπλέον όφελος της μετάβασης σε οριζόντια μορφή (1536×1024) για την οριστική έκδοση. Σε πέντε δοκιμές και μία παράδοση, οι εξοικονομήσεις που αναφέρονται στο τέλος του σεναρίου κυμαίνονται γύρω στο 60% σε σύγκριση με μια εξερεύνηση που διεξήχθη εξ ολοκλήρου σε high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Ροή εργασίας δύο φάσεων:
    1. Γρήγορα προσχέδια σε χαμηλή ποιότητα
    2. Τελική απόδοση σε υψηλή ποιότητα
    """
    # Φάση 1: Γρήγορη εξερεύνηση
    print("Φάση 1: γρήγορα προσχέδια (χαμηλή ποιότητα)")
    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"  Προσχέδιο {i+1}: {path}")

    # Φάση 2: Τελική απόδοση (μετά την ανθρώπινη επιλογή του καλύτερου προσχεδίου)
    print("\nΦάση 2: τελική απόδοση (υψηλή ποιότητα)")
    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"  Τελική απόδοση: {output}")

    # Σύνοψη: 5 low + 1 high αντί για 5 high
    print(f"\nΣύνοψη: {n_drafts} προσχέδια low + 1 τελικό high")
    print("Εκτιμώμενη εξοικονόμηση: ~60% σε σύγκριση με εξερεύνηση εξ ολοκλήρου σε high")


economical_workflow(
    "Εικονογράφηση μιας πανεπιστημιούπολης πράσινης τεχνολογίας με ηλιακά πάνελ, αρχιτεκτονικό στυλ",
    "campus_final.png"
)

Μην Πληρώνετε Ποτέ Δύο Φορές για την Ίδια Εικόνα

Σε μια πραγματική εφαρμογή, το ίδιο prompt επιστρέφει πολύ πιο συχνά από ό,τι θα περιμένατε: ένας χρήστης που ανανεώνει τη σελίδα, ένα script build που επανεκτελεί μια δημιουργία ή ένα εικονίδιο που επαναχρησιμοποιείται σε τρεις σελίδες. Κάθε μία από αυτές τις περιπτώσεις αποτελεί περιττή χρέωση. Η cache παρακάτω τις εξαλείφει υπολογίζοντας ένα hash SHA-256 του τριπλέτου (prompt, size, quality)—τα τρία στοιχεία που καθορίζουν το χρεώσιμο αποτέλεσμα—και περικόπτοντας αυτό το hash σε δεκαέξι χαρακτήρες για να δημιουργήσει ένα διαχειρίσιμο όνομα αρχείου. Σημειώστε τον έλεγχο 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:
    """Φορτώνει το ευρετήριο της cache."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Αποθηκεύει το ευρετήριο της cache."""
    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:
    """Δημιουργεί μια εικόνα ή επιστρέφει το αποτέλεσμα από την cache."""
    # Δημιουργία μοναδικού κλειδιού βάσει παραμέτρων
    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: {cached_path}")
            return cached_path
        else:
            print("Η cache έληξε, αναδημιουργία...")

    # Δεν υπάρχει στην cache: δημιουργία
    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"Δημιουργήθηκε και αποθηκεύτηκε στην cache: {path}")
    return path


# Πρώτη δημιουργία: κλήση API
path1 = generate_with_cache("Μινιμαλιστικό λογότυπο για τεχνολογική startup, μπλε και άσπρο")
# Δεύτερη ίδια κλήση: εξυπηρετείται από την cache
path2 = generate_with_cache("Μινιμαλιστικό λογότυπο για τεχνολογική startup, μπλε και άσπρο")

Μέγεθος με Ακρίβεια

Η δημιουργία μιας thumbnail υψηλής ανάλυσης που θα εμφανίζεται σε ένα τετράγωνο 80 pixel είναι σαν να πληρώνετε για ένα εκθεσιακό εκτύπωμα απλώς για να το βάλετε σε ένα πορτοφόλι. Η λύση είναι να σταματήσετε να αφήνετε αυτή την επιλογή στην ιδιοτροπία του προγραμματιστή και αντ’ αυτού να την εξάγετε από τη δηλωμένη χρήση. Το λεξικό generate_for_usage χωρίζει τις περιπτώσεις σε τρεις οικογένειες: μικρές web μορφές—thumbnails και avatars—που βολεύονται με low· τυπική web χρήση—επικεφαλίδες blog, αναρτήσεις social—που απαιτούν medium· και μέσα όπου η λεπτομέρεια έχει πραγματικά σημασία—hero banners, εκτύπωση A4, portfolios—που δικαιολογούν το high. Οι δύο τελευταίες κλήσεις illustrate το χάσμα: η ίδια γάτα αστροναύτης κοστίζει ένα πολλαπλάσιο ανάλογα με το αν καταλήγει ως thumbnail ή ως banner αρχικής σελίδας.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Επιλέγει αυτόματα τη βέλτιστη ανάλυση και ποιότητα."""
    configs = {
        # Μικρή web χρήση
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Τυπική web χρήση
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # Χρήση υψηλής ποιότητας
        "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} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Χαριτωμένη γάτα με στολή αστροναύτη", "thumbnail", "cat_thumb.png")
generate_for_usage("Χαριτωμένη γάτα με στολή αστροναύτη", "hero_banner", "cat_hero.png")

Επεξεργασία Αντί για Αναδημιουργία

Ο πελάτης εγκρίνει τη φωτογραφία αλλά θέλει διαφορετικό ουρανό. Ο φυσικός αντανακλασμός—η επανεκτέλεση της πλήρους δημιουργίας με ένα προσαρμοσμένο prompt—σας κάνει να πληρώσετε για ολόκληρη την εικόνα και, χειρότερα, σας κάνει να χάσετε το υπόλοιπο της σύνθεσης που όλοι είχαν εγκρίνει. Το images.edit() διαχειρίζεται αυτή την κατάσταση στην τιμή μιας επεξεργασίας: η συνάρτηση edit_detail δημιουργεί μια μάσκα που ελευθερώνει μόνο το σχετικό ορθογώνιο, εδώ τα πάνω 300 pixels ύψους που αντιστοιχούν στον ουρανό, και το prompt περιγράφει μόνο το περιεχόμενο αυτής της λωρίδας. Το ίδιο το τοπίο δεν μετακινείται ούτε κατά ένα pixel.

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

client = OpenAI()

# Αντί να αναδημιουργήσετε ολόκληρη την εικόνα για να αλλάξετε μια λεπτομέρεια,
# επεξεργαστείτε μόνο τη σχετική περιοχή.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Επεξεργάζεται μια λεπτομέρεια σε μια υπάρχουσα εικόνα.
    zone: (x1, y1, x2, y2) της περιοχής προς τροποποίηση
    """
    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"Λεπτομέρεια επεξεργασμένη: {output}")
    print("Κόστος: 1 επεξεργασία αντί για 1 πλήρη δημιουργία")


# Παράδειγμα: αλλαγή μόνο του ουρανού μιας φωτογραφίας
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Μπλε ουρανός με μερικά αφράτα λευκά σύννεφα",
    "landscape_sky_edited.png"
)

Γνωρίστε Πού Πάνε τα Χρήματα

Οι τέσσερις προηγούμενες στρατηγικές προϋποθέτουν ότι γνωρίζετε τι καταναλώνετε, και αυτή η ορατότητα δεν έρχεται αυτόματα: ο πίνακας ελέγχου του παρόχου σας δίνει ένα σύνολο, όχι μια ανάλυση ανά έργο ή ποιότητα. Ένα τοπικό log καλύπτει αυτό το κενό με αμελητέο κόστος ανάπτυξης. Το log_generation προσθέτει μια χρονολογημένη γραμμή για κάθε κλήση, περικόπτοντας το prompt στους 100 χαρακτήρες για να παραμείνει ευανάγνωστο, και το usage_report στη συνέχεια συγκεντρώνει τα πάντα ανά επίπεδο ποιότητας. Αυτή η ανάλυση πυροδοτεί αποφάσεις: αν το log σας αποκαλύπτει ότι το 80% των εικόνων σας δημιουργείται σε high ενώ η πλειοψηφία καταλήγει σε social posts, μόλις βρήκατε την πηγή εξοικονόμησής σας.

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):
    """Καταγράφει κάθε δημιουργία για παρακολούθηση κόστους."""
    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():
    """Εμφανίζει μια αναφορά κατανάλωσης."""
    if not os.path.exists(USAGE_FILE):
        print("Δεν υπάρχουν δεδομένα κατανάλωσης.")
        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}")
    print(f"Ανάλυση ανά ποιότητα:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} εικόνες")


usage_report()

Από Πού να Ξεκινήσετε

Δεν προσφέρουν όλες αυτές οι στρατηγικές την ίδια απόδοση σε σχέση με την προσπάθεια, και ο παρακάτω πίνακας σας βοηθά να τις θέσετε σε προτεραιότητα.

ΣτρατηγικήΕκτιμώμενη ΕξοικονόμησηΠροσπάθεια
Low για πρωτοτυποποίηση50-70%Ελάχιστη
Caching prompt10-30% (αν επαναλαμβάνεται)Μέτρια
Προσαρμοσμένη ανάλυση20-40%Ελάχιστη
Επεξεργασία vs αναδημιουργία30-50% (ανά τροποποίηση)Μέτρια
Παρακολούθηση δαπανώνΈμμεση (ορατότητα)Μέτρια

Δύο γραμμές ξεχωρίζουν ξεκάθαρα: η πρωτοτυποποίηση σε low και η προσαρμογή της ανάλυσης στη χρήση απαιτούν ελάχιστη προσπάθεια για το μισό των πιθανών εξοικονομήσεων. Ξεκινήστε με αυτές και στη συνέχεια προσθέστε caching και στοχευμένη επεξεργασία όταν ο όγκος σας το δικαιολογεί. Η ίδια η παρακολούθηση δαπανών δεν εξοικονομεί τίποτα άμεσα—αλλά είναι αυτή που σας λέει ποιες από τις άλλες τέσσερις αποδίδουν πραγματικά στο συγκεκριμένο πλαίσιο σας.

Ο καλύτερος τρόπος για να σταματήσετε να το σκέφτεστε είναι να ενσωματώσετε αυτούς τους κανόνες σε ένα μοναδικό σημείο ελέγχου. Γράψτε ένα wrapper γύρω από το client.images.generate() που ενσωματώνει caching prompt, αυτόματη προσαρμογή ποιότητας και ανάλυσης βάσει δηλωμένης χρήσης, και καταγραφή κάθε κλήσης· στη συνέχεια εκτελέστε το σε δέκα δημιουργίες και διαβάστε την αναφορά κατανάλωσης. Από εκεί και πέρα, ολόκληρη η ομάδα σας εξοικονομεί χρήματα χωρίς να χρειάζεται να θυμάται οτιδήποτε.