Compilation, training, and inference

import argparse
import os
from pathlib import Path
from typing import Tuple

import sambaflow.samba.utils as utils
import torch
import torch.nn as nn
import torchvision.transforms as transforms
from mnist_utils import CustomMNIST, write_labels
from sambaflow import __version__ as sambaflow_version
from sambaflow import samba
from sambaflow.samba.utils.argparser import parse_app_args
from sambaflow.samba.utils.pef_utils import get_pefmeta
from torch.utils.data.dataloader import DataLoader


class LeNet(nn.Module):
    """
    LeNet model for MNIST classification.

    Attributes:
        state: Dictionary to hold model's completed_steps and completed_epochs.
        conv1, conv2: Convolutional layers.
        maxpool1, maxpool2: Max pooling layers.
        fc1, fc2, fc3: Fully connected layers.
        criterion: Loss function.
    """

    def __init__(self, num_classes: int) -> None:
        super(LeNet, self).__init__()
        self.state = {"completed_steps": 0, "completed_epochs": 0}

        self.conv1 = nn.Conv2d(in_channels=1,
                               out_channels=6,
                               kernel_size=(3, 3),
                               stride=(1, 1),
                               padding=(1, 1),
                               dilation=(1, 1),
                               bias=False)

        self.maxpool1 = nn.MaxPool2d(kernel_size=(2, 2))

        self.conv2 = nn.Conv2d(in_channels=6,
                               out_channels=16,
                               kernel_size=(3, 3),
                               stride=(1, 1),
                               padding=(1, 1),
                               dilation=(1, 1),
                               bias=False)
        self.maxpool2 = nn.MaxPool2d(kernel_size=(2, 2))

        self.fc1 = nn.Linear(16 * 7 * 7, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, num_classes)

        self.criterion = nn.CrossEntropyLoss()

    def forward(self, inputs, labels):
        """Defines the forward propagation step."""
        x = self.conv1(inputs).relu()
        x = self.maxpool1(x)
        x = self.conv2(x).relu()
        x = self.maxpool2(x)
        x = torch.reshape(x, [x.shape[0], -1])
        x = self.fc1(x).relu()
        x = self.fc2(x).relu()
        out = self.fc3(x)
        loss = self.criterion(out, labels)
        return loss, out


def get_inputs(params) -> Tuple[samba.SambaTensor, samba.SambaTensor]:
    """
    Creates input images and labels to set the model's shape for compilation.

    Args:
        params: A dictionary containing various parameters including 'batch_size' and 'num_classes'.

    Returns:
        A tuple of input images and labels.
    """
    images = samba.randn(params['batch_size'],
                         1,
                         28,
                         28,
                         name='image',
                         batch_dim=0)
    labels = samba.randint(params['num_classes'], (params['batch_size'],),
                           name='label',
                           batch_dim=0)
    return (images, labels)


def get_dataset(dataset_name: str, params):
    """Retrieves the specified dataset after applying necessary transformations.

    Args:
        dataset_name: The name of the dataset to retrieve.
        params: A dictionary containing various parameters including 'data_dir' and 'inference'.

    Returns:
        The requested dataset as a CustomMNIST object.
    """
    transform = transforms.Compose([
        transforms.ToTensor(),
        # norm by mean and var
        transforms.Normalize((0.1307,), (0.3081,)),
        # Reshape image to 1x28x28
        lambda x: x.reshape((1, 28, 28)),
    ])

    data_dir = Path(params['data_dir'])
    img_file = data_dir / (dataset_name + "-images-idx3-ubyte")
    if params['inference']:  # if running for inference there's no labels file
        lbl_file = None
    else:
        lbl_file = data_dir / (dataset_name + "-labels-idx1-ubyte")
    dataset = CustomMNIST(img_file, lbl_file, transform=transform)

    return dataset


def load_checkpoint(model, optimizer, init_ckpt_path: str):
    """
    Loads a checkpoint from a file and initialize the model and optimizer.

    Args:
        model (object): The model to be loaded.
        optimizer (object): The optimizer to be loaded.
        init_ckpt_path (str): The path to the checkpoint file.

    Returns:
        None
    """
    print(f"Loading checkpoint from file {init_ckpt_path}")
    ckpt = torch.load(init_ckpt_path)
    if model:
        print("Loading model...")
        model.load_state_dict(ckpt['model'])
        model.state['completed_steps'] = ckpt['completed_steps']
        model.state['completed_epochs'] = ckpt['completed_epochs']
    if optimizer:
        print("Loading optimizer...")
        optimizer.load_state_dict(ckpt['optimizer'])


