mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00

Translator 513115c15d Translated ['src/AI/AI-llm-architecture/2.-data-sampling.md'] to de

2025-08-04 12:29:06 +00:00

14 KiB

Raw Blame History

2. Datenstichprobe

Datenstichprobe

Datenstichprobe ist ein entscheidender Prozess bei der Vorbereitung von Daten für das Training großer Sprachmodelle (LLMs) wie GPT. Es beinhaltet die Organisation von Textdaten in Eingabe- und Zielsequenzen, die das Modell verwendet, um zu lernen, wie man das nächste Wort (oder Token) basierend auf den vorhergehenden Wörtern vorhersagt. Eine ordnungsgemäße Datenstichprobe stellt sicher, dass das Modell Sprachmuster und Abhängigkeiten effektiv erfasst.

Tip

Das Ziel dieser zweiten Phase ist sehr einfach: Proben Sie die Eingabedaten und bereiten Sie sie für die Trainingsphase vor, indem Sie den Datensatz normalerweise in Sätze einer bestimmten Länge unterteilen und auch die erwartete Antwort generieren.

Warum Datenstichprobe wichtig ist

LLMs wie GPT werden trainiert, um Text zu generieren oder vorherzusagen, indem sie den Kontext verstehen, der durch vorherige Wörter bereitgestellt wird. Um dies zu erreichen, müssen die Trainingsdaten so strukturiert sein, dass das Modell die Beziehung zwischen Wortsequenzen und ihren nachfolgenden Wörtern lernen kann. Dieser strukturierte Ansatz ermöglicht es dem Modell, zu verallgemeinern und kohärenten sowie kontextuell relevanten Text zu generieren.

Schlüsselkonzepte in der Datenstichprobe

Tokenisierung: Zerlegen von Text in kleinere Einheiten, die als Tokens bezeichnet werden (z. B. Wörter, Subwörter oder Zeichen).
Sequenzlänge (max_length): Die Anzahl der Tokens in jeder Eingabesequenz.
Gleitendes Fenster: Eine Methode zur Erstellung überlappender Eingabesequenzen, indem ein Fenster über den tokenisierten Text bewegt wird.
Stride: Die Anzahl der Tokens, die das gleitende Fenster vorwärts bewegt, um die nächste Sequenz zu erstellen.

Schritt-für-Schritt-Beispiel

Lassen Sie uns ein Beispiel durchgehen, um die Datenstichprobe zu veranschaulichen.

Beispieltext

"Lorem ipsum dolor sit amet, consectetur adipiscing elit."

Tokenisierung

Angenommen, wir verwenden einen einfachen Tokenizer, der den Text in Wörter und Satzzeichen aufteilt:

Tokens: ["Lorem", "ipsum", "dolor", "sit", "amet,", "consectetur", "adipiscing", "elit."]

Parameter

Maximale Sequenzlänge (max_length): 4 Tokens
Schiebefenster-Schritt: 1 Token

Erstellen von Eingabe- und Zielsequenzen

Schiebefensteransatz:

Eingabesequenzen: Jede Eingabesequenz besteht aus max_length Tokens.
Zielsequenzen: Jede Zielsequenz besteht aus den Tokens, die unmittelbar auf die entsprechende Eingabesequenz folgen.

Generierung von Sequenzen:

Fensterposition	Eingabesequenz	Zielsequenz
1	["Lorem", "ipsum", "dolor", "sit"]	["ipsum", "dolor", "sit", "amet,"]
2	["ipsum", "dolor", "sit", "amet,"]	["dolor", "sit", "amet,", "consectetur"]
3	["dolor", "sit", "amet,", "consectetur"]	["sit", "amet,", "consectetur", "adipiscing"]
4	["sit", "amet,", "consectetur", "adipiscing"]	["amet,", "consectetur", "adipiscing", "elit."]

Ergebnis der Eingabe- und Zielarrays:

Eingabe:

