HuggingFace Transformers

# Instalasi library transformers dan dependencies
pip install transformers datasets evaluate accelerate

# Dengan PyTorch (sudah terinstal jika ikuti tutorial PyTorch)
pip install torch

# Untuk fine-tuning model besar
pip install peft bitsandbytes  # Parameter-Efficient Fine-Tuning

# Verifikasi
python -c "from transformers import pipeline; print('HuggingFace Transformers OK!')"

# Login ke HuggingFace Hub (opsional, untuk akses model private)
pip install huggingface_hub
huggingface-cli login

from transformers import pipeline

# ===== SENTIMENT ANALYSIS =====
# Hanya 3 baris kode!
classifier = pipeline("sentiment-analysis")

texts = [
    "Film ini sangat bagus dan mengharukan!",
    "Pelayanan restoran buruk sekali, sangat mengecewakan.",
    "Cuaca hari ini cerah, cocok untuk jalan-jalan.",
    "Produk ini rusak setelah dipakai 2 hari. Tidak recommended!",
    "Terima kasih atas pelayanan yang sangat baik!"
]

results = classifier(texts)

print("=== SENTIMENT ANALYSIS ===")
for text, result in zip(texts, results):
    emoji = "😊" if result['label'] == 'POSITIVE' else "😞"
    print(f"{emoji} [{result['label']}] ({result['score']:.4f}) → {text}")

from transformers import pipeline

# ===== ZERO-SHOT CLASSIFICATION =====
# Klasifikasi tanpa perlu training data!
zero_shot = pipeline("zero-shot-classification")

text = "Apple meluncurkan iPhone baru dengan chip M3 yang lebih cepat"
labels = ["teknologi", "olahraga", "politik", "kesehatan", "ekonomi"]

result = zero_shot(text, candidate_labels=labels)
print("=== ZERO-SHOT CLASSIFICATION ===")
print(f"Teks: {text}")
for label, score in zip(result['labels'], result['scores']):
    bar = "█" * int(score * 30)
    print(f"  {label:<15}: {score:.4f} {bar}")

# ===== TEXT GENERATION =====
generator = pipeline("text-generation", model="gpt2")
prompt = "Artificial Intelligence di masa depan akan"
result = generator(prompt, max_length=100, num_return_sequences=1, temperature=0.7)
print(f"\n=== TEXT GENERATION ===")
print(f"Prompt: {prompt}")
print(f"Generated: {result[0]['generated_text']}")

# ===== SUMMARIZATION =====
summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
article = """
PyTorch adalah framework Deep Learning open-source yang dikembangkan oleh Meta AI.
PyTorch menjadi sangat populer di kalangan peneliti dan industri berkat API-nya
yang Pythonic, dukungan dynamic computation graph, dan ekosistem yang sangat kaya.
Banyak model AI terbaru seperti GPT, BERT, dan LLaMA dibangun menggunakan PyTorch.
Ekosistem PyTorch termasuk TorchVision untuk computer vision, TorchText untuk NLP,
dan integrasi dengan HuggingFace untuk akses ke ribuan model pre-trained.
"""
summary = summarizer(article, max_length=60, min_length=20, do_sample=False)
print(f"\n=== SUMMARIZATION ===")
print(f"Original ({len(article.split())} kata): {article[:100]}...")
print(f"Summary: {summary[0]['summary_text']}")

# ===== FILL MASK =====
unmasker = pipeline("fill-mask", model="bert-base-uncased")
results = unmasker("Indonesia adalah negara [MASK] terbesar di Asia Tenggara.")
print(f"\n=== FILL MASK ===")
for r in results:
    print(f"  {r['token_str']} ({r['score']:.4f}) → {r['sequence']}")

from transformers import AutoModel, AutoTokenizer, AutoModelForSequenceClassification
import torch

# ===== AUTO CLASS: Cara Universal Memuat Model =====
# Auto classes otomatis mendeteksi arsitektur model
model_name = "bert-base-uncased"

# Load tokenizer dan model terpisah
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModel.from_pretrained(model_name)

