NLP: Natural Language Processing untuk Pemula

import re
import string

def clean_text(text):
    """Membersihkan teks dari noise"""
    # 1. Lowercase — ubah ke huruf kecil
    text = text.lower()

    # 2. Hapus URL
    text = re.sub(r'http\S+|www\S+|https\S+', '', text)

    # 3. Hapus mention dan hashtag (media sosial)
    text = re.sub(r'@\w+|#\w+', '', text)

    # 4. Hapus HTML tags
    text = re.sub(r'<.*?>', '', text)

    # 5. Hapus emoji dan karakter non-ASCII
    text = re.sub(r'[^\x00-\x7F]+', '', text)

    # 6. Hapus angka
    text = re.sub(r'\d+', '', text)

    # 7. Hapus tanda baca
    text = text.translate(str.maketrans('', '', string.punctuation))

    # 8. Hapus whitespace berlebihan
    text = re.sub(r'\s+', ' ', text).strip()

    return text

# Contoh penggunaan
teks_asli = "Halo! 👋 Saya suka banget belajar #NLP di https://beebanelabs.com 😊 Rating: 5/5!!!"
teks_bersih = clean_text(teks_asli)
print(f"Asli:   {teks_asli}")
print(f"Bersih: {teks_bersih}")
# Output: "halo saya suka banget belajar nlp di rating"

import nltk
from nltk.corpus import stopwords

# Download stopwords (jalankan sekali saja)
nltk.download('stopwords')

# Stopwords bahasa Indonesia
stop_words_id = set(stopwords.words('indonesian'))
print(f"Jumlah stopwords Indonesia: {len(stop_words_id)}")
# Contoh: yang, di, dan, ini, itu, dengan, untuk, pada, adalah, dari, ...

# Stopwords bahasa Inggris
stop_words_en = set(stopwords.words('english'))
print(f"Jumlah stopwords Inggris: {len(stop_words_en)}")
# Contoh: the, is, at, which, and, a, an, in, on, it, ...

def remove_stopwords(text, language='indonesian'):
    """Menghapus stopwords dari teks"""
    stop_words = set(stopwords.words(language))
    words = text.split()
    filtered = [w for w in words if w not in stop_words]
    return ' '.join(filtered)

# Contoh
teks = "saya adalah mahasiswa yang sedang belajar di universitas indonesia"
hasil = remove_stopwords(teks)
print(f"Sebelum: {teks}")
print(f"Sesudah: {hasil}")
# Output: "mahasiswa sedang belajar universitas indonesia"

import nltk
from nltk.stem import PorterStemmer, WordNetLemmatizer

nltk.download('wordnet')

# Stemming — menghilangkan akhiran kata secara mekanis
# Contoh: "running" → "run", "studies" → "studi", "beautiful" → "beauti"
stemmer = PorterStemmer()

kata = ['running', 'studies', 'beautifully', 'organization', 'quickly']
for k in kata:
    print(f"{k} → {stemmer.stem(k)}")
# running → run
# studies → studi
# beautiful → beauti
# organization → organ
# quickly → quickli

# Lemmatization — mengembalikan kata ke bentuk dasar yang valid
# Lebih akurat dari stemming tapi lebih lambat
lemmatizer = WordNetLemmatizer()

kata = ['running', 'studies', 'better', 'geese', 'organizations']
for k in kata:
    print(f"{k} → {lemmatizer.lemmatize(k, pos='v')}")
# running → run
# studies → study
# better → good (dengan pos='a')
# geese → goose

# Untuk bahasa Indonesia, gunakan Sastrawi
# pip install Sastrawi
from Sastrawi.Stemmer.StemmerFactory import StemmerFactory

factory = StemmerFactory()
stemmer_id = factory.create_stemmer()

teks = "para mahasiswa sedang mengerjakan tugas-tugas mereka"
hasil = stemmer_id.stem(teks)
print(f"Hasil: {hasil}")
# Output: "para mahasiswa sedang tugas tugas mereka"

import nltk
from nltk.tokenize import word_tokenize, sent_tokenize

# Download tokenizer data (jalankan sekali)
nltk.download('punkt')
nltk.download('punkt_tab')

# Word Tokenization — pecah teks menjadi kata
teks = "Natural Language Processing adalah bidang AI yang menarik! Bagaimana cara kerjanya?"
kata = word_tokenize(teks)
print(f"Word tokens: {kata}")
# ['Natural', 'Language', 'Processing', 'adalah', 'bidang', 'AI',
#  'yang', 'menarik', '!', 'Bagaimana', 'cara', 'kerjanya', '?']
print(f"Jumlah token: {len(kata)}")

