# ===========================
# Core libraries
# ===========================
pip install transformers        # models, pipelines, Auto classes
pip install datasets            # dataset loading & processing
pip install tokenizers          # fast Rust-based tokenizers
pip install accelerate          # multi-GPU, mixed precision

# Or install everything at once:
pip install transformers[torch] datasets accelerate

# ===========================
# Backend: PyTorch or TensorFlow
# ===========================
pip install torch               # PyTorch (RECOMMENDED — community default)
# pip install tensorflow        # TensorFlow (also supported)
# HF Transformers supports BOTH backends!
# This series uses PyTorch (90% of HF community uses PyTorch)

# ===========================
# Optional but useful
# ===========================
pip install evaluate            # evaluation metrics
pip install peft                # LoRA, QLoRA (efficient fine-tuning)
pip install trl                 # RLHF training (ChatGPT-style)
pip install bitsandbytes        # 4-bit/8-bit quantization
pip install sentencepiece       # for T5, LLaMA tokenizers

# ===========================
# Verify installation
# ===========================
python -c "import transformers; print(f'transformers {transformers.__version__}')"
python -c "import datasets; print(f'datasets {datasets.__version__}')"
python -c "import torch; print(f'PyTorch {torch.__version__}, CUDA: {torch.cuda.is_available()}')"
# transformers 4.47.x
# datasets 3.2.x
# PyTorch 2.5.x, CUDA: True

# ===========================
# 1. Buka colab.research.google.com
# 2. Runtime → Change runtime type → GPU (T4)
# 3. Jalankan cell berikut:
# ===========================

# Install/update HF libraries (sudah pre-installed, tapi update)
!pip install -q transformers datasets accelerate evaluate

# Verify GPU
import torch
print(f"GPU: {torch.cuda.get_device_name(0)}")
# GPU: Tesla T4

# Test pipeline
from transformers import pipeline
classifier = pipeline("sentiment-analysis", device=0)  # GPU!
print(classifier("Hugging Face is amazing!"))
# [{'label': 'POSITIVE', 'score': 0.9998}]

# ✅ Selesai! Siap fine-tuning BERT dengan GPU gratis!
# Colab T4 = 16GB VRAM → cukup untuk BERT, DistilBERT, RoBERTa
# Tidak cukup untuk: LLaMA 7B+, Stable Diffusion (butuh A100)

# ===========================
# Setup di laptop/desktop Anda
# ===========================

# 1. Buat virtual environment (recommended!)
python -m venv hf-env
source hf-env/bin/activate  # Linux/Mac
# hf-env\Scripts\activate    # Windows

# 2. Install PyTorch (pilih sesuai GPU Anda)
# CPU only:
pip install torch torchvision torchaudio
# NVIDIA GPU (CUDA 12.x):
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

# 3. Install Hugging Face stack
pip install transformers datasets accelerate evaluate

# 4. Test
python -c "from transformers import pipeline; print(pipeline('sentiment-analysis')('Hello!'))"

# ===========================
# Di mana model disimpan?
# ===========================
# Model di-download ke cache folder:
# Linux/Mac: ~/.cache/huggingface/hub/
# Windows:   C:\Users\\.cache\huggingface\hub\
#
# BERT base: ~420 MB
# DistilBERT: ~250 MB
# GPT-2 small: ~550 MB
# LLaMA 3.2 1B: ~2.5 GB
# LLaMA 3.2 8B: ~16 GB
#
# Pertama kali download → lambat
# Kedua kali → instant (cached!)
#
# Hapus cache: rm -rf ~/.cache/huggingface/hub/

import requests

# ===========================
# Method 1: Direct HTTP request (no library needed!)
# ===========================
API_URL = "https://api-inference.huggingface.co/models/distilbert-base-uncased-finetuned-sst-2-english"
headers = {"Authorization": "Bearer hf_YOUR_TOKEN_HERE"}
# Get free token: huggingface.co/settings/tokens

response = requests.post(API_URL, headers=headers,
    json={"inputs": "I love this product!"})
print(response.json())
# [[{'label': 'POSITIVE', 'score': 0.9998}]]

# ===========================
# Method 2: huggingface_hub library (easier)
# ===========================
from huggingface_hub import InferenceClient

client = InferenceClient(token="hf_YOUR_TOKEN")

# Text classification
result = client.text_classification("I love this!")
print(result)  # [TextClassificationOutput(label='POSITIVE', score=0.9998)]

