1. Lost in the Middle — diagnoza i rozwiązania

Dlaczego to się dzieje

Modele z popularnymi schematami pozycjonowania (np. RoPE i metody ekstrapolacji pozycji) wykazują bias pozycyjny: zwykle lepiej „trzymają” początek i koniec sekwencji, a środek bywa najsłabszy. Gdy igła ląduje w środku, trafność spada — nawet w modelach „long-context”.

Co działa od ręki (bez trenowania)

1. Ekstremalne ułożenie: po rerankingu umieść najistotniejsze fragmenty na początku i końcu kontekstu (środek zostaw na materiały wspierające).
2. Iteracyjne pobieranie (Self-RAG/FLARE): nie ładuj wszystkiego naraz — generuj w krokach i dociągaj brakujące fakty.
3. Hierarchiczne streszczenia (map → reduce): skondensuj sekcje do 1–2 zdań, z których złożysz „mapę” argumentów.

Co działa na poziomie modelu/pipeline’u

• Reranking krzyżowy (cross-encoder/LLM-ranker) przed ułożeniem kontekstu.
• Lepsze pozycjonowanie: LongRoPE/YaRN/PI — stabilniejsze okna; oraz Ms-PoE (Found in the Middle) nastawione na poprawę „środka”.
• SFT z debiasingiem pozycyjnym: rotacja/losowanie kolejności, „igły” w różnych pozycjach; ogólnie — augmentacja pozycyjna w duchu najnowszych zaleceń dla long-context.

Wzorzec promptu (minimalny)

ZADANIE: {pytanie}
ZASADY: Używaj tylko fragmentów oznaczonych [ISTOTNE]. Pomijaj [DODATKOWE].
FORMAT:
[DOWODY] wypunktowane zdania z cytatem --> {id_pasażu}
[ODPOWIEDŹ] zwięzła konkluzja

2. Prompty rozpraszające i „kuszący” szum

Dlaczego to się dzieje

LLM-y są wrażliwe na dystraktory semantycznie podobne do właściwej odpowiedzi. Jedno zdanie nieistotne może odchylić rozumowanie.

Taktyki bez trenowania

1. Instrukcja + format odpowiedzi: poproś o wypisanie najpierw dowodów/relewantnych zdań, potem wniosku.
2. Few-shot z dystraktorami: w przykładach pokaż krok „odfiltruj nieistotne → rozwiąż”.
3. Self-Consistency: kilka niezależnych trajektorii rozumowania i głosowanie większością.
4. Gating/abstencja na poziomie pasażu: testuj każdy fragment — jeśli nie zawiera odpowiedzi, model ma wypisać NO-RESPONSE; użyj tego filtru przed finałową generacją.

Pipeline RAG odporny na szum

Retriever → Cross-Encoder Rerank → Filtry NLI/entailment → Kompresja (LongLLMLingua/LLMLingua-2) → Ekstremalne ułożenie → Gating/abstencja → Generacja z self-consistency.

Wzorzec promptu (gating pasaży)

Dla każdego pasażu wykonaj:
1) Czy ten pasaż zawiera informacje konieczne do odpowiedzi na "{pytanie}"?
2) Jeśli NIE, zwróć: NO-RESPONSE | {id}
3) Jeśli TAK, zwróć: EVIDENCE | {id} | {krótki_cytat}

3. Wielkie konteksty i spadek wydajności

Skąd degradacja

• Pozycje: ekstrapolacja poza rozkład treningowy.
• Optymalizacja: długie sekwencje przeciążają KV-cache i stabilność atencji.
• Selekcja: realnie użyteczne jest mniej niż deklarowane okno; reszta bywa szumem.

Warstwy obrony (od praktyki po architekturę)

A. Praktyka „na jutro”

• Kompresja kontekstu (LongLLMLingua/LLMLingua-2): 2–6× krótsze wejścia; w wielu zadaniach bez straty, a czasem z poprawą jakości; raportowane przyspieszenia ~1.4–2.9× zależnie od zadania.
• Adaptacyjny retrieval (Self-RAG/FLARE): „pobierz tylko wtedy, gdy trzeba”, z autorefleksją nad źródłami.
• Budżet pozycyjny: celuj w ~20–40% okna na twarde dowody; resztę zostaw na własny tok rozumowania modelu (heurystyka — zweryfikuj A/B pod swoje dane).