# Sentence Tokenization — pecah teks menjadi kalimat
kalimat = sent_tokenize(teks)
print(f"Sentence tokens: {kalimat}")
# ['Natural Language Processing adalah bidang AI yang menarik!',
#  'Bagaimana cara kerjanya?']

# Tokenization bahasa Indonesia
teks_id = "Budi pergi ke pasar. Dia membeli sayur dan buah. Harganya sangat murah."
kalimat_id = sent_tokenize(teks_id, language='indonesian')
print(f"Kalimat: {kalimat_id}")

from sklearn.feature_extraction.text import CountVectorizer

# Bag of Words — merepresentasikan teks sebagai vektor frekuensi kata
corpus = [
    "saya suka belajar NLP",
    "NLP adalah bagian dari AI",
    "saya suka AI dan NLP",
    "belajar AI sangat menarik",
]

# Buat BoW representation
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(corpus)

# Lihat vocabulary (kata unik)
print("Vocabulary:", vectorizer.get_feature_names_out())
# ['adalah', 'ai', 'bagian', 'belajar', 'dan', 'dari', 'menarik', 'nlp', 'sangat', 'suka', 'saya']

# Lihat vektor BoW
print("BoW Matrix:")
print(X.toarray())
# [[0 0 0 1 0 0 0 1 0 1 1],   ← "saya suka belajar NLP"
#  [1 1 1 0 0 1 0 1 0 0 0],   ← "NLP adalah bagian dari AI"
#  [0 1 0 0 1 0 0 1 0 1 1],   ← "saya suka AI dan NLP"
#  [0 1 0 1 0 0 1 0 1 0 0]]   ← "belajar AI sangat menarik"

from sklearn.feature_extraction.text import TfidfVectorizer

# TF-IDF — bobot kata berdasarkan frekuensi dan keunikannya
# Kata yang muncul di semua dokumen → bobot rendah
# Kata yang jarang tapi penting → bobot tinggi

corpus = [
    "saya suka belajar NLP",
    "NLP adalah bagian dari AI",
    "saya suka AI dan NLP",
    "belajar AI sangat menarik",
]

tfidf = TfidfVectorizer()
X_tfidf = tfidf.fit_transform(corpus)

print("Vocabulary:", tfidf.get_feature_names_out())
print("\nTF-IDF Matrix:")
import numpy as np
feature_names = tfidf.get_feature_names_out()
for i, doc in enumerate(corpus):
    print(f"\nDokumen {i}: \"{doc}\"")
    scores = X_tfidf[i].toarray()[0]
    for j, score in enumerate(scores):
        if score > 0:
            print(f"  {feature_names[j]}: {score:.4f}")

# Kata "saya" muncul di 2/4 dokumen → bobot moderat
# Kata "menarik" muncul di 1/4 dokumen → bobot tinggi

import nltk
from nltk.sentiment.vader import SentimentIntensityAnalyzer

# Download VADER lexicon
nltk.download('vader_lexicon')

# VADER — rule-based sentiment analysis
# Cocok untuk teks media sosial, review, dan komentar
sia = SentimentIntensityAnalyzer()

# Analisis sentimen
texts = [
    "I love this product! It's absolutely amazing!",
    "This is the worst experience I've ever had.",
    "The movie was okay, nothing special.",
    "Not bad but could be better.",
    "Terrible quality, waste of money!!!",
]

for text in texts:
    scores = sia.polarity_scores(text)
    # scores: {'neg': ..., 'neu': ..., 'pos': ..., 'compound': ...}
    # compound > 0.05 → positif
    # compound < -0.05 → negatif
    # -0.05 <= compound <= 0.05 → netral

    if scores['compound'] >= 0.05:
        label = '🟢 Positif'
    elif scores['compound'] <= -0.05:
        label = '🔴 Negatif'
    else:
        label = '🟡 Netral'

    print(f"{label} (score: {scores['compound']:.3f}): {text}")

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Dataset dummy (di nyata, gunakan dataset review produk/film)
texts = [
    "Produk ini sangat bagus dan berkualitas tinggi",
    "Pengiriman cepat, barang sesuai deskripsi",
    "Sangat puas dengan pembelian ini, recommended!",
    "Kualitas buruk, barang rusak saat sampai",
    "Tidak sesuai ekspektasi, kecewa berat",
    "Pelayanan buruk, respon lambat dan tidak ramah",
    "Harga terjangkau dengan kualitas yang baik",
    "Barang bagus tapi pengiriman sangat lama",
    "Produk luar biasa, pasti beli lagi!",
    "Kecewa, barang palsu dan tidak bisa dikembalikan",
]