# Text generation
result = client.text_generation(
    "The meaning of life is",
    model="gpt2",
    max_new_tokens=50
)
print(result)

# Translation
result = client.translation("I am learning AI",
    model="Helsinki-NLP/opus-mt-en-id")
print(result)  # "Saya sedang belajar AI"

# ===========================
# Kapan pakai Inference API?
# ===========================
# ✅ Prototyping cepat (tidak perlu GPU lokal)
# ✅ Demo kecil (< 1000 requests/hari)
# ✅ Test model baru sebelum download
# ❌ Training / fine-tuning (hanya inference!)
# ❌ Production (rate limited, cold starts)
# ❌ Data sensitif (data dikirim ke server HF)

import gradio as gr
from transformers import pipeline

# Load model
classifier = pipeline("sentiment-analysis")

# Define interface
def analyze(text):
    result = classifier(text)[0]
    return f"{result['label']} ({result['score']:.1%})"

# Create Gradio app
demo = gr.Interface(
    fn=analyze,
    inputs=gr.Textbox(placeholder="Type your text here..."),
    outputs="text",
    title="🤗 Sentiment Analyzer",
    description="Analyze sentiment of any English text",
)
demo.launch()

# ===========================
# Deploy ke HF Spaces:
# 1. Buat repo di huggingface.co/new-space
# 2. Pilih "Gradio" sebagai SDK
# 3. Upload app.py + requirements.txt
# 4. Otomatis deploy → dapat URL: username.hf.space/sentiment
# 5. GRATIS untuk CPU! GPU mulai $0.60/jam
# ===========================

# ===========================
# Option 5: HF Inference Endpoints (managed hosting)
# → huggingface.co/inference-endpoints
# ===========================
# 1. Pilih model dari Hub
# 2. Pilih hardware (CPU/GPU/A100)
# 3. Pilih region (US, EU, Asia)
# 4. Deploy → dapat production API URL
# 5. Auto-scaling, monitoring, HTTPS included
# 
# Pricing:
# CPU (2 vCPU):     ~$0.06/jam  (~$43/bulan)
# GPU T4 (16GB):    ~$0.60/jam  (~$432/bulan)
# GPU A10G (24GB):  ~$1.30/jam  (~$936/bulan)
# GPU A100 (80GB):  ~$4.50/jam  (~$3,240/bulan)
# 
# Best for: production API tanpa manage infrastructure

# ===========================
# Option 6: Self-Hosting (Docker on your server)
# ===========================
# A. Simple: FastAPI + model
from fastapi import FastAPI
from transformers import pipeline

app = FastAPI()
classifier = pipeline("sentiment-analysis", device=0)

@app.post("/predict")
async def predict(text: str):
    result = classifier(text)
    return result

# uvicorn app:app --host 0.0.0.0 --port 8000
# Deploy dengan Docker → AWS EC2, GCP VM, DigitalOcean, dll.

# B. Optimized: Text Generation Inference (TGI)
# Docker container dari HF untuk LLM serving
# docker run --gpus all -p 8080:80 \
#   ghcr.io/huggingface/text-generation-inference \
#   --model-id meta-llama/Llama-3.2-1B
# 
# Optimized: continuous batching, flash attention, quantization
# Best for: high-throughput LLM serving

# C. vLLM (alternative to TGI)
# pip install vllm
# python -m vllm.entrypoints.openai.api_server \
#   --model meta-llama/Llama-3.2-1B --port 8000
# → OpenAI-compatible API for any HF model!

from transformers import pipeline

# ===========================
# 1. Sentiment Analysis — one line!
# ===========================
classifier = pipeline("sentiment-analysis")
# First run: downloads model (~270MB) — cached for future use

result = classifier("I absolutely love this product! Best purchase ever.")
print(result)
# [{'label': 'POSITIVE', 'score': 0.9998}]

# Multiple texts at once (batched!)
results = classifier([
    "This movie was fantastic!",
    "Terrible experience, waste of money.",
    "It was okay, nothing special."
])
for r in results:
    print(f"  {r['label']:8s} ({r['score']:.1%})")
# POSITIVE (99.9%)
# NEGATIVE (99.8%)
# POSITIVE (63.1%)  ← uncertain → neutral-ish

# ===========================
# 2. Specify a different model
# ===========================
classifier_multi = pipeline(
    "sentiment-analysis",
    model="nlptown/bert-base-multilingual-uncased-sentiment"
)
# Now supports 6 languages! (EN, DE, NL, ES, FR, IT)
result = classifier_multi("Film ini sangat bagus!")  # Indonesian!
print(result)
# [{'label': '5 stars', 'score': 0.73}]