def save_checkpoint(model, optimizer, completed_steps, completed_epochs,
                    ckpt_dir):
    """
    Saves the model checkpoint with the given parameters.

    Args:
        model (nn.Module): The model to be saved.
        optimizer (torch.optim.Optimizer): The optimizer to be saved.
        completed_steps (int): The number of completed steps.
        completed_epochs (int): The number of completed epochs.
        ckpt_dir (str): The directory in which to save the checkpoint.

    Returns:
        str: The path of the saved checkpoint.
    """
    ckpt_dir_path = Path(ckpt_dir)
    ckpt_dir_path.mkdir(parents=True, exist_ok=True)

    state_dict = {
        'completed_steps': completed_steps,
        'completed_epochs': completed_epochs,
        'model': model.state_dict(),
        'optimizer': optimizer.state_dict()
    }

    ckpt_path = ckpt_dir_path / (str(completed_steps) + ".pt")
    torch.save(state_dict, ckpt_path)
    return ckpt_path


def log_step(epoch, num_epochs, current_step, total_steps, loss):
    """
    Prints the current step information during training.

    Args:
        epoch (int): The current epoch number.
        num_epochs (int): The total number of epochs.
        current_step (int): The current step number.
        total_steps (int): The total number of steps.
        loss (float): The loss value for the current step.

    Returns:
        None
    """
    print(
        f"Epoch [{epoch}/{num_epochs}], Step [{current_step}/{total_steps}], Loss: {loss:.4f}"
    )


def prepare(model: nn.Module, optimizer, params):
    """
    Prepares the model by loading a checkpoint and tracing the graph.

    Args:
        model (nn.Module): The model to prepare.
        optimizer: The optimizer for the model.
        params: A dictionary of parameters.

    Returns:
        None
    """

    # We need to load the checkpoint first and then trace the graph to sync the weights from CPU to RDU
    if params['init_ckpt_path']:
        load_checkpoint(model, optimizer, params['init_ckpt_path'])
    else:
        print('[WARNING] No valid initial checkpoint has been provided')

    inputs = get_inputs(params)
    utils.trace_graph(model,
                      inputs,
                      optimizer,
                      pef=params['pef'],
                      mapping=params['mapping'])


def train(model: LeNet, optimizer, params) -> None:
    """
    Trains the given model using the specified optimizer and parameters.

    Args:
        model (LeNet): The model to be trained.
        optimizer: The optimizer to be used during training.
        params: A dictionary containing the parameters for training.

    Returns:
        None
    """
    if params['dataset_name'] is None:
        dataset_name = "train"
    else:
        dataset_name = params['dataset_name']
    data_dir = Path(params['data_dir'])
    print(f"Using dataset: {data_dir / dataset_name}")
    train_dataset = get_dataset(dataset_name, params)
    train_loader = DataLoader(train_dataset,
                              batch_size=params['batch_size'],
                              drop_last=True,
                              shuffle=True)

    # Train the model
    current_step = model.state['completed_steps']
    current_epoch = model.state['completed_epochs']
    total_steps = len(train_loader) * params['num_epochs']
    if current_epoch == params['num_epochs']:
        print(
            f"Epochs trained: {current_epoch} is equal to epochs requested: {params['num_epochs']}. Exiting..."
        )
        return
    print("=" * 30)
    print(f"Initial epoch: {current_epoch:3n}, initial step: {current_step:6n}")
    print(
        f"Target epoch:  {params['num_epochs']:3n}, target step:  {total_steps:6n}"
    )
    hyperparam_dict = {
        "lr": params['lr'],
        "momentum": params['momentum'],
        "weight_decay": params['weight_decay']
    }
    for epoch in range(current_epoch + 1, params['num_epochs'] + 1):
        avg_loss = 0
        for i, (images, labels) in enumerate(train_loader):
            sn_images = samba.from_torch_tensor(images,
                                                name='image',
                                                batch_dim=0)
            sn_labels = samba.from_torch_tensor(labels,
                                                name='label',
                                                batch_dim=0)

            loss, outputs = samba.session.run(
                input_tensors=[sn_images, sn_labels],
                output_tensors=model.output_tensors,
                hyperparam_dict=hyperparam_dict,
                data_parallel=params['data_parallel'],
                reduce_on_rdu=params['reduce_on_rdu'])
            loss, outputs = samba.to_torch(loss), samba.to_torch(outputs)
            avg_loss += loss.mean()
            current_step += 1

            if (i + 1) % 100 == 0:
                log_step(epoch, params['num_epochs'], current_step, total_steps,
                         avg_loss / (i + 1))

    current_epoch = epoch

    samba.session.to_cpu(model)
    save_checkpoint(model, optimizer, current_step, current_epoch,
                    params['ckpt_dir'])


