Datasets:

ysn-rfd
/

text-dataset-tiny-code-script-py-format

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}')

	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}')