# ===========================
# 3. GPU acceleration
# ===========================
classifier_gpu = pipeline("sentiment-analysis", device=0)  # GPU:0
# device=0 → first GPU
# device=-1 → CPU (default)
# device="mps" → Apple Silicon

# ===========================
# 4. How pipeline() works internally
# ===========================
# pipeline("sentiment-analysis") is equivalent to:
# 1. tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased-finetuned-sst-2-english")
# 2. model = AutoModelForSequenceClassification.from_pretrained("...")
# 3. inputs = tokenizer(text, return_tensors="pt")
# 4. outputs = model(**inputs)
# 5. predictions = softmax(outputs.logits)
# 6. label = model.config.id2label[predicted_class]
# Pipeline wraps ALL of this in one call!

from transformers import pipeline

# ===========================
# 1. Named Entity Recognition (NER)
# Identifikasi entitas: orang, tempat, organisasi
# ===========================
ner = pipeline("ner", grouped_entities=True)
result = ner("Joko Widodo visited Google headquarters in Mountain View, California.")
for entity in result:
    print(f"  {entity['word']:20s} → {entity['entity_group']:5s} ({entity['score']:.1%})")
# Joko Widodo          → PER   (99.8%)
# Google               → ORG   (99.6%)
# Mountain View        → LOC   (99.9%)
# California           → LOC   (99.9%)

# ===========================
# 2. Question Answering (extractive)
# Jawab pertanyaan berdasarkan konteks
# ===========================
qa = pipeline("question-answering")
result = qa(
    question="What is the capital of France?",
    context="France is a country in Europe. Its capital is Paris, a city known for the Eiffel Tower."
)
print(f"Answer: {result['answer']} (score: {result['score']:.1%})")
# Answer: Paris (score: 98.7%)

# ===========================
# 3. Text Summarization
# ===========================
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
article = """
Hugging Face has raised $235 million in a Series D funding round, 
bringing the company's valuation to $4.5 billion. The round was led 
by Salesforce Ventures, with participation from Google, Amazon, NVIDIA, 
Intel, AMD, and Qualcomm. The company plans to use the funding to 
expand its open-source AI platform and hire more researchers.
"""
summary = summarizer(article, max_length=50, min_length=20)
print(summary[0]['summary_text'])
# "Hugging Face raised $235M at $4.5B valuation, led by Salesforce..."

# ===========================
# 4. Translation
# ===========================
translator = pipeline("translation_en_to_fr")
result = translator("Hugging Face is the best AI platform.")
print(result[0]['translation_text'])
# "Hugging Face est la meilleure plateforme d'IA."

# Multi-language: Helsinki-NLP models
id_to_en = pipeline("translation", model="Helsinki-NLP/opus-mt-id-en")
result = id_to_en("Saya sedang belajar kecerdasan buatan.")
print(result[0]['translation_text'])
# "I'm learning artificial intelligence."

# ===========================
# 5. Text Generation (GPT-style)
# ===========================
generator = pipeline("text-generation", model="gpt2")
result = generator(
    "Artificial intelligence will",
    max_length=50,
    num_return_sequences=2,    # generate 2 variations
    temperature=0.7,           # creativity (0=deterministic, 1=random)
    do_sample=True
)
for i, r in enumerate(result):
    print(f"  Variation {i+1}: {r['generated_text'][:80]}...")

# ===========================
# 6. Fill-Mask (BERT-style)
# ===========================
fill = pipeline("fill-mask")
results = fill("The capital of Indonesia is [MASK].")
for r in results[:3]:
    print(f"  {r['token_str']:10s} ({r['score']:.1%})")
# Jakarta    (92.3%)
# Bandung    (2.1%)
# Surabaya   (1.4%)

from transformers import pipeline

# ===========================
# 1. Image Classification
# ===========================
img_classifier = pipeline("image-classification")
result = img_classifier("https://upload.wikimedia.org/wikipedia/commons/4/4d/Cat_November_2010-1a.jpg")
for r in result[:3]:
    print(f"  {r['label']:30s} ({r['score']:.1%})")
# tabby, tabby cat              (43.2%)
# Egyptian cat                  (22.1%)
# tiger cat                     (13.8%)

# ===========================
# 2. Object Detection
# ===========================
detector = pipeline("object-detection")
results = detector("https://example.com/street_scene.jpg")
for r in results:
    print(f"  {r['label']:10s} ({r['score']:.1%}) at {r['box']}")