B. Model i inferencja

• LongRoPE/YaRN/PI: stabilizacja i rozszerzanie okna 32k+.
• ProLong: kontynuowany pre-training + SFT pod długie sekwencje (modele do 512k).
• LIFT (test-time adaptation): adapter/uczenie z długim wejściem w czasie testu; poprawa rozumienia długiego kontekstu.
• Streaming + attention-sinks: stała pula tokenów-kotwic + okno przesuwne KV dla długich strumieni.
• Pamięć zewnętrzna: LM-Infinite/InfLLM i pokrewne — taniej niż liniowe powiększanie promptu.

C. Wielojęzyczność

• Zgodność języka (instrukcja ≈ dokumenty) albo normalizacja do jednego języka.
• Ewaluacja per język — rozjazdy rosną wraz z długością sekwencji; używaj benchmarków wielojęzycznych.

Spójny pipeline produkcyjny (szkic)

1. Retrieval: BM25 + bi-encoder (dense); weź top-50.
2. Reranking: cross-encoder/LLM-ranker → top-k (np. 8–12).
3. Kompresja: LongLLMLingua-2/LongLLMLingua z celem np. 3–5k tok.
4. Ułożenie: extreme ordering — najważniejsze na początek i koniec; środek = wsparcie.
5. Gating: szybki przebieg NO-RESPONSE po pasażach.
6. Generacja: self-consistency (n=3–7) + krytyk/refleksja nad cytatami.
7. Strumienie 64k+: włącz streaming attention z sink-tokenami i budżetem KV.

# Pseudokod
docs = retriever(q, k=50)
scored = cross_encoder.rank(q, docs)
sel = topk(scored, 10)
compressed = longllmlingua(sel, target_tokens=4000)
ordered = extreme_ordering(compressed)   # front + tail boost
kept = passage_gating(ordered, rule="NO-RESPONSE")
answer = llm.generate(kept, self_consistency=5, cite_sources=True)

Jak rzetelnie mierzyć postęp

Zestaw testów

• RULER / ONERULER: długości 8k→128k, igły wielorakie, warianty językowe (retrieval, śledzenie, agregacja).
• „Needle-in-the-Haystack” na sterydach: kilka igieł + „trudne negatywy”.
• Zadania rzeczywiste: QA/analizy z oceną faithfulness (czy cytuje właściwe źródła?).

Metryki

• Exact/EM, F1, citation precision/recall, latency, koszt tok./zapytanie, % odpowiedzi „abstain”.
• Krzywe jakość vs długość (8k, 16k, 32k, 64k…) i jakość vs budżet kontekstu.

Prosty plan A/B

1. Zbiór ~200–500 pytań (min. 3 domeny, 2 języki).
2. Warunki: baseline, +reranking, +kompresja, +ordering, +gating, +self-consistency.
3. Analiza błędów: osobno „środek kontekstu”, „dystraktory”, „przepełnienie”.
4. Raport: tabela z kosztem i poprawą jakości per warunek.

Checklisty wdrożeniowe

Lost in the Middle

• Cross-encoder reranking przed wstawieniem do promptu.
• Extreme ordering (front+tail).
• Hierarchiczne streszczenia (map→reduce).
• Jeśli możliwe: LongRoPE/YaRN/PI + Ms-PoE; augmentacja pozycyjna w SFT.

Rozpraszające prompty

• Instrukcja „używaj tylko koniecznych informacji” + format z [DOWODY]→[ODP.].
• Few-shot z hałasem i filtrowaniem.
• Gating/abstencja (NO-RESPONSE) na pasażach.
• Self-consistency (n≥3) dla zadań wrażliwych.

Wielkie konteksty

