Sıfırdan LLM

class TransformerBlock:
    def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1):
        self.att = MultiHeadAttention(num_heads, key_dim=embed_dim)
        self.ffn = Sequential([
            Dense(ff_dim, activation="relu"),
            Dense(embed_dim)
        ])
        self.layernorm1 = LayerNormalization(epsilon=1e-6)
        self.layernorm2 = LayerNormalization(epsilon=1e-6)
        self.dropout1 = Dropout(rate)
        self.dropout2 = Dropout(rate)
    def call(self, inputs, training):
        attn_output = self.att(inputs, inputs)
        attn_output = self.dropout1(attn_output, training=training)
        out1 = self.layernorm1(inputs + attn_output)
        ffn_output = self.ffn(out1)
        ffn_output = self.dropout2(ffn_output, training=training)
        return self.layernorm2(out1 + ffn_output)

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
text = "Merhaba dünya, LLM eğitiyoruz!"
# Token'lara böl
tokens = tokenizer.tokenize(text)
# Token ID'lerine çevir
input_ids = tokenizer.encode(text)
print("Tokenlar:", tokens)
print("Token ID'leri:", input_ids)

# Veri seti yükleme ve önişleme örneği (PySpark ile)
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("LLM Data Preprocessing").getOrCreate()
# Büyük veri dosyalarını oku
df = spark.read.text("s3://my-bucket/raw_data/*.txt")
# Temizleme işlemleri: HTML tag'leri kaldır, deduplikasyon yap, dil filtresi uygula
cleaned_df = df.filter(...).map(clean_html).dropDuplicates()
# Tokenizasyon öncesi kaydet
cleaned_df.write.parquet("s3://my-bucket/cleaned_data/")

import torch.nn.functional as F
# Model çıktıları (logits): [batch_size, sequence_length, vocab_size]
logits = model(input_ids)  # Şekil: (B, T, V)
# Hedefler: Bir sonraki token'ların ID'leri
targets = input_ids[:, 1:]  # Şekil: (B, T-1)
# Çıktıları kaydırmak (shift)
shifted_logits = logits[:, :-1, :]  # Şekil: (B, T-1, V)
# Kayıp: Cross Entropy
loss = F.cross_entropy(
    shifted_logits.reshape(-1, shifted_logits.size(-1)),
    targets.reshape(-1)
)

for epoch in range(num_epochs):
    for batch in dataloader:
        optimizer.zero_grad()
        outputs = model(batch['input_ids'])
        loss = compute_loss(outputs, batch['labels'])
        loss.backward()          # Gradyanları hesapla
        optimizer.step()         # Ağırlıkları güncelle
        # Gradyanları kes (gradient clipping)
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        # İlerleme kaydı
        if step % 100 == 0:
            print(f"Adım {step}, Kayıp: {loss.item():.4f}")

# PyTorch ile çoklu GPU kullanımı
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
# Dağıtık ortamı başlat
dist.init_process_group(backend="nccl")
# Modeli GPU'ya taşı ve DDP'ye sar
model = MyLLMModel().to(device)
model = DDP(model, device_ids=[local_rank])
# Optimizatörü ve DataLoader'ı ayarla
optimizer = torch.optim.AdamW(model.parameters())
dataloader = prepare_distributed_dataloader(dataset)

# Hugging Face Transformers ile fine-tuning
from transformers import GPT2LMHeadModel, Trainer, TrainingArguments
model = GPT2LMHeadModel.from_pretrained("gpt2")
training_args = TrainingArguments(
    output_dir="./results",
    per_device_train_batch_size=4,
    num_train_epochs=3,
    save_steps=500,
    logging_steps=100,
)
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=data_collator,
)
trainer.train()