# car        (97.2%) at {'xmin': 12, 'ymin': 50, ...}
# person     (95.1%) at {'xmin': 200, 'ymin': 30, ...}

# ===========================
# 3. Zero-Shot Classification (NO TRAINING NEEDED!)
# Classify text into ANY categories — even ones the model never saw!
# ===========================
zero_shot = pipeline("zero-shot-classification")
result = zero_shot(
    "Harga saham Tesla naik 15% setelah pengumuman earnings Q4.",
    candidate_labels=["finance", "sports", "technology", "politics", "health"]
)
for label, score in zip(result['labels'], result['scores']):
    print(f"  {label:12s}: {score:.1%}")
# finance     : 78.3%
# technology  : 15.2%
# politics    :  3.8%
# sports      :  1.5%
# health      :  1.2%

# ===========================
# 4. Automatic Speech Recognition
# ===========================
# asr = pipeline("automatic-speech-recognition", model="openai/whisper-base")
# result = asr("audio_file.mp3")
# print(result["text"])  # "Hello, how are you today?"
# Whisper supports 99 languages including Indonesian!

# ===========================
# 5. Text-to-Speech
# ===========================
# tts = pipeline("text-to-speech", model="microsoft/speecht5_tts")
# audio = tts("Hello, welcome to the Hugging Face tutorial!")
# # Returns audio array that can be saved as .wav

from huggingface_hub import HfApi, list_models

# ===========================
# 1. Search models programmatically
# ===========================
api = HfApi()
models = api.list_models(
    filter="text-classification",
    sort="downloads",
    direction=-1,
    limit=5
)
for m in models:
    print(f"  {m.id:50s} ↓{m.downloads:>10,}")
# distilbert-base-uncased-finetuned-sst-2-english  ↓ 85,432,100
# nlptown/bert-base-multilingual-uncased-sentiment  ↓ 12,345,000
# cardiffnlp/twitter-roberta-base-sentiment-latest  ↓  8,765,000

# ===========================
# 2. Indonesian NLP models
# ===========================
id_models = api.list_models(
    filter="text-classification",
    search="indonesian",
    sort="downloads",
    direction=-1,
    limit=5
)
for m in id_models:
    print(f"  {m.id}")
# indobenchmark/indobert-base-p1
# indolem/indobert-base-uncased
# cahya/bert-base-indonesian-522M

# ===========================
# 3. Model naming convention
# ===========================
# Format: organization/model-name
# Examples:
# google-bert/bert-base-uncased         ← Google's BERT
# meta-llama/Llama-3.2-1B              ← Meta's LLaMA
# openai-community/gpt2                ← OpenAI's GPT-2
# facebook/bart-large-cnn              ← Meta's BART
# sentence-transformers/all-MiniLM-L6-v2 ← sentence embeddings

# ===========================
# 4. Download model manually (for offline use)
# ===========================
from transformers import AutoModel, AutoTokenizer

model = AutoModel.from_pretrained("bert-base-uncased")
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
# Downloads to ~/.cache/huggingface/ (~420MB for BERT base)

# Save locally
model.save_pretrained("./my_bert")
tokenizer.save_pretrained("./my_bert")

# Load from local
model = AutoModel.from_pretrained("./my_bert")
tokenizer = AutoTokenizer.from_pretrained("./my_bert")

from transformers import (
    AutoModel, AutoTokenizer, AutoConfig,
    AutoModelForSequenceClassification,
    AutoModelForTokenClassification,
    AutoModelForQuestionAnswering,
    AutoModelForCausalLM,
    AutoModelForSeq2SeqLM,
)

# ===========================
# 1. AutoTokenizer — universal tokenizer loader
# ===========================
# Doesn't matter if model uses WordPiece, BPE, or SentencePiece!
tokenizer_bert = AutoTokenizer.from_pretrained("bert-base-uncased")      # WordPiece
tokenizer_gpt = AutoTokenizer.from_pretrained("gpt2")                    # BPE
tokenizer_t5 = AutoTokenizer.from_pretrained("google-t5/t5-small")      # SentencePiece
tokenizer_llama = AutoTokenizer.from_pretrained("meta-llama/Llama-3.2-1B")  # BPE

# All have the SAME interface!
for name, tok in [("BERT", tokenizer_bert), ("GPT-2", tokenizer_gpt), ("T5", tokenizer_t5)]:
    encoded = tok("Hello world", return_tensors="pt")
    print(f"  {name:6s}: {encoded['input_ids'][0].tolist()}")