def test(model, dataset_name, params):
    """
    Calculates the test accuracy and loss for the given model and dataset.

    Parameters:
        model (object): The model to be tested.
        dataset_name (str): The name of the dataset to be used.
        params (dict): A dictionary of parameters.

    Returns:
        None
    """
    if dataset_name is None:
        dataset_name = "t10k"
    data_dir = Path(params['data_dir'])
    print(f"Using dataset: {data_dir / dataset_name}")
    test_dataset = get_dataset(dataset_name, params)
    test_loader = DataLoader(test_dataset,
                             drop_last=True,
                             batch_size=params['batch_size'])

    samba.session.to_cpu(model)
    test_acc = 0.0
    with torch.no_grad():
        correct = 0
        total = 0
        total_loss = 0
        for images, labels in test_loader:
            loss, outputs = model(images, labels)
            loss, outputs = samba.to_torch(loss), samba.to_torch(outputs)
            total_loss += loss.mean()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum()

        test_acc = 100.0 * correct / total
        print('Test Accuracy: {:.2f}'.format(test_acc),
              ' Loss: {:.4f}'.format(total_loss.item() / (len(test_loader))))


def batch_predict(model, dataset_name: str, params):
    """
    Generates the predictions for a given model on a dataset.

    Args:
        model (object): The trained model to use for prediction.
        dataset_name (str): The name of the dataset to use for prediction.
        params (dict): Additional parameters for the prediction.

    Returns:
        None
    """
    if dataset_name is None:
        dataset_name = "inference"
    data_dir = Path(params['data_dir'])
    print(f"Using dataset: {data_dir / dataset_name}")
    dataset = get_dataset(dataset_name, params)

    loader = DataLoader(dataset,
                        batch_size=params.get('batch_size', 32),
                        drop_last=True,
                        shuffle=False)

    predicted_labels = []
    for _, (images, labels) in enumerate(loader):
        sn_images = samba.from_torch_tensor(images, name='image', batch_dim=0)
        sn_labels = samba.from_torch_tensor(labels, name='label', batch_dim=0)

        loss, predictions = samba.session.run(
            input_tensors=[sn_images, sn_labels],
            output_tensors=model.output_tensors,
            section_types=['fwd'])
        loss, predictions = samba.to_torch(loss), samba.to_torch(predictions)
        _, predicted_indices = torch.max(predictions, axis=1)  # type: ignore

        predicted_labels += predicted_indices.tolist()

    # write to the file in the same format labels are stored
    results_dir = Path(params['results_dir'])
    results_dir.mkdir(parents=True, exist_ok=True)
    write_labels(predicted_labels,
                 str(results_dir / "prediction-labels-idx1-ubyte"))


def add_common_args(parser: argparse.ArgumentParser):
    """
    Adds common arguments to the given ArgumentParser object.

    Args:
        parser (argparse.ArgumentParser): The ArgumentParser object to add the arguments to.

    Returns:
        None
    """
    parser.add_argument('--num-classes',
                        type=int,
                        default=10,
                        help="Number of output classes (default=10)")
    parser.add_argument('--num-features',
                        type=int,
                        default=784,
                        help="Number of input features (default=784)")
    parser.add_argument('--lr',
                        type=float,
                        default=0.1,
                        help="Learning rate (default=0.1)")
    parser.add_argument('-b',
                        '--batch-size',
                        type=int,
                        default=32,
                        help="Batch size (default=32)")
    parser.add_argument('--momentum',
                        type=float,
                        default=0.0,
                        help="Momentum (default=0.0)")
    parser.add_argument('--weight-decay',
                        type=float,
                        default=0.01,
                        help="Weight decay (default=0.01)")
    parser.add_argument('--print-params',
                        action='store_true',
                        default=False,
                        help="Print the model parameters (default=False)")


def add_run_args(parser: argparse.ArgumentParser):
    """
    Add runtime arguments to the parser.

    Args:
        parser (argparse.ArgumentParser): The parser to which the arguments will be added.

    Returns:
        None
    """
    parser.add_argument('-e', '--num-epochs', type=int, default=1)
    parser.add_argument('--log-path', type=str, default='checkpoints')
    parser.add_argument('--test',
                        action="store_true",
                        help="Test the trained model")
    parser.add_argument('--init-ckpt-path',
                        type=str,
                        default='',
                        help='Path to load checkpoint')
    parser.add_argument('--ckpt-dir',
                        type=str,
                        default=os.getcwd(),
                        help='Path to save checkpoint')
    parser.add_argument('--data-dir',
                        type=str,
                        default='./data',
                        help="Directory containing datasets")
    parser.add_argument('--dataset-name',
                        type=str,
                        help="Dataset name: train, t10k, inference, etc.")
    parser.add_argument('--results-dir',
                        type=str,
                        default='./results',
                        help="Directory to store inference results")


def print_params(params):
    """
    Prints the parameters and their values when --print-params is passed.

    Args:
        params (dict): A dictionary containing the parameters and their values.

    Returns:
        None
    """
    for k in sorted(params.keys()):
        print(f"{k}: {params[k]}")


