Przejdź do głównej treści
Polski— Wybierz język
Menu

Moderacja, niezgodności SDK i kontrola kosztów

Lekcja 14 z 14 Zaktualizowano 3 listopada 2026 Początkujący
Na tej stronie
  1. Zrozumienie limitów API obrazów
  2. Moderacja treści
  3. Niezgodność SDK OpenAI przy edycji
  4. Kontrola kosztów
  5. Punkt końcowy odkrywania modeli
  6. Kluczowe wnioski
  7. Sprawdź swoją wiedzę

Zaktualizowano 2 listopada 2026 — Imagine. grok-imagine-image-quality został usunięty 2 listopada 2026 (jego żądania są obsługiwane przez Imagine 2.0 w jakości low): przykłady używają teraz grok-imagine-image (Imagine 1.0) oraz grok-imagine-image-2.0 (Imagine 2.0, jakość low, medium lub auto). W przypadku SDK OpenAI parametry aspect_ratio, resolution i quality przesyłane są przez extra_body, a edycja odbywa się poprzez SDK xAI lub żądanie HTTP.

Zrozumienie limitów API obrazów

Aby budować niezawodne aplikacje z wykorzystaniem API generowania obrazów Grok, musisz znać jego ograniczenia: automatyczną moderację, niezgodność z niektórymi metodami SDK OpenAI oraz mechanizmy kontroli kosztów.

Moderacja treści

API automatycznie moderuje prompty i wygenerowane obrazy. Pewne typy treści są odrzucane:

  • Treści wyraźnie przemocowe lub krwawe
  • Treści wyraźnie seksualne
  • Treści nienawistne lub dyskryminujące
  • Treści niewłaściwie involvingujące małoletnie osoby

Gdy uruchomi się moderacja, API zwraca błąd zamiast obrazu.

Obsługa odmów moderacji

import requests
import os

headers = {
    "Authorization": f"Bearer {os.getenv('XAI_API_KEY')}",
    "Content-Type": "application/json"
}

def generate_safe(prompt, **kwargs):
    """Generuj obraz, obsługując odmowy moderacji."""
    try:
        response = requests.post(
            "https://api.x.ai/v1/images/generations",
            headers=headers,
            json={"model": "grok-imagine-image", "prompt": prompt, **kwargs}
        )
        response.raise_for_status()
        return response.json()["data"][0]["url"]
    except requests.exceptions.HTTPError as e:
        if response.status_code == 400:
            print(f"Prompt odrzucony przez moderację: {prompt[:50]}...")
            return None
        raise

Najlepsze praktyki dotyczące moderacji

W praktyce obsługuj moderację z wyprzedzeniem, a nie reaktywnie. Jeśli legitny prompt zostanie zablokowany, przetestuj warianty, aby zidentyfikować słowo wyzwalające – „epic battle“ przejdzie, podczas gdy grubiańskie określenie nie, a mapowanie tych wrażliwości pozwala uniknąć powtarzających się blokad. Gdy prompty pochodzą od Twoich użytkowników, dodaj serwerowy filtr wstępny przed wywołaniem API: przechwytuje on ewidentne żądania niezgodne z polityką bez konsumowania żądania i pozwala Ci zachować kontrolę nad wyświetlanym komunikatem. Ten ostatni punkt robi różnicę w doświadczeniu użytkownika: blokada moderacji nigdy nie powinna dotrzeć do użytkownika jako surowy błąd techniczny, lecz jako jasny komunikat – „to żądanie nie jest zgodne z naszym regulaminem wewnętrznym“ – który wyjaśnia sytuację, nie ujawniając szczegółów API.

Niezgodność SDK OpenAI przy edycji

To kluczowy punkt: metoda images.edit() z SDK OpenAI nie działa z API xAI. SDK OpenAI wysyła dane jako multipart/form-data, podczas gdy API xAI oczekuje application/json.

# NIE DZIAŁA
from openai import OpenAI
client = OpenAI(api_key=os.getenv("XAI_API_KEY"), base_url="https://api.x.ai/v1")
client.images.edit(
    model="grok-imagine-image",
    image=open("photo.png", "rb"),
    prompt="Edit this image"
)
# → Błąd Content-type!

# DZIAŁA: bezpośrednie wywołanie REST
import requests
response = requests.post(
    "https://api.x.ai/v1/images/edits",
    headers={
        "Authorization": f"Bearer {os.getenv('XAI_API_KEY')}",
        "Content-Type": "application/json"
    },
    json={
        "model": "grok-imagine-image",
        "prompt": "Edit this image",
        "image": {"url": "https://exemple.com/photo.jpg"}
    }
)

Podsumowanie kompatybilności

Operacja SDK OpenAI REST (requests)
images.generate() Kompatybilne Kompatybilne
images.edit() Niekompatybilne Kompatybilne

Kontrola kosztów

Monitorowanie zużycia

Skonfiguruj w kodzie licznik wydatków:

