import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
data, targets = iris.data, iris.target

print(iris.DESCR)

print ("target_names",iris.target_names)
print ("X, y",data.shape, targets.shape)
print(data[0:5],'\n', targets)

target_names ['setosa' 'versicolor' 'virginica']
X, y (150, 4) (150,)
[[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
 [5.  3.6 1.4 0.2]] 
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]

fig, axes = plt.subplots(4, 4, figsize=(15, 15))
features = iris.feature_names

for i in range(4):
    for j in range(4):
        ax = axes[i, j]
        # Plot scatter plots only on off-diagonal combinations
        if i != j:
            scatter = ax.scatter(data[:, j], data[:, i], c=iris.target, cmap='viridis', s=15)

        # Add labels to the outer edges of the grid
        if i == 3:
            ax.set_xlabel(features[j])
        if j == 0:
            ax.set_ylabel(features[i])

# Add a main legend to the figure
handles, labels = scatter.legend_elements()
fig.legend(handles, iris.target_names, loc='upper right', title="Classes")

plt.tight_layout()
plt.show()

n_samples, n_features = data.shape
X_train_np, X_test_np, y_train_np, y_test_np = train_test_split (data,targets, test_size=0.2, random_state = 4)

X_train = torch.from_numpy(X_train_np.astype(np.float32))
X_test = torch.from_numpy(X_test_np.astype(np.float32))

y_train = torch.from_numpy(y_train_np).long() # Target labels should be 1D and of type long
y_test = torch.from_numpy(y_test_np).long()   # Target labels should be 1D and of type long

print (X_train.shape, y_train.shape)
print (X_test.shape, y_test.shape)

torch.Size([120, 4]) torch.Size([120])
torch.Size([30, 4]) torch.Size([30])

max_train,__ = X_train.max(dim=0)
min_train, __ = X_train.min(dim=0)

def Normalize_minMax(X):
    return (X - min_train) / (max_train - min_train)


print (max_train, min_train)

tensor([7.9000, 4.4000, 6.9000, 2.5000]) tensor([4.3000, 2.2000, 1.0000, 0.1000])

X_train = Normalize_minMax(X_train)
X_test = Normalize_minMax(X_test)
# X_train = Normalize_z(X_train)
# X_test = Normalize_z(X_test)
print (X_train[0:5])
max_val, max_idx = X_train.max(dim=0)
print (max_val, max_idx)

tensor([[0.3056, 0.3636, 0.5932, 0.5833],
        [0.0833, 0.4545, 0.0678, 0.0417],
        [0.6667, 0.1364, 0.8136, 0.7083],
        [0.1667, 0.3636, 0.0678, 0.0417],
        [0.1944, 0.0455, 0.3898, 0.3750]])
tensor([1., 1., 1., 1.]) tensor([102,  16,  22,   5])

if torch.cuda.is_available():
    device = torch.device('cuda')
else:
    device = torch.device('cpu')
print(device)

X_train = X_train.to(device)
X_test = X_test.to(device)
y_train = y_train.to(device)
y_test = y_test.to(device)

learning_rate = 1e-2
epochs = 1000
losses = [] # tensor to save losses for print

# design model
class ANN_Model(nn.Module):
    def __init__(self, input_size, num_classes):
        super().__init__()
        self.linear1 = nn.Linear(input_size,64)
        self.linear2 = nn.Linear(64, 128)
        self.linear3 = nn.Linear(128, num_classes)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.linear1(x)
        x = self.relu(x)         # torch.nn.functional as F
        x = self.linear2(x)
        x = self.relu(x)
        x = self.linear3(x)
        return x

Model = ANN_Model(input_size=4, num_classes=3).to(device)

#construct loss and optimizer
Loss = nn.CrossEntropyLoss ()

# init optimizer
optim = torch.optim.Adam(Model.parameters(), lr=learning_rate)

