AI Prompt Engineering · Lekcja

Kolejność przykładów i ich aktualność

Wpływ kolejności przykładów na wynik

Lekcja 3 z 413 kroki

Kolejność przykładów i ich aktualność to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Kolejność to ukryty hiperparametr

Kolejność przykładów few-shot może zmienić dokładność o kilka punktów procentowych, czasami przekształcając prompt o skuteczności bliskiej losowej w prompt bardzo skuteczny i odwrotnie. Ta zmienność występuje nawet wtedy, gdy zbiór przykładów pozostaje niezmieniony.

Kolejność należy traktować jako pełnoprawny hiperparametr do przeszukania, a nie jako szczegół pozostawiony na koniec. Raportowanie wyników few-shot bez kontrolowania kolejności jest metodologicznie niepoprawne.

import itertools

def order_search(demos, eval_set, build, max_perms=24):
    perms = list(itertools.permutations(demos))[:max_perms]
    scored = [(p, evaluate(build(p), eval_set)) for p in perms]
    return max(scored, key=lambda x: x[1])

Wyjaśnienie biasu recencyjnego

Transformatory typu decoder-only wykazują bias recencyjny: tokeny znajdujące się bliżej punktu generowania wywierają nieproporcjonalnie duży wpływ. Ostatnia demonstracja przed zapytaniem najczęściej kształtuje format, etykietę i ton.

Jest to częściowo artefakt wzorców uwagi i kodowania pozycyjnego. Praktyczny wniosek jest następujący: model najłatwiej naśladuje to, co znajduje się na końcu.

# Position weight intuition (illustrative, not exact)
# influence(example_i) roughly increases with proximity to the query
# => the FINAL demo disproportionately anchors the next generation
weights = [0.1, 0.15, 0.25, 0.5]  # earlier ... latest

Zagubienie w środku kontekstu

Badania nad długim kontekstem ujawniają profil uwagi w kształcie litery U: modele dobrze skupiają uwagę na początku i końcu kontekstu, ale słabiej na jego środku. Krytyczne demonstracje ukryte w środkowej części promptu są w praktyce pomijane.

Najważniejsze lub najbardziej podchwytliwe przykłady należy umieszczać na początku albo, ze względu na bias recencyjny, blisko końca; nie wolno pozostawiać ich w środku długiego bloku demonstracji.