[
["Lorem", "ipsum", "dolor", "sit"],
["ipsum", "dolor", "sit", "amet,"],
["dolor", "sit", "amet,", "consectetur"],
["sit", "amet,", "consectetur", "adipiscing"],
]

Ziel:

[
["ipsum", "dolor", "sit", "amet,"],
["dolor", "sit", "amet,", "consectetur"],
["sit", "amet,", "consectetur", "adipiscing"],
["amet,", "consectetur", "adipiscing", "elit."],
]

Visuelle Darstellung

Token-Position	Token
1	Lorem
2	ipsum
3	dolor
4	sit
5	amet,
6	consectetur
7	adipiscing
8	elit.

Schiebefenster mit Schritt 1:

Erstes Fenster (Positionen 1-4): ["Lorem", "ipsum", "dolor", "sit"] → Ziel: ["ipsum", "dolor", "sit", "amet,"]
Zweites Fenster (Positionen 2-5): ["ipsum", "dolor", "sit", "amet,"] → Ziel: ["dolor", "sit", "amet,", "consectetur"]
Drittes Fenster (Positionen 3-6): ["dolor", "sit", "amet,", "consectetur"] → Ziel: ["sit", "amet,", "consectetur", "adipiscing"]
Viertes Fenster (Positionen 4-7): ["sit", "amet,", "consectetur", "adipiscing"] → Ziel: ["amet,", "consectetur", "adipiscing", "elit."]

Verständnis des Schrittes

Schritt von 1: Das Fenster bewegt sich bei jedem Schritt um ein Token nach vorne, was zu stark überlappenden Sequenzen führt. Dies kann zu einem besseren Lernen der kontextuellen Beziehungen führen, erhöht jedoch das Risiko von Overfitting, da ähnliche Datenpunkte wiederholt werden.
Schritt von 2: Das Fenster bewegt sich bei jedem Schritt um zwei Tokens nach vorne, wodurch die Überlappung verringert wird. Dies reduziert Redundanz und Rechenaufwand, könnte jedoch einige kontextuelle Nuancen übersehen.
Schritt gleich max_length: Das Fenster bewegt sich um die gesamte Fenstergröße nach vorne, was zu nicht überlappenden Sequenzen führt. Dies minimiert die Datenredundanz, könnte jedoch die Fähigkeit des Modells einschränken, Abhängigkeiten zwischen Sequenzen zu lernen.

Beispiel mit Schritt von 2:

Unter Verwendung des gleichen tokenisierten Textes und max_length von 4:

Erstes Fenster (Positionen 1-4): ["Lorem", "ipsum", "dolor", "sit"] → Ziel: ["ipsum", "dolor", "sit", "amet,"]
Zweites Fenster (Positionen 3-6): ["dolor", "sit", "amet,", "consectetur"] → Ziel: ["sit", "amet,", "consectetur", "adipiscing"]
Drittes Fenster (Positionen 5-8): ["amet,", "consectetur", "adipiscing", "elit."] → Ziel: ["consectetur", "adipiscing", "elit.", "sed"] (Annahme der Fortsetzung)

Codebeispiel

Lass uns das besser anhand eines Codebeispiels von https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb verstehen:

# Download the text to pre-train the LLM
import urllib.request
url = ("https://raw.githubusercontent.com/rasbt/LLMs-from-scratch/main/ch02/01_main-chapter-code/the-verdict.txt")
file_path = "the-verdict.txt"
urllib.request.urlretrieve(url, file_path)

with open("the-verdict.txt", "r", encoding="utf-8") as f:
raw_text = f.read()

"""
Create a class that will receive some params lie tokenizer and text
and will prepare the input chunks and the target chunks to prepare
the LLM to learn which next token to generate
"""
import torch
from torch.utils.data import Dataset, DataLoader

class GPTDatasetV1(Dataset):
def __init__(self, txt, tokenizer, max_length, stride):
self.input_ids = []
self.target_ids = []

# Tokenize the entire text
token_ids = tokenizer.encode(txt, allowed_special={"<|endoftext|>"})