for epoch in range(epochs):
    # forward
    y_predict = Model(X_train)

    # backward
    loss = Loss(y_predict, y_train)
    loss.backward()

    # update wights
    optim.step()
    losses.append(loss.item())

    if epoch % 10 == 0:
        print(f"epoch= {epoch} loss={loss.item():.4f} ")

    # zero grads
    optim.zero_grad()

epoch= 0 loss=1.1119 
epoch= 10 loss=0.3873 
...
epoch= 990 loss=0.0000

plt.plot(losses)
plt.show()

with torch.no_grad():
    y_predicted = Model(X_test)
    __,y_predict_arg = torch.max(y_predicted,1)
    n_correct = (y_predict_arg == y_test).sum().item()
    accuracy = n_correct / float(y_predicted.shape[0])
    print (f'accuracy = {accuracy*100:.4f}%')

accuracy = 93.3333%

print ("predicted, test \n", torch.cat((y_predict_arg.view(-1,1), y_test.view(-1,1)), dim=1))

predicted, test 
 tensor([[2, 2],
        [0, 0],
        [2, 2],
        [2, 2],
        [2, 2],
        [1, 1],
        [2, 1],
        [0, 0],
        [0, 0],
        [1, 2],
        [0, 0],
        [0, 0],
        [0, 0],
        [1, 1],
        [2, 2],
        [0, 0],
        [1, 1],
        [0, 0],
        [0, 0],
        [2, 2],
        [0, 0],
        [2, 2],
        [1, 1],
        [0, 0],
        [0, 0],
        [0, 0],
        [0, 0],
        [0, 0],
        [0, 0],
        [2, 2]], device='cuda:0')

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import torchvision
import torchvision.transforms as transforms

if torch.cuda.is_available():
    device = torch.device('cuda')
else:
    device = torch.device('cpu')
print(device)

train_dataset = torchvision.datasets.FashionMNIST(root='./data',
                                           train=True,
                                           transform=transforms.ToTensor(),
                                           download=True)

test_dataset = torchvision.datasets.FashionMNIST(root='./data',
                                          train=False,
                                          transform=transforms.ToTensor(),
                                          download=True)

print(train_dataset)
print(test_dataset)

Dataset FashionMNIST
    Number of datapoints: 60000
    Root location: ./data
    Split: Train
    StandardTransform
Transform: ToTensor()
Dataset FashionMNIST
    Number of datapoints: 10000
    Root location: ./data
    Split: Test
    StandardTransform
Transform: ToTensor()

print(f'Class names: {train_dataset.classes}')
for number, name in enumerate(train_dataset.classes):
    print(f"Class Number: {number}, Class Name: {name}")

Class names: ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
Class Number: 0, Class Name: T-shirt/top
Class Number: 1, Class Name: Trouser
Class Number: 2, Class Name: Pullover
Class Number: 3, Class Name: Dress
Class Number: 4, Class Name: Coat
Class Number: 5, Class Name: Sandal
Class Number: 6, Class Name: Shirt
Class Number: 7, Class Name: Sneaker
Class Number: 8, Class Name: Bag
Class Number: 9, Class Name: Ankle boot

batch_size = 50

train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
                                          batch_size=batch_size,
                                          shuffle=False)

print(len(train_loader))
print(len(test_loader))

1200
200

examples = iter(test_loader)
example_data, example_targets = next(examples)
example_data, example_targets = next(examples)

for i in range(9):
    plt.subplot(3,3,i+1)
    plt.title (train_dataset.classes[example_targets[i].item()])
    plt.imshow(example_data[i][0], cmap='gray')
    print(example_targets[i].item(), example_data[i].shape)

plt.show()
print(example_data[8][0][10])

4 torch.Size([1, 28, 28])
4 torch.Size([1, 28, 28])
5 torch.Size([1, 28, 28])
8 torch.Size([1, 28, 28])
2 torch.Size([1, 28, 28])
2 torch.Size([1, 28, 28])
8 torch.Size([1, 28, 28])
4 torch.Size([1, 28, 28])
8 torch.Size([1, 28, 28])