print(f"Model: {model_name}")
print(f"Jumlah parameter: {sum(p.numel() for p in model.parameters()):,}")
print(f"Arsitektur: {model.__class__.__name__}")

# ===== MODEL UNTUK TUGAS SPESIFIK =====
# Model untuk klasifikasi (dengan classification head)
clf_model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased",
    num_labels=2  # Jumlah kelas output
)

# Forward pass manual
text = "HuggingFace sangat memudahkan NLP!"
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
print(f"\nTokenizer output keys: {list(inputs.keys())}")
print(f"Input IDs shape: {inputs['input_ids'].shape}")
print(f"Attention mask: {inputs['attention_mask']}")

# Inference
with torch.no_grad():
    outputs = model(**inputs)
    print(f"\nOutput shape: {outputs.last_hidden_state.shape}")  # [batch, seq_len, hidden]
    print(f"CLS token embedding: {outputs.last_hidden_state[:, 0, :].shape}")

from transformers import AutoTokenizer

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

# ===== BASIC TOKENIZATION =====
text = "HuggingFace Transformers sangat powerful untuk NLP!"

# Tokenize
tokens = tokenizer.tokenize(text)
print(f"Teks: {text}")
print(f"Tokens: {tokens}")
print(f"Jumlah token: {len(tokens)}")

# Convert ke IDs
ids = tokenizer.encode(text)
print(f"\nToken IDs: {ids}")
print(f"Decoded: {tokenizer.decode(ids)}")

# ===== DETAILED OUTPUT =====
# return_tensors='pt' untuk PyTorch tensor
# padding=True untuk menyamakan panjang
# truncation=True untuk memotong jika terlalu panjang
encoded = tokenizer(
    text,
    return_tensors="pt",
    padding=True,
    truncation=True,
    max_length=128
)

print(f"\nInput IDs: {encoded['input_ids']}")
print(f"Shape: {encoded['input_ids'].shape}")
print(f"Attention Mask: {encoded['attention_mask']}")

# Decode kembali ke teks
decoded = tokenizer.decode(encoded['input_ids'][0])
print(f"Decoded: {decoded}")

# ===== BATCH TOKENIZATION =====
texts = [
    "Saya suka belajar machine learning!",
    "PyTorch adalah framework yang bagus.",
    "HuggingFace memudahkan akses ke model AI."
]

batch_encoded = tokenizer(
    texts,
    return_tensors="pt",
    padding=True,    # Tambah [PAD] agar semua sama panjang
    truncation=True,
    max_length=64
)

print(f"\n=== BATCH TOKENIZATION ===")
print(f"Batch input shape: {batch_encoded['input_ids'].shape}")
for i, text in enumerate(texts):
    tokens = tokenizer.convert_ids_to_tokens(batch_encoded['input_ids'][i])
    print(f"  [{i}] Tokens: {[t for t in tokens if t != '[PAD]']}")

# ===== MENGETAHUI VOCABULARY =====
vocab = tokenizer.get_vocab()
print(f"\nVocabulary size: {len(vocab)}")
print(f"Special tokens:")
print(f"  [CLS]: {tokenizer.cls_token_id}")
print(f"  [SEP]: {tokenizer.sep_token_id}")
print(f"  [PAD]: {tokenizer.pad_token_id}")
print(f"  [MASK]: {tokenizer.mask_token_id}")
print(f"  [UNK]: {tokenizer.unk_token_id}")

import torch
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    TrainingArguments,
    Trainer
)
from datasets import Dataset
import numpy as np

# ===== 1. PERSIAPAN DATA =====
# Contoh dataset: Klasifikasi sentimen ulasan produk
train_texts = [
    "Produk ini sangat bagus, saya suka sekali!",
    "Kualitas sangat buruk, kecewa berat.",
    "Pengiriman cepat dan barang sesuai deskripsi.",
    "Tidak sesuai ekspektasi, warna berbeda dari foto.",
    "Harga terjangkau dengan kualitas oke banget!",
    "Barang rusak saat sampai, sangat mengecewakan.",
    "Recommended banget! Teman-teman juga mau beli.",
    "Pelayanan kurang ramah, tapi produk lumayan.",
    "Best purchase ever! Akan beli lagi.",
    "Ukuran kekecilan, tidak sesuai ukuran di foto.",
    "Packing rapi dan aman, barang bagus.",
    "Sudah 2 minggu belum sampai juga. Buruk!",
    "Sangat memuaskan, sesuai dengan harganya.",
    "Kualitas bahan tipis dan mudah sobek.",
    "Seller responsif dan helpful. Sukses terus!",
]

