Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Moderering, SDK-inkompatibiliteter och kostnadskontroll

Lektion 14 av 14 Uppdaterad 3 november 2026 Nybörjare
På denna sida
  1. Förstå gränserna för bild-API:t
  2. Innehållsmoderering
  3. OpenAI SDK-inkompatibilitet för redigering
  4. Kostnadskontroll
  5. Slutpunkt för modellupptäckt
  6. Viktiga punkter
  7. Testa dina kunskaper

Uppdaterat 2 november 2026 — Imagine. grok-imagine-image-quality togs bort den 2 november 2026 (dess förfrågningar hanteras av Imagine 2.0 i low-kvalitet): exemplen använder nu grok-imagine-image (Imagine 1.0) och grok-imagine-image-2.0 (Imagine 2.0, kvalitet low, medium eller auto). Med OpenAI SDK skickas aspect_ratio, resolution och quality via extra_body, medan redigering sker via xAI SDK eller en HTTP-förfrågan.

Förstå gränserna för bild-API:t

För att bygga tillförlitliga applikationer med Groks API för bildgenerering måste du känna till dess begränsningar: automatisk moderering, inkompatibilitet med vissa OpenAI SDK-metoder och mekanismer för kostnadskontroll.

Innehållsmoderering

API:t modererar automatiskt både prompts och genererade bilder. Vissa innehållstyper nekas:

  • Explicit våldsamt innehåll eller gore
  • Explicit sexuellt innehåll
  • Hatiskt eller diskriminerande innehåll
  • Innehåll som på ett olämpligt sätt involverar minderåriga

När moderering utlöses returnerar API:t ett felmeddelande istället för en bild.

Hantera nekanden från modereringen

import requests
import os

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

def generate_safe(prompt, **kwargs):
    """Generera en bild medan nekanden från modereringen hanteras."""
    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 nekad av moderering: {prompt[:50]}...")
            return None
        raise

Bästa praxis för moderering

I praktiken bör du hantera moderering i förväg snarare än reaktivt. Om en legitim prompt blockeras, testa variationer för att identifiera utlösande ord – “episk strid” kan passera där ett grövre ord inte gör det, och att kartlägga dessa känsligheter undviker återkommande blockeringar. När prompts kommer från dina användare, lägg till ett server-side filter innan API-anropet: det fångar upp uppenbart otillåtna förfrågningar utan att konsumera en begäran, och håller dig i kontroll över det meddelande som visas. För denna sista punkt gör skillnaden i upplevelsen: en blockering från modereringen ska aldrig nå användaren som ett rått tekniskt fel, utan som ett tydligt meddelande – “denna förfrågan följer inte våra användarvillkor” – som förklarar utan att avslöja API-detaljer.

OpenAI SDK-inkompatibilitet för redigering

Detta är en kritisk punkt: OpenAI SDK:s metod images.edit() fungerar inte med xAI API:t. OpenAI SDK skickar data som multipart/form-data, medan xAI API:t förväntar sig application/json.

# FUNGERAR INTE
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"
)
# → Fel i Content-type!

# FUNGERAR: direkt REST-anrop
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"}
    }
)

Sammanfattning av kompatibilitet

Operation OpenAI SDK REST (requests)
images.generate() Kompatibel Kompatibel
images.edit() Inkompatibel Kompatibel

Kostnadskontroll

Övervaka förbrukningen

Sätt upp en räknare för utgifter i din kod:

class ImageBudgetTracker:
    PRICES = {
        "grok-imagine-image": 0.02,
        "grok-imagine-image-2.0": 0.04,  # låg kvalitet; medel enligt gällande taxa
    }

    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"Bilder genererade: {self.image_count}")
        print(f" spenderat: ${self.total_spent:.2f}")
        print(f"Återstående budget: ${remaining:.2f}")

# Användning
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()

Optimera kostnader

Den gyllene regeln är att skilja på utforskning och produktion. Under sökandet efter rätt prompt, arbeta med Imagine 1.0 ($0.02) med n=3-5 för att jämföra variationer till lägre kostnad; när prompten är stabil, byt till Imagine 2.0 med n=1 för den slutliga renderingen. Denna sekvensering reserverar den högsta taxan endast för utvalda bilder.

Två mekanismer kompletterar setupen på applikationssidan. Först, en cache för resultat: om samma prompt återkommer – katalogbilder, standardbilder som regenereras av flera användare – leverera den redan genererade bilden istället för att betala för en ny förfrågan. Sedan kvoter, om dina användare själva utlöser genereringar: en gräns per dag eller timme skyddar din budget från orimlig användning och missbruk. Håll slutligen koll på hastighetsgränser (300 RPM standard, 30 RPM pro): en batch-pipeline som ignorerar dessa ackumulerar 429-fel och onödiga försök.

Uppskattning av månadskostnad

För en app med 100 användare som genererar 10 bilder per dag:

  • Imagine 1.0: 100 x 10 x 30 x $0.02 = $600/månad
  • Imagine 2.0 i low: 100 x 10 x 30 x $0.04 = $1 200/månad
  • Blandat (80/20): 24 000 x $0.02 + 6 000 x $0.04 = $720/månad

Slutpunkt för modellupptäckt

För att programmatiskt kontrollera tillgängliga bildmodeller och deras priser:

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']}/bild, "
          f"max prompt : {model['max_prompt_length']} tecken")

Taxor från och med 5 augusti 2026 – priserna ändras regelbundet: innan någon budgetberäkning, kontrollera den aktuella taxan på xAI:s officiella sida för modeller och taxor.

Viktiga punkter

  • Moderering är automatisk: hantera nekanden i din kod
  • OpenAI SDK images.edit() är inkompatibel med xAI: använd requests
  • OpenAI SDK images.generate() fungerar normalt
  • Implementera en budgetspårare för att kontrollera utgifterna
  • Kontrollera modeller och priser via slutpunkten /v1/image-generation-models

Testa dina kunskaper

Bildgenerering och redigering: den operativa översikten.

1. Vad skiljer Imagine 1.0 och Imagine 2.0 åt?

Svar: Avvägningen mellan kvalitet och kostnad: Imagine 1.0 ($0.02) för volym och iterationer, Imagine 2.0 ($0.04 i low, med en quality-inställning) för slutliga renderingar – du prototyper med den första, finaliserar med den andra.

2. Vad kännetecknar en bra bildprompt?

Svar: Motiv, stil, komposition och explicita detaljer – beskriv scenen som en brief för art direction, iterera sedan med riktade justeringar snarare än att skriva om allt.

3. Vad möjliggör slutpunkten /v1/images/edits?

Svar: Redigera befintliga bilder: målinriktad redigering via prompt, redigering av flera bilder med referenser och redigering över flera steg – du retuscherar precist istället för att regenerera.

4. Hur producerar man effektivt i stor volym?

Svar: Parametern n för batchar, async-klienten för genomströmning – och eftersom utgående URL:er är tillfälliga, ladda ner och arkivera omedelbart.

5. Vilka skyddsåtgärder behövs före produktion?

Svar: Moderering av prompts och utdata, kunskap om SDK-inkompatibiliteter och kostnadskontroll (modell, upplösning, volymer) – skapande i stor skala kräver styrning.

Prototypa, redigera, industrialisera, styr: den kompletta bildpipelinen – med kostnaderna under kontroll i varje steg.