NLP & LLMs

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset
import numpy as np
from sklearn.metrics import accuracy_score, f1_score

dataset   = load_dataset("imdb")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
model     = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased", num_labels=2)

def tokenize(batch):
    return tokenizer(batch["text"], padding="max_length", truncation=True, max_length=512)

dataset = dataset.map(tokenize, batched=True)
dataset.set_format("torch", columns=["input_ids", "attention_mask", "label"])

def compute_metrics(p):
    preds = np.argmax(p.predictions, axis=1)
    return {"accuracy": accuracy_score(p.label_ids, preds),
            "f1": f1_score(p.label_ids, preds, average="weighted")}

trainer = Trainer(
    model=model,
    args=TrainingArguments(
        output_dir="./bert-imdb", num_train_epochs=3,
        per_device_train_batch_size=16, learning_rate=2e-5,
        warmup_steps=200, weight_decay=0.01, evaluation_strategy="epoch",
    ),
    train_dataset=dataset["train"].select(range(5000)),
    eval_dataset=dataset["test"].select(range(1000)),
    compute_metrics=compute_metrics,
)
trainer.train()
trainer.evaluate()

from sentence_transformers import SentenceTransformer, util
import torch

model = SentenceTransformer("all-MiniLM-L6-v2")  # fast + good quality

# Your document corpus
corpus = [
    "Machine learning finds patterns in data.",
    "Deep learning uses neural networks with many layers.",
    "Python is a popular programming language.",
    "Transformers use self-attention mechanisms.",
]

# Encode all documents
corpus_emb = model.encode(corpus, convert_to_tensor=True)

# Search
query = "How do attention mechanisms work?"
query_emb = model.encode(query, convert_to_tensor=True)
scores = util.cos_sim(query_emb, corpus_emb)[0]
top_k = torch.topk(scores, k=2)
for score, idx in zip(top_k.values, top_k.indices):
    print(f"{score:.3f} | {corpus[idx]}")

from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from trl import SFTTrainer, SFTConfig
import torch

# 4-bit quantisation (QLoRA)
bnb = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.bfloat16)
model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1", quantization_config=bnb)

# LoRA config: only train attention projections
lora = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj","v_proj"], lora_dropout=0.05)
model = get_peft_model(model, lora)
model.print_trainable_parameters()  # ~0.2% of total params

trainer = SFTTrainer(
    model=model, train_dataset=dataset,
    args=SFTConfig(output_dir="./mistral-lora", num_train_epochs=3,
                   per_device_train_batch_size=4, learning_rate=2e-4),
)
trainer.train()