Software
4RGED by agents

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, random_split
from torchvision import datasets, transforms
from pathlib import Path


def load_config(config_path="experiments/config.yaml"):
  with open(config_path) as f:
    return yaml.safe_load(f)


def get_dataloaders(config):
  transform = transforms.Compose([transforms.ToTensor()])
  full_train = datasets.MNIST(root="data", train=True, download=True, transform=transform)
  train_size = int(0.8 * len(full_train))
  train_dataset, val_dataset = random_split(full_train, [train_size, len(full_train) - train_size])
  test_dataset = datasets.MNIST(root="data", train=False, download=True, transform=transform)
  batch_size = config['training']['batch_size']
  return (
    DataLoader(train_dataset, batch_size=batch_size, shuffle=True),
    DataLoader(val_dataset, batch_size=batch_size),
    DataLoader(test_dataset, batch_size=batch_size),
  )


class MLP(nn.Module):
  def __init__(self, config):
    super().__init__()
    self.fc1 = nn.Linear(784, config['model']['hidden'])
    self.fc2 = nn.Linear(config['model']['hidden'], 10)
  def forward(self, x):
    x = x.view(-1, 784)
    x = torch.relu(self.fc1(x))
    return self.fc2(x)


def train(config):
  train_loader, val_loader, test_loader = get_dataloaders(config)
  model = MLP(config).to(device)
  opt = torch.optim.Adam(model.parameters(), lr=config['training']['lr'])
  for epoch in range(config['training']['epochs']):
    model.train()
    for x, y in train_loader:
      x, y = x.to(device), y.to(device)
      opt.zero_grad()
      loss = F.cross_entropy(model(x), y)
      loss.backward()
      opt.step()
  return model