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

Optymalizacja end-to-end: od promptu do sieci

Lekcja 2 z 20 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Optymalizacja to system, a nie pojedynczy parametr
  2. Optymalizacja promptu
  3. Optymalizacja parametrów API
  4. Optymalizacja sieci
  5. Optymalizacja post-processingu
  6. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Optymalizacja to system, a nie pojedynczy parametr

Redukcja opóźnień i kosztów aplikacji LLM nie polega jedynie na wyborze szybszego modelu. To łańcuch optymalizacji rozciągający się od promptu po konfigurację sieci, gdzie najsłabsze ogniwo determinuje wydajność całości. Zespół, który zmniejszy rozmiar promptu systemowego o połowę, ale pozostawi serwer otwierający nowe połączenie TLS dla każdego żądania, straci w narzucie sieciowym tyle, ile zaoszczędził na tokenach.

Kolejność, w jakiej zajmujesz się tymi dźwigniami, ma znaczenie. Zacznij od promptu, ponieważ wpływa on zarówno na koszt, jak i opóźnienie, nie wymagając zmian w infrastrukturze. Następnie zajmij się parametrami API, potem konfiguracją sieci, a na końcu sposobem, w jaki Twoja aplikacja konsumuje odpowiedź. Ta lekcja poprowadzi Cię przez każdą z tych dźwigni w podanej kolejności.

Optymalizacja promptu

Każdy token wejściowy kosztuje czas i pieniądze, a większość promptów produkcyjnych niesie bagaż z fazy prototypowania: instrukcje dodawane po kolei, każda przeredagowująca poprzednią. Twoim pierwszym odruchem powinno być gęste przepisanie promptu, usuwając formy adresatywne i powtórzenia, nie naruszając przy tym rzeczywistych ograniczeń przekazywanych modelowi.

# ❌ Rozwlekły prompt
prompt_long = """
Jesteś ekspertem ds. analizy finansowej. Zawsze musisz
odpowiadać w sposób profesjonalny i ustrukturyzowany. Musisz używać
danych liczbowych, gdy to możliwe. Musisz unikać niepotrzebnego żargonu.
Musisz być zwięzły, ale kompletny.
Przeanalizuj poniższy raport kwartalny: ...
"""

# ✅ Zoptymalizowany prompt (ten sam wynik, mniej tokenów)
prompt_court = """Rola: Starszy analityk finansowy.
Ograniczenia: Ustrukturyzowane, liczbowe, zwięzłe.
Zadanie: Przeanalizuj ten raport kwartalny: ..."""

Obie wersje przekazują dokładnie te same pięć ograniczeń; druga robi to bez pięciu fraz „Musisz“, które nic nie wnoszą dla modelu. W serwisie przetwarzającym dziesięć tysięcy raportów dziennie, ta trzydziestosekundowa przeróbka zwraca się każdego dnia.

Wybór odpowiedniego modelu do zadania

Druga dźwignia opiera się na fakcie, że nie każde wywołanie wymaga tego samego modelu. Przekierowanie zadania ekstrakcji pola do modelu o wysokim poziomie rozumowania oznacza płacenie za moce obliczeniowe, których zadanie nie wykorzystuje, oraz dłuższe oczekiwanie na identyczny wynik.

Typ zadaniaZalecany modelPowód
Klasyfikacja / ekstrakcjagpt-5.6-lunaSzybki, ekonomiczny
Złożone rozumowaniegpt-5.6-terra z rozumowaniem średnimNajlepszy stosunek jakości do kosztu
Zadania krytycznegpt-5.6-sol z rozumowaniem wysokimNajwyższa jakość, wolniejszy
Duża skalagpt-5.6-luna przez Batch API-50% kosztów

W praktyce zakoduj ten wybór w funkcji routingu, zamiast pozostawiać go uznaniu programistów; w przeciwnym razie zawsze wygra model domyślny:

import openai

client = openai.OpenAI()

def route_model(task: str, complexity: str) -> str:
    """Wybiera optymalny model na podstawie zadania."""
    if complexity == "low":
        return "gpt-5.6-luna"
    elif task in ("reasoning", "math", "code"):
        return "gpt-5.6-terra"
    elif complexity == "critical":
        return "gpt-5.6-sol"
    return "gpt-5.6-terra"

