2. Uzorkovanje podataka

Uzorkovanje podataka

Uzorkovanje podataka je ključni proces u pripremi podataka za obuku velikih jezičkih modela (LLM) poput GPT-a. Uključuje organizovanje tekstualnih podataka u ulazne i ciljne sekvence koje model koristi da nauči kako da predviđa sledeću reč (ili token) na osnovu prethodnih reči. Pravilno uzorkovanje podataka osigurava da model efikasno hvata jezičke obrasce i zavisnosti.

Zašto je uzorkovanje podataka važno

LLM-ovi kao što je GPT obučeni su da generišu ili predviđaju tekst razumevanjem konteksta koji pružaju prethodne reči. Da bi se to postiglo, obučeni podaci moraju biti strukturirani na način da model može naučiti odnos između sekvenci reči i njihovih sledećih reči. Ovaj strukturirani pristup omogućava modelu da generalizuje i generiše koherentan i kontekstualno relevantan tekst.

Ključni koncepti u uzorkovanju podataka

1. Tokenizacija: Razbijanje teksta na manje jedinice nazvane tokeni (npr. reči, podreči ili karakteri).
2. Dužina sekvence (max_length): Broj tokena u svakoj ulaznoj sekvenci.
3. Klizni prozor: Metoda za kreiranje preklapajućih ulaznih sekvenci pomeranjem prozora preko tokenizovanog teksta.
4. Korak: Broj tokena koje klizni prozor pomera unapred da bi kreirao sledeću sekvencu.

Primer korak po korak

Hajde da prođemo kroz primer kako bismo ilustrovali uzorkovanje podataka.

Primer teksta

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

Tokenizacija

Pretpostavimo da koristimo osnovni tokenizator koji deli tekst na reči i interpunkcijske znakove:

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

Parametri

• Maksimalna dužina sekvence (max_length): 4 tokena
• Korak kliznog prozora: 1 token

Kreiranje ulaznih i ciljanih sekvenci

1. Pristup kliznom prozoru:

• Ulazne sekvence: Svaka ulazna sekvenca se sastoji od max_length tokena.
• Ciljane sekvence: Svaka ciljana sekvenca se sastoji od tokena koji odmah slede odgovarajuću ulaznu sekvencu.

2. Generisanje sekvenci:

3. Rezultantni ulazni i ciljani nizovi:

• Ulaz:

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

• Cilj:

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

Vizuelna reprezentacija

Klizni prozor sa korakom 1:

• Prvi prozor (Pozicije 1-4): ["Lorem", "ipsum", "dolor", "sit"] → Cilj: ["ipsum", "dolor", "sit", "amet,"]
• Drugi prozor (Pozicije 2-5): ["ipsum", "dolor", "sit", "amet,"] → Cilj: ["dolor", "sit", "amet,", "consectetur"]
• Treći prozor (Pozicije 3-6): ["dolor", "sit", "amet,", "consectetur"] → Cilj: ["sit", "amet,", "consectetur", "adipiscing"]
• Četvrti prozor (Pozicije 4-7): ["sit", "amet,", "consectetur", "adipiscing"] → Cilj: ["amet,", "consectetur", "adipiscing", "elit."]

Razumevanje koraka

• Korak od 1: Prozor se pomera napred za jedan token svaki put, što rezultira visokom preklapanju sekvenci. To može dovesti do boljeg učenja kontekstualnih odnosa, ali može povećati rizik od prekomernog prilagođavanja jer se slične tačke podataka ponavljaju.
• Korak od 2: Prozor se pomera napred za dva tokena svaki put, smanjujući preklapanje. Ovo smanjuje redundanciju i računarsko opterećenje, ali može propustiti neke kontekstualne nijanse.
• Korak jednak max_length: Prozor se pomera napred za celu veličinu prozora, što rezultira nepreklapajućim sekvencama. Ovo minimizira redundanciju podataka, ali može ograničiti sposobnost modela da uči zavisnosti između sekvenci.

Primer sa korakom od 2:

Koristeći isti tokenizovani tekst i max_length od 4:

• Prvi prozor (Pozicije 1-4): ["Lorem", "ipsum", "dolor", "sit"] → Cilj: ["ipsum", "dolor", "sit", "amet,"]
• Drugi prozor (Pozicije 3-6): ["dolor", "sit", "amet,", "consectetur"] → Cilj: ["sit", "amet,", "consectetur", "adipiscing"]
• Treći prozor (Pozicije 5-8): ["amet,", "consectetur", "adipiscing", "elit."] → Cilj: ["consectetur", "adipiscing", "elit.", "sed"] (Pretpostavljajući nastavak)

Primer koda

Hajde da ovo bolje razumemo iz primera koda sa https://github.com/rasbt/LLMs-from-scratch/blob/main/ch02/01_main-chapter-code/ch02.ipynb:

# 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]])
]

Reference

• https://www.manning.com/books/build-a-large-language-model-from-scratch