# Use a sliding window to chunk the book into overlapping sequences of max_length
for i in range(0, len(token_ids) - max_length, stride):
input_chunk = token_ids[i:i + max_length]
target_chunk = token_ids[i + 1: i + max_length + 1]
self.input_ids.append(torch.tensor(input_chunk))
self.target_ids.append(torch.tensor(target_chunk))

def __len__(self):
return len(self.input_ids)

def __getitem__(self, idx):
return self.input_ids[idx], self.target_ids[idx]


"""
Create a data loader which given the text and some params will
prepare the inputs and targets with the previous class and
then create a torch DataLoader with the info
"""

import tiktoken

def create_dataloader_v1(txt, batch_size=4, max_length=256,
stride=128, shuffle=True, drop_last=True,
num_workers=0):

# Initialize the tokenizer
tokenizer = tiktoken.get_encoding("gpt2")

# Create dataset
dataset = GPTDatasetV1(txt, tokenizer, max_length, stride)

# Create dataloader
dataloader = DataLoader(
dataset,
batch_size=batch_size,
shuffle=shuffle,
drop_last=drop_last,
num_workers=num_workers
)

return dataloader


"""
Finally, create the data loader with the params we want:
- The used text for training
- batch_size: The size of each batch
- max_length: The size of each entry on each batch
- stride: The sliding window (how many tokens should the next entry advance compared to the previous one). The smaller the more overfitting, usually this is equals to the max_length so the same tokens aren't repeated.
- shuffle: Re-order randomly
"""
dataloader = create_dataloader_v1(
raw_text, batch_size=8, max_length=4, stride=1, shuffle=False
)

data_iter = iter(dataloader)
first_batch = next(data_iter)
print(first_batch)

# Note the batch_size of 8, the max_length of 4 and the stride of 1
[
# Input
tensor([[   40,   367,  2885,  1464],
[  367,  2885,  1464,  1807],
[ 2885,  1464,  1807,  3619],
[ 1464,  1807,  3619,   402],
[ 1807,  3619,   402,   271],
[ 3619,   402,   271, 10899],
[  402,   271, 10899,  2138],
[  271, 10899,  2138,   257]]),
# Target
tensor([[  367,  2885,  1464,  1807],
[ 2885,  1464,  1807,  3619],
[ 1464,  1807,  3619,   402],
[ 1807,  3619,   402,   271],
[ 3619,   402,   271, 10899],
[  402,   271, 10899,  2138],
[  271, 10899,  2138,   257],
[10899,  2138,   257,  7026]])
]

# With stride=4 this will be the result:
[
# Input
tensor([[   40,   367,  2885,  1464],
[ 1807,  3619,   402,   271],
[10899,  2138,   257,  7026],
[15632,   438,  2016,   257],
[  922,  5891,  1576,   438],
[  568,   340,   373,   645],
[ 1049,  5975,   284,   502],
[  284,  3285,   326,    11]]),
# Target
tensor([[  367,  2885,  1464,  1807],
[ 3619,   402,   271, 10899],
[ 2138,   257,  7026, 15632],
[  438,  2016,   257,   922],
[ 5891,  1576,   438,   568],
[  340,   373,   645,  1049],
[ 5975,   284,   502,   284],
[ 3285,   326,    11,   287]])
]

Fortgeschrittene Sampling-Strategien (2023-2025)

1. Temperaturbasierte Mischgewichtung

State-of-the-art LLMs werden selten auf einem einzelnen Korpus trainiert. Stattdessen sampeln sie aus mehreren heterogenen Datenquellen (Code, Web, wissenschaftliche Arbeiten, Foren…). Der relative Anteil jeder Quelle kann die nachgelagerte Leistung stark beeinflussen. Neuere Open-Source-Modelle wie Llama 2 führten ein temperaturbasiertes Sampling-Schema ein, bei dem die Wahrscheinlichkeit, ein Dokument aus dem Korpus i zu ziehen, wird

p(i) = \frac{w_i^{\alpha}}{\sum_j w_j^{\alpha}}