# BERT  : [101, 7592, 2088, 102]           ← [CLS] hello world [SEP]
# GPT-2 : [15496, 995]                      ← hello world (no special tokens)
# T5    : [8774, 296, 1]                    ← Hello▁world 

# ===========================
# 2. AutoModel — base model (no head)
# ===========================
model = AutoModel.from_pretrained("bert-base-uncased")
print(f"Type: {type(model).__name__}")  # BertModel
print(f"Params: {model.num_parameters():,}")  # 109,482,240
# Output: last_hidden_state (batch, seq_len, hidden_size)
# → Raw embeddings, NO classification head

# ===========================
# 3. AutoModelForSequenceClassification — with classifier head
# ===========================
model_cls = AutoModelForSequenceClassification.from_pretrained(
    "bert-base-uncased",
    num_labels=3  # positive, negative, neutral
)
print(f"Type: {type(model_cls).__name__}")  # BertForSequenceClassification
# Output: logits (batch, num_labels) → ready for classification!

# ===========================
# 4. Task-specific Auto Classes
# ===========================
# AutoModelForSequenceClassification  → sentiment, topic classification
# AutoModelForTokenClassification     → NER, POS tagging
# AutoModelForQuestionAnswering       → extractive QA
# AutoModelForCausalLM                → text generation (GPT-style)
# AutoModelForSeq2SeqLM               → translation, summarization (T5-style)
# AutoModelForMaskedLM                → fill-mask (BERT-style)
# AutoModelForImageClassification     → image classification (ViT)
# AutoModelForObjectDetection         → object detection (DETR)

# ===========================
# 5. AutoConfig — model configuration
# ===========================
config = AutoConfig.from_pretrained("bert-base-uncased")
print(f"Hidden size: {config.hidden_size}")       # 768
print(f"Num layers:  {config.num_hidden_layers}")  # 12
print(f"Num heads:   {config.num_attention_heads}") # 12
print(f"Vocab size:  {config.vocab_size}")         # 30522

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

# ===========================
# 1. Step by step tokenization
# ===========================
text = "Hugging Face's tokenizers are incredibly fast!"

# Step 1: Tokenize (split into subwords)
tokens = tokenizer.tokenize(text)
print(f"Tokens: {tokens}")
# ['hugging', 'face', "'", 's', 'token', '##ize', '##rs', 'are', 'incredibly', 'fast', '!']
# Note: "tokenizers" → ["token", "##ize", "##rs"] (WordPiece subwords!)
# "##" prefix means "continuation of previous word"

# Step 2: Convert to IDs
ids = tokenizer.convert_tokens_to_ids(tokens)
print(f"IDs: {ids}")
# [17662, 2227, 1005, 1055, 19204, 4697, 2869, 2024, 12978, 3435, 999]

# Step 3: Add special tokens + create attention mask
encoded = tokenizer(text, return_tensors="pt")
print(f"input_ids:      {encoded['input_ids'][0].tolist()}")
print(f"attention_mask: {encoded['attention_mask'][0].tolist()}")
print(f"token_type_ids: {encoded['token_type_ids'][0].tolist()}")
# input_ids:      [101, 17662, 2227, ..., 999, 102]    ← [CLS] ... [SEP]
# attention_mask: [1, 1, 1, ..., 1, 1]                  ← all real tokens
# token_type_ids: [0, 0, 0, ..., 0, 0]                  ← single sentence

# ===========================
# 2. Decode back to text
# ===========================
decoded = tokenizer.decode(encoded['input_ids'][0])
print(f"Decoded: {decoded}")
# "[CLS] hugging face's tokenizers are incredibly fast! [SEP]"

decoded_skip = tokenizer.decode(encoded['input_ids'][0], skip_special_tokens=True)
print(f"Clean:   {decoded_skip}")
# "hugging face's tokenizers are incredibly fast!"

# ===========================
# 3. Padding & Truncation
# ===========================
texts = ["Short text.", "This is a much longer sentence that has more words in it."]

# Without padding: different lengths → can't batch!
for t in texts:
    enc = tokenizer(t)
    print(f"  Length: {len(enc['input_ids'])}")
# Length: 4
# Length: 14  ← different! Can't make a tensor