labels = [1, 1, 1, 0, 0, 0, 1, 0, 1, 0]  # 1=positif, 0=negatif

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    texts, labels, test_size=0.3, random_state=42
)

# TF-IDF + Naive Bayes
vectorizer = TfidfVectorizer()
X_train_vec = vectorizer.fit_transform(X_train)
X_test_vec = vectorizer.transform(X_test)

model = MultinomialNB()
model.fit(X_train_vec, y_train)

# Evaluasi
y_pred = model.predict(X_test_vec)
print(classification_report(y_test, y_pred, target_names=['Negatif', 'Positif']))

# Prediksi teks baru
teks_baru = ["Produk ini sangat memuaskan dan berkualitas!"]
teks_vec = vectorizer.transform(teks_baru)
pred = model.predict(teks_vec)
print(f"Prediksi: {'Positif' if pred[0] == 1 else 'Negatif'}")

import re
import random

class SimpleChatbot:
    """Chatbot sederhana berbasis pattern matching"""

    def __init__(self):
        # Definisi pola dan response
        self.patterns = {
            'greeting': {
                'patterns': [
                    r'halo|hai|hi|hey|selamat (pagi|siang|sore|malam)',
                    r'apa kabar|gimana kabar',
                ],
                'responses': [
                    'Halo! 👋 Ada yang bisa saya bantu?',
                    'Hai! Selamat datang! Silakan tanya apa saja.',
                    'Halo! Senang bisa membantu Anda. 😊',
                ]
            },
            'product_info': {
                'patterns': [
                    r'(info|informasi|detail) (produk|barang)',
                    r'(produk|barang) (apa|yang) (tersedia|ada|jual)',
                    r'cari (produk|barang)',
                ],
                'responses': [
                    'Kami menyediakan berbagai produk elektronik, fashion, dan aksesoris. Kategori apa yang Anda cari?',
                    'Silakan lihat katalog kami di halaman utama. Ada yang spesifik yang Anda cari?',
                ]
            },
            'price': {
                'patterns': [
                    r'harga (berapa|nya)',
                    r'berapa (harga|biayanya)',
                    r'(mahal|murah)',
                ],
                'responses': [
                    'Harga produk kami sangat bersaing! Silakan sebutkan produk yang diminati untuk info harga.',
                    'Kami punya promo menarik! Kunjungi halaman harga untuk detail lengkap.',
                ]
            },
            'order': {
                'patterns': [
                    r'(cara|bagaimana) (pesan|order|beli)',
                    r'mau (beli|pesan|order)',
                    r'(order|pesan|beli)',
                ],
                'responses': [
                    'Untuk memesan, silakan pilih produk yang diinginkan dan klik "Tambah ke Keranjang".',
                    'Anda bisa langsung order melalui website kami. Butuh bantuan untuk proses tertentu?',
                ]
            },
            'thanks': {
                'patterns': [
                    r'terima kasih|thanks|makasih|thx',
                ],
                'responses': [
                    'Sama-sama! Senang bisa membantu. 😊',
                    'Terima kasih kembali! Jangan ragu bertanya lagi ya.',
                ]
            },
            'goodbye': {
                'patterns': [
                    r'bye|sampai jumpa|selamat tinggal|dadah',
                ],
                'responses': [
                    'Sampai jumpa! Semoga harimu menyenangkan! 👋',
                    'Bye! Jangan lupa kembali lagi ya! 😊',
                ]
            },
        }

    def preprocess(self, text):
        """Bersihkan input user"""
        text = text.lower().strip()
        text = re.sub(r'[^\w\s]', '', text)
        return text

    def get_intent(self, text):
        """Identifikasi intent dari input user"""
        processed = self.preprocess(text)

        for intent, data in self.patterns.items():
            for pattern in data['patterns']:
                if re.search(pattern, processed):
                    return intent

        return 'unknown'

    def get_response(self, intent):
        """Generate response berdasarkan intent"""
        if intent in self.patterns:
            return random.choice(self.patterns[intent]['responses'])
        else:
            return random.choice([
                'Maaf, saya belum memahami pertanyaan Anda. Bisa diulang?',
                'Hmm, saya kurang mengerti. Coba tanyakan dengan cara lain?',
                'Mohon maaf, silakan hubungi customer service untuk bantuan lebih lanjut.',
            ])

    def chat(self, user_input):
        """Main chat function"""
        intent = self.get_intent(user_input)
        response = self.get_response(intent)
        return response