• Kompresja (LongLLMLingua/LLMLingua-2) przed włożeniem do LLM.
• Streaming attention + sink tokens przy strumieniach.
• Pamięć zewnętrzna zamiast „wszystko w prompt”.
• ProLong/LIFT, gdy masz wpływ na model/inferencję.

Najczęstsze anty-wzorce (i jak je naprawić)

• „Wrzucę więcej kontekstu, będzie lepiej” → Nie. Najpierw selekcja/kompresja, potem ułożenie.
• „Damy 20 przykładów few-shot” → Krótszy, dobrze dobrany wzorzec + format bywa odporniejszy.
• „Skoro okno to 128k, użyjemy 120k” → Realnie skuteczne bywa 20–40% okna. Resztę trzymaj w indeksie/pamięci (heurystyka → sprawdź A/B).

Na koniec

Długi kontekst bywa kuszący, ale nie jest darmowy. Najlepsze wyniki daje selekcja i kompresja informacji, świadome obchodzenie biasu pozycyjnego (front+tail), oraz pipeline, który wie, kiedy milczeć (gating/abstencja) i kiedy dopytać źródła (iteracyjny retrieval). Zmiany architektoniczne i treningowe potrafią dołożyć kolejne punkty, lecz najpierw wyciśnij maksimum z warstwy aplikacyjnej.

Bibliografia i wybrane źródła

1. Liu, N. F., et al. (2023/2024). Lost in the Middle: How Language Models Use Long Contexts / wersja TACL: PDF.
2. Shi, F., et al. (2023). Large Language Models Can Be Easily Distracted by Irrelevant Context (ICLR). Alternatywnie: wersja wydawnicza.
3. Hsieh, C.-P., et al. (2024). RULER: What’s the Real Context Size of Your Long-Context Language Models? (+ repo).
4. Kim, Y., et al. (2025). OneRULER: Benchmarking multilingual long-context language models (OpenReview: strona).
5. Hengle, A., et al. (2025). Can LLMs reason over extended multilingual contexts?
6. Ding, Y., et al. (2024). LongRoPE: Extending LLM Context Window Beyond 2 Million Tokens.
7. Peng, B., et al. (2023). YaRN: Efficient Context Window Extension of Large Language Models (OpenReview: strona).
8. Chen, S., et al. (2023). Position Interpolation (PI).
9. Gao, T., Wettig, A., Yen, H., Chen, D. (2024/2025). How to Train Long-Context Language Models (Effectively) (ACL-Findings 2025: PDF; ProLong: repo).
10. Mao, Y., et al. (2024/2025). LIFT: Improving Long Context Understanding Through Long Input Fine-Tuning.
11. Xiao, G., et al. (2023/ICLR-2024). Efficient Streaming Language Models with Attention Sinks (StreamingLLM) (GitHub: repo).
12. Han, C., et al. (2024). LM-Infinite: Zero-Shot Extreme Length Generalization for LLMs.
13. Xiao, C., et al. (2024). InfLLM: Training-Free Long-Context Extrapolation for LLMs with an Efficient Context Memory.
14. Jiang, H., et al. (2023). LLMLingua; Jiang, H., et al. (2024). LongLLMLingua (ACL-Long 2024: PDF); Pan, Z., et al. (2024). LLMLingua-2 (MSR: strona).
15. Asai, A., et al. (2023). Self-RAG: Learning to Retrieve, Generate, and Critique (strona: selfrag.github.io).
16. Jiang, Z., et al. (2023). FLARE: Active Retrieval Augmented Generation (EMNLP 2023: strona).
17. Zhang, Z., et al. (2024). Found in the Middle: Plug-and-Play Positional Encoding (Ms-PoE).
18. Amiraz, C., Cuconasu, F., Filice, S., Karnin, Z. (2025). The Distracting Effect: Understanding Irrelevant Passages in RAG (ACL 2025: PDF).
19. (Reranking) Nogueira, R., Cho, K. (2019). Passage Re-ranking with BERT.
20. (Dense late-interaction) Santhanam, K., et al. (2022). ColBERTv2: Effective and Efficient Retrieval via Lightweight Late Interaction (NAACL 2022: PDF).