• w_i – Rohtoken-Prozentsatz des Korpus i
• α ("Temperatur") – ein Wert in (0,1]. α < 1 flacht die Verteilung ab und gewichtet kleinere, qualitativ hochwertige Korpora stärker.

Llama 2 verwendete α = 0.7 und zeigte, dass eine Verringerung von α die Bewertungsergebnisse bei wissensintensiven Aufgaben verbesserte, während die Trainingsmischung stabil blieb. Der gleiche Trick wird von Mistral (2023) und Claude 3 übernommen.

from collections import Counter

def temperature_sample(corpus_ids, alpha=0.7):
counts = Counter(corpus_ids)           # number of tokens seen per corpus
probs  = {c: c_count**alpha for c, c_count in counts.items()}
Z = sum(probs.values())
probs = {c: p/Z for c, p in probs.items()}
# Now draw according to probs to fill every batch


### 2. Sequence Packing / Dynamic Batching
GPU memory is wasted when every sequence in a batch is padded to the longest example.  "Packing" concatenates multiple shorter sequences until the **exact** `max_length` is reached and builds a parallel `attention_mask` so that tokens do not attend across segment boundaries.  Packing can improve throughput by 20–40 % with no gradient change and is supported out-of-the-box in

* PyTorch `torchtext.experimental.agents.PackedBatch`
* HuggingFace `DataCollatorForLanguageModeling(pad_to_multiple_of=…)`

Dynamic batching frameworks (e.g. FlashAttention 2, vLLM 2024) combine sequence packing with just-in-time kernel selection, enabling thousand-token context training at 400+ K tokens/s on A100-80G.

### 3. Deduplication & Quality Filtering
Repeated passages cause memorization and provide an easy channel for data-poisoning.  Modern pipelines therefore:

1. MinHash/FAISS near-duplicate detection at **document** and **128-gram** level.
2. Filter documents whose perplexity under a small reference model is > µ + 3σ (noisy OCR, garbled HTML).
3. Block-list documents that contain PII or CWE keywords using regex & spaCy NER.

The Llama 2 team deduplicated with 8-gram MinHash and removed ~15 % of CommonCrawl before sampling.  OpenAI’s 2024 "Deduplicate Everything" paper demonstrates ≤0.04 duplicate ratio reduces over-fitting and speeds convergence.

## Security & Privacy Considerations During Sampling

### Data-Poisoning / Backdoor Attacks
Researchers showed that inserting <1 % backdoored sentences can make a model obey a hidden trigger ("PoisonGPT", 2023).  Recommended mitigations:

* **Shuffled mixing** – make sure adjacent training examples originate from different sources; this dilutes gradient alignment of malicious spans.
* **Gradient similarity scoring** – compute cosine similarity of example gradient to batch average; outliers are candidates for removal.
* **Dataset versioning & hashes** – freeze immutable tarballs and verify SHA-256 before each training run.

### Membership-Inference & Memorization
Long overlap between sliding-window samples increases the chance that rare strings (telephone numbers, secret keys) are memorized.  OpenAI’s 2024 study on ChatGPT memorization reports that raising stride from 1 × `max_length` to 4 × reduces verbatim leakage by ≈50 % with negligible loss in perplexity.

Practical recommendations:

* Use **stride ≥ max_length** except for <1B parameter models where data volume is scarce.
* Add random masking of 1-3 tokens per window during training; this lowers memorization while preserving utility.

---

## References

- [Build a Large Language Model from Scratch (Manning, 2024)](https://www.manning.com/books/build-a-large-language-model-from-scratch)
- [Llama 2: Open Foundation and Fine-Tuned Chat Models (2023)](https://arxiv.org/abs/2307.09288)
- [PoisonGPT: Assessing Backdoor Vulnerabilities in Large Language Models (BlackHat EU 2023)](https://arxiv.org/abs/2308.12364)

{{#include ../../banners/hacktricks-training.md}}

14 KiB Raw Blame History Unescape Escape