From 0b043da6773b30021636f7d4f3581876236e6f6e Mon Sep 17 00:00:00 2001
From: yhteoh <yhteoh@uwaterloo.ca>
Date: Tue, 28 May 2024 14:35:35 -0400
Subject: [PATCH] Updated documentation

---
 .github/workflows/python-publish.yml |   2 +-
 docs/examples/1_overview.ipynb       | 263 -------------------
 docs/examples/2_Dataset.ipynb        | 289 ---------------------
 docs/examples/3_Observables.ipynb    | 360 ---------------------------
 docs/get_started.md                  |   3 +
 mkdocs.yaml                          |   8 -
 setup.cfg                            |   3 +-
 7 files changed, 5 insertions(+), 923 deletions(-)
 delete mode 100644 docs/examples/1_overview.ipynb
 delete mode 100644 docs/examples/2_Dataset.ipynb
 delete mode 100644 docs/examples/3_Observables.ipynb

diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
index 446219ee..01c04ba6 100644
--- a/.github/workflows/python-publish.yml
+++ b/.github/workflows/python-publish.yml
@@ -26,5 +26,5 @@ jobs:
           restore-keys: |
             mkdocs-material-
       - run: python -m pip install -e . --no-deps
-      - run: pip install mkdocstrings pymdown-extensions mkdocs-material mkdocstrings-python mknotebooks
+      - run: pip install mkdocstrings pymdown-extensions mkdocs-material mkdocstrings-python
       - run: mkdocs gh-deploy --force