# Jalankan chatbot
bot = SimpleChatbot()

# Simulasi percakapan
conversations = [
    "Halo, apa kabar?",
    "Mau pesan produk",
    "Berapa harga laptop ASUS?",
    "Terima kasih!",
    "Bye!",
]

for msg in conversations:
    print(f"User: {msg}")
    print(f"Bot:  {bot.chat(msg)}\n")

# Instal HuggingFace Transformers dan dependencies
pip install transformers torch

# Untuk pipeline sederhana (sudah termasuk model)
pip install transformers[sentencepiece]

# Untuk dataset
pip install datasets

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

from transformers import pipeline

# 1. Sentiment Analysis — dalam satu baris!
classifier = pipeline('sentiment-analysis')
result = classifier("I love this product! It's amazing!")
print(result)
# [{'label': 'POSITIVE', 'score': 0.9998}]

# Batch sentiment analysis
texts = [
    "This movie is fantastic!",
    "I hate waiting in long lines.",
    "The weather is okay today.",
    "Best restaurant in town, highly recommended!",
]
results = classifier(texts)
for text, result in zip(texts, results):
    print(f"{result['label']} ({result['score']:.4f}): {text}")

# 2. Text Generation
generator = pipeline('text-generation', model='gpt2')
result = generator("Natural Language Processing adalah", max_length=50, num_return_sequences=1)
print(result[0]['generated_text'])

# 3. Question Answering
qa = pipeline('question-answering')
context = """
TensorFlow adalah framework machine learning open-source yang dikembangkan oleh Google.
TensorFlow pertama kali dirilis pada tahun 2015 dan telah menjadi salah satu framework
paling populer untuk deep learning.
"""
result = qa(question="Siapa yang mengembangkan TensorFlow?", context=context)
print(f"Jawaban: {result['answer']}")
print(f"Skor: {result['score']:.4f}")

# 4. Summarization
summarizer = pipeline('summarization')
teks_panjang = """
Natural Language Processing (NLP) adalah bidang kecerdasan buatan yang berfokus pada
interaksi antara komputer dan bahasa manusia. NLP menggunakan teknik dari linguistik
komputational, machine learning, dan deep learning untuk memproses dan memahami teks.
Aplikasi NLP meliputi machine translation, sentiment analysis, text summarization,
question answering, dan banyak lagi. Perkembangan terbaru dalam NLP didorong oleh
transformer models seperti BERT, GPT, dan T5 yang telah mencapai performa manusia
dalam berbagai benchmark NLP.
"""
summary = summarizer(teks_panjang, max_length=50, min_length=20)
print(f"Ringkasan: {summary[0]['summary_text']}")

# 5. Translation
translator = pipeline('translation_en_to_id', model='Helsinki-NLP/opus-mt-en-id')
result = translator("Hello, how are you? I am learning NLP.")
print(f"Terjemahan: {result[0]['translation_text']}")

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model dan tokenizer dari HuggingFace Hub
model_name = "indolem/indobert-base-uncased"  # BERT untuk bahasa Indonesia
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# Tokenisasi teks
teks = "Film ini sangat bagus dan menghibur!"
inputs = tokenizer(teks, return_tensors="pt", padding=True, truncation=True)

print(f"Input IDs: {inputs['input_ids']}")
print(f"Tokens: {tokenizer.convert_ids_to_tokens(inputs['input_ids'][0])}")
# ['[CLS]', 'film', 'ini', 'sangat', 'bagus', 'dan', 'menghibur', '!', '[SEP]']

# Prediksi
with torch.no_grad():
    outputs = model(**inputs)
    logits = outputs.logits
    prediction = torch.argmax(logits, dim=-1)
    print(f"Prediksi: {'Positif' if prediction.item() == 1 else 'Negatif'}")

# Fine-tuning pada dataset sendiri
from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=tokenizer,
)

# Mulai training
# trainer.train()