train_labels = [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1]  # 1=Positif, 0=Negatif

test_texts = [
    "Produk ini sangat recommended untuk dibeli!",
    "Sangat menyesal beli produk ini.",
    "Cukup baik untuk harga segitu.",
    "Barang tidak berfungsi dengan baik.",
]
test_labels = [1, 0, 1, 0]

# Buat HuggingFace Dataset
train_dataset = Dataset.from_dict({"text": train_texts, "label": train_labels})
test_dataset = Dataset.from_dict({"text": test_texts, "label": test_labels})

print(f"Train dataset: {len(train_dataset)} sampel")
print(f"Test dataset: {len(test_dataset)} sampel")

# ===== 2. TOKENIZER =====
model_name = "indobenchmark/indobert-base-p1"  # Model BERT bahasa Indonesia
tokenizer = AutoTokenizer.from_pretrained(model_name)

def tokenize_function(examples):
    return tokenizer(
        examples["text"],
        padding="max_length",
        truncation=True,
        max_length=128
    )

train_tokenized = train_dataset.map(tokenize_function, batched=True)
test_tokenized = test_dataset.map(tokenize_function, batched=True)

print(f"Contoh tokenized: {train_tokenized[0]}")

from transformers import TrainingArguments, Trainer
from evaluate import load
import numpy as np

# ===== 3. MODEL =====
model = AutoModelForSequenceClassification.from_pretrained(
    model_name,
    num_labels=2  # Binary classification
)

# ===== 4. EVALUATION METRIC =====
accuracy_metric = load("accuracy")

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return accuracy_metric.compute(predictions=predictions, references=labels)

# ===== 5. TRAINING ARGUMENTS =====
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    learning_rate=2e-5,
    weight_decay=0.01,
    eval_strategy="epoch",
    save_strategy="epoch",
    logging_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="accuracy",
    warmup_steps=50,
    seed=42,
)

# ===== 6. TRAINER =====
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_tokenized,
    eval_dataset=test_tokenized,
    compute_metrics=compute_metrics,
)

# ===== 7. TRAIN! =====
print("=== MEMULAI FINE-TUNING ===")
trainer.train()

# ===== 8. EVALUASI =====
results = trainer.evaluate()
print(f"\n=== HASIL EVALUASI ===")
print(f"Accuracy: {results['eval_accuracy']:.4f}")
print(f"Loss: {results['eval_loss']:.4f}")

# ===== 9. PREDIKSI DATA BARU =====
def predict_sentiment(text):
    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    with torch.no_grad():
        outputs = model(**inputs)
    probs = torch.softmax(outputs.logits, dim=-1)
    predicted_class = torch.argmax(probs, dim=-1).item()
    confidence = probs[0][predicted_class].item()
    label = "POSITIF 😊" if predicted_class == 1 else "NEGATIF 😞"
    return label, confidence

# Test prediksi
test_reviews = [
    "Pengalaman belanja yang luar biasa! Puas banget.",
    "Produk tidak sesuai gambar, sangat kecewa.",
    "Biasa aja sih, tidak istimewa tapi tidak jelek juga.",
]

print(f"\n=== PREDIKSI ULASAN BARU ===")
for review in test_reviews:
    label, conf = predict_sentiment(review)
    print(f"  {label} ({conf:.2%}) → {review}")

from huggingface_hub import HfApi, list_models, model_info
from transformers import AutoModel, AutoTokenizer

# ===== MENCARI MODEL =====
# Cari model untuk tugas tertentu
models = list(list_models(
    task="text-classification",
    language="id",           # Bahasa Indonesia
    sort="downloads",
    direction=-1,
    limit=5
))