tensor([0.0000, 0.0000, 0.0000, 0.0588, 0.9843, 0.8039, 0.7961, 0.8353, 0.8275,
        0.8078, 0.8196, 0.8235, 0.8353, 0.8314, 0.8314, 0.8392, 0.8353, 0.8392,
        0.8471, 0.8392, 0.8314, 0.8196, 0.8392, 0.8275, 0.8235, 0.8235, 0.9020,
        0.2431])

input_size = 784 # 28x28
hidden_size1 = 256
hidden_size2 = 128
output_size = 10
epochs = 5
learning_rate = 1e-3

# design model
class ANN_Model(nn.Module):
    def __init__(self, input_size, num_classes):
        super().__init__()
        self.linear1 = nn.Linear(input_size,hidden_size1)
        self.linear2 = nn.Linear(hidden_size1, hidden_size2)
        self.linear3 = nn.Linear(hidden_size2, num_classes)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.linear1(x)
        x = self.relu(x)
        x = self.linear2(x)
        x = self.relu(x)
        x = self.linear3(x)
        return x

Model = ANN_Model(input_size, output_size).to(device)

#construct loss and optimizer
Loss = nn.CrossEntropyLoss ()

# init optimizer
optim = torch.optim.Adam(Model.parameters(), lr=learning_rate)

n_total_steps = len(train_loader)
for epoch in range(epochs):
    for i, (images, lables) in enumerate(train_loader):

        # origin shape: [50, 1, 28, 28]
        # resized: [50, 784]
        images = images.reshape(-1, 28*28).to(device)
        lables = lables.to(device)

        # forward
        Y_predict = Model(images)

        # backward
        loss = Loss(Y_predict, lables)
        loss.backward()

        # update wights
        optim.step()

        if (i + epoch * n_total_steps) % 100 == 0:
            print(f"epoch= {epoch} i= {i} num= {i+epoch * n_total_steps} loss={loss.item():.4f} ")

        # zero grads
        optim.zero_grad()

epoch= 0 i= 0 num= 0 loss=2.2812 
epoch= 0 i= 100 num= 100 loss=0.6721 
...
epoch= 4 i= 1100 num= 5900 loss=0.1990

with torch.no_grad():
    n_correct = 0
    n_samples = 0
    for images, lables in test_loader:
        images = images.reshape(-1, 28*28).to(device)
        labels = lables.to(device)
        labels_pre = Model(images)
        __,labels_pre_arg = torch.max(labels_pre,1)
        n_correct += (labels_pre_arg == labels).sum().item()
        n_samples += lables.size(0)


    acc = 100 * n_correct / n_samples
    print(f'Accuracy of the network on the {n_samples} test images: {acc} %')

Accuracy of the network on the 10000 test images: 87.56 %

print(len(test_loader))
print (n_samples)
print(lables.shape)
examples = iter(test_loader)
example_data, example_targets = next(examples)
example_data = example_data.to(device)
example_targets = example_targets.to(device)
with torch.no_grad():
    # Get raw model outputs (logits)
    raw_predictions = Model(example_data.reshape(-1, 28*28))
    # Calculate probabilities using softmax
    probabilities = torch.softmax(raw_predictions, dim=1)
    # Apply argmax to find the predicted class for each example
    predicted_classes = torch.argmax(raw_predictions, dim=1)

print("Predicted, True (Class Index) and Probability")
for i in range(len(example_data)):
    predicted_class_index = predicted_classes[i].item()
    predicted_prob = probabilities[i, predicted_class_index].item()
    print (f"Pred: {predicted_class_index}, True: {example_targets[i].item()}, Prob: {predicted_prob:.2f}")

