Natural Language ProcessingNLP & Transformers

import numpy as np
import pandas as pd
import nltk
import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline

nltk.download("stopwords", quiet=True)
nltk.download("punkt", quiet=True)
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer

STOP_WORDS = set(stopwords.words("english"))
stemmer = PorterStemmer()

def clean_text(text: str) -> str:
    """Lowercase, remove URLs/HTML/special chars, stem."""
    text = text.lower()
    text = re.sub(r"http\S+|www\S+", "", text)
    text = re.sub(r"<[^>]+>", "", text)
    text = re.sub(r"[^a-z\s]", "", text)
    tokens = text.split()
    tokens = [t for t in tokens if t not in STOP_WORDS and len(t) > 2]
    tokens = [stemmer.stem(t) for t in tokens]
    return " ".join(tokens)

# ── Movie Review Sentiment Dataset ────────────────────────
reviews = [
    "This movie was absolutely fantastic! The acting was superb.",
    "Terrible film. Completely boring and a waste of time.",
    "An incredible cinematic experience. Beautifully crafted story.",
    "I fell asleep halfway through. Very disappointing.",
    "The special effects were breathtaking! Loved every minute.",
    "Poorly written script with one-dimensional characters.",
    "A masterpiece. One of the best films I have seen.",
    "Complete garbage. The director should be ashamed.",
    "Heartwarming and emotionally powerful. A must-watch.",
    "Predictable plot, cliched dialogue. Nothing new here.",
] * 100

labels = ([1, 0, 1, 0, 1, 0, 1, 0, 1, 0] * 100)

df_nlp = pd.DataFrame({"review": reviews, "sentiment": labels})
df_nlp["cleaned"] = df_nlp["review"].apply(clean_text)

X_train_nlp, X_test_nlp, y_train_nlp, y_test_nlp = train_test_split(
    df_nlp["cleaned"], df_nlp["sentiment"],
    test_size=0.2, random_state=42, stratify=df_nlp["sentiment"]
)

# ── TF-IDF + LR Pipeline ─────────────────────────────────
text_pipeline = Pipeline([
    ("tfidf", TfidfVectorizer(
        max_features=15000, ngram_range=(1, 2),
        min_df=2, max_df=0.95, sublinear_tf=True
    )),
    ("clf", LogisticRegression(C=5.0, max_iter=1000, random_state=42))
])

text_pipeline.fit(X_train_nlp, y_train_nlp)
y_pred_nlp = text_pipeline.predict(X_test_nlp)

print("📊 TF-IDF + Logistic Regression Results:")
print(classification_report(y_test_nlp, y_pred_nlp,
    target_names=["Negative", "Positive"]))

import torch
from transformers import (
    BertTokenizer, BertForSequenceClassification,
    Trainer, TrainingArguments, DataCollatorWithPadding,
)
from datasets import Dataset
import numpy as np
from sklearn.metrics import accuracy_score, f1_score

device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device.upper()}")

MODEL_NAME = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(MODEL_NAME)
model = BertForSequenceClassification.from_pretrained(
    MODEL_NAME, num_labels=2,
    hidden_dropout_prob=0.1, attention_probs_dropout_prob=0.1,
)

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

raw_dataset = Dataset.from_dict({"text": reviews, "label": labels})
raw_dataset = raw_dataset.train_test_split(test_size=0.2, seed=42)
tokenized_datasets = raw_dataset.map(
    tokenize_function, batched=True, remove_columns=["text"],
)

data_collator = DataCollatorWithPadding(tokenizer=tokenizer)

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return {
        "accuracy": accuracy_score(labels, predictions),
        "f1": f1_score(labels, predictions, average="weighted"),
    }

training_args = TrainingArguments(
    output_dir="./bert_sentiment",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    learning_rate=2e-5,
    weight_decay=0.01,
    warmup_ratio=0.1,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    fp16=(device == "cuda"),
    report_to="none",
)

trainer = Trainer(
    model=model, args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
    tokenizer=tokenizer, data_collator=data_collator,
    compute_metrics=compute_metrics,
)

print("\n🚀 Starting BERT Fine-Tuning...")
trainer.train()

results = trainer.evaluate()
print(f"\n✅ Eval Accuracy: {results['eval_accuracy']:.4f}")
print(f"✅ Eval F1 Score: {results['eval_f1']:.4f}")

trainer.save_model("./bert_sentiment_final")
tokenizer.save_pretrained("./bert_sentiment_final")
print("💾 Model saved to ./bert_sentiment_final")