File size: 4,471 Bytes
104f15a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
import pandas as pd
import torch
import torch.nn as nn
from gensim.models.fasttext import load_facebook_model
from torch.utils.data import DataLoader, Dataset
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import os
FASTTEXT_PATH = "FastText.bin"
TEST_PATH = "Test-1.tsv"
LSTM_MODEL_PATH = "fasttext_lstm.pt"
CNN_MODEL_PATH = "fasttext_cnn.pt"
print("Učitavanje FastText modela...")
ft_model = load_facebook_model(FASTTEXT_PATH)
embedding_dim = ft_model.vector_size
def tokenize(text):
return text.lower().split()
class FastTextDataset(Dataset):
def __init__(self, texts, labels):
self.texts = [tokenize(text) for text in texts]
self.labels = labels
def __len__(self):
return len(self.labels)
def __getitem__(self, idx):
tokens = self.texts[idx]
vectors = [ft_model.wv[token] if token in ft_model.wv else np.zeros(embedding_dim) for token in tokens]
max_len = 50
if len(vectors) > max_len:
vectors = vectors[:max_len]
else:
vectors += [np.zeros(embedding_dim)] * (max_len - len(vectors))
return torch.tensor(vectors, dtype=torch.float32), torch.tensor(self.labels[idx], dtype=torch.long)
class CNNClassifier(nn.Module):
def __init__(self, embedding_dim, num_classes):
super(CNNClassifier, self).__init__()
self.conv1 = nn.Conv1d(embedding_dim, 100, kernel_size=3, padding=1)
self.relu = nn.ReLU()
self.pool = nn.AdaptiveMaxPool1d(1)
self.dropout = nn.Dropout(0.5)
self.fc = nn.Linear(100, num_classes)
def forward(self, x):
x = x.permute(0, 2, 1)
x = self.relu(self.conv1(x))
x = self.pool(x).squeeze(2)
x = self.dropout(x)
return self.fc(x)
class LSTMClassifier(nn.Module):
def __init__(self, embedding_dim, hidden_dim, num_classes):
super(LSTMClassifier, self).__init__()
self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True, bidirectional=True)
self.dropout = nn.Dropout(0.5)
self.fc = nn.Linear(hidden_dim * 2, num_classes)
def forward(self, x):
_, (hn, _) = self.lstm(x)
hn = torch.cat((hn[-2], hn[-1]), dim=1)
x = self.dropout(hn)
return self.fc(x)
print("Učitavanje testnog skupa...")
test_df = pd.read_csv(TEST_PATH, sep="\t").rename(columns={"Sentence": "text", "Label": "label"})
test_df["label"] = test_df["label"].astype(int)
num_classes = test_df["label"].nunique()
label_names = sorted(test_df["label"].unique())
test_dataset = FastTextDataset(test_df["text"].tolist(), test_df["label"].tolist())
test_loader = DataLoader(test_dataset, batch_size=32)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def evaluate_model(model, loader, model_name):
model.eval()
all_preds = []
all_labels = []
with torch.no_grad():
for x, y in loader:
x, y = x.to(device), y.to(device)
output = model(x)
preds = torch.argmax(output, dim=1)
all_preds.extend(preds.cpu().numpy())
all_labels.extend(y.cpu().numpy())
print(f"\n=== Evaluacija: {model_name} ===")
print("Distribucija predikcija:", np.bincount(all_preds))
print("Stvarna distribucija:", np.bincount(all_labels))
report = classification_report(all_labels, all_preds, digits=4, zero_division=0)
print(report)
cm = confusion_matrix(all_labels, all_preds, labels=label_names)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=label_names, yticklabels=label_names)
plt.title(f"Confusion Matrix: {model_name}")
plt.xlabel("Predicted")
plt.ylabel("True")
os.makedirs("confusion_matrices", exist_ok=True)
plt.savefig(f"confusion_matrices/confusion_matrix_{model_name.lower()}.png")
plt.close()
print("\n=== EVALUACIJA: LSTM model ===")
lstm_model = LSTMClassifier(embedding_dim, hidden_dim=256, num_classes=num_classes)
lstm_model.load_state_dict(torch.load(LSTM_MODEL_PATH, map_location=device))
lstm_model.to(device)
evaluate_model(lstm_model, test_loader, "LSTM")
print("\n=== EVALUACIJA: CNN model ===")
cnn_model = CNNClassifier(embedding_dim, num_classes=num_classes)
cnn_model.load_state_dict(torch.load(CNN_MODEL_PATH, map_location=device))
cnn_model.to(device)
evaluate_model(cnn_model, test_loader, "CNN")
|