PyTorch

import sys, platform

print(sys.version)
print(platform.platform())

import numpy as np
import pandas as pd
import matplotlib
import sklearn

print(f'NumPy {np.__version__}')
print(f'pandas {pd.__version__}')
print(f'matplotlib {matplotlib.__version__}')
print(f'Scikit-Learn {sklearn.__version__}')

import torch

print(f'PyTorch {torch.__version__}')
assert torch.cuda.is_available(), 'CUDA GPU is not available'

x = torch.rand(5, 3)
print(x)
print(x.to('cuda') if torch.cuda.is_available() else 'CUDA not available')

import keras

print(f'Keras {keras.__version__}')
print(keras.backend.backend())

import torch
import torchvision
import torchvision.transforms as transforms

# Transformations
transform = transforms.Compose(
    [transforms.ToTensor(),])
    #  transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# Training data
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
# Test data
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

from sklearn.model_selection import train_test_split

trainset, valset = train_test_split(trainset, test_size=0.2, random_state=0)

batch_size = 100

trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=4)
valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False, num_workers=4)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=4)

import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

def train(model, dataloader, criterion, optimizer, device):
    model.train()  # Set model to training mode
    total_loss = 0.0
    for inputs, targets in dataloader:
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()  # Zero the parameter gradients
        outputs = model(inputs)  # Forward pass
        loss = criterion(outputs, targets)  # Compute loss
        loss.backward()  # Backward pass
        optimizer.step()  # Optimize the model parameters
        total_loss += loss.item()

    avg_loss = total_loss / len(dataloader)
    return avg_loss

def evaluate(model, dataloader, criterion, device):
    model.eval()  # Set model to evaluation mode
    total_loss = 0.0
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, targets in dataloader:
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, targets)

            total_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += targets.size(0)
            correct += (predicted == targets).sum().item()
    avg_loss = total_loss / len(dataloader)
    accuracy = correct / total
    return avg_loss, accuracy


class model(nn.Module):
    def __init__(self):
        super(model, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = model()

# Device configuration
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9)

n_epochs = 5
best_val_loss = float('inf')

model.train()  # Set model to training mode
for epoch in range(n_epochs):
    running_loss = 0.0
    # Training step using the train function
    train_loss = train(model, trainloader, criterion, optimizer, device)
    print(f'Epoch [{epoch + 1}/{n_epochs}], Loss: {train_loss:.4f}')

    # Validation step using the evaluate function
    val_loss, val_acc = evaluate(model, valloader, criterion, device)
    print(f'Validation Loss: {val_loss:.4f} | Validation Accuracy: {val_acc:.2%}')

    # Save the model if validation loss has decreased
    if val_loss < best_val_loss:
        print(f'Validation loss decreased ({best_val_loss:.4f} --> {val_loss:.4f}). Saving model...')
        torch.save(model.state_dict(), f'model_epoch_{epoch + 1}.pth')
        best_val_loss = val_loss

    # Step the scheduler
    # scheduler.step()

test_loss, test_acc = evaluate(model, testloader, criterion, device)
print(f'[Test] Loss: {test_loss:.4f} Acc: {test_acc:.2%}')

import os
assert os.environ.get('KERAS_BACKEND', '') == 'torch', os.environ.get('KERAS_BACKEND', '')

import keras
print(f'Keras {keras.__version__}')

import keras
from keras import layers

keras.backend.clear_session()
model = keras.models.Sequential([
    keras.Input(shape=(3, 32, 32)),
    # layers.Permute((2, 3, 1)),
    layers.Conv2D(6, kernel_size=5, activation='relu', data_format='channels_first'),
    layers.MaxPooling2D(pool_size=(2, 2)),
    layers.Conv2D(16, kernel_size=5, activation='relu', data_format='channels_first'),
    layers.MaxPooling2D(pool_size=(2, 2)),
    layers.Flatten(),
    layers.Dense(120, activation='relu'),
    layers.Dense(84, activation='relu'),
    layers.Dense(10)
])

model.summary()
# train
model.compile(optimizer='adam', loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy'])
checkpoint_path = "cifar10_convnet_torch.keras"
callbacks = [
    keras.callbacks.ModelCheckpoint(checkpoint_path, save_best_only=True),
    # keras.callbacks.TensorBoard(log_dir="./logs"),
]
history = model.fit(trainloader, epochs=5, validation_data=valloader, callbacks=callbacks)
# evaluate the model
model = keras.models.load_model(checkpoint_path)
test_loss, test_acc = model.evaluate(testloader)
print(f'[Test] Loss: {test_loss:.4f}, Accuracy: {test_acc:.4f}')
    

(train_images, train_labels), (test_images, test_labels) = keras.datasets.cifar100.load_data()
print(f'Train images: {train_images.shape}, Test images: {test_images.shape}')

from sklearn.model_selection import train_test_split

train_images, val_images, train_labels, val_labels = train_test_split(train_images, train_labels, test_size=0.2, random_state=0)

trainset = [(image, label) for image, label in zip(train_images, train_labels)]
valset = [(image, label) for image, label in zip(val_images, val_labels)]
testset = [(image, label) for image, label in zip(test_images, test_labels)]

batch_size = 64
num_workers = 4
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=num_workers, pin_memory=True)
valloader = torch.utils.data.DataLoader(valset, batch_size=batch_size, shuffle=False, num_workers=num_workers)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=num_workers)

import numpy as np
import keras

# define model
input_shape = train_images.shape[1:]
num_classes = len(np.unique(train_labels))
print(f'Input shape: {input_shape}, Number of classes: {num_classes}')

keras.backend.clear_session()
model = keras.applications.ResNet50(
    include_top=True,
    weights=None,
    input_shape=input_shape,
    classes=num_classes,)

# train the model
loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=False)
checkpoint_path = "cifar100_resnet50_pth.keras"
callbacks = [
    keras.callbacks.ModelCheckpoint(checkpoint_path, save_best_only=True),
    # keras.callbacks.TensorBoard(log_dir="./logs"),
]
model.compile(optimizer="adam", loss=loss_fn, metrics=["accuracy"])#, jit_compile=True)
history = model.fit(trainloader,epochs=5, validation_data=valloader, callbacks=callbacks)
# evaluate the model
model = keras.models.load_model(checkpoint_path)
test_loss, test_acc = model.evaluate(testloader)
print(f'[Test] Loss: {test_loss:.4f}, Accuracy: {test_acc:.4f}')

import pandas as pd

results = pd.DataFrame(history.history)
results.to_csv('pytorch_cifar100_results.csv', index=False)
results.round(4)

from matplotlib import pyplot as plt

plt.figure(figsize=(10, 5))
ax1 = plt.subplot(1, 2, 1)
results[["loss", "val_loss"]].plot(ax=ax1, title="Loss")
ax2 = plt.subplot(1, 2, 2)
results[["accuracy", "val_accuracy"]].plot(ax=ax2, title="Accuracy")
plt.show()