200
10000
torch.Size([50])
Predicted, True (Class Index) and Probability
Pred: 9, True: 9, Prob: 0.98
Pred: 2, True: 2, Prob: 1.00
Pred: 1, True: 1, Prob: 1.00
Pred: 1, True: 1, Prob: 1.00
Pred: 0, True: 6, Prob: 0.49
Pred: 1, True: 1, Prob: 1.00
Pred: 4, True: 4, Prob: 0.99
Pred: 6, True: 6, Prob: 0.99
Pred: 5, True: 5, Prob: 1.00
Pred: 7, True: 7, Prob: 1.00
Pred: 4, True: 4, Prob: 0.72
Pred: 5, True: 5, Prob: 1.00
Pred: 7, True: 7, Prob: 0.74
Pred: 3, True: 3, Prob: 1.00
Pred: 4, True: 4, Prob: 0.61
Pred: 1, True: 1, Prob: 1.00
Pred: 2, True: 2, Prob: 1.00
Pred: 2, True: 4, Prob: 0.98
Pred: 8, True: 8, Prob: 1.00
Pred: 0, True: 0, Prob: 0.98
Pred: 2, True: 2, Prob: 0.99
Pred: 5, True: 5, Prob: 0.82
Pred: 7, True: 7, Prob: 1.00
Pred: 9, True: 9, Prob: 0.49
Pred: 1, True: 1, Prob: 1.00
Pred: 2, True: 4, Prob: 0.85
Pred: 6, True: 6, Prob: 0.88
Pred: 0, True: 0, Prob: 0.81
Pred: 9, True: 9, Prob: 0.98
Pred: 3, True: 3, Prob: 0.48
Pred: 8, True: 8, Prob: 1.00
Pred: 8, True: 8, Prob: 1.00
Pred: 3, True: 3, Prob: 0.97
Pred: 3, True: 3, Prob: 0.96
Pred: 8, True: 8, Prob: 1.00
Pred: 0, True: 0, Prob: 0.98
Pred: 7, True: 7, Prob: 1.00
Pred: 5, True: 5, Prob: 1.00
Pred: 7, True: 7, Prob: 1.00
Pred: 9, True: 9, Prob: 1.00
Pred: 0, True: 6, Prob: 0.98
Pred: 1, True: 1, Prob: 1.00
Pred: 6, True: 3, Prob: 0.40
Pred: 7, True: 7, Prob: 0.86
Pred: 6, True: 6, Prob: 0.97
Pred: 7, True: 7, Prob: 0.93
Pred: 2, True: 2, Prob: 0.98
Pred: 1, True: 1, Prob: 1.00
Pred: 2, True: 2, Prob: 0.62
Pred: 6, True: 2, Prob: 0.58

examples = iter(test_loader)
example_data, example_targets = next(examples)
example_data = example_data.to(device)
example_targets = example_targets.to(device)

with torch.no_grad():
    raw_predictions_plot = Model(example_data.reshape(-1, 28*28))
    probabilities = torch.softmax(raw_predictions_plot, dim=1)
    predicted_classes_plot = torch.argmax(raw_predictions_plot, dim=1)

num_images = 50
cols = 4
rows = (num_images + cols - 1) // cols

plt.figure(figsize=(16, rows * 4))

for i in range(num_images):
    plt.subplot(rows, cols, i + 1)

    true_label = train_dataset.classes[example_targets[i].item()]
    pred_idx = predicted_classes_plot[i].item()
    pred_label = train_dataset.classes[pred_idx]
    pred_prob = probabilities[i, pred_idx].item()

    color = 'black' # Default color for correct answers
    if pred_idx != example_targets[i].item():
        color = 'red' # Red for incorrect answers

    plt.title(
        f"Label: {true_label}\nPred: {pred_label} ({pred_prob:.2f})",
        fontsize=12,
        pad=8,
        color=color
    )

    plt.imshow(example_data[i][0].cpu(), cmap="gray")
    plt.axis("off")

plt.subplots_adjust(wspace=0.25, hspace=0.6)
plt.show()