File size: 3,463 Bytes
835424e |
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 |
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.feature_extraction.text import CountVectorizer
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.metrics import accuracy_score, classification_report
# 1. Load data
data = pd.read_csv('data.csv') # Replace 'data.csv' with your dataset
print("Columns in the dataset:", data.columns) # Check column names
# 2. Preprocess data
X = data['text'] # Assuming your text column is named 'text'
y = data['label'] # Assuming your label column is named 'label'
# Encode labels
label_encoder = LabelEncoder()
y_encoded = label_encoder.fit_transform(y)
# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)
# Convert text to numerical features
vectorizer = CountVectorizer()
X_train_vectorized = vectorizer.fit_transform(X_train)
X_test_vectorized = vectorizer.transform(X_test)
# 3. Define the neural network model
class SentimentModel(nn.Module):
def __init__(self, input_size, hidden_size, output_size):
super(SentimentModel, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_size)
self.relu = nn.ReLU()
self.fc2 = nn.Linear(hidden_size, output_size)
def forward(self, x):
x = self.fc1(x)
x = self.relu(x)
x = self.fc2(x)
return x
# Initialize model
input_size = X_train_vectorized.shape[1]
hidden_size = 512
output_size = len(label_encoder.classes_)
model = SentimentModel(input_size, hidden_size, output_size)
# 4. Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 5. Train the model
num_epochs = 1000
for epoch in range(num_epochs):
model.train()
optimizer.zero_grad()
outputs = model(torch.FloatTensor(X_train_vectorized.toarray()))
loss = criterion(outputs, torch.LongTensor(y_train))
loss.backward()
optimizer.step()
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
# 6. Evaluate the model
model.eval()
with torch.no_grad():
test_outputs = model(torch.FloatTensor(X_test_vectorized.toarray()))
_, predicted = torch.max(test_outputs, 1)
# Calculate accuracy
accuracy = accuracy_score(y_test, predicted.numpy())
print(f'Accuracy: {accuracy:.4f}')
# Detailed classification report
print(classification_report(y_test, predicted.numpy(), target_names=label_encoder.classes_))
# 7. Test the model with new sample inputs
def predict_sentiment(text):
# Vectorize the input text
text_vectorized = vectorizer.transform([text])
with torch.no_grad():
output = model(torch.FloatTensor(text_vectorized.toarray()))
_, predicted = torch.max(output, 1)
return label_encoder.inverse_transform(predicted.numpy())[0]
# Test the model with new sentences
new_samples = [
"It is very good",
"Bad",
"Good",
"loving you",
"Loving you",
"love you",
"Love you",
"Very bad",
"I love you",
"Fuck",
"fuck",
"bad store",
"i dont love this",
"not like this"
]
for sample in new_samples:
sentiment = predict_sentiment(sample)
print(f'Text: "{sample}" -> Predicted Sentiment: {sentiment}')
|