use_case_examples/mnist/mnist_in_fhe.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "48790992",
   "metadata": {},
   "source": [
    "# MNIST Classification with Brevitas Quantization-Aware Training \n",
    "\n",
    "In this notebook, we show how to use [Brevitas](https://github.com/Xilinx/brevitas) to perform quantization-aware training on the famous [MNIST](http://yann.lecun.com/exdb/mnist/) dataset, using a fast FHE-friendly model with a low bit-width accumulator of 6-bits. Then, we show how the FHE simulation mode can be used to finetune parameters and find the best setting, before finally checking computations in FHE."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "01d93a9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "# Concrete-Python\n",
    "from concrete.fhe.compilation import Configuration\n",
    "\n",
    "# The QAT model\n",
    "from model import MNISTQATModel  # pylint: disable=no-name-in-module\n",
    "from torch import nn, optim\n",
    "from torch.optim.lr_scheduler import StepLR\n",
    "from torchvision import datasets, transforms\n",
    "from tqdm import tqdm\n",
    "\n",
    "# Concrete ML\n",
    "from concrete.ml.torch.compile import compile_brevitas_qat_model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9878260c",
   "metadata": {},
   "source": [
    "Here are the classical functions to train and test the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "95137753",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, device, train_loader, optimizer, epoch, criterion):\n",
    "    \"\"\"Train the model.\"\"\"\n",
    "\n",
    "    model.train()\n",
    "\n",
    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        output = model(data).squeeze()\n",
    "        loss = criterion(output, target)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        if epoch % 4 == 0 and batch_idx % 500 == 0:\n",
    "            print(\n",
    "                f\"Train Epoch: {epoch + 1} [{batch_idx}/{len(train_loader.dataset) // len(data)}\"\n",
    "                f\" ({100.0 * batch_idx / len(train_loader):.0f}%)]{'':5}\"\n",
    "                f\"\\tLoss: {loss.item():.6f}\"\n",
    "            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f432e903",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(model, device, test_loader, epoch, criterion):\n",
    "    \"\"\"Test the model.\"\"\"\n",
    "\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for data, target in tqdm(test_loader, disable=epoch % 4 != 0):\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            output = model(data).squeeze()\n",
    "            test_loss += criterion(output, target).item()  # sum up batch loss\n",
    "            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability\n",
    "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "\n",
    "    if epoch % 4 == 0:\n",
    "        print(\n",
    "            f\"Test set: Average loss: {test_loss:.4f}, \"\n",
    "            \"Accuracy: \"\n",
    "            f\"{correct}/{len(test_loader.dataset)} \"\n",
    "            f\"({100.0 * correct / len(test_loader.dataset):.0f}%)\"\n",
    "        )\n",
    "\n",
    "    return test_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "67d9b236",
   "metadata": {},
   "outputs": [],
   "source": [
    "def manage_dataset(train_kwargs, test_kwargs):\n",
    "    \"\"\"Get training and test parts of MNIST dataset.\"\"\"\n",
    "\n",
    "    transform = transforms.Compose(\n",
    "        [\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0.1307,), (0.3081,)),\n",
    "            transforms.Lambda(torch.flatten),\n",
    "        ]\n",
    "    )\n",
    "\n",
    "    # Manage datasets\n",
    "    dataset1 = datasets.MNIST(\"./data\", train=True, download=True, transform=transform)\n",
    "    dataset2 = datasets.MNIST(\"./data\", train=False, transform=transform)\n",
    "    train_loader = torch.utils.data.DataLoader(dataset1, **train_kwargs)\n",
    "    test_loader = torch.utils.data.DataLoader(dataset2, **test_kwargs)\n",
    "\n",
    "    return train_loader, test_loader"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59bd35b2",
   "metadata": {},
   "source": [
    "The following function is used to test the model, it can be done either using FHE execution or with FHE simulation  (i.e. on clear data).\n",
    "\n",
    "Evaluating models using FHE simulation is a very good habit to have when working with Concrete ML since it allows to check several aspects without having to wait for long FHE computations:\n",
    "- the impact of the FHE execution on the accuracy\n",
    "- the bit-widths of intermediate values, which impact FHE execution time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "24132f48",
   "metadata": {},
   "outputs": [],
   "source": [
    "def compile_and_test(\n",
    "    model,\n",
    "    use_simulation,\n",
    "    test_data,\n",
    "    test_data_length,\n",
    "    test_target,\n",
    "    show_mlir,\n",
    "    current_index,\n",
    "):\n",
    "    # Compile the QAT model and test\n",
    "    configuration = Configuration(\n",
    "        enable_unsafe_features=True,  # This is for our tests only, never use that in prod\n",
    "        use_insecure_key_cache=True,  # This is for our tests only, never use that in prod\n",
    "        insecure_key_cache_location=\"/tmp/keycache\",\n",
    "    )\n",
    "\n",
    "    if use_simulation:\n",
    "        print(f\"\\n{current_index}. Compiling with the FHE simulation\")\n",
    "    else:\n",
    "        print(f\"\\n{current_index}. Compiling in FHE\")\n",
    "\n",
    "    q_module = compile_brevitas_qat_model(\n",
    "        model,\n",
    "        test_data,\n",
    "        configuration=configuration,\n",
    "        show_mlir=show_mlir,\n",
    "    )\n",
    "\n",
    "    # Check max bit-width\n",
    "    max_bit_width = q_module.fhe_circuit.graph.maximum_integer_bit_width()\n",
    "\n",
    "    if max_bit_width > 8:\n",
    "        raise Exception(\n",
    "            f\"Too large bit-width ({max_bit_width}): training this network resulted in an \"\n",
    "            \"accumulator size that is too large. Possible solutions are:\"\n",
    "            \"    - this network should, on average, have 8bit accumulators. In your case an unlucky\"\n",
    "            f\"initialization resulted in {max_bit_width} accumulators. You can try to train the \"\n",
    "            \"network again\"\n",
    "            \"    - reduce the sparsity to reduce the number of active neuron connexions\"\n",
    "            \"    - if the weight and activation bitwidth is more than 2, you can try to reduce one \"\n",
    "            \"or both to a lower value\"\n",
    "        )\n",
    "\n",
    "    # Check the accuracy\n",
    "    if use_simulation:\n",
    "        print(\n",
    "            f\"\\n{current_index + 1}. Checking accuracy with the FHE simulation mode \"\n",
    "            f\"(length {test_data_length})\"\n",
    "        )\n",
    "    else:\n",
    "        print(f\"\\n{current_index + 1}. Checking accuracy in FHE (length {test_data_length})\")\n",
    "\n",
    "    # Key generation\n",
    "    if not use_simulation:\n",
    "        q_module.fhe_circuit.keygen()\n",
    "\n",
    "    correct_fhe = 0\n",
    "\n",
    "    # Reduce the test data, since very slow in FHE\n",
    "    reduced_test_data = test_data[0:test_data_length, :]\n",
    "    test_target = test_target[0:test_data_length, :]\n",
    "\n",
    "    fhe_mode = \"simulate\" if use_simulation else \"execute\"\n",
    "\n",
    "    prediction = q_module.forward(reduced_test_data, fhe=fhe_mode)\n",
    "\n",
    "    correct_fhe = (np.argmax(prediction, axis=1) == test_target.ravel()).sum()\n",
    "\n",
    "    # Final accuracy\n",
    "    return correct_fhe, reduced_test_data.shape[0], max_bit_width"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06a39bbb",
   "metadata": {},
   "source": [
    "## Settings\n",
    "\n",
    "Here, the user can change some settings. The most important ones are:\n",
    "- epochs: how many epochs during the training\n",
    "- sparsity: to define the number of active neurons in layers; make this value smaller and there will be less active neurons\n",
    "- quantization_bits: the number of bits during quantization. The larger the more accurate, but also the faster we are above the limits of Concrete ML in term of maximal bitwidth\n",
    "- do_training: whether we do the training. If not, we use the previously saved ONNX model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fb62ea33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Options: the most important ones\n",
    "epochs = 20\n",
    "sparsity = 4\n",
    "quantization_bits = 2\n",
    "do_training = True\n",
    "\n",
    "# Options: can be changed\n",
    "lr = 0.02\n",
    "gamma = 0.33\n",
    "test_data_length_reduced = 2  # This is notably the length of the computation in FHE\n",
    "test_data_length_full = 10000\n",
    "\n",
    "# Options: no real reason to change\n",
    "show_mlir = False\n",
    "batch_size = 32\n",
    "test_batch_size = 32\n",
    "use_cuda_if_available = True\n",
    "seed = None\n",
    "criterion = nn.CrossEntropyLoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "267c0c5e",
   "metadata": {},
   "source": [
    "Seeding if we want to, to try to make everything as reproducible as possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3ddb9ee3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Using seed 1949909803\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Seeding\n",
    "if seed is None:\n",
    "    seed = np.random.randint(0, 2**32 - 1)\n",
    "\n",
    "print(f\"\\nUsing seed {seed}\\n\")\n",
    "torch.manual_seed(seed);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efcd103e",
   "metadata": {},
   "source": [
    "Settings few things for the training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e14bdea4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Using cuda device\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Training and test arguments\n",
    "train_kwargs = {\"batch_size\": batch_size}\n",
    "test_kwargs = {\"batch_size\": test_batch_size}\n",
    "\n",
    "# Cuda management\n",
    "use_cuda = torch.cuda.is_available() and use_cuda_if_available\n",
    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "\n",
    "if use_cuda:\n",
    "    cuda_kwargs = {\"num_workers\": 1, \"pin_memory\": True, \"shuffle\": True}\n",
    "    train_kwargs.update(cuda_kwargs)\n",
    "    test_kwargs.update(cuda_kwargs)\n",
    "\n",
    "print(f\"\\nUsing {device} device\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02c0a2e7",
   "metadata": {},
   "source": [
    "Managing the MNIST data set, and splitting it into a train and testing set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b6c83939",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Manage dataset\n",
    "train_loader, test_loader = manage_dataset(train_kwargs, test_kwargs)\n",
    "img_size = train_loader.dataset.data[0].shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5caa0263",
   "metadata": {},
   "source": [
    "### Defining the model\n",
    "\n",
    "The model is defined in `model.py`. You may want to have a look to this file to see how things work in Brevitas or apply few changes here, to see what are the effects on the QAT training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e02f7dc9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model definition\n",
    "model = MNISTQATModel(quantization_bits, quantization_bits)\n",
    "model = model.to(device)\n",
    "model.prune(sparsity, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84c9f5c7",
   "metadata": {},
   "source": [
    "### Running the training\n",
    "\n",
    "Below, we run the quantization-aware training, which can be quite slow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "afd06825",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performing MNIST task with 2-bits in quantization and a sparsity of 4\n",
      "\n",
      "1. Training\n",
      "Train Epoch: 1 [0/1875 (0%)]     \tLoss: 11.338525\n",
      "Train Epoch: 1 [500/1875 (27%)]     \tLoss: 0.375854\n",
      "Train Epoch: 1 [1000/1875 (53%)]     \tLoss: 0.730532\n",
      "Train Epoch: 1 [1500/1875 (80%)]     \tLoss: 0.918802\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:01<00:00, 233.53it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set: Average loss: 0.0128, Accuracy: 8790/10000 (88%)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 5 [0/1875 (0%)]     \tLoss: 0.289679\n",
      "Train Epoch: 5 [500/1875 (27%)]     \tLoss: 0.175034\n",
      "Train Epoch: 5 [1000/1875 (53%)]     \tLoss: 0.432675\n",
      "Train Epoch: 5 [1500/1875 (80%)]     \tLoss: 0.356409\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:02<00:00, 114.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set: Average loss: 0.0098, Accuracy: 8942/10000 (89%)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 9 [0/1875 (0%)]     \tLoss: 0.473744\n",
      "Train Epoch: 9 [500/1875 (27%)]     \tLoss: 0.214084\n",
      "Train Epoch: 9 [1000/1875 (53%)]     \tLoss: 0.219320\n",
      "Train Epoch: 9 [1500/1875 (80%)]     \tLoss: 0.274142\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:02<00:00, 108.17it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set: Average loss: 0.0081, Accuracy: 9193/10000 (92%)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 13 [0/1875 (0%)]     \tLoss: 0.071514\n",
      "Train Epoch: 13 [500/1875 (27%)]     \tLoss: 0.200415\n",
      "Train Epoch: 13 [1000/1875 (53%)]     \tLoss: 0.304704\n",
      "Train Epoch: 13 [1500/1875 (80%)]     \tLoss: 0.120540\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:01<00:00, 262.74it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set: Average loss: 0.0088, Accuracy: 9173/10000 (92%)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train Epoch: 17 [0/1875 (0%)]     \tLoss: 0.460386\n",
      "Train Epoch: 17 [500/1875 (27%)]     \tLoss: 0.705041\n",
      "Train Epoch: 17 [1000/1875 (53%)]     \tLoss: 0.508183\n",
      "Train Epoch: 17 [1500/1875 (80%)]     \tLoss: 0.142191\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:01<00:00, 268.64it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set: Average loss: 0.0084, Accuracy: 9220/10000 (92%)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "2. Exporting to ONNX and saving the Brevitas model\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Training part\n",
    "print(\n",
    "    f\"Performing MNIST task with {quantization_bits}-bits in quantization and a \"\n",
    "    f\"sparsity of {sparsity}\"\n",
    ")\n",
    "\n",
    "if do_training:\n",
    "    print(\"\\n1. Training\")\n",
    "    optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=0.0001)\n",
    "    scheduler = StepLR(optimizer, step_size=1, gamma=gamma)\n",
    "    loss_values = []\n",
    "\n",
    "    for epoch in range(epochs):\n",
    "        train(model, device, train_loader, optimizer, epoch, criterion)\n",
    "        cur_loss = test(model, device, test_loader, epoch, criterion)\n",
    "\n",
    "        scheduler.step()\n",
    "\n",
    "        loss_values.append(cur_loss)\n",
    "\n",
    "    model.prune(sparsity, False)\n",
    "\n",
    "    # Plot the loss\n",
    "    fig = plt.figure()\n",
    "    plt.plot(loss_values)\n",
    "    fig.suptitle(\"Loss during QAT\")\n",
    "    plt.xlabel(\"Epochs\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.xticks(range(len(loss_values)))\n",
    "\n",
    "    # Export to ONNX\n",
    "    print(\"\\n2. Exporting to ONNX and saving the Brevitas model\")\n",
    "    inp = torch.rand((1, img_size * img_size)).to(device)\n",
    "    torch.onnx.export(model, inp, \"mnist.qat.onnx\", opset_version=14)\n",
    "    torch.save(model.state_dict(), \"state_dict.pt\")\n",
    "else:\n",
    "    print(\"\\n1. Loading pre-trained model\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3e909ba2",
   "metadata": {},
   "source": [
    "To avoid the training phase, you can directly load the pre-trained model by setting `do_training = False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "93eca8f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "checkpoint = torch.load(\"state_dict.pt\")\n",
    "model.load_state_dict(checkpoint)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce19d042",
   "metadata": {},
   "source": [
    "We prepare the ground truth, for final check of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d3736e4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 313/313 [00:00<00:00, 325.26it/s]\n"
     ]
    }
   ],
   "source": [
    "# Prepare tests\n",
    "test_data = np.zeros((len(test_loader.dataset), img_size * img_size))\n",
    "test_target = np.zeros((len(test_loader.dataset), 1))\n",
    "idx = 0\n",
    "\n",
    "for data, target in tqdm(test_loader):\n",
    "    target_np = target.cpu().numpy()\n",
    "    for idx_batch, im in enumerate(data.numpy()):\n",
    "        test_data[idx] = im\n",
    "        test_target[idx] = target_np[idx_batch]\n",
    "        idx += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14025865",
   "metadata": {},
   "source": [
    "### Measuring accuracy with FHE simulation and FHE execution\n",
    "\n",
    "Finally, we measure:\n",
    "- accuracy with FHE simulation for the full test set\n",
    "- accuracy with FHE simulation for the reduced test set\n",
    "- accuracy in FHE for the reduced test set   \n",
    "\n",
    "and we check that accuracy with FHE simulation and in FHE are equivalent on the reduced test set. \n",
    "\n",
    "Running FHE computations on a too large reduced test set may be prohibitive since we're 100% on CPU for the time being. Later, we'll have HW accelerators, to make these computations several order of magnitude faster. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "eb014141",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "3. Compiling with the FHE simulation\n",
      "\n",
      "4. Checking accuracy with the FHE simulation mode (length 10000)\n",
      "Accuracy in Simulation with length 10000: 9240/10000 = 0.9240, in 6-bits\n",
      "\n",
      "5. Compiling with the FHE simulation\n",
      "\n",
      "6. Checking accuracy with the FHE simulation mode (length 2)\n",
      "Accuracy in Simulation with length 2: 2/2 = 1.0000, in 6-bits\n",
      "\n",
      "7. Compiling in FHE\n",
      "\n",
      "8. Checking accuracy in FHE (length 2)\n",
      "Accuracy in FHE with length 2: 2/2 = 1.0000, in 6-bits\n"
     ]
    }
   ],
   "source": [
    "# Test in the FHE simulation and in real FHE computation\n",
    "accuracy = {}\n",
    "current_index = 3\n",
    "\n",
    "for use_simulation, use_full_dataset in [(True, True), (True, False), (False, False)]:\n",
    "    test_data_length = test_data_length_full if use_full_dataset else test_data_length_reduced\n",
    "\n",
    "    correct_fhe, test_data_shape_0, max_bit_width = compile_and_test(\n",
    "        model.cpu(),\n",
    "        use_simulation,\n",
    "        test_data,\n",
    "        test_data_length,\n",
    "        test_target,\n",
    "        show_mlir,\n",
    "        current_index,\n",
    "    )\n",
    "\n",
    "    current_index += 2\n",
    "    current_accuracy = correct_fhe / test_data_shape_0\n",
    "\n",
    "    print(\n",
    "        f\"Accuracy in {'Simulation' if use_simulation else 'FHE'} with length {test_data_length}: \"\n",
    "        f\"{correct_fhe}/{test_data_shape_0} = \"\n",
    "        f\"{current_accuracy:.4f}, in {max_bit_width}-bits\"\n",
    "    )\n",
    "\n",
    "    if (use_simulation, use_full_dataset) == (True, True):\n",
    "        accuracy[\"FHE Simulation full\"] = current_accuracy\n",
    "    elif (use_simulation, use_full_dataset) == (True, False):\n",
    "        accuracy[\"FHE simulation short\"] = current_accuracy\n",
    "    else:\n",
    "        assert (use_simulation, use_full_dataset) == (False, False)\n",
    "        accuracy[\"FHE short\"] = current_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bf39f067",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check that the accuracy is the same in FHE real-world compulations and simulated ones\n",
    "assert (\n",
    "    accuracy[\"FHE simulation short\"] == accuracy[\"FHE short\"]\n",
    "), \"Error, accuracy in FHE real-world compuations and simulated ones is not the same\"\n",
    "\n",
    "# Check that accuracy is random-looking\n",
    "assert accuracy[\"FHE Simulation full\"] > 0.8, \"Error, accuracy is too bad\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5060f56",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "We've shown how to train a model with Brevitas in quantization-aware training and how easy it is to obtain a satisfactory accuray of 92% even if it is lower than the state-of-the-art on cleartexts. \n",
    "\n",
    "Brevitas is not the only third-party package one can use for QAT. Other examples with other frameworks will certainly be added in our repository."
   ]
  }
 ],
 "metadata": {
  "execution": {
   "timeout": 10800
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}