Inom området artificiell intelligens har Large Language Models (LLM) som GPT (Generative Pretrained Transformers) tagit centrumscenen. Du har förmodligen använt ChatGPT, Bard eller någon annan textgenererande trollformel för att fråga om allt från programmering till cocktailrecept. Men bakom magin finns en komplex arkitektur som drivs av djupinlärning, neurala nätverk och enorma textdataset. Låt oss bryta ner detta, och under processen kommer jag att visa dig hur du kodar och bygger din egen LLM från grunden.

Denna guide kommer att leda dig genom de väsentliga delarna av vad en LLM är, hur man bygger en, hur man tränar den, och, viktigast av allt, hur man gör det medan man njuter av en varm kopp te.

1. Vad är en LLM?

Föreställ dig en robot som är riktigt bra på att förstå och generera text. Det är en Large Language Model. Den är som den där vännen som kan avsluta dina meningar men inte är lika irriterande eftersom den drivs av miljarder parametrar som förutsäger nästa ord i en sekvens. LLM är tekniken bakom textgenerering, översättning, sammanfattning och mer. De fungerar baserat på djupa neurala nätverk, tränade med enorma mängder textdata för att uppfatta nyanser, relationer och sammanhang i mänskligt språk.

LLM förlitar sig på en arkitektur som kallas Transformers, introducerad i 2017 års artikel Attention Is All You Need. Transformers gör det möjligt för modeller att fokusera på olika delar av en ingång (kallas självuppmärksamhet) och generera sammanhängande text. Och nej, de "förstår" faktiskt inte språk som människor, de gör bara mycket smarta gissningar baserade på statistiska mönster i datan.

2. Bygga en LLM: Stegen

Steg 1: Datainsamling och förbehandling

Innan du hoppar in i kodningen behöver du en dataset. En LLM tränas på massiva mängder textdata. Till exempel tränades GPT-3 på ungefär 570 GB text från CommonCrawl dataset, böcker, Wikipedia och mer. För att hålla saker enkla (och ditt grafikkort intakt), kan du börja smått genom att träna på en korpus som The Verdict av Edith Wharton.

Tokenisering: Din modell kan inte förstå rå text. Den behöver siffror. Det är där tokenisering kommer in – att dela upp text i hanterbara bitar (ord, subord eller tecken) och omvandla dem till siffror (ID). Detta görs med tokenizers som Byte Pair Encoding (BPE) och genom att använda PyTorch-biblioteket.

import re

def simple_tokenizer(text):
    tokens = re.findall(r'\b\w+\b', text.lower())
    return tokens

text = "Hello, I am building an LLM!"
tokens = simple_tokenizer(text)
print(tokens)

Steg 2: Transformer-arkitekturen

Ryggraden i de flesta LLM är Transformern. På en hög nivå har en Transformer en kodare (för att läsa text) och en avkodare (för att generera text). I GPT-modeller behöver du dock bara avkodardelen eftersom du bara genererar text, inte översätter den.

import torch
import torch.nn as nn

class SimpleTransformer(nn.Module):
    def __init__(self, vocab_size, d_model, nhead, num_layers):
        super(SimpleTransformer, self).__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.transformer = nn.Transformer(d_model, nhead, num_layers)
        self.fc = nn.Linear(d_model, vocab_size)
    
    def forward(self, src, tgt):
        src_emb = self.embedding(src)  # Bädda in indata
        tgt_emb = self.embedding(tgt)
        transformer_out = self.transformer(src_emb, tgt_emb)
        output = self.fc(transformer_out)
        return output

Steg 3: Förtränar din modell

Att träna en LLM som GPT från grunden är dyrt (tänk miljontals dollar för molnberäkning). Men vi kan implementera en förenklad träningsloop med PyTorch.

Först måste du träna din modell på en textkorpus där uppgiften är att förutsäga nästa ord. Detta kallas nästa-ord-förutsägelse:

import torch.optim as optim

def train(model, data, epochs=10):
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    for epoch in range(epochs):
        for batch in data:
            src, tgt = batch
            optimizer.zero_grad()
            output = model(src, tgt[:-1])
            loss = criterion(output.view(-1, model.fc.out_features), tgt[1:].view(-1))
            loss.backward()
            optimizer.step()

        print(f'Epoch {epoch + 1}, Loss: {loss.item()}')

# Förutsätter att `data` är en DataLoader som tillhandahåller satser med (källa, mål) par.
train(model, data)

I denna träningsloop lär sig modellen att förutsäga nästa ord i målföljden givet källföljden. Du behöver en ordentlig datasetladdare (kolla PyTorch's DataLoader) för att mata in batchar av tokeniserad text i modellen.

Steg 4: Finjustering

När du har tränat din basmodell är det dags att finjustera den för specifika uppgifter. Detta kan vara allt från att svara på frågor till att översätta språk. Du tar den förtränade modellen och fortsätter att träna den på en mindre, uppgiftsspecifik dataset.

Finjustering kräver en dataset med indata-utdata-par, som frågor och svar. Modellen justeras för att minimera fel vid förutsägelse av rätt utdata för varje indata.

Steg 5: Använda förtränade modeller

Om förträning låter för mycket för din CPU kan du använda öppet tillgängliga förtränade modeller, som GPT-2 eller GPT-3 via bibliotek som Hugging Face's Transformers. Här är hur du kan ladda en modell för textgenerering:

from transformers import GPT2LMHeadModel, GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")

input_text = "Once upon a time"
input_ids = tokenizer.encode(input_text, return_tensors="pt")
output = model.generate(input_ids, max_length=50)

print(tokenizer.decode(output[0], skip_special_tokens=True))

På bara några rader har du en textgenererande maskin som kan fortsätta vilken prompt som helst.

3. Hur man tränar en LLM

Förträning

Förträning innebär att man matar in stora mängder text till modellen för att förutsäga nästa ord i en sekvens. Det är dyrt men viktigt för att lära sig allmänna språkmönster.

• Självövervakad inlärning: Modellen skapar sina egna etiketter (nästa ord) från indatasekvensen, vilket gör detta till en självövervakad uppgift.
• Massiva dataset: GPT-3 tränades på 300 miljarder tokens. I utbildningssyfte kan du börja med mindre dataset.

Finjustering

Finjustering innebär att modellen tränas ytterligare på en specifik uppgift. Till exempel kan du finjustera en LLM för att utmärka sig inom textsummering eller frågesvar.

# Finjusteringskod med en mindre dataset
model.train()
for epoch in range(5):
    for batch in fine_tune_data:
        inputs, labels = batch
        optimizer.zero_grad()
        outputs = model(inputs, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

4. Slutord

Att bygga en LLM från grunden är en spännande resa genom djupinlärningslandet. Det är som att konstruera ett sinne som kan prata, skriva och (nästan) tänka. Med denna guide har du en ritning för att bygga en enkel LLM, finjustera den eller helt enkelt använda förtränade modeller. Oavsett om du skapar din egen AI-assistent eller en textgenererande bot, är möjligheterna oändliga.

Denna artikel gick igenom mina reflektioner över "Build an Large Language Model from Scratch" skriven av Sebastian Raschka. Kodavsnitten är förenklade för att undvika att ditt grafikkort tar eld, men koncepten hjälper dig att skala upp om du bestämmer dig för att dyka djupare.

Lycka till med kodningen, och må dina LLM alltid vara vältaliga!