File size: 6,405 Bytes
74c6a41 |
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 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 |
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, accuracy_score
# Importing Classifiers
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import MultinomialNB
from sklearn.neural_network import MLPClassifier
from xgboost import XGBClassifier
# Function to preprocess data (optional scaling for certain models)
def preprocess_data(X, scale=False):
if scale:
scaler = StandardScaler()
X = scaler.fit_transform(X)
return X
# Logistic Regression
def logistic_regression(X, y):
# X = preprocess_data(X, scale=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = LogisticRegression(multi_class='multinomial', solver='lbfgs', max_iter=1000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# Decision Tree Classifier
def decision_tree(X, y):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = DecisionTreeClassifier()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# Random Forest Classifier
def random_forest(X, y):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# Support Vector Machine (SVM)
def support_vector_machine(X, y):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = SVC(kernel='rbf', probability=True) # Enable progress output
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# k-Nearest Neighbors (k-NN)
def knn(X, y, k=5):
# X = preprocess_data(X, scale=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# Naïve Bayes
def naive_bayes(X, y):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = MultinomialNB()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# Gradient Boosting Classifier (XGBoost)
def xgboost_classifier(X, y):
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
model = XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
# Multi-Layer Perceptron (MLP - Neural Network)
# def mlp_classifier(X, y):
# # X = preprocess_data(X, scale=True)
# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# model = MLPClassifier(hidden_layer_sizes=(100, 50), max_iter=500, random_state=42)
# model.fit(X_train, y_train)
# y_pred = model.predict(X_test)
# return classification_report(y_test, y_pred), accuracy_score(y_test, y_pred)
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, accuracy_score
def mlp_classifier(X, y, epochs=500, lr=0.01):
# Normalize data without centering (for sparse matrices)
scaler = StandardScaler(with_mean=False) # Fix applied here
X = scaler.fit_transform(X)
# Convert to PyTorch tensors
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
X_train, X_test = torch.tensor(X_train.toarray(), dtype=torch.float32), torch.tensor(X_test.toarray(), dtype=torch.float32)
y_train, y_test = torch.tensor(y_train, dtype=torch.long), torch.tensor(y_test, dtype=torch.long)
# Move to GPU if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
X_train, X_test, y_train, y_test = X_train.to(device), X_test.to(device), y_train.to(device), y_test.to(device)
# Define MLP model
class MLP(nn.Module):
def __init__(self, input_size, hidden_sizes, output_size):
super(MLP, self).__init__()
self.fc1 = nn.Linear(input_size, hidden_sizes[0])
self.fc2 = nn.Linear(hidden_sizes[0], hidden_sizes[1])
self.fc3 = nn.Linear(hidden_sizes[1], output_size)
self.relu = nn.ReLU()
def forward(self, x):
x = self.relu(self.fc1(x))
x = self.relu(self.fc2(x))
x = self.fc3(x)
return x
# Initialize model
model = MLP(input_size=X.shape[1], hidden_sizes=[100, 50], output_size=len(set(y))).to(device)
# Loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=lr)
# Train model
for epoch in range(epochs):
model.train()
optimizer.zero_grad()
outputs = model(X_train)
loss = criterion(outputs, y_train)
loss.backward()
optimizer.step()
# Evaluate model
model.eval()
with torch.no_grad():
y_pred = model(X_test)
y_pred = torch.argmax(y_pred, dim=1).cpu().numpy()
# Return classification report and accuracy score
return classification_report(y_test.cpu().numpy(), y_pred), accuracy_score(y_test.cpu().numpy(), y_pred)
# Example usage:
# report, acc = logistic_regression(X, y)
# print("Accuracy:", acc)
# print(report)
|