def place_key_demos(key, filler):
    # U-shape aware: key items at the edges, filler in the middle
    head = key[: len(key)//2]
    tail = key[len(key)//2 :]
    return head + filler + tail

Dominująca etykieta i ostatnia pozycja

Bias recencyjny i bias dominującej etykiety wzajemnie się wzmacniają. Jeśli ostatnia demonstracja należy do klasy A, model skłania się ku przewidywaniu A. W połączeniu ze zbiorem demonstracji z przewagą A rozkład a priori staje się silnie przesunięty.

W przypadku zrównoważonej klasyfikacji należy stosować naprzemienne etykiety i dopilnować, aby ostatni przykład nie należał zawsze do tej samej klasy w różnych wariantach promptu.

def alternate_labels(by_label, k):
    labels = list(by_label)
    out = []
    i = 0
    while len(out) < k:
        lbl = labels[i % len(labels)]
        if by_label[lbl]:
            out.append(by_label[lbl].pop())
        i += 1
    return out  # final element varies by construction

Demonstracje uporządkowane według podobieństwa (rosnąco)

Solidna heurystyka w few-shot wspomaganym wyszukiwaniem polega na uporządkowaniu wyszukanych przykładów według rosnącego podobieństwa do zapytania, tak aby najbardziej trafna demonstracja znajdowała się najbliżej zapytania i korzystała z efektu świeżości.

Łączy to dynamiczny wybór z wykorzystaniem efektu świeżości: trafny kontekst jest zarówno obecny, jak i umieszczony w miejscu, na które model zwraca największą uwagę.

def order_by_similarity(query_emb, retrieved):
    scored = [(d, cos(query_emb, d.emb)) for d in retrieved]
    scored.sort(key=lambda x: x[1])     # ascending
    return [d for d, _ in scored]        # most similar last (near query)

Porządkowanie według programu nauczania

W przypadku rozumowania lub generowania uporządkowanie według programu nauczania (od łatwych do trudnych przykładów) może pomóc modelowi stopniowo przyswoić pożądane zachowanie, kończąc na złożonym przykładzie, który tuż przed zapytaniem demonstruje pełną głębię rozumowania.

Zależy to od zadania, dlatego należy porównać tę metodę z porządkowaniem losowym i według podobieństwa, zamiast zakładać, że zawsze pomaga.

def curriculum(demos, difficulty_fn):
    return sorted(demos, key=difficulty_fn)  # easiest first, hardest last

Pomiar wrażliwości na kolejność

Można określić, jak kruchy jest prompt, losując wiele kolejności i raportując wariancję dokładności. Wysoka wariancja sygnalizuje niestabilny prompt, który może nieprzewidywalnie pogarszać wyniki na produkcji.

Proszę używać tej metryki do porównywania projektów promptów: prompt odporny na kolejność jest bezpieczniejszy niż nieznacznie lepiej oceniany, ale niestabilny prompt.

import random

def order_sensitivity(demos, eval_set, build, trials=20):
    accs = []
    for _ in range(trials):
        perm = random.sample(demos, len(demos))
        accs.append(evaluate(build(perm), eval_set))
    return mean(accs), stdev(accs)  # report both; low stdev = robust

Wybór kolejności bez sondowania

Jeśli nie mają Państwo etykiet do oceny kolejności, mogą Państwo wybrać kolejność na podstawie entropii predykcji modelu na zbiorze sondującym: kolejności dające pewne, niskoentropijne i dobrze rozłożone predykcje zazwyczaj lepiej się uogólniają (Lu et al., 2022).

Pozwala to wybrać dobrą permutację bez etykietowanego zbioru walidacyjnego.

def select_order_by_entropy(perms, probe_inputs, build):
    def score(perm):
        ents = [entropy(model_probs(build(perm), x)) for x in probe_inputs]
        return -mean(ents)        # prefer confident, low-entropy orderings
    return max(perms, key=score)

Stabilizacja za pomocą kalibracji

Wrażliwość na kolejność i efekt świeżości zwiększają prawdopodobieństwo niektórych etykiet. Kalibracja kontekstowa łagodzi ten problem, szacując rozkład aprioryczny modelu na wejściu pozbawionym treści i korygując przewidywane prawdopodobieństwa, co zmniejsza wpływ dowolnej pojedynczej kolejności.

Kalibracja w połączeniu z przyzwoitą kolejnością zapewnia stabilniejsze zachowanie na produkcji niż poszukiwanie pojedynczej, najlepszej permutacji.

p_prior = model_probs(build(perm), content_free='N/A')
def calibrate(probs):
    return normalize(probs / p_prior)  # cancels order-induced label skew

Buforowanie i stabilność kolejności

Jeśli używają Państwo buforowania promptów, prefiks (w tym blok przykładów demonstracyjnych) musi pozostać identyczny bajt po bajcie, aby można było trafić do pamięci podręcznej. Częste przetasowywanie przykładów dla każdego żądania uniemożliwia ponowne wykorzystanie pamięci podręcznej oraz zwiększa koszty i opóźnienia.

Rozwiązanie: ustalić jedną zweryfikowaną kolejność dla statycznego bloku przykładów demonstracyjnych i ją buforować; dynamiczne porządkowanie ograniczyć wyłącznie do pobieranej, zależnej od zapytania końcowej części.

# Stable cached prefix + dynamic tail
prefix = render(FIXED_ORDERED_DEMOS)   # cache_control on this block
tail   = render(order_by_similarity(q_emb, retrieved))
prompt = prefix + tail + query

Lista kontrolna strategii porządkowania

Praktyczne ustawienia domyślne: równoważyć i przeplatać etykiety, umieszczać kluczowe lub trudne przykłady na obrzeżach (unikać środka), porządkować pobierane przykłady według rosnącego podobieństwa, aby najlepszy znajdował się blisko zapytania, mierzyć wariancję zależną od kolejności oraz stosować kalibrację w celu ograniczenia pozostałego odchylenia.

Następnie należy zablokować kolejność na potrzeby buforowania i ponownie przeprowadzić walidację za każdym razem, gdy zmieni się zbiór przykładów.

def final_order(demos, q_emb):
    demos = alternate_labels(group(demos), len(demos))
    return order_by_similarity(q_emb, demos)  # validated, then cached

Szybkie sprawdzenie

Proszę przeanalizować położenie kluczowej demonstracji.

Odpowiedz w interaktywnej lekcji

Podsumowanie

Najważniejsze wnioski:

Kolejność przykładów jest hiperparametrem, który może zmienić dokładność o kilka punktów procentowych; należy ją przeszukiwać i raportować wariancję.
Efekt świeżości sprawia, że ostatnia demonstracja ma największy wpływ; zjawisko „zagubienia w środku” zmniejsza wagę przykładów centralnych.
Należy równoważyć i przeplatać etykiety, porządkować pobierane demonstracje według rosnącego podobieństwa oraz rozważyć porządkowanie według programu nauczania.
Przy niedoborze etykiet należy wybierać kolejność na podstawie entropii oraz stosować kalibrację kontekstową w celu ograniczenia odchylenia.
Należy zablokować stabilną kolejność na potrzeby buforowania promptu, a porządkować ponownie wyłącznie dynamicznie pobieraną końcową część.

Bezpłatny start

Ucz się AI Prompt Engineering dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 53
Lekcje: 199

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Kolejność przykładów i ich aktualność” jest bezpłatna?

Tak — pełny tekst „Kolejność przykładów i ich aktualność” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Kolejność przykładów i ich aktualność”?

Wpływ kolejności przykładów na wynik Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?

Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Kolejność przykładów i ich aktualność”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?

Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do AI Prompt Engineering