Datele și tokenizarea
Un model de limbaj învață doar din textul pe care îl primește. În această primă etapă pregătim datele și le aducem la forma pe care rețeaua o poate prelucra: un șir de numere de identificare (ID-uri), câte unul pentru fiecare token.
La redare, playerul se încarcă de pe YouTube (detalii).
Setul de date TinyStories
Secțiune intitulată „Setul de date TinyStories”TinyStories este un set de povești scurte pentru copii, în limba engleză, publicat în 2023 de Ronen Eldan și Yuanzhi Li, de la Microsoft Research, în articolul „TinyStories: How Small Can Language Models Be and Still Speak Coherent English?”. Poveștile au fost generate de GPT-3.5 și GPT-4 și folosesc doar cuvinte pe care le înțelege un copil de 3–4 ani. Versiunea a doua, folosită aici, conține doar povești generate de GPT-4.
Articolul a arătat că modele de doar câteva milioane de parametri, antrenate pe aceste povești, scriu texte coerente și corecte gramatical. Un model la fel de mic, antrenat pe pagini web, ar produce mai ales fraze fără sens, pentru că ar trebui să acopere un vocabular și o varietate de subiecte mult mai mari. Datorită datelor simple, antrenarea durează doar câteva minute pe un laptop. Poveștile sunt în engleză, deci și modelul din laborator va scrie în engleză.
Exemplul de mai jos citește eșantionul de 300 de povești folosit în browser, în care poveștile sunt separate prin tokenul <|endoftext|>, apoi afișează câteva statistici și prima poveste.
from js import locationfrom pyodide.http import open_url
LAB = location.origin + "/laboratoare/model-lingvistic-de-la-zero/"text = open_url(LAB + "date/povesti.txt").read()
EOT = "<|endoftext|>"stories = [s.strip() for s in text.split(EOT) if s.strip()]words = sum(len(s.split()) for s in stories)print(f"Povești: {len(stories)}, caractere: {len(text):,}")print(f"Cuvinte pe poveste, în medie: {words / len(stories):.0f}")print()print(stories[0])Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Descărcarea
Secțiune intitulată „Descărcarea”Fișierul data.py descarcă primii 80 MB din TinyStories și din TinyStories-Instruct, varianta cu instrucțiuni pe care o folosim la ajustarea fină. Fiecare set are o parte de antrenare (train) și una de validare (valid). Partea de validare nu este folosită la antrenare, ci doar pentru a măsura cât de bine se descurcă modelul pe texte pe care nu le-a văzut.
DOWNLOADS = { "train.txt": f"{HF}/TinyStories/resolve/main/TinyStoriesV2-GPT4-train.txt", "valid.txt": f"{HF}/TinyStories/resolve/main/TinyStoriesV2-GPT4-valid.txt", "instruct_train.txt": f"{HF}/TinyStoriesInstruct/resolve/main/TinyStories-Instruct-train.txt", "instruct_valid.txt": f"{HF}/TinyStoriesInstruct/resolve/main/TinyStories-Instruct-valid.txt",}
MAX_BYTES = 80 * 2**20
def download(url, path): with urllib.request.urlopen(url) as response: raw = response.read(MAX_BYTES) text = raw.decode("utf-8", errors="ignore") text = text[: text.rfind(EOT) + len(EOT)] with open(path, "w", encoding="utf-8") as f: f.write(text) print(f"{os.path.basename(path):<20}{len(raw) / 2**20:6.1f} MB {text.count(EOT):>9,} povești")Citirea se oprește după 80 MB, iar textul este tăiat după ultimul <|endoftext|>, ca să nu rămână la final o poveste neterminată. Pentru un model de 14,6 milioane de parametri, cele aproximativ 20 de milioane de tokenuri din partea de antrenare sunt suficiente, pentru că în zece minute modelul nu ajunge să le vadă nici măcar o dată pe toate.
Pretokenizarea
Secțiune intitulată „Pretokenizarea”Un tokenizator are două părți: o regulă care taie textul în bucăți și un vocabular (vocabulary), adică lista bucăților pe care modelul le cunoaște. Laboratorul folosește cea mai simplă variantă care funcționează în practică, un tokenizator la nivel de cuvânt (word-level tokenizer). O expresie regulată păstrează cuvintele și șirurile de semne de punctuație și renunță la spații.
PRETOKENIZE = re.compile(r"\w+|[^\w\s]+")
def pretokenize(text): return PRETOKENIZE.findall(text)În Python, \w recunoaște și literele cu diacritice, așa că și cuvintele românești rămân întregi. Exemplul folosește chiar fișierul tokenizer.py al laboratorului.
from tokenizer import pretokenize
print(pretokenize('Once upon a time, a cat said "Hello!"'))print(pretokenize("Rețelele neuronale învață din date."))print(pretokenize("It's 3:30... time to go!"))Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Semnele de punctuație alăturate rămân împreună, de exemplu !" sau ..., iar It's se desparte în trei bucăți. Spațiile și trecerile la rând nou dispar complet, așa că modelul nu le va vedea niciodată.
Vocabularul
Secțiune intitulată „Vocabularul”Vocabularul are 10.000 de tokenuri. Primele trei sunt tokenuri speciale (special tokens), iar restul sunt cele mai frecvente bucăți din datele de antrenare.
[UNK]înlocuiește orice bucată care nu este în vocabular.[PAD]completează secvențele scurte dintr-un lot, la ajustarea fină.<|endoftext|>marchează sfârșitul unei povești.
def build_vocab(paths, size, min_count=2): counts = Counter() for path in paths: with open(path, encoding="utf-8") as f: for line in f: counts.update(pretokenize(line.replace(EOT, " "))) ranked = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0])) words = [word for word, count in ranked if count >= min_count] return SPECIALS + words[: size - len(SPECIALS)], countsLa frecvențe egale, bucățile sunt ordonate alfabetic. Astfel, aceleași date dau mereu același vocabular și aceleași numere de identificare, numite ID-uri. Bucățile care apar o singură dată (min_count=2) nu intră în vocabular, pentru că sunt adesea greșeli de scriere sau nume inventate.
Exemplul de mai jos construiește din eșantion vocabulare de mai multe mărimi și calculează ce parte din text acoperă fiecare.
from tokenizer import build_vocab
vocab, counts = build_vocab(["povesti.txt"], size=1000)total = sum(counts.values())print(f"Bucăți în eșantion: {total:,}, distincte: {len(counts):,}")print("Cele mai frecvente:", vocab[3:23])print()for size in [50, 100, 500, 1000, 2000]: v, _ = build_vocab(["povesti.txt"], size) covered = sum(counts[w] for w in v[3:]) print(f"Vocabular de {size:>4} tokenuri: {len(v):>4} folosite, acoperă {covered / total:.1%} din text")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Câteva sute de cuvinte acoperă cea mai mare parte a textului, iar fiecare cuvânt nou adăugat în vocabular acoperă tot mai puțin. Pe datele complete, cele 10.000 de tokenuri din vocabular sunt alese dintre 22.245 de bucăți distincte și lasă necunoscute doar 0,08% din tokenuri.
Codificarea și decodificarea
Secțiune intitulată „Codificarea și decodificarea”Clasa WordTokenizer face trecerea în ambele sensuri. Metoda encode transformă textul în ID-uri, iar decode face transformarea inversă.
def detokenize(tokens): text = " ".join(tokens) text = re.sub(r" ([.,!?;:]\S*)", r"\1", text) text = re.sub(r"(\w) ' (\w)", r"\1'\2", text) text = re.sub(r'(^|\s)" ', r'\1"', text) return text
class WordTokenizer: def __init__(self, vocab): self.id_to_token = list(vocab) self.token_to_id = {token: i for i, token in enumerate(self.id_to_token)} self.unk_id = self.token_to_id[UNK] self.pad_id = self.token_to_id[PAD] self.eot_id = self.token_to_id[EOT]
def __len__(self): return len(self.id_to_token)
def encode(self, text): ids = [] for piece in SPECIALS_SPLIT.split(text): if piece in SPECIALS: ids.append(self.token_to_id[piece]) else: ids.extend(self.token_to_id.get(t, self.unk_id) for t in pretokenize(piece)) return ids
def decode(self, ids, skip_special=True): tokens = [self.id_to_token[i] for i in ids] if skip_special: tokens = [t for t in tokens if t not in SPECIALS] return detokenize(tokens)Tokenurile speciale sunt separate înainte de pretokenizare, ca <|endoftext|> să devină un singur ID. Altfel, expresia regulată ar tăia tokenul în trei bucăți: <|, endoftext și |>. La decodificare, tokenurile sunt unite cu spații, iar funcția detokenize scoate spațiile dinaintea punctuației.
from tokenizer import WordTokenizer, build_vocab
vocab, _ = build_vocab(["povesti.txt"], size=1000)tokenizer = WordTokenizer(vocab)
text = 'Once upon a time, a little robot said "Hello!"'ids = tokenizer.encode(text)print([tokenizer.id_to_token[i] for i in ids])print(ids)print(tokenizer.decode(ids))print(tokenizer.decode(tokenizer.encode("The dog ran.<|endoftext|>The end."), skip_special=False))Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Cu vocabularul de 1.000 de tokenuri din eșantion, un cuvânt care lipsește devine [UNK] și se pierde la decodificare. Tot la decodificare se pierde și forma exactă a textului, pentru că spațiile multiple și trecerile la rând nou nu mai pot fi refăcute.
Fișierele cu tokenuri
Secțiune intitulată „Fișierele cu tokenuri”După construirea vocabularului, fiecare parte a setului de date este codificată o singură dată și salvată ca șir de ID-uri.
def encode(tokenizer, src, dst): with open(src, encoding="utf-8") as f: ids = np.array(tokenizer.encode(f.read()), dtype=np.uint16) ids.tofile(dst) unknown = (ids == tokenizer.unk_id).mean() print(f"{os.path.basename(dst):<20}{len(ids):>12,} tokenuri {unknown:8.2%} necunoscute")
def load_tokenizer(): with open(os.path.join(DATA_DIR, "vocab.txt"), encoding="utf-8") as f: return WordTokenizer(f.read().split("\n"))
def main(): os.makedirs(DATA_DIR, exist_ok=True) for name, url in DOWNLOADS.items(): path = os.path.join(DATA_DIR, name) if not os.path.exists(path): download(url, path)
train = [os.path.join(DATA_DIR, n) for n in ("train.txt", "instruct_train.txt")] vocab, counts = build_vocab(train, VOCAB_SIZE) with open(os.path.join(DATA_DIR, "vocab.txt"), "w", encoding="utf-8") as f: f.write("\n".join(vocab)) print(f"vocabular: {len(vocab):,} din {len(counts):,} tokenuri distincte")
tokenizer = WordTokenizer(vocab) for split in ("train", "valid"): encode(tokenizer, os.path.join(DATA_DIR, f"{split}.txt"), os.path.join(DATA_DIR, f"{split}.bin"))
text = 'Once upon a time, a cat said "Hello!"' ids = tokenizer.encode(text) print() print(text) print([tokenizer.id_to_token[i] for i in ids]) print(ids) print(tokenizer.decode(ids))ID-urile sunt mai mici de 65.536, așa că fiecare încape în doi octeți, ca număr întreg fără semn pe 16 biți (uint16). Vocabularul se construiește o singură dată, din poveștile simple și din instrucțiuni împreună, pentru că după antrenarea modelului nu mai poate fi schimbat. La antrenare, fișierul train.bin este citit prin np.memmap, deci rămâne pe disc, iar în memorie ajung doar bucățile folosite.
Mai jos, același proces este aplicat eșantionului din browser.
import numpy as npfrom tokenizer import WordTokenizer, build_vocab
vocab, _ = build_vocab(["povesti.txt"], size=1000)tokenizer = WordTokenizer(vocab)with open("povesti.txt", encoding="utf-8") as f: text = f.read()
ids = np.array(tokenizer.encode(text), dtype=np.uint16)print(ids[:16])print(f"{len(ids):,} tokenuri în {ids.nbytes:,} octeți, față de {len(text.encode()):,} octeți de text")print(f"Tokenuri necunoscute: {(ids == tokenizer.unk_id).mean():.2%}")Codul poate fi modificat și rulat direct în browser (Ctrl + Enter).
Rularea locală
Secțiune intitulată „Rularea locală”Pe calculatorul local, după pregătirea mediului, toată etapa se reduce la o singură comandă.
python data.pyDescărcarea durează câteva minute, în funcție de conexiune, iar construirea vocabularului și codificarea, circa 10 secunde pe un laptop recent. Rezultatul arată astfel.
train.txt 80.0 MB 102,243 poveștivalid.txt 21.5 MB 27,630 poveștiinstruct_train.txt 80.0 MB 76,875 poveștiinstruct_valid.txt 25.7 MB 25,027 poveștivocabular: 10,000 din 22,245 tokenuri distinctetrain.bin 19,853,261 tokenuri 0.08% necunoscutevalid.bin 5,324,231 tokenuri 0.10% necunoscute
Once upon a time, a cat said "Hello!"['Once', 'upon', 'a', 'time', ',', 'a', 'cat', 'said', '"', 'Hello', '!"'][60, 61, 7, 47, 4, 7, 100, 19, 11, 449, 58]Once upon a time, a cat said "Hello!"În directorul data/ rămân textele descărcate, vocabularul (vocab.txt, un token pe rând) și cele două fișiere binare cu tokenuri.
Directordata/
- train.txt
- valid.txt
- instruct_train.txt
- instruct_valid.txt
- vocab.txt
- train.bin
- valid.bin
Pe pagina următoare construim modelul care va învăța din aceste date.
Bibliografie
Secțiune intitulată „Bibliografie”- Eldan, R. și Li, Y. (2023). TinyStories: How Small Can Language Models Be and Still Speak Coherent English? Preprint arXiv:2305.07759. ↩︎
- Radford, A. et al. (2019). Language Models are Unsupervised Multitask Learners. Raport tehnic OpenAI.
- Sennrich, R., Haddow, B. și Birch, A. (2016). Neural Machine Translation of Rare Words with Subword Units. ACL 2016.
Cookie-uri
Site-ul folosește Google Analytics pentru statistici de trafic. Cookie-urile de analiză se activează doar după acceptare. Detalii în politica de cookie-uri.