diff --git a/docs/examples/1_overview.ipynb b/docs/examples/1_overview.ipynb
deleted file mode 100644
index 7805de3a..00000000
--- a/docs/examples/1_overview.ipynb
+++ /dev/null
@@ -1,263 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tutorial: Overview"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "\n",
-    "import itertools as it\n",
-    "import numpy as np\n",
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "from torch_geometric.utils import to_networkx\n",
-    "import numpy as np\n",
-    "import networkx as nx\n",
-    "import torch\n",
-    "from torch_geometric.data import Data"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Introduction \n",
-    "\n",
-    "Machine learning has recently emerged as a powerful tool for predicting properties of quantum many-body systems. Generative models can learn from measurements of a single quantum state to accurately reconstruct the state and predict local observables for many ground states of Hamiltonians. In this tutorial, we focus on Rydberg atom systems and propose the use of conditional generative models to simultaneously represent a family of states by learning shared structures of different quantum states from measurements.\n",
-    "\n",
-    "Refs: \n",
-    "\n",
-    "[Predicting Properties of Quantum Systems with Conditional Generative Models](https://arxiv.org/abs/2211.16943)\n",
-    "\n",
-    "[Transformer Quantum State: A Multi-Purpose Model for Quantum Many-Body Problems](http://arxiv.org/abs/2208.01758)\n",
-    "\n",
-    "[Bloqade](https://queracomputing.github.io/Bloqade.jl/dev/)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Rydberg Hamiltonian \n",
-    "\n",
-    "\n",
-    "We consider a system of $N=L \\times L$ atoms arranged on a square lattice.\n",
-    "The governing Hamiltonian defining the Rydberg atom array interactions has the following form:\n",
-    "\n",
-    "$$\n",
-    "\\hat{H} = \\sum_{i<j} \\frac{C_6}{\\lVert \\mathbf{r}_i - \\mathbf{r}_j \\rVert^6} \\hat{n}_i \\hat{n}_j -\\delta \\sum_{i=1}^N \\hat{n}_i - \\frac{\\Omega}{2} \\sum_{i=1}^N \\hat{\\sigma}^x_i. \\quad (1)\n",
-    "$$\n",
-    "\n",
-    "$$\n",
-    "    C_6 = \\Omega \\left( \\frac{R_b}{a} \\right)^6, \\quad\n",
-    "    V_{ij} =  \\frac{a^6}{\\lVert \\mathbf{r}_i - \\mathbf{r}_j \\rVert^6}, \\quad (2)\n",
-    "$$\n",
-    "\n",
-    "where $\\hat{\\sigma}^{x}_{i} = \\vert g \\rangle_i \\langle r\\vert_i + \\vert r \\rangle_i \\langle g\\vert_i$, the occupation number operator $\\hat{n}_i = \\frac{1}{2} \\left( \\hat{\\sigma}_{i} + \\mathbb{1} \\right) =  \\vert r\\rangle_i \\langle r \\vert_i$ and $\\hat{\\sigma}_{i} = \\vert r \\rangle_i \\langle r \\vert_i - \\vert g \\rangle_i \\langle g \\vert_i$. The experimental settings of a Rydberg atom array are controlled by the detuning from resonance $\\delta$, [Rabi frequency](https://en.wikipedia.org/wiki/Rabi_frequency#:~:text=The\\%20Rabi\\%20frequency\\%20is\\%20the,intensity) $\\Omega$, lattice length scale $a$ and the positions of the atoms $\\{\\mathbf{r}_i\\}_i^N$. From equation (2) above, we obtain a symmetric matrix $\\mathbf{V}$, that encapsulates the relevant information about the lattice geometry, and derive the Rydberg blockade radius $R_b$, within which simultaneous excitations are penalized. Finally, for the purposes of our study, the atom array is considered to be affected by thermal noise, in equilibrium at a temperature $T$. The experimental settings are thus captured by the set of parameters $\\mathbf{x} = (\\Omega, \\delta/\\Omega, R_b/a, \\mathbf{V}, \\beta / \\Omega)$, where $\\beta$ is the inverse temperature."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Representation of the quantum state\n",
-    "Decomposing the joint distribution into a product of conditional distributions in an autoregressive manner,\n",
-    "\n",
-    "$$\n",
-    " p_{\\theta}(\\boldsymbol{\\sigma}) = \\prod_{i=1}^n p_{\\theta}\\left(\\sigma_i \\mid \\sigma_{i-1}, \\ldots, \\sigma_1\\right).\n",
-    "$$\n",
-    "\n",
-    "where $\\theta$ denotes the set of parameters of the generative model."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# The Graph Encoder Decoder Transformer architecture\n",
-    "\n",
-    "In this tutorial, we will explain the network architecture used in the `get_rydberg_graph_encoder_decoder` function, which creates a RydbergEncoderDecoder model. This model is designed to process graph-structured data using a combination of Graph Convolutional Networks (GCNs) and the classic Encoder-Decoder architecture as introduced in [Vaswani et al.](https://papers.nips.cc/paper_files/paper/2017/hash/3f5ee243547dee91fbd053c1c4a845aa-Abstract.html)."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import copy\n",
-    "from typing import Tuple\n",
-    "\n",
-    "import torch\n",
-    "from pytorch_lightning import LightningModule\n",
-    "from torch import Tensor, nn\n",
-    "from torch_geometric.nn import GATConv, GCNConv\n",
-    "\n",
-    "from rydberggpt.models.graph_embedding.models import GraphEmbedding\n",
-    "from rydberggpt.models.rydberg_encoder_decoder import RydbergEncoderDecoder\n",
-    "\n",
-    "from rydberggpt.models.transformer.layers import DecoderLayer, EncoderLayer\n",
-    "from rydberggpt.models.transformer.models import (\n",
-    "    Decoder,\n",
-    "    Encoder,\n",
-    "    EncoderDecoder,\n",
-    "    Generator,\n",
-    ")\n",
-    "from rydberggpt.models.transformer.modules import (\n",
-    "    PositionalEncoding,\n",
-    "    PositionwiseFeedForward,\n",
-    ")\n",
-    "from rydberggpt.utils import to_one_hot"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Main components \n",
-    "\n",
-    "The `RydbergEncoderDecoder` model consists of the following main components:\n",
-    "\n",
-    "**Encoder:** The encoder processes the input graph data and generates a continuous representation. It consists of multiple `EncoderLayer` blocks, each containing a multi-head self-attention mechanism and a position-wise feed-forward network, followed by layer normalization and dropout.\n",
-    "\n",
-    "**Decoder:** The decoder takes the continuous representation generated by the encoder and produces the output predictions. It is composed of multiple `DecoderLayer` blocks, each containing two multi-head attention mechanisms (self-attention and encoder-decoder attention) and a position-wise feed-forward network, followed by layer normalization and dropout.\n",
-    "\n",
-    "**src_embed:** This component is responsible for transforming the input graph data into a continuous representation. It uses the `GraphEmbedding` class, which employs `GCNConv` layers (or other graph convolution layers, such as `GATConv`) to process the graph structure. The number of graph layers can be controlled with the `num_layers` parameter.\n",
-    "\n",
-    "**tgt_embed:** This is a sequential model that first applies a linear transformation to the target input states and then adds positional encoding to provide information about the sequence order. The positional encoding is applied using the `PositionalEncoding` class.\n",
-    "\n",
-    "**Generator:** The generator is a simple linear layer that maps the output of the decoder to the desired output dimension (in this case, 2). It is used for producing the final output predictions.\n",
-    "\n",
-    "In the `get_rydberg_graph_encoder_decoder` function, the model is created using the provided configuration (config). This configuration contains information about the model's dimensions, number of layers, and other hyperparameters. After initializing the model, the weights of the parameters with more than one dimension are initialized using [Xavier uniform initialization](https://paperswithcode.com/method/xavier-initialization).\n",
-    "\n",
-    "Overall, this network architecture combines the power of graph convolutional networks for processing graph-structured data with the sequence-to-sequence learning capabilities of the Encoder-Decoder architecture. This allows the model to effectively learn complex patterns in both the graph structure and the sequence data."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def get_rydberg_graph_encoder_decoder(config):\n",
-    "    c = copy.deepcopy\n",
-    "    attn = nn.MultiheadAttention(config.d_model, config.num_heads, batch_first=True)\n",
-    "    position = PositionalEncoding(config.d_model, config.dropout)\n",
-    "    ff = PositionwiseFeedForward(config.d_model, config.d_ff, config.dropout)\n",
-    "\n",
-    "    model = RydbergEncoderDecoder(\n",
-    "        encoder=Encoder(\n",
-    "            EncoderLayer(config.d_model, c(attn), c(ff), config.dropout),\n",
-    "            config.num_blocks_encoder,\n",
-    "        ),\n",
-    "        decoder=Decoder(\n",
-    "            DecoderLayer(config.d_model, c(attn), c(attn), c(ff), config.dropout),\n",
-    "            config.num_blocks_decoder,\n",
-    "        ),\n",
-    "        src_embed=GraphEmbedding(\n",
-    "            graph_layer=GCNConv,  # GATConv\n",
-    "            in_node_dim=config.in_node_dim,\n",
-    "            d_hidden=config.graph_hidden_dim,\n",
-    "            d_model=config.d_model,\n",
-    "            num_layers=config.graph_num_layers,\n",
-    "            dropout=config.dropout,\n",
-    "        ),\n",
-    "        tgt_embed=nn.Sequential(\n",
-    "            nn.Linear(config.num_states, config.d_model), c(position)\n",
-    "        ),\n",
-    "        generator=Generator(config.d_model, 2),\n",
-    "        config=config,\n",
-    "    )\n",
-    "\n",
-    "    for p in model.parameters():\n",
-    "        if p.dim() > 1:\n",
-    "            nn.init.xavier_uniform_(p)\n",
-    "\n",
-    "    return model"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Loss function\n",
-    "\n",
-    "The dataset is composed of $N_H$ Hamiltonians and obtain $N_s$ measurement outcomes for each ground state leading to a training set $\\mathcal{D}$  of size $N_HN_s$. The training objective is the average negative log-likelihood loss, \n",
-    "\n",
-    "$$\n",
-    "\\mathcal{L}(\\theta) \\approx -\\frac{1}{|\\mathcal{D}|} \\sum_{\\boldsymbol{\\sigma} \\in \\mathcal{D}} \\ln p_{\\theta}(\\boldsymbol{\\sigma}).\n",
-    "$$\n",
-    "\n",
-    "corresponding to maximizing the conditional likelihoods over the observed measurment outcomes. "
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Graph Embedding in Rydberg Atom Systems"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "\n",
-    "\n",
-    "In our approach, we leverage graph neural networks (GNNs) to process the underlying graph structure of Rydberg atom systems. In these systems, the graph nodes represent the Rydberg atoms, and each node is assigned a node_feature vector containing information about the Rabi frequency (Ω), detuning (Δ), and temperature (β). The Rydberg blockade radius, which determines the interaction strength between atoms, is encoded as edge attributes in the graph.\n",
-    "\n",
-    "GNNs are powerful tools for learning representations of graph-structured data, capturing both local and global information within the graph. In our model, we employ graph convolutional layers, such as GCNConv, to learn meaningful embeddings of the input graph. These embeddings take into account both node features and edge attributes, enabling the model to learn complex relationships between atoms in the Rydberg system.\n",
-    "\n",
-    "To understand the basics of graph neural networks and their applications, we recommend the following resources:\n",
-    "\n",
-    "1. [A Gentle Introduction to Graph Neural Networks](https://distill.pub/2021/gnn-intro/): This article provides an accessible and visually appealing introduction to GNNs, covering their motivation, core concepts, and various architectures.\n",
-    "\n",
-    "2. [Understanding Convolutions on Graphs](https://distill.pub/2021/understanding-gnns/): This article dives deeper into the inner workings of GNNs, specifically focusing on convolution operations on graphs. It provides insights into how graph convolutions can be understood as message-passing mechanisms and how they can be generalized.\n",
-    "\n",
-    "3. [Pytorch_geometric](https://pytorch-geometric.readthedocs.io/en/latest/get_started/introduction.html): PyTorch Geometric is a library for deep learning on irregular input data such as graphs, point clouds, and manifolds. It provides efficient implementations of various GNN layers and models, making it easier to implement and experiment with graph-based neural networks. This resource serves as a guide to getting started with the library and provides documentation for its various features.\n",
-    "\n",
-    "In our Rydberg atom system model, the graph embedding component serves as a crucial bridge between the graph-structured input data and the encoder-decoder architecture. By leveraging the capabilities of GNNs, we can effectively learn complex patterns in the graph structure and enhance the performance of our model for predicting properties of quantum many-body systems."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "qgpt",
-   "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.10.13"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/examples/2_Dataset.ipynb b/docs/examples/2_Dataset.ipynb
deleted file mode 100644
index 65e35804..00000000
--- a/docs/examples/2_Dataset.ipynb
+++ /dev/null
@@ -1,289 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tutorial: Dataset\n",
-    "\n",
-    "In this tutorial we discuss how the dataset is structured, and how to load it to train a model. The dataset is hosted through xanadu.ai and can be accessed via ADD LINK. \n",
-    "\n",
-    "## Structure\n",
-    "\n",
-    "The dataset is build up of smaller subdatasets, each for a specific Hamiltonian parameter regime. Each sub folder contains four files, namely:\n",
-    "- config.json: contains the configuration of the dataset\n",
-    "- dataset.h5: contains the measurements of shape [num_samples, num_atoms]\n",
-    "- graph.json: contains the graph of the dataset\n",
-    "- properties.json: contains the observables of the dataset such as energy, magnetization, etc."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%load_ext autoreload\n",
-    "%autoreload 2\n",
-    "\n",
-    "import os\n",
-    "\n",
-    "import matplotlib.colors as mcolors\n",
-    "import matplotlib.pyplot as plt\n",
-    "import networkx as nx\n",
-    "from tqdm import tqdm\n",
-    "\n",
-    "from rydberggpt.data.dataclasses import GridGraph\n",
-    "from rydberggpt.data.graph_structures import get_graph\n",
-    "from rydberggpt.data.rydberg_dataset import get_rydberg_dataloader\n",
-    "from rydberggpt.data.utils_graph import graph_to_dict\n",
-    "from rydberggpt.utils import shift_inputs\n",
-    "\n",
-    "\n",
-    "base_path = os.path.abspath(\"../\")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# The system prompt\n",
-    "\n",
-    "The transformer encoder takes as input a graph structure. Each graph has num_atoms nodes and each nodes has a node feature vector containing delta, omega and beta.\n",
-    "\n",
-    "Lets generate an example graph and visualize it."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n_rows = 4\n",
-    "n_cols = 4\n",
-    "num_atoms = n_rows * n_cols\n",
-    "\n",
-    "graph_config = GridGraph(\n",
-    "    num_atoms=num_atoms,\n",
-    "    graph_name=\"grid_graph\",\n",
-    "    Rb=1.0,\n",
-    "    delta=1.0,\n",
-    "    omega=1.0,\n",
-    "    beta=1.0,\n",
-    "    n_rows=n_rows,\n",
-    "    n_cols=n_cols,\n",
-    ")\n",
-    "\n",
-    "graph = get_graph(graph_config)\n",
-    "graph_dict = graph_to_dict(graph)\n",
-    "graph_nx = nx.node_link_graph(graph_dict)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "adj_matrix = nx.to_numpy_array(graph_nx)\n",
-    "plt.imshow(adj_matrix, cmap=\"Blues\")\n",
-    "plt.title(\"Adjacency Matrix\")\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "or plot the graph."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def plot_graph(graph):\n",
-    "    # Get node positions from the graph\n",
-    "    pos = nx.get_node_attributes(graph, \"pos\")\n",
-    "\n",
-    "    # Extract edge weights for edge coloring\n",
-    "    edges, weights = zip(*nx.get_edge_attributes(graph, \"weight\").items())\n",
-    "\n",
-    "    # Normalize edge weights for better visualization\n",
-    "    normalized_weights = [w / max(weights) for w in weights]\n",
-    "\n",
-    "    # Calculate edge widths proportional to normalized weights\n",
-    "    edge_widths = [w * 2 for w in normalized_weights]\n",
-    "\n",
-    "    # Create a color map for the edges\n",
-    "    cmap = plt.cm.Blues\n",
-    "    norm = mcolors.Normalize(vmin=min(normalized_weights), vmax=max(normalized_weights))\n",
-    "\n",
-    "    # Plot the graph\n",
-    "    fig, ax = plt.subplots(figsize=(8, 8))\n",
-    "    nx.draw(\n",
-    "        graph,\n",
-    "        pos,\n",
-    "        node_color=\"white\",\n",
-    "        with_labels=True,\n",
-    "        font_color=\"black\",\n",
-    "        edge_cmap=cmap,\n",
-    "        node_size=400,\n",
-    "        width=edge_widths,\n",
-    "        alpha=0.5,\n",
-    "        edgecolors=\"black\",\n",
-    "        edgelist=edges,\n",
-    "        edge_color=normalized_weights,\n",
-    "        verticalalignment=\"center_baseline\",\n",
-    "        font_size=12,\n",
-    "    )\n",
-    "    plt.title(\"Grid Graph\", fontsize=18)\n",
-    "\n",
-    "    # Add a color bar\n",
-    "    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)\n",
-    "    sm.set_array([])\n",
-    "    cbar = plt.colorbar(sm, ax=ax)\n",
-    "    cbar.set_label(\"1/Distance\")\n",
-    "\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 800x800 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plot_graph(graph_nx)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Each node contains a node_feature vector encoding omega, delta and beta. "
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Loading the test dataset\n",
-    "\n",
-    "We use the datapipes provided via [torchdata](https://pytorch.org/data/main/index.html) to load the dataset. During training we sample from the dataset a list of `buffer_size` subset datasets, and then sample from this new smaller dataset the training batch.\n",
-    "\n",
-    "Each batch contains a datastructure with 2 elements (see rydberggpt.data.dataclasses). \n",
-    "The first element is a pytorch_geometrich graph object ( `batch.graph`, based on the [batch](https://pytorch-geometric.readthedocs.io/en/latest/generated/torch_geometric.data.Batch.html)). Each graph has num_atoms nodes and each nodes has a node feature vector containing delta, omega and beta. Finally we need the measurement data. These are one-hot encoded and stored in a tensor of shape [num_samples, num_atoms, 2]. \n",
-    "\n",
-    "```python\n",
-    "@dataclass\n",
-    "class Batch:\n",
-    "    graph: Data\n",
-    "    m_onehot: torch.Tensor\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "torch.Size([128, 36, 2])\n",
-      "torch.Size([128, 36, 2])\n",
-      "torch.Size([128, 36, 2])\n",
-      "torch.Size([128, 36, 2])\n"
-     ]
-    }
-   ],
-   "source": [
-    "import warnings\n",
-    "\n",
-    "with warnings.catch_warnings():\n",
-    "    warnings.simplefilter(\"ignore\")\n",
-    "\n",
-    "    batch_size = 128\n",
-    "    buffer_size = 2\n",
-    "    num_workers = 0\n",
-    "\n",
-    "    data_path = os.path.join(base_path, \"src/rydberggpt/tests/dataset_test/\")\n",
-    "\n",
-    "\n",
-    "    dataloader = get_rydberg_dataloader(\n",
-    "        batch_size=batch_size,\n",
-    "        data_path=data_path,\n",
-    "        buffer_size=buffer_size,\n",
-    "        num_workers=num_workers,\n",
-    "    )\n",
-    "\n",
-    "\n",
-    "    counter = 0\n",
-    "    for batch in dataloader:\n",
-    "        print(batch.m_onehot.shape)\n",
-    "        m_shifted_onehot = shift_inputs(batch.m_onehot)\n",
-    "        print(m_shifted_onehot.shape)\n",
-    "\n",
-    "\n",
-    "        counter += 1\n",
-    "\n",
-    "        if counter > 1:\n",
-    "            break"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "qgpt",
-   "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.10.13"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/examples/3_Observables.ipynb b/docs/examples/3_Observables.ipynb
deleted file mode 100644
index 6ef3fcf3..00000000
--- a/docs/examples/3_Observables.ipynb
+++ /dev/null
@@ -1,360 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Tutorial: Observables \n",
-    "\n",
-    "## Background\n",
-    "\n",
-    "In this tutorial, we are going to load a pretrained model, use it to generate new samples, and calculate relevant observables based on these samples.\n",
-    "\n",
-    "We consider a system of $N=L \\times L$ atoms arranged on a square lattice.\n",
-    "The governing Hamiltonian defining the Rydberg atom array interactions has the following form:\n",
-    "\n",
-    "$$\n",
-    "\\hat{H} = \\sum_{i<j} \\frac{C_6}{\\lVert \\mathbf{r}_i - \\mathbf{r}_j \\rVert^6} \\hat{n}_i \\hat{n}_j -\\delta \\sum_{i=1}^N \\hat{n}_i - \\frac{\\Omega}{2} \\sum_{i=1}^N \\hat{\\sigma}^x_i. \\quad (1)\n",
-    "$$\n",
-    "\n",
-    "$$\n",
-    "    C_6 = \\Omega \\left( \\frac{R_b}{a} \\right)^6, \\quad\n",
-    "    V_{ij} =  \\frac{a^6}{\\lVert \\mathbf{r}_i - \\mathbf{r}_j \\rVert^6}, \\quad (2)\n",
-    "$$\n",
-    "\n",
-    "where $\\hat{\\sigma}^{x}_{i} = \\vert g \\rangle_i \\langle r\\vert_i + \\vert r \\rangle_i \\langle g\\vert_i$, the occupation number operator $\\hat{n}_i = \\frac{1}{2} \\left( \\hat{\\sigma}_{i} + \\mathbb{1} \\right) =  \\vert r\\rangle_i \\langle r \\vert_i$ and $\\hat{\\sigma}_{i} = \\vert r \\rangle_i \\langle r \\vert_i - \\vert g \\rangle_i \\langle g \\vert_i$. The experimental settings of a Rydberg atom array are controlled by the detuning from resonance $\\delta$, Rabi frequency $\\Omega$, lattice length scale $a$ and the positions of the atoms $\\{\\mathbf{r}_i\\}_i^N$. From equation (2) above, we obtain a symmetric matrix $\\mathbf{V}$, that encapsulates the relevant information about the lattice geometry, and derive the Rydberg blockade radius $R_b$, within which simultaneous excitations are penalized. Finally, for the purposes of our study, the atom array is considered to be affected by thermal noise, in equilibrium at a temperature $T$. The experimental settings are thus captured by the set of parameters $\\mathbf{x} = (\\Omega, \\delta/\\Omega, R_b/a, \\mathbf{V}, \\beta / \\Omega)$, where $\\beta$ is the inverse temperature. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "import torch\n",
-    "from rydberggpt.models.rydberg_encoder_decoder import get_rydberg_graph_encoder_decoder\n",
-    "from rydberggpt.models.utils import generate_prompt\n",
-    "from rydberggpt.observables.rydberg_energy import (\n",
-    "    get_rydberg_energy,\n",
-    "    get_staggered_magnetization,\n",
-    "    get_x_magnetization,\n",
-    ")\n",
-    "from rydberggpt.utils import create_config_from_yaml, load_yaml_file\n",
-    "from rydberggpt.utils_ckpt import get_model_from_ckpt\n",
-    "from torch_geometric.data import Batch"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Loading the model\n",
-    "\n",
-    "We have three pretrained models trained on three different datasets. Model $M_1$ is trained with data for systems of size $L=5,6$ (`models/ds_1`); Model $M_2$ utilizes datasets for systems with $L=5,6,11,12$ (`models/ds_2`); and Model $M_3$ is trained on data covering  $L=5,6,11,12,15,16$ (`models/ds_3`).\n",
-    "\n",
-    "Let's start by loading the pretrained model and setting it into eval mode to ensure that the dropout layers are disabled."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "RydbergEncoderDecoder(\n",
-       "  (encoder): Encoder(\n",
-       "    (layers): ModuleList(\n",
-       "      (0): EncoderLayer(\n",
-       "        (self_attn): MultiheadAttention(\n",
-       "          (out_proj): NonDynamicallyQuantizableLinear(in_features=32, out_features=32, bias=True)\n",
-       "        )\n",
-       "        (feed_forward): PositionwiseFeedForward(\n",
-       "          (w_1): Linear(in_features=32, out_features=128, bias=True)\n",
-       "          (w_2): Linear(in_features=128, out_features=32, bias=True)\n",
-       "          (dropout): Dropout(p=0.1, inplace=False)\n",
-       "        )\n",
-       "        (sublayer): ModuleList(\n",
-       "          (0-1): 2 x SublayerConnection(\n",
-       "            (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
-       "            (dropout): Dropout(p=0.1, inplace=False)\n",
-       "          )\n",
-       "        )\n",
-       "      )\n",
-       "    )\n",
-       "    (norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
-       "  )\n",
-       "  (decoder): Decoder(\n",
-       "    (layers): ModuleList(\n",
-       "      (0-2): 3 x DecoderLayer(\n",
-       "        (self_attn): MultiheadAttention(\n",
-       "          (out_proj): NonDynamicallyQuantizableLinear(in_features=32, out_features=32, bias=True)\n",
-       "        )\n",
-       "        (src_attn): MultiheadAttention(\n",
-       "          (out_proj): NonDynamicallyQuantizableLinear(in_features=32, out_features=32, bias=True)\n",
-       "        )\n",
-       "        (feed_forward): PositionwiseFeedForward(\n",
-       "          (w_1): Linear(in_features=32, out_features=128, bias=True)\n",
-       "          (w_2): Linear(in_features=128, out_features=32, bias=True)\n",
-       "          (dropout): Dropout(p=0.1, inplace=False)\n",
-       "        )\n",
-       "        (sublayer): ModuleList(\n",
-       "          (0-2): 3 x SublayerConnection(\n",
-       "            (layer_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
-       "            (dropout): Dropout(p=0.1, inplace=False)\n",
-       "          )\n",
-       "        )\n",
-       "      )\n",
-       "    )\n",
-       "    (norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
-       "  )\n",
-       "  (src_embed): GraphEmbedding(\n",
-       "    (layers): ModuleList(\n",
-       "      (0): GraphLayer(\n",
-       "        (graph_layer): GCNConv(4, 64)\n",
-       "        (norm): LayerNorm((64,), eps=1e-05, elementwise_affine=True)\n",
-       "        (dropout): Dropout(p=0.1, inplace=False)\n",
-       "      )\n",
-       "      (1): GCNConv(64, 32)\n",
-       "    )\n",
-       "    (final_norm): LayerNorm((32,), eps=1e-05, elementwise_affine=True)\n",
-       "  )\n",
-       "  (tgt_embed): Sequential(\n",
-       "    (0): Linear(in_features=2, out_features=32, bias=True)\n",
-       "    (1): PositionalEncoding(\n",
-       "      (dropout): Dropout(p=0.1, inplace=False)\n",
-       "    )\n",
-       "  )\n",
-       "  (generator): Generator(\n",
-       "    (proj): Linear(in_features=32, out_features=2, bias=True)\n",
-       "  )\n",
-       ")"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "device = \"cpu\"\n",
-    "\n",
-    "base_path = os.path.abspath(\"../\")\n",
-    "log_path = os.path.join(base_path, \"models/M_1/\")\n",
-    "\n",
-    "yaml_dict = load_yaml_file(log_path, \"hparams.yaml\")\n",
-    "config = create_config_from_yaml(yaml_dict)\n",
-    "\n",
-    "model = get_model_from_ckpt(\n",
-    "    log_path, model=get_rydberg_graph_encoder_decoder(config), ckpt=\"best\"\n",
-    ")\n",
-    "model.to(device=device)\n",
-    "model.eval()  # don't forget to set to eval mode"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Generating system prompt and samples\n",
-    "\n",
-    "Next, let us define our system prompt $\\mathbf{x} = (\\Omega, \\delta/\\Omega, R_b/a, \\mathbf{V}, \\beta / \\Omega)$. Below is a function `generate_prompt` that generates the required prompt structure to query the trained model. The prompt is a graph structure capturing the relevant information about the system, such as the lattice geometry, the Rydberg blockade radius, the temperature, and the Rabi frequency. The function `generate_samples` generates samples from the model given the prompt.\n",
-    "\n",
-    "### System prompt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "L = 5\n",
-    "delta = 1.0\n",
-    "omega = 1.0\n",
-    "beta = 64.0\n",
-    "Rb = 1.15\n",
-    "num_samples = 5\n",
-    "\n",
-    "pyg_graph = generate_prompt(\n",
-    "    model_config=config,\n",
-    "    n_rows=L,\n",
-    "    n_cols=L,\n",
-    "    delta=delta,\n",
-    "    omega=omega,\n",
-    "    beta=beta,\n",
-    "    Rb=Rb,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Generating samples\n",
-    "\n",
-    "The sampling function requires a batch of prompts; therefore, we duplicate our `pyg_graph` prompts as many times as we want to generate samples. The reasoning behind this is to allow the model to generate samples in parallel for different Hamiltonian parameters. This is especially helpful when training variationally."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Generating atom 25/25                                                          \n"
-     ]
-    }
-   ],
-   "source": [
-    "# duplicate the prompt for num_samples\n",
-    "cond = [pyg_graph for _ in range(num_samples)]\n",
-    "cond = Batch.from_data_list(cond)\n",
-    "\n",
-    "samples = model.get_samples(\n",
-    "    batch_size=len(cond), cond=cond, num_atoms=L**2, fmt_onehot=False\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Observables \n",
-    "\n",
-    "Now we are ready to calculate observables based on the samples generated. We consider three observables: the stagger-magnetization, x-magnetization and the Rydberg energy.\n",
-    "### Rydberg energy \n",
-    "\n",
-    "We consider an estimate of the ground state energy $\\langle E \\rangle$, which is defined as\n",
-    "\n",
-    "$$\n",
-    "\\langle E \\rangle  \n",
-    "\\approx \\frac{1}{N_s} \\sum_{\\boldsymbol{\\sigma} \\sim p_{\\theta}(\\boldsymbol{\\sigma};\\mathbf{x})} \\frac{\\langle \\boldsymbol{\\sigma}|\\widehat{H}|\\Psi_{\\theta}\\rangle}{\\langle \\boldsymbol{\\sigma}|\\Psi_{\\theta}\\rangle}.\n",
-    "$$\n",
-    "\n",
-    "We provide a function `get_rydberg_energy` that calculates the Rydberg energy of the samples generated. Note that this fn requires a single prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(0.0248)\n"
-     ]
-    }
-   ],
-   "source": [
-    "energy = get_rydberg_energy(model, samples, cond=pyg_graph, device=device)\n",
-    "print(energy.mean() / L**2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Stagger magnetization\n",
-    "\n",
-    "The staggered magnetization for the square-lattice Rydberg array defined in its occupation basis.  This quantity is the order parameter for the disorder-to-checkerboard quantum phase transition, and can be calculated simply with \n",
-    "\n",
-    "$$\n",
-    "    \\langle\\hat{\\sigma}^{\\text{stag}}\\rangle  \\approx \\frac{1}{N_s} \\sum_{\\boldsymbol{\\sigma} \\sim p_\\theta(\\boldsymbol{\\sigma};\\mathbf{x})}\n",
-    "    \\left|   \\sum_{i=1}^{N} (-1)^i  \\frac{n_i(\\boldsymbol{\\sigma}) - 1/2}{N} \\right| ,\n",
-    "$$\n",
-    "\n",
-    "where $i$ runs over all $N = L \\times L$ atoms and $n_i(\\boldsymbol{\\sigma}) = \\langle \\boldsymbol{\\sigma}| r_i \\rangle\\langle r_i|\\boldsymbol{\\sigma} \\rangle$ is the occupation number operator acting on atom $i$ in a given configuration $\\boldsymbol{\\sigma}$. \n",
-    "Because this observable is diagonal, it can be computed directly from samples inferred from the decoder. The outer sum shows how importance sampling is used to estimate the expectation value over this operator, approximating the probability of a given configuration with the frequency with which it is sampled. \n",
-    "\n",
-    "\n",
-    "We provide a function `get_staggered_magnetization` that calculates the stagger magnetization of the samples generated."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(0.0208)\n"
-     ]
-    }
-   ],
-   "source": [
-    "staggered_magnetization = get_staggered_magnetization(samples, L, L, device=device)\n",
-    "print(staggered_magnetization.mean() / L**2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### X-magnetization\n",
-    "\n",
-    "We consider an off-diagonal observable, where we must make use of the ground state wave function amplitudes of the inferred samples $\\Psi(\\boldsymbol{\\sigma}) = \\sqrt{p_{\\theta}(\\boldsymbol{\\sigma})}$. \n",
-    "As an example, we examine the spatially averaged expectation value of $\\hat{\\sigma}_x$, which is defined as\n",
-    "\n",
-    "$$\n",
-    "    \\langle \\hat{\\sigma}^x \\rangle  \\approx \\frac{1}{N_s} \\sum_{\\boldsymbol{\\sigma} \\sim p_\\theta(\\boldsymbol{\\sigma};\\mathbf{x})} \\frac{1}{N}\n",
-    "    \\sum_{\\boldsymbol{\\sigma}' \\in \\mathrm{SSF}(\\boldsymbol{\\sigma})} \\frac{\\Psi_\\theta(\\boldsymbol{\\sigma}')}{\\Psi_\\theta(\\boldsymbol{\\sigma})},\n",
-    "$$\n",
-    "\n",
-    "where the variable $\\left\\{\\boldsymbol{\\sigma'}\\right\\}$ is the set of configurations that are connected to $\\boldsymbol{\\sigma}$ by a single spin flip (SSF).\n",
-    "\n",
-    "We provide a function `get_x_magnetization` that calculates the stagger magnetization of the samples generated.\n",
-    "Note that we do not have to batch our prompt. The energy is calculated for a single system prompt."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "tensor(0.7317)\n"
-     ]
-    }
-   ],
-   "source": [
-    "x_magnetization = get_x_magnetization(model, samples, cond=pyg_graph, device=device)\n",
-    "print(x_magnetization.mean() / L**2)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "rydberggpt",
-   "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.10.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/docs/get_started.md b/docs/get_started.md
index 493b43da..417aad5c 100644
--- a/docs/get_started.md
+++ b/docs/get_started.md
@@ -13,6 +13,9 @@ pip install .
 ```
 
 ## Usage
+### Tutorials
+You find tutorials for using RydbergGPT in the [`examples/`](https://github.com/PIQuIL/RydbergGPT/tree/main/examples) folder.
+
 ### Configuration
 The`config.yaml` is used to define the hyperparameters for:
 - Model architecture
diff --git a/mkdocs.yaml b/mkdocs.yaml
index 7cff837b..0951caa2 100644
--- a/mkdocs.yaml
+++ b/mkdocs.yaml
@@ -20,10 +20,6 @@ nav:
     - Welcome to RydbergGPT: index.md
     - Get Started: get_started.md
     - Data: data.md
-  - Tutorials:
-    - Overview: examples/1_Overview.ipynb
-    - Dataset: examples/2_Dataset.ipynb
-    - Observables: examples/3_Observables.ipynb
   - API Reference:
     - Data: reference/data.md
     - Models:
@@ -69,10 +65,6 @@ theme:
   - toc.follow
 
 plugins:
-  - mknotebooks:
-      execute: false
-      timeout: 100
-      allow_errors: True
   - search:
   - mkdocstrings:
       handlers:
diff --git a/setup.cfg b/setup.cfg
index 8274a06a..e7072b2c 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -42,5 +42,4 @@ docs =
     pymdown-extensions
     mkdocstrings
     mkdocs-material
-    mkdocstrings-python
-    mknotebooks
\ No newline at end of file
+    mkdocstrings-python
\ No newline at end of file