How can i increease the accusracy further

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

class CustomCNN(nn.Module):
def init(self):
super(CustomCNN, self).init()
self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, stride=1, padding=1)
self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
self.fc1 = nn.Linear(64 * 8 * 8, 512) # Assuming input size is 32x32
self.fc2 = nn.Linear(512, 10) # CIFAR-10 has 10 classes

def forward(self, x):
    x = self.pool(F.relu(self.conv1(x)))  # Apply Conv1 + ReLU + Pooling
    x = self.pool(F.relu(self.conv2(x)))  # Apply Conv2 + ReLU + Pooling
    x = x.view(-1, 64 * 8 * 8)  # Flatten the tensor
    x = F.relu(self.fc1(x))     # Apply FC1 + ReLU
    x = self.fc2(x)             # Apply FC2
    return x

def train_model(net, trainloader, criterion, optimizer, num_epochs=10):
net.train() # Set the model to training mode
for epoch in range(num_epochs):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if i % 100 == 99: # Print every 100 mini-batches
print(f’Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}], Loss: {running_loss / 100:.4f}')
running_loss = 0.0
print(‘Finished Training’)

def evaluate_model(net, testloader):
net.eval() # Set the model to evaluation mode
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f’Accuracy of the network on the 10000 test images: {accuracy:.2f}%')
return accuracy

if name == ‘main’:
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=300, shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)

net = CustomCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001,)

train_model(net, trainloader, criterion, optimizer, num_epochs=10)
test_accuracy = evaluate_model(net, testloader)

‘’’
Accuracy of the network on the 10000 test images: 72.54%
i am getting this accuracy i tried increasing learning rate to 0.02,0.03 … and increased the number of channels too but still the range is between 70-75 its not improving.
*i am working on CIFAR-10 DATASET

I recommend using a deeper network, using batch normalization between layers.