def main():
    args = parse_app_args(dev_mode=True,
                          common_parser_fn=add_common_args,
                          test_parser_fn=add_run_args,
                          run_parser_fn=add_run_args)
    utils.set_seed(42)
    params = vars(args)
    if args.print_params:
        print_params(params)

    model = LeNet(args.num_classes)
    samba.from_torch_model_(model)

    inputs = get_inputs(params)

    optimizer = samba.optim.SGD(model.parameters(),
                                lr=0.0) if not args.inference else None
    if args.command == "compile":
        pef_metadata=get_pefmeta(args, model)
        pef_metadata['sambaflow_version'] = sambaflow_version
        pef_metadata['input_shapes'] = (inputs[0].shape, inputs[1].shape)
        samba.session.compile(model,
                              inputs,
                              optimizer,
                              name='lenet',
                              app_dir=utils.get_file_dir(__file__),
                              squeeze_bs_dim=True,
                              config_dict=vars(args),
                              pef_metadata=pef_metadata)

    elif args.command == "test":
        print("Test is not implemented in this version.")
    elif args.command == "run":
        if args.inference:
            prepare(model, optimizer, params)
            batch_predict(model, params['dataset_name'], params)
        elif args.test:
            prepare(model, optimizer, params)
            test(model, params['dataset_name'], params)
        else:
            prepare(model, optimizer, params)
            train(model, optimizer, params)


if __name__ == '__main__':
    main()

import struct
from array import array
from typing import Callable, Optional, Tuple, List
import numpy as np
from torch.utils.data import Dataset
from pathlib import Path


class CustomMNIST(Dataset):
    """Custom dataset that is compatible with MNIST format."""

    def __init__(self,
                 images_path: Path,
                 labels_path: Optional[Path],
                 transform: Optional[Callable] = None) -> None:
        """Initialize the dataset with images and labels path, and a transform.

        Args:
            images_path (str): Path to the images file.
            labels_path (str): Path to the labels file.
            transform (Optional[Callable]): Optional transform to be applied on an image.
        """
        self.images = self.read_images(images_path)
        if labels_path == None:  # in case of inference
            self.labels = [0] * len(self.images)
        else:
            self.labels = self.read_labels(labels_path)
        self.transform = transform

    def __getitem__(self, idx: int) -> Tuple[np.array, int]:
        """Fetch an image-label pair by index.

        Args:
            idx (int): Index to the data.

        Returns:
            Tuple[np.array, int]: A tuple containing an image and its corresponding label.
        """
        label = self.labels[idx]
        image = self.images[idx]
        if self.transform:
            image = self.transform(image)
        return image, label

    def __len__(self) -> int:
        """Get the size of the dataset.

        Returns:
            int: The number of images in the dataset.
        """
        return len(self.labels)

    @staticmethod
    def check_magic_number(magic: int, expected: int) -> None:
        """Check if the magic number matches the expected number.

        Args:
            magic (int): The actual magic number.
            expected (int): The expected magic number.
        """
        if magic != expected:
            raise ValueError(
                f"Magic number is wrong: expected {expected}, got {magic}")

    @staticmethod
    def read_labels(file_path: Path) -> List[int]:
        """Read labels from an MNIST-formatted file.

        Args:
            file_path (Path): Path to the file to read from.

        Returns:
            List[int]: List of labels.
        """
        file_data = file_path.read_bytes()
        magic, size = struct.unpack(">II", file_data[:8])
        CustomMNIST.check_magic_number(magic, 2049)
        return list(array("B", file_data[8:]))

    @staticmethod
    def read_images(file_path: Path) -> List[np.array]:
        """Read images from an MNIST-formatted file.

        Args:
            file_path (Path): Path to the file to read from.

        Returns:
            List[np.array]: List of images.
        """
        file_data = file_path.read_bytes()
        magic, size, rows, cols = struct.unpack(">IIII", file_data[:16])
        CustomMNIST.check_magic_number(magic, 2051)
        image_data = array("B", file_data[16:])

        return [
            np.array(image_data[i * rows * cols:(i + 1) * rows * cols]).reshape(
                28, 28) for i in range(size)
        ]


def write_labels(labels: List[int], filename: str) -> None:
    """Write labels to an MNIST-formatted file.

    Args:
        labels (List[int]): List of labels.
        filename (str): Filename to write to.
    """
    with open(filename, 'wb') as f:
        f.write(struct.pack('>ii', 2049, len(labels)))
        f.writelines(struct.pack('B', label) for label in labels)

