📦 Import Libraries

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

📂 Load Data

df = pd.read_csv(“data.csv”) # 🔁 Replace with your actual dataset
df = df.fillna(method=’ffill’) # ✅ Handle missing values

🧹 Encode categorical columns

le = LabelEncoder()
for col in df.select_dtypes(include=’object’).columns:
df[col] = le.fit_transform(df[col])

🎯 Feature / Target Split

X = df.drop(“target”, axis=1) # 🔁 Replace ‘target’
y = df[“target”]

🔃 Feature Scaling

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

🔀 Train/Test Split

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)

✅ SKLEARN MODELS

models = {
“Logistic Regression”: LogisticRegression(),
“Random Forest”: RandomForestClassifier(),
“Decision Tree”: DecisionTreeClassifier(),
“Support Vector Machine”: SVC()
}

for name, model in models.items():
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(f”\n[{name}]”)
print(“Accuracy:”, accuracy_score(y_test, y_pred))
print(“Classification Report:\n”, classification_report(y_test, y_pred))

# 🔍 Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print("Confusion Matrix:\n", cm)
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues")
plt.title(f"{name} - Confusion Matrix")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.show()

✅ TENSORFLOW DEEP LEARNING MODEL

Auto-detect binary or multi-class

num_classes = len(np.unique(y))
activation_fn = ‘sigmoid’ if num_classes == 2 else ‘softmax’
loss_fn = ‘binary_crossentropy’ if num_classes == 2 else ‘sparse_categorical_crossentropy’
output_units = 1 if num_classes == 2 else num_classes

model = Sequential()
model.add(Dense(128, activation=’relu’, input_shape=(X_train.shape[1],)))
model.add(Dense(64, activation=’relu’))
model.add(Dense(output_units, activation=activation_fn))

model.compile(optimizer=’adam’, loss=loss_fn, metrics=[‘accuracy’])
model.fit(X_train, y_train, epochs=10, batch_size=16, validation_split=0.1)

Evaluate model

loss, acc = model.evaluate(X_test, y_test)
print(“\n[TensorFlow DNN]”)
print(“Test Accuracy:”, acc)

🔍 Predictions & Confusion Matrix

y_pred_dl = model.predict(X_test)
if num_classes == 2:
y_pred_class = np.round(y_pred_dl).flatten()
else:
y_pred_class = np.argmax(y_pred_dl, axis=1)

print(“DL Classification Report:\n”, classification_report(y_test, y_pred_class))

cm_dl = confusion_matrix(y_test, y_pred_class)
print(“DL Confusion Matrix:\n”, cm_dl)
sns.heatmap(cm_dl, annot=True, fmt=”d”, cmap=”Greens”)
plt.title(“TensorFlow DNN – Confusion Matrix”)
plt.xlabel(“Predicted”)
plt.ylabel(“Actual”)
plt.show()