سحر و جادو طبقه بندی متن: متن خام را به بینش عاطفی تبدیل کنید

# Environment Setup - Watch how quickly these install with Colab's lightning-fast internet!
! pip install transformers datasets accelerate pandas numpy evaluate

# Import Libraries
import pandas as pd
import numpy as np
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import Trainer, TrainingArguments
from transformers import EarlyStoppingCallback
from datasets import Dataset
import evaluate

# Access your data from Google Drive
from google.colab import drive
drive.mount('/content/drive')

def parse_emotion_file(file_path):
    texts, emotions = [], []
    with open(file_path, 'r', encoding='utf-8') as file:
        for line in file:
            text, emotion = line.strip().split(';')
            texts.append(text)
            emotions.append(emotion)
    return pd.DataFrame({'text': texts, 'emotion': emotions})

# Define your data directories
PARENT_DIR = "/content/drive/MyDrive/MLEng/"
MODEL_DIR = PARENT_DIR + "model_outputs/"

# Load your datasets - these will be the foundation of your emotion detector!
train_df = parse_emotion_file(PARENT_DIR + "data/train.txt")
val_df = parse_emotion_file(PARENT_DIR + "data/val.txt")
test_df = parse_emotion_file(PARENT_DIR + "data/test.txt")

# Get a glimpse of what you're working with
print(f"Training examples: {len(train_df)}")
print(f"Validation examples: {len(val_df)}")
print(f"Test examples: {len(test_df)}")
print(f"Emotions in our dataset: {sorted(train_df['emotion'].unique())}")

# Load the tokenizer - this will convert text to tokens our model understands
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-uncased")

# Create datasets from your dataframes
train_dataset = Dataset.from_pandas(train_df)
val_dataset = Dataset.from_pandas(val_df)
test_dataset = Dataset.from_pandas(test_df)

# This function transforms your text into sequences of token IDs
def tokenize_function(examples):
    return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=128)

# Apply tokenization to all your datasets
train_dataset = train_dataset.map(tokenize_function, batched=True)
val_dataset = val_dataset.map(tokenize_function, batched=True)
test_dataset = test_dataset.map(tokenize_function, batched=True)

# Create a mapping between emotion labels and IDs
labels = sorted(train_df["emotion"].unique())
label2id = {label: idx for idx, label in enumerate(labels)}
id2label = {idx: label for label, idx in label2id.items()}

print("Our emotion mappings:")
for label, idx in label2id.items():
    print(f"{label}: {idx}")

# Add numerical labels to your datasets
def add_labels(examples):
    examples["labels"] = [label2id[emotion] for emotion in examples["emotion"]]
    return examples

train_dataset = train_dataset.map(add_labels, batched=True)
val_dataset = val_dataset.map(add_labels, batched=True)
test_dataset = test_dataset.map(add_labels, batched=True)

# Set up an evaluation metric - accuracy is perfect for multi-class classification
accuracy = evaluate.load("accuracy")

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = np.argmax(predictions, axis=1)
    return {"accuracy": accuracy.compute(predictions=predictions, references=labels)}

# Load the pre-trained model and customize it for our emotion classification task
model = AutoModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased",
    num_labels=len(labels),
    label2id=label2id,
    id2label=id2label
)

# Configure training parameters - these are carefully tuned for optimal learning
training_args = TrainingArguments(
    output_dir=os.path.join(MODEL_DIR, "checkpoints"),
    evaluation_strategy="epoch",
    save_strategy="epoch",
    learning_rate=3e-5,  # Small learning rate for fine-tuning
    per_device_train_batch_size=32,
    per_device_eval_batch_size=64,
    num_train_epochs=5,
    weight_decay=0.01,  # Prevents overfitting
    load_best_model_at_end=True,
    metric_for_best_model="accuracy",
    fp16=True,  # Mixed precision training for speed
    gradient_accumulation_steps=2
)

# Initialize the Trainer with everything it needs
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
    tokenizer=tokenizer,
    compute_metrics=compute_metrics,
    callbacks=[EarlyStoppingCallback(early_stopping_patience=2)]  # Stop if not improving
)

# The moment of truth - train your model!
print("🚀 Training started! This might take a while, but the results will be worth it...")
trainer.train()

# Evaluate on the test set
test_results = trainer.evaluate(test_dataset)
print(f"📊 Test results: {test_results}")

# A glimpse at what your model achieved
print(f"🎯 Accuracy: {test_results['eval_accuracy']:.2%}")

Test results: {'eval_loss': 0.15945003926753998, 'eval_accuracy': 0.925, 'eval_runtime': 1.6421, 'eval_samples_per_second': 1217.947, 'eval_steps_per_second': 19.487, 'epoch': 5.0}
Model saved to /content/drive/MyDrive/MLEng/model_outputs/final_model

# Save the fine-tuned model and tokenizer
final_model_path = os.path.join(MODEL_DIR, "final_model")
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)

print(f"✅ Model successfully saved to {final_model_path}")

from transformers import pipeline

# Create an emotion classification pipeline
emotion_classifier = pipeline("text-classification", model=final_model_path, tokenizer=final_model_path)

# Try it on some examples
test_texts = [
    "I'm feeling very happy today!",
    "This news is absolutely devastating.",
    "I'm so angry I could scream!",
    "The test results have me feeling very anxious."
]

# Get predictions
for text in test_texts:
    result = emotion_classifier(text)
    print(f"Text: '{text}'")
    print(f"Predicted emotion: {result[0]['label']}, Confidence: {result[0]['score']:.2%}\n")