PyTorch vs Keras: which deep learning framework should you choose?

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from torchvision import datasets, transforms

# Define model
class SimpleNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = x.view(x.size(0), -1)
        x = torch.relu(self.fc1(x))
        return self.fc2(x)

model = SimpleNet()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()

# Load data
train_data = datasets.MNIST('./data', train=True, download=True,
                            transform=transforms.ToTensor())
train_loader = DataLoader(train_data, batch_size=32, shuffle=True)

# Training loop (explicit: this is PyTorch's flexibility)
model.train()
for epoch in range(3):
    for images, labels in train_loader:
        optimizer.zero_grad()
        logits = model(images)  # Forward pass
        loss = loss_fn(logits, labels)
        loss.backward()  # Backprop: automatic differentiation
        optimizer.step()
    print(f'Epoch {epoch} done')

model.eval()
# PyTorch requires explicit inference mode and no_grad context
with torch.no_grad():
    test_images, _ = next(iter(train_loader))
    predictions = model(test_images)
    print(f'Sample prediction shape: {predictions.shape}')

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# Define model using Functional API
inputs = keras.Input(shape=(28*28,))
x = layers.Dense(128, activation='relu')(inputs)
outputs = layers.Dense(10)(x)
model = keras.Model(inputs, outputs)

# Compile (optimizer + loss + metrics in one call)
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=['accuracy']
)

# Load data
(x_train, y_train), _ = keras.datasets.mnist.load_data()
x_train = x_train.reshape(-1, 28*28).astype('float32') / 255.0

# Training (one line: Keras handles batching, validation, metrics)
model.fit(x_train, y_train, epochs=3, batch_size=32, verbose=1)

# Evaluation
test_images = x_train[:32]  # Use sample
predictions = model.predict(test_images)  # Automatic batch processing
print(f'Sample prediction shape: {predictions.shape}')