{
    "cells": [
     {
      "cell_type": "markdown",
      "id": "ec5e46fe",
      "metadata": {},
      "source": [
       "# Run inference on RDU\n",
       "\n",
       "In this example you run inference on RDU using the LeNet model.\n",
       "You generate predictions and then visualize them.\n",
       "The images and prediction labels files use the same format as the MNIST files.\n",
       "\n",
       "You randomly choose images and their predicted labels from the dataset and visualize them.\n",
       "Then you visually estimate the accuracy by inspecting the images and comparing to the predicted labels."
      ]
     },
     {
      "cell_type": "markdown",
      "id": "5672b5b8",
      "metadata": {},
      "source": [
       "## Model parameters\n",
       "\n",
       "First, define some parameters to use with the model.\n",
       "\n",
       "* `data_dir`: where your dataset is stored\n",
       "* `dataset_name`: the dataset name you are going to use for inference\n",
       "* `results_dir`: where the prediction labels will be stored\n",
       "* `inir_ckpt_path`: the checkpoint file that we created during training\n",
       "* `batch_size`: batch size; should match the batch size in the PEF file\n",
       "* `num_classes`: number of classes (categories); usually 10 for MNIST datasets\n",
       "* `num_features`: number of pixels in the input images; usually 28x28 = 784\n",
       "* `pef`: the PEF file that was compiled for this model; could be the same we used in training or compiled for inference only\n",
       "* `mapping`: use `section` here\n",
       "* `inference`: set to True (obviously)"
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 2,
      "id": "f4652a48",
      "metadata": {},
      "outputs": [],
      "source": [
       "params = {\n",
       "    \"data_dir\": \"/home/pavela/datasets/fashion-mnist\",\n",
       "    \"dataset_name\": \"t10k\",\n",
       "    \"results_dir\": \"/home/pavela/results/lenet/\",\n",
       "    \"init_ckpt_path\": \"/home/pavela/checkpoints/lenet/checkpoints-b32/1875.pt\",\n",
       "    \"batch_size\": 32,\n",
       "    \"num_classes\": 10,\n",
       "    \"num_features\": 784,\n",
       "    \"pef\": \"/home/pavela/sambaflow-apps/starters/lenet/out/lenet-b32/lenet-b32.pef\",\n",
       "    \"mapping\": \"section\",\n",
       "    \"inference\": True,\n",
       "}"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "064ea7bf",
      "metadata": {},
      "source": [
       "## Imports\n",
       "\n",
       "Some necessary imports.\n",
       "\n",
       "Note: sometimes you have to execute the cell below 2 or 3 times to eliminate the import errors."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 15,
      "id": "356a1f89",
      "metadata": {},
      "outputs": [],
      "source": [
       "import os\n",
       "from pathlib import Path\n",
       "from typing import Tuple, Optional, Callable, List\n",
       "from sys import exit\n",
       "\n",
       "import torch\n",
       "import torch.nn as nn\n",
       "import torchvision.transforms as transforms\n",
       "import sambaflow\n",
       "from sambaflow import samba\n",
       "from torch.utils.data.dataloader import DataLoader\n",
       "from mnist_utils import CustomMNIST, write_labels\n",
       "from sambaflow.samba.utils.utils import trace_graph\n",
       "from sambaflow.logging import samba_logger"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "42513f76",
      "metadata": {},
      "source": [
       "## Set the log level"
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 16,
      "id": "e9747681",
      "metadata": {},
      "outputs": [],
      "source": [
       "# Set the log level\n",
       "samba_logger.set_level('error')"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "f59da2a1",
      "metadata": {},
      "source": [
       "## Define the model\n",
       "\n",
       "Use the same model class that was used in training."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 10,
      "id": "32d07117",
      "metadata": {},
      "outputs": [],
      "source": [
       "class LeNet(nn.Module):\n",
       "    \"\"\"\n",
       "    LeNet model for MNIST classification.\n",
       "\n",
       "    Attributes:\n",
       "        state: Dictionary to hold model's completed_steps and completed_epochs.\n",
       "        conv1, conv2: Convolutional layers.\n",
       "        maxpool1, maxpool2: Max pooling layers.\n",
       "        fc1, fc2, fc3: Fully connected layers.\n",
       "        criterion: Loss function.\n",
       "    \"\"\"\n",
       "\n",
       "    def __init__(self, num_classes: int) -> None:\n",
       "        super(LeNet, self).__init__()\n",
       "        self.state = {\"completed_steps\": 0, \"completed_epochs\": 0}\n",
       "\n",
       "        self.conv1 = nn.Conv2d(\n",
       "            in_channels=1,\n",
       "            out_channels=6,\n",
       "            kernel_size=(3, 3),\n",
       "            stride=(1, 1),\n",
       "            padding=(1, 1),\n",
       "            dilation=(1, 1),\n",
       "            bias=False,\n",
       "        )\n",
       "\n",
       "        self.maxpool1 = nn.MaxPool2d(kernel_size=(2, 2))\n",
       "\n",
       "        self.conv2 = nn.Conv2d(\n",
       "            in_channels=6,\n",
       "            out_channels=16,\n",
       "            kernel_size=(3, 3),\n",
       "            stride=(1, 1),\n",
       "            padding=(1, 1),\n",
       "            dilation=(1, 1),\n",
       "            bias=False,\n",
       "        )\n",
       "        self.maxpool2 = nn.MaxPool2d(kernel_size=(2, 2))\n",
       "\n",
       "        self.fc1 = nn.Linear(16 * 7 * 7, 120)\n",
       "        self.fc2 = nn.Linear(120, 84)\n",
       "        self.fc3 = nn.Linear(84, num_classes)\n",
       "\n",
       "        self.criterion = nn.CrossEntropyLoss()\n",
       "\n",
       "    def forward(self, inputs, labels):\n",
       "        \"\"\"Defines the forward propagation step.\"\"\"\n",
       "        x = self.conv1(inputs).relu()\n",
       "        x = self.maxpool1(x)\n",
       "        x = self.conv2(x).relu()\n",
       "        x = self.maxpool2(x)\n",
       "        x = torch.reshape(x, [x.shape[0], -1])\n",
       "        x = self.fc1(x).relu()\n",
       "        x = self.fc2(x).relu()\n",
       "        out = self.fc3(x)\n",
       "        loss = self.criterion(out, labels)\n",
       "        return loss, out"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "ce44bab5",
      "metadata": {},
      "source": [
       "## Prepare the model\n",
       "\n",
       "The following functions prepare the model: they load the checkpoint that we created during training and trace the model's graph."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 11,
      "id": "180e2132",
      "metadata": {},
      "outputs": [],
      "source": [
       "def load_checkpoint(model, optimizer, init_ckpt_path: str):\n",
       "    \"\"\"\n",
       "    Loads a checkpoint from a file and initialize the model and optimizer.\n",
       "\n",
       "    Args:\n",
       "        model (object): The model to be loaded.\n",
       "        optimizer (object): The optimizer to be loaded.\n",
       "        init_ckpt_path (str): The path to the checkpoint file.\n",
       "\n",
       "    Returns:\n",
       "        None\n",
       "    \"\"\"\n",
       "    print(f\"Loading checkpoint from file {init_ckpt_path}\")\n",
       "    ckpt = torch.load(init_ckpt_path)\n",
       "    if model:\n",
       "        print(\"Loading model...\")\n",
       "        model.load_state_dict(ckpt[\"model\"])\n",
       "        model.state[\"completed_steps\"] = ckpt[\"completed_steps\"]\n",
       "        model.state[\"completed_epochs\"] = ckpt[\"completed_epochs\"]\n",
       "    if optimizer:\n",
       "        print(\"Loading optimizer...\")\n",
       "        optimizer.load_state_dict(ckpt[\"optimizer\"])\n",
       "\n",
       "\n",
       "def get_inputs(params) -> Tuple[samba.SambaTensor, samba.SambaTensor]:\n",
       "    \"\"\"\n",
       "    Creates input images and labels to set the model's shape for compilation.\n",
       "\n",
       "    Args:\n",
       "        params: A dictionary containing various parameters including 'batch_size' and 'num_classes'.\n",
       "\n",
       "    Returns:\n",
       "        A tuple of input images and labels.\n",
       "    \"\"\"\n",
       "    images = samba.randn(params[\"batch_size\"], 1, 28, 28, name=\"image\", batch_dim=0)\n",
       "    labels = samba.randint(\n",
       "        params[\"num_classes\"], (params[\"batch_size\"],), name=\"label\", batch_dim=0\n",
       "    )\n",
       "    return (images, labels)\n",
       "\n",
       "\n",
       "def prepare(model: nn.Module, optimizer, params):\n",
       "    \"\"\"\n",
       "    Prepares the model by loading a checkpoint and tracing the graph.\n",
       "\n",
       "    Args:\n",
       "        model (nn.Module): The model to prepare.\n",
       "        optimizer: The optimizer for the model.\n",
       "        params: A dictionary of parameters.\n",
       "\n",
       "    Returns:\n",
       "        None\n",
       "    \"\"\"\n",
       "\n",
       "    # We need to load the checkpoint first and then trace the graph to sync the weights from CPU to RDU\n",
       "    if params[\"init_ckpt_path\"]:\n",
       "        load_checkpoint(model, optimizer, params[\"init_ckpt_path\"])\n",
       "    else:\n",
       "        return False\n",
       "\n",
       "    inputs = get_inputs(params)\n",
       "\n",
       "    trace_graph(model, inputs, optimizer, pef=params[\"pef\"], mapping=params[\"mapping\"])\n",
       "    return True"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "60dff13a",
      "metadata": {},
      "source": [
       "## Create a custom dataset\n",
       "\n",
       "Create a custom dataset using the PyTorch's Dataset class.\n",
       "You can read more about that here: https://pytorch.org/tutorials/beginner/basics/data_tutorial.html#creating-a-custom-dataset-for-your-files\n",
       "\n",
       "The `CustomMNIST` class is described in the `mnist_utils.py` file and imported above."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 12,
      "id": "91417821",
      "metadata": {},
      "outputs": [],
      "source": [
       "def get_dataset(dataset_name: str, params):\n",
       "    \"\"\"Retrieves the specified dataset after applying necessary transformations.\n",
       "\n",
       "    Args:\n",
       "        dataset_name: The name of the dataset to retrieve.\n",
       "        params: A dictionary containing various parameters including 'data_dir' and 'inference'.\n",
       "\n",
       "    Returns:\n",
       "        The requested dataset as a CustomMNIST object.\n",
       "    \"\"\"\n",
       "    transform = transforms.Compose(\n",
       "        [\n",
       "            transforms.ToTensor(),\n",
       "            # norm by mean and var\n",
       "            transforms.Normalize((0.1307,), (0.3081,)),\n",
       "            # Reshape image to 1x28x28\n",
       "            lambda x: x.reshape((1, 28, 28)),\n",
       "        ]\n",
       "    )\n",
       "\n",
       "    data_dir = Path(params[\"data_dir\"])\n",
       "    img_file = data_dir / (dataset_name + \"-images-idx3-ubyte\")\n",
       "    if params[\"inference\"]:  # if running for inference there's no labels file\n",
       "        lbl_file = None\n",
       "    else:\n",
       "        lbl_file = data_dir / (dataset_name + \"-labels-idx1-ubyte\")\n",
       "    dataset = CustomMNIST(img_file, lbl_file, transform=transform)\n",
       "\n",
       "    return dataset"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "f9800bdc",
      "metadata": {},
      "source": [
       "## Create the inference function \n",
       "\n",
       "This function runs inference on the RDU to predict image labels using our trained model."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 13,
      "id": "2a883e06",
      "metadata": {},
      "outputs": [],
      "source": [
       "def batch_predict(model, dataset_name: str, params):\n",
       "    \"\"\"\n",
       "    Generates the predictions for a given model on a dataset.\n",
       "\n",
       "    Args:\n",
       "        model (object): The trained model to use for prediction.\n",
       "        dataset_name (str): The name of the dataset to use for prediction.\n",
       "        params (dict): Additional parameters for the prediction.\n",
       "\n",
       "    Returns:\n",
       "        None\n",
       "    \"\"\"\n",
       "    if dataset_name is None:\n",
       "        dataset_name = \"inference\"\n",
       "    data_dir = Path(params[\"data_dir\"])\n",
       "    print(f\"Using dataset: {data_dir / dataset_name}\")\n",
       "    dataset = get_dataset(dataset_name, params)\n",
       "\n",
       "    loader = DataLoader(\n",
       "        dataset, batch_size=params.get(\"batch_size\", 32), drop_last=True, shuffle=False\n",
       "    )\n",
       "\n",
       "    predicted_labels = []\n",
       "    for _, (images, labels) in enumerate(loader):\n",
       "        sn_images = samba.from_torch_tensor(images, name=\"image\", batch_dim=0)\n",
       "        sn_labels = samba.from_torch_tensor(labels, name=\"label\", batch_dim=0)\n",
       "\n",
       "        loss, predictions = samba.session.run(\n",
       "            input_tensors=[sn_images, sn_labels],\n",
       "            output_tensors=model.output_tensors,\n",
       "            section_types=[\"fwd\"],\n",
       "        )\n",
       "        loss, predictions = samba.to_torch(loss), samba.to_torch(predictions)\n",
       "        _, predicted_indices = torch.max(predictions, axis=1)\n",
       "\n",
       "        predicted_labels += predicted_indices.tolist()\n",
       "\n",
       "    return predicted_labels"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "acce38a5",
      "metadata": {},
      "source": [
       "## Run inference"
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 14,
      "id": "f876c09e",
      "metadata": {},
      "outputs": [
       {
        "name": "stdout",
        "output_type": "stream",
        "text": [
         "Loading checkpoint from file /home/pavela/checkpoints/lenet/checkpoints-b32/1875.pt\n",
         "Loading model...\n",
         "Using dataset: /home/pavela/datasets/fashion-mnist/t10k\n"
        ]
       }
      ],
      "source": [
       "# Reset the Samba session\n",
       "samba.session.reset(params[\"pef\"])\n",
       "# Create the model for 10 output classes\n",
       "model = LeNet(10)\n",
       "# Copy the model to RDU\n",
       "samba.from_torch_model_(model)\n",
       "# The optimizer is set to None because we are running inference\n",
       "optimizer = None\n",
       "# We need a valid checkpoint to run inference\n",
       "if prepare(model, optimizer, params):\n",
       "    predicted_labels = batch_predict(model, params[\"dataset_name\"], params)\n",
       "else:\n",
       "    print(\"No valid checkpoint has been provided. Can't run prediction.\")"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "ac979eb5",
      "metadata": {},
      "source": [
       "## Save the predicted labels\n",
       "\n",
       "Save the predicted labels in a file in the same format that MNIST uses to provide training labels."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 31,
      "id": "7c1a7d2a",
      "metadata": {},
      "outputs": [],
      "source": [
       "results_dir = Path(params[\"results_dir\"])\n",
       "results_dir.mkdir(parents=True, exist_ok=True)\n",
       "write_labels(predicted_labels, str(results_dir / \"prediction-labels-idx1-ubyte\"))"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "562d8599",
      "metadata": {},
      "source": [
       "## Create a custom dataset with predicted labels\n",
       "\n",
       "Read the images from our inference dataset and predicted labels from the file generated by the model."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 42,
      "id": "467ea79f",
      "metadata": {},
      "outputs": [],
      "source": [
       "data_dir = Path(params[\"data_dir\"])\n",
       "predict_images_file = data_dir / \"t10k-images-idx3-ubyte\"\n",
       "predict_labels_file = results_dir / \"prediction-labels-idx1-ubyte\""
      ]
     },
     {
      "cell_type": "markdown",
      "id": "75e7328f",
      "metadata": {},
      "source": [
       "Create a custom PyTorch dataset using the inference images, predicted labels, and the `data_transform` function."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 44,
      "id": "6ec14f3c",
      "metadata": {},
      "outputs": [],
      "source": [
       "data_transform = transforms.Compose(\n",
       "    [transforms.ToTensor(), transforms.Normalize(mean=(0.1307,), std=(0.3081,))]\n",
       ")\n",
       "\n",
       "predict_dataset = CustomMNIST(\n",
       "    predict_images_file, predict_labels_file, transform=data_transform\n",
       ")"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "28b5e7df",
      "metadata": {},
      "source": [
       "## Create a display function"
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 34,
      "id": "4688296f",
      "metadata": {},
      "outputs": [],
      "source": [
       "import matplotlib.pyplot as plt\n",
       "\n",
       "\n",
       "def plot_examples(images, labels, columns=5):  # by default set rows=1\n",
       "    rows = len(images) // (columns)\n",
       "    fig = plt.figure(figsize=(6.4, 2 * rows))\n",
       "    for i, (img, lbl) in enumerate(zip(images, labels)):\n",
       "        if i < columns * rows:\n",
       "            ax = fig.add_subplot(rows, columns, i + 1)\n",
       "            ax.imshow(img.reshape(28, 28), cmap=\"gray\")\n",
       "            ax.set_xticks([])  # set empty label for x axis\n",
       "            ax.set_yticks([])  # set empty label for y axis\n",
       "            ax.set_title(lbl)\n",
       "    plt.tight_layout()\n",
       "    return fig"
      ]
     },
     {
      "cell_type": "markdown",
      "id": "082af9b7",
      "metadata": {},
      "source": [
       "## Display the images and predicted labels\n",
       "\n",
       "Pick several (`sample_size`) images and their predicted labels randomly and display them. We use the Fashion MNIST dataset labels here."
      ]
     },
     {
      "cell_type": "code",
      "execution_count": 45,
      "id": "d29b1874",
      "metadata": {},
      "outputs": [
       {
        "data": {
         "image/png": "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\n",
         "text/plain": [
          "<Figure size 460.8x576 with 20 Axes>"
         ]
        },
        "metadata": {},
        "output_type": "display_data"
       }
      ],
      "source": [
       "import random\n",
       "\n",
       "images = []\n",
       "labels = []\n",
       "sample_size = 20\n",
       "\n",
       "fashion_items = [\n",
       "    \"T-shirt/top\",\n",
       "    \"Trouser\",\n",
       "    \"Pullover\",\n",
       "    \"Dress\",\n",
       "    \"Coat\",\n",
       "    \"Sandal\",\n",
       "    \"Shirt\",\n",
       "    \"Sneaker\",\n",
       "    \"Bag\",\n",
       "    \"Ankle boot\",\n",
       "]\n",
       "\n",
       "for i in range(0, sample_size):\n",
       "    r = random.randint(0, len(predict_dataset))\n",
       "    images.append(predict_dataset[r][0])\n",
       "    labels.append(fashion_items[predict_dataset[r][1]])\n",
       "\n",
       "plot_examples(images, labels, columns=5)\n",
       "# keep the semicolon here or it will output the images twice"
      ]
     },
     {
      "cell_type": "code",
      "execution_count": null,
      "id": "8830f532",
      "metadata": {},
      "outputs": [],
      "source": []
     }
    ],
    "metadata": {
     "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
     },
     "language_info": {
      "codemirror_mode": {
       "name": "ipython",
       "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.6"
     }
    },
    "nbformat": 4,
    "nbformat_minor": 5
   }