def optimized_call(prompt: str, task: str, complexity: str) -> str:
    model = route_model(task, complexity)
    response = client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

Optymalizacja parametrów API

Zbyt długa odpowiedź marnuje czas generowania, którego nikt nie przeczyta. Zawsze określaj max_output_tokens: jest to twardy limit chroniący zarówno Twój rachunek, jak i interfejs, zapobiegając sytuacji, w której źle sformułowany prompt przeradza się w dwutysięczną słowną dygresję.

response = client.responses.create(
    model="gpt-5.6-terra",
    reasoning={"effort": "none"},  # temperature wymaga effort none
    input="Streszcz ten tekst w jednym zdaniu.",
    max_output_tokens=100,  # Twardy limit
    temperature=0.0,         # Deterministyczne = szybsze
)

Parametry próbkowania działają w tym samym kierunku. Ustawienie temperature=0 sprawia, że odpowiedzi są deterministyczne i nieco szybsze, co jest dokładnie tym, czego potrzebujesz w zadaniach ekstrakcji lub klasyfikacji, gdzie kreatywność jest źródłem wariancji, a nie atutem. Zmniejszenie top_p do 0.1 ogranicza przestrzeń wyszukiwania i przyspiesza generowanie; zarezerwuj to ustawienie dla zadań, gdzie akceptowalne jest tylko jedno sformułowanie, a wartości domyślne zachowaj tam, gdzie bogactwo odpowiedzi jest częścią produktu.

Optymalizacja sieci

Koszty podróży pakietów sumują się przy każdym wywołaniu, choć pozostają niewidoczne w metrykach Twojej aplikacji. API OpenAI jest hostowane głównie na wschodnim wybrzeżu USA: umieszczenie serwera aplikacji w tym samym regionie co punkt końcowy może przynieść potencjalny zysk od 50 do 150 milisekund w opóźnieniu sieciowym. Dla aplikacji konwersacyjnej jest to znacząca część czasu do pierwszego tokenu (TTFT).

Drugi zysk pochodzi z ponownego wykorzystania połączenia. Bez puli każde żądanie powtarza uzgadnianie TLS, dodając kilka rund komunikacji zanim popłyną jakiekolwiek użyteczne dane. Konfiguracja klienta HTTP raz na zawsze rozwiązuje ten problem:

import httpx

# Klient z trwałą pulą połączeń
client_http = httpx.Client(
    base_url="https://api.openai.com/v1",
    timeout=60.0,
    limits=httpx.Limits(
        max_connections=20,
        max_keepalive_connections=10,
    ),
)

Optymalizacja post-processingu

Ostatnie ogniwo jest często tym, o którym się zapomina: aplikacja, która otrzymuje odpowiedź strumieniową, ale czeka do końca, aby ją wyświetlić, niweczy wszystkie korzyści ze strumieniowania. Przetwarzaj odpowiedź na bieżąco, a nie po pełnym odebraniu.

async def progressive_processing(prompt: str):
    """Przetwarza każdy fragment natychmiast po jego nadejściu."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    buffer = ""
    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Przetwarzaj po pełnym zdaniu
            if buffer.endswith((".", "!", "?")):
                yield buffer.strip()
                buffer = ""

Podział na pełne zdania jest celowym kompromisem: emitowanie każdego tokenu powoduje drgający wyświetlacz, podczas gdy oczekiwanie na cały akapit przywraca uczucie czekania. Zdanie jest jednostką, którą czytelnicy naturalnie konsumują. Wykorzystuj ten wzorzec zawsze, gdy Twój interfejs musi wyświetlać, czytać na głos lub strumieniować to, co produkuje model.

Kluczowe wnioski

  • Najpierw optymalizuj prompt: mniej tokenów = mniejsze opóźnienie i koszt
  • Kieruj żądania do odpowiedniego modelu w zależności od złożoności zadania
  • Ograniczaj max_output_tokens i używaj temperature=0, gdy to możliwe
  • Ponownie wykorzystuj połączenia HTTP i przetwarzaj odpowiedzi poprzez strumieniowanie