print("=== TOP 5 TEXT CLASSIFICATION MODELS (Bahasa Indonesia) ===")
for m in models:
    info = model_info(m.modelId)
    print(f"  {m.modelId:<45} ↓{m.downloads:>8,}")

# ===== LOAD MODEL DARI HUB =====
# Cukup berikan nama model
tokenizer = AutoTokenizer.from_pretrained("indobenchmark/indobert-base-p1")
model = AutoModel.from_pretrained("indobenchmark/indobert-base-p1")
print(f"\nLoaded: indobenchmark/indobert-base-p1")
print(f"Parameters: {sum(p.numel() for p in model.parameters()):,}")

# ===== UPLOAD MODEL (setelah fine-tuning) =====
# Uncomment untuk upload:
# model.push_to_hub("username/my-fine-tuned-model")
# tokenizer.push_to_hub("username/my-fine-tuned-model")
#
# Atau dengan Trainer:
# trainer.push_to_hub("username/my-fine-tuned-model")

from transformers import pipeline

# Named Entity Recognition
ner = pipeline("ner", grouped_entities=True)

text = "Joko Widodo adalah Presiden Indonesia yang berkantor di Istana Negara, Jakarta."
entities = ner(text)

print(f"Teks: {text}")
print(f"\nEntities yang ditemukan:")
for entity in entities:
    print(f"  [{entity['entity_group']}] {entity['word']:<20} (score: {entity['score']:.4f})")

from transformers import pipeline

qa = pipeline("question-answering", model="distilbert-base-cased-distilled-squad")

context = """
PyTorch adalah framework Deep Learning open-source yang dikembangkan oleh Meta AI.
PyTorch pertama kali dirilis pada tahun 2016. PyTorch menjadi sangat populer
di kalangan peneliti berkat dynamic computation graph dan API yang Pythonic.
Banyak model AI terbaru seperti GPT dan LLaMA dibangun menggunakan PyTorch.
"""

questions = [
    "Siapa yang mengembangkan PyTorch?",
    "Kapan PyTorch pertama kali dirilis?",
    "Apa keunggulan utama PyTorch?",
    "Model apa yang dibangun menggunakan PyTorch?",
]

print("=== QUESTION ANSWERING ===")
for q in questions:
    result = qa(question=q, context=context)
    print(f"\nQ: {q}")
    print(f"A: {result['answer']} (score: {result['score']:.4f})")

from transformers import pipeline

# Text generation dengan GPT-2
generator = pipeline("text-generation", model="gpt2")

prompts = [
    "Di tahun 2030, teknologi AI akan",
    "Python adalah bahasa pemrograman yang",
    "Machine learning dapat digunakan untuk",
]

print("=== TEXT GENERATION ===")
for prompt in prompts:
    result = generator(
        prompt,
        max_length=80,
        num_return_sequences=1,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
        pad_token_id=50256
    )
    print(f"\nPrompt: {prompt}")
    print(f"Generated: {result[0]['generated_text']}")
    print("-" * 60)

from transformers import pipeline

# English to Indonesian
translator_en_id = pipeline("translation", model="Helsinki-NLP/opus-mt-en-id")

# Indonesian to English
translator_id_en = pipeline("translation", model="Helsinki-NLP/opus-mt-id-en")

texts_en = [
    "Machine learning is a subset of artificial intelligence.",
    "Python is the most popular programming language for data science.",
    "Deep learning models require large amounts of data.",
]

print("=== ENGLISH → BAHASA INDONESIA ===")
for text in texts_en:
    result = translator_en_id(text)
    print(f"EN: {text}")
    print(f"ID: {result[0]['translation_text']}")
    print()

texts_id = [
    "Indonesia adalah negara kepulauan terbesar di dunia.",
    "Bali adalah destinasi wisata yang sangat populer.",
]

print("=== BAHASA INDONESIA → ENGLISH ===")
for text in texts_id:
    result = translator_id_en(text)
    print(f"ID: {text}")
    print(f"EN: {result[0]['translation_text']}")
    print()