# With padding + truncation: same length → can batch!
batch = tokenizer(texts,
    padding=True,           # pad shorter sequences
    truncation=True,         # truncate if too long
    max_length=128,          # max sequence length
    return_tensors="pt"     # return PyTorch tensors
)
print(f"Batch shape: {batch['input_ids'].shape}")
# Batch shape: torch.Size([2, 14])  ← padded to longest!
print(f"Attention mask: {batch['attention_mask'][0].tolist()}")
# [1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
# 1=real token, 0=padding → model IGNORES padding!

# ===========================
# 4. Special tokens per model
# ===========================
print(f"BERT special tokens:")
print(f"  CLS: {tokenizer.cls_token} (ID: {tokenizer.cls_token_id})")  # [CLS] = 101
print(f"  SEP: {tokenizer.sep_token} (ID: {tokenizer.sep_token_id})")  # [SEP] = 102
print(f"  PAD: {tokenizer.pad_token} (ID: {tokenizer.pad_token_id})")  # [PAD] = 0
print(f"  UNK: {tokenizer.unk_token} (ID: {tokenizer.unk_token_id})")  # [UNK] = 100
print(f"  Vocab size: {tokenizer.vocab_size}")  # 30522

# ===========================
# 5. Sentence pairs (for NLI, QA, etc.)
# ===========================
encoded_pair = tokenizer(
    "What is the capital?",     # sentence A
    "The capital of France is Paris.",  # sentence B
    return_tensors="pt"
)
print(encoded_pair['token_type_ids'][0].tolist())
# [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1]
# 0=sentence A, 1=sentence B
# [CLS] What is the capital ? [SEP] The capital of France is Paris . [SEP]

import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification

# ===========================
# Step 1: Load tokenizer & model
# ===========================
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name)

# ===========================
# Step 2: Tokenize input
# ===========================
text = "I absolutely love learning about Hugging Face!"
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
print(f"Input IDs shape: {inputs['input_ids'].shape}")
print(f"Tokens: {tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])}")
# ['[CLS]', 'i', 'absolutely', 'love', 'learning', 'about', 'hugging', 'face', '!', '[SEP]']

# ===========================
# Step 3: Forward pass (no gradient needed for inference!)
# ===========================
with torch.no_grad():  # disable gradient computation → faster + less memory
    outputs = model(**inputs)

print(f"Output type: {type(outputs)}")
# SequenceClassifierOutput
print(f"Logits: {outputs.logits}")
# tensor([[-4.2532,  4.5687]])  ← raw scores (NOT probabilities!)

# ===========================
# Step 4: Post-process — logits → probabilities
# ===========================
probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(f"Probabilities: {probabilities}")
# tensor([[0.0001, 0.9999]])  ← [NEGATIVE, POSITIVE]

# ===========================
# Step 5: Map to label
# ===========================
predicted_class = torch.argmax(probabilities, dim=-1).item()
label = model.config.id2label[predicted_class]
confidence = probabilities[0][predicted_class].item()

print(f"\\n🎯 Prediction: {label} ({confidence:.1%})")
# 🎯 Prediction: POSITIVE (99.99%)

# ===========================
# Compare with pipeline (should be identical!)
# ===========================
from transformers import pipeline
pipe = pipeline("sentiment-analysis", model=model_name)
print(f"Pipeline: {pipe(text)}")
# [{'label': 'POSITIVE', 'score': 0.9999}] ← identical! ✓

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset

# ===========================
# Fine-tune BERT on IMDB — PREVIEW (Page 2 = full version)
# ===========================

# 1. Load dataset
dataset = load_dataset("imdb")
print(dataset)
# DatasetDict({'train': Dataset(25000 rows), 'test': Dataset(25000 rows)})

# 2. Load tokenizer & model
model_name = "distilbert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 3. Tokenize dataset
def tokenize(batch):
    return tokenizer(batch["text"], truncation=True, padding="max_length", max_length=256)

tokenized = dataset.map(tokenize, batched=True)

# 4. Training arguments
args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    eval_strategy="epoch",
    learning_rate=2e-5,
    weight_decay=0.01,
    fp16=True,             # mixed precision!
)

# 5. Create Trainer & train!
trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized["train"],
    eval_dataset=tokenized["test"],
    tokenizer=tokenizer,
)

trainer.train()
# → 93%+ accuracy on IMDB in ~15 minutes on Google Colab T4!
# Compare: BiLSTM from TF series = 87%. BERT = 93%+. That's the power!

# Page 2 will cover: full Trainer API, custom metrics, hyperparameter
# tuning, data collators, and pushing models to the Hub.