class ImageBudgetTracker:
    PRICES = {
        "grok-imagine-image": 0.02,
        "grok-imagine-image-2.0": 0.04,  # niska jakość; średnia według stawki siatki
    }

    def __init__(self, budget_limit=10.0):
        self.total_spent = 0.0
        self.budget_limit = budget_limit
        self.image_count = 0

    def can_generate(self, model, n=1):
        cost = self.PRICES[model] * n
        return (self.total_spent + cost) <= self.budget_limit

    def record(self, model, n=1):
        cost = self.PRICES[model] * n
        self.total_spent += cost
        self.image_count += n

    def report(self):
        remaining = self.budget_limit - self.total_spent
        print(f"Images generated: {self.image_count}")
        print(f"Spent: ${self.total_spent:.2f}")
        print(f"Remaining budget: ${remaining:.2f}")

# Użycie
tracker = ImageBudgetTracker(budget_limit=5.0)

if tracker.can_generate("grok-imagine-image", n=5):
    response = client.images.generate(
        model="grok-imagine-image",
        prompt="My image",
        n=5
    )
    tracker.record("grok-imagine-image", n=5)

tracker.report()

Optymalizacja kosztów

Złotą zasadą jest rozdzielenie etapu eksploracji od produkcji. Podczas szukania odpowiedniego promptu pracuj z Imagine 1.0 (0,02 USD) z parametrem n=3-5, aby porównać warianty niższym kosztem; gdy prompt jest już stabilny, przełącz się na Imagine 2.0 z n=1 dla finalnego renderu. Taka sekwencja rezerwuje najwyższą stawkę wyłącznie dla wybranych obrazów.

Dwa mechanizmy uzupełniają konfigurację po stronie aplikacji. Po pierwsze, pamięć podręczna wyników: jeśli ten sam prompt wróci – wizualizacje katalogowe, standardowe obrazy regenerowane przez wielu użytkowników – zwróć już wygenerowany obraz zamiast płacić za nowe żądanie. Następnie limity (kwoty), jeśli to użytkownicy uruchamiają generowanie: limit dzienny lub godzinowy chroni Twój budżet przed nierozsądnym użyciem i nadużyciami. Na koniec miej oko na limity częstotliwości (standardowo 300 RPM, 30 RPM w wersji pro): potok wsadowy, który je ignoruje, accumuluje błędy 429 i niepotrzebne ponowienia.

Szacowanie miesięcznego budżetu

Dla aplikacji z 100 użytkownikami generującymi 10 obrazów dziennie:

  • Imagine 1.0: 100 × 10 × 30 × 0,02 USD = 600 USD/miesiąc
  • Imagine 2.0 w low: 100 × 10 × 30 × 0,04 USD = 1200 USD/miesiąc
  • Mieszane (80/20): 24 000 × 0,02 USD + 6 000 × 0,04 USD = 720 USD/miesiąc

Punkt końcowy odkrywania modeli

Aby programowo sprawdzić dostępne modele obrazów i ich ceny:

response = requests.get(
    "https://api.x.ai/v1/image-generation-models",
    headers={"Authorization": f"Bearer {os.getenv('XAI_API_KEY')}"}
)

for model in response.json()["data"]:
    print(f"{model['id']} : ${model['image_price']}/image, "
          f"max prompt : {model['max_prompt_length']} chars")

Stawki na dzień 5 sierpnia 2026 – ceny zmieniają się regularnie: przed jakimkolwiek obliczeniem budżetu sprawdź aktualną siatkę na oficjalnej stronie modeli i stawek xAI.

Kluczowe wnioski

  • Moderacja jest automatyczna: obsługuj odmowy w swoim kodzie
  • images.edit() z SDK OpenAI jest niezgodne z xAI: użyj requests
  • images.generate() z SDK OpenAI działa normalnie
  • Wdrąż tracker budżetu, aby kontrolować wydatki
  • Sprawdzaj modele i ceny poprzez punkt końcowy /v1/image-generation-models

Sprawdź swoją wiedzę

Generowanie i edycja obrazów: przegląd operacyjny.

1. Co różni Imagine 1.0 od Imagine 2.0?

Odpowiedź: Kompromis między jakością a kosztem: Imagine 1.0 (0,02 USD) do dużych wolumenów i iteracji, Imagine 2.0 (0,04 USD w low, z ustawieniem quality) do finalnych renderów – prototypujesz z pierwszym, finalizujesz z drugim.

2. Co składa się na dobry prompt obrazowy?

Odpowiedź: Temat, styl, kompozycja i wyraźne detale – opisz scenę jak brief artystyczny, a następnie iteruj z celowymi poprawkami, zamiast przepisywać wszystko od nowa.

3. Co umożliwia punkt końcowy /v1/images/edits?

Odpowiedź: Edycję istniejących obrazów: edycję celowaną promptem, edycję wieloobrazową z odniesieniami oraz edycję wieloetapową – retuszujesz precyzyjnie zamiast generować od nowa.

4. Jak efektywnie produkować na dużą skalę?

Odpowiedź: Parametr n do partii, klient asynchroniczny dla przepustowości – a ponieważ URL-e wyjściowe są tymczasowe, pobieraj i archiwizuj je natychmiast.

5. Jakie zabezpieczenia wdrożyć przed produkcją?

Odpowiedź: Moderację promptów i wyników, znajomość niezgodności SDK oraz kontrolę kosztów (model, rozdzielczość, wolumeny) – tworzenie na skalę wymaga ładu.

Prototypuj, edytuj, uprzemysławiaj, zarządzaj: kompletny potok obrazowy – z kosztami pod kontrolą na każdym etapie.