Multi-Layer Perceptron: Backpropagation Visualizer

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelBinarizer
from sklearn.metrics import classification_report, confusion_matrix

import tensorflow as tf
from tensorflow.keras import Model
from tensorflow.keras.layers import Dense, Input
from tensorflow.keras.utils import plot_model
from IPython.display import Image, display

FILE_PATH = "Iris.csv"
data = pd.read_csv(FILE_PATH)
if "Id" in data.columns:
    data = data.drop("Id", axis=1)
    
print("Shape:", data.shape)
display(data.head())
print(data["Species"].value_counts())

Shape: (150, 5)

	SepalLengthCm	SepalWidthCm	PetalLengthCm	PetalWidthCm	Species
0	5.1	3.5	1.4	0.2	Iris-setosa
1	4.9	3.0	1.4	0.2	Iris-setosa
2	4.7	3.2	1.3	0.2	Iris-setosa
3	4.6	3.1	1.5	0.2	Iris-setosa
4	5.0	3.6	1.4	0.2	Iris-setosa

Iris-setosa: 50
Iris-versicolor: 50
Iris-virginica: 50

X = data.drop("Species", axis=1).values
y_species = data["Species"]

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

binarizer = LabelBinarizer()
y_encoded = binarizer.fit_transform(y_species)

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

print("Train Shape:", X_train.shape)
print("Test Shape:", X_test.shape)
print("Classes:", binarizer.classes_)

input_dim = 4

inputs = Input(shape=(input_dim,))
x1 = Dense(10, activation="relu")(inputs)
x2 = Dense(8, activation="relu")(x1)
outputs = Dense(3, activation="softmax")(x2)

model = Model(inputs, outputs)
model.compile(
    optimizer=tf.keras.optimizers.Adam(0.001),
    loss="categorical_crossentropy",
    metrics=["accuracy"]
)

model.summary()

history = model.fit(
    X_train, y_train,
    epochs=50,
    batch_size=8,
    validation_split=0.1,
    verbose=0
)

model.compile(
    optimizer=tf.keras.optimizers.SGD(
        learning_rate=0.01
    ),
    loss="categorical_crossentropy",
    metrics=["accuracy"]
)

print("Training Completed!")

Epochs:

Batch Size:

Optimizer:

Learning Rate:

y_true = binarizer.inverse_transform(y_test)
y_pred = binarizer.inverse_transform(
    model.predict(X_test, verbose=0)
)

report = pd.DataFrame(
    classification_report(y_true, y_pred, output_dict=True)
).transpose()

display(report)

# Confusion Matrix
cm = confusion_matrix(y_true, y_pred)
plt.figure(figsize=(6,5))
plt.imshow(cm, cmap="Blues")
plt.title("Confusion Matrix")
plt.colorbar()
plt.show()