{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Introduction to Geometric Quantum Machine Learning\n", "\n", "\n", "Symmetries are at the heart of physics. Indeed in condensed matter and particle physics we often define a thing simply by the symmetries it adheres to. What does symmetry mean for those in machine learning? In this context the ambition is straightforward --- it is a means to reduce the parameter space and improve the trained model\\'s ability to sucessfully label unseen data, i.e., its ability to generalise.\n", "\n", "Suppose we have a learning task and the data we are learning from has an underlying symmetry. For example, consider a game of Noughts and Crosses (aka Tic-tac-toe): if we win a game, we would have won it if the board was rotated or flipped along any of the lines of symmetry. Now if we want to train an algorithm to spot the outcome of these games, we can either ignore the existence of this symmetry or we can somehow include\n", "it. The advantage of paying attention to the symmetry is it identifies multiple configurations of the board as \\'the same thing\\' as far as the symmetry is concerned. This means we can reduce our parameter space, and\n", "so the amount of data our algorithm must sift through is immediately reduced. Along the way, the fact that our learning model must encode a symmetry that actually exists in the system we are trying to represent\n", "naturally encourages our results to be more generalisable. The encoding of symmetries into our learning models is where the term *equivariance* will appear. We will see that demanding that certain symmetries are\n", "included in our models means that the mappings that make up our algorithms must be such that we could transform our input data with respect to a certain symmetry, then apply our mappings, and this would\n", "be the same as applying the mappings and then transforming the output data with the same symmetry. This is the technical property that gives us the name \\\"equavariant learning\\\".\n", "\n", "In classical machine learning, this area is often referred to as geometric deep learning (GDL) due to the traditional association of symmetry to the world of geometry, and the fact that these considerations usually focus on deep neural networks (see Michael M. Bronstein, Joan Bruna, Taco Cohen, Petar Veličković (2021). Geometric Deep Learning: Grids, Groups, Graphs, Geodesics, and Gauges. arXiv:2104.13478\n", " or Quynh T. Nguyen, Louis Schatzki, Paolo Braccia, Michael Ragone, Patrick J. Coles, Frédéric Sauvage, Martín Larocca, and M. Cerezo (2022). Theory for Equivariant Quantum Neural Networks. arXiv:2210.08566\n", " for a broad introduction). We will refer to the quantum computing version of this as *quantum geometric machine learning* (QGML).\n", "\n", "## Representation theory in circuits\n", "\n", "\n", "The first thing to discuss is how do we work with symmetries in the first place? The answer lies in the world of group representation theory.\n", "\n", "First, let\\'s define what we mean by a group:\n", "\n", "**Definition**: A group is a set $G$ together with a binary operation on\n", "$G$, here denoted $\\circ$, that combines any two elements $a$ and $b$ to\n", "form an element of $G$, denoted $a \\circ b$, such that the following\n", "three requirements, known as group axioms, are satisfied as follows:\n", "\n", "1. **Associativity**: For all $a, b, c$ in $G$, one has\n", "\n", " $(a \\circ b) \\circ c=a \\circ (b \\circ c)$.\n", "\n", "2. **Identity element**: There exists an element $e$ in $G$ such that, for every $a$ in $G$, one\n", " : has $e \\circ a=a$ and $a \\circ e=a$. Such an element is unique.\n", " It is called the identity element of the group.\n", "\n", "3. **Inverse element**: For each $a$ in $G$, there exists an element $b$ in $G$\n", " : such that $a \\circ b=e$ and $b \\circ a=e$, where $e$ is the\n", " identity element. For each $a$, the element $b$ is unique: it is\n", " called the inverse of $a$ and is commonly denoted $a^{-1}$.\n", "\n", "With groups defined, we are in a position to articulate what a representation is: Let $\\varphi$ be a map sending $g$ in group $G$ to a linear map $\\varphi(g): V \\rightarrow V$, for some vector space $V$, which satisfies\n", "\n", "$$\\varphi\\left(g_{1} g_{2}\\right)=\\varphi\\left(g_{1}\\right) \\circ \\varphi\\left(g_{2}\\right) \\quad \\text { for all } g_{1}, g_{2} \\in G.$$\n", "\n", "The idea here is that just as elements in a group act on each other to reach further elements, i.e., $g\\circ h = k$, a representation sends us to a mapping acting on a vector space such that $\\varphi(g)\\circ \\varphi(h) = \\varphi(k)$. In this way we are representing the structure of the group as a linear map. For a representation, our mapping must send us to the general linear group $GL(n)$ (the space of invertible $n \\times n$ matrices with matrix multiplication as the group multiplication). Note how this is both a group, and by virtue of being a collection of invertible matrices, also a set of linear maps (they\\'re all invertble matrices that can act on\n", "row vectors). Fundamentally, representation theory is based on the prosaic observation that linear algebra is easy and group theory is abstract. So what if we can study groups via linear maps?\n", "\n", "Now due to the importance of unitarity in quantum mechnics, we are particularly interested in the unitary representations: representations where the linear maps are unitary matrices. If we can identify these then we will have a way to naturally encode groups in quantum circuits (which are mostly made up of unitary gates).\n", "\n", "![](images/sphere_equivariant.png)\n", "\n", "How does all this relate to symmetries? Well, a large class of symmetries can be characterised as a group, where all the elements of the group leave some space we are considering unchanged. Let\\'s consider an example: the symmetries of a sphere. Now when we think of this symmetry we probably think something along the lines of \\\"it\\'s the same no matter how we rotate it, or flip it left to right, etc\\\". There is this idea of being invariant under some operation. We also have the idea of being able to undo these actions: if we rotate one way, we can rotate it back. If we flip the sphere right-to-left we can flip it left-to-right to get back to where we started (notice too all these inverses are unique). Trivially we can also do nothing. What exactly are we describing here? We have elements that correspond to an action on a sphere that can be inverted and for which there exists an identity. It is also trivially the case here that if we consider three operations a, b, c from the set of rotations and reflections of the sphere, that if we combine two of them together then $a\\circ (b \\circ c) = (a\\circ b) \\circ c$. The operations are associative. These features turn out to literally define a group!\n", "\n", "As we\\'ve seen the group in itself is a very abstract creature; this is why we look to its representations. The group labels what symmetries we care about, they tell us the mappings that our system is invariant under, and the unitary representations show us how those symmetries look on a particular space of unitary matrices. If we want to encode the structure of the symmeteries in a quantum circuit we must restrict our gates to being unitary representations of the group.\n", "\n", "There remains one question: *what is equivariance?* With our newfound knowledge of group representation theory we are ready to tackle this. Let $G$ be our group, and $V$ and $W$, with elements $v$ and $w$ respectively, be vector spaces over some field $F$ with a map $f$ between them. Suppose we have representations $\\varphi: G \\rightarrow GL(V)$ and $\\psi: G \\rightarrow GL(W)$. Furthermore, let\\'s write $\\varphi_g$ for the representation of $g$ as a\n", "linear map on $V$ and $\\psi_g$ as the same group element represented as a linear map on $W$ respectively. We call $f$ *equivariant* if\n", "\n", "$$f(\\varphi_g(v))=\\psi_g(f(v)) \\quad \\text { for all } g\\in G.$$\n", "\n", "The importance of such a map in machine learning is that if, for example, our neural network layers are equivariant maps then two inputs that are related by some intrinsic symmetry (maybe they are reflections) preserve this information in the outputs.\n", "\n", "Consider the following figure for example. What we see is a board with a cross in a certain square on the left and some numerical encoding of this on the right, where the 1 is where the X is in the number grid. We\n", "present an equivariant mapping between these two spaces with respect to a group action that is a rotation or a swap (here a $\\pi$ rotation). We can either apply a group action to the original grid and then map to the number grid, or we could map to the number grid and then apply the group action. Equivariance demands that the result of either of these procedures should be the same.\n", "\n", "![](images/equivariant-example.jpg)\n", "\n", "Given the vast amount of input data required to train a neural network the principle that one can pre-encode known symmetry structures into the network allows us to learn better and faster. Indeed it is the reason\n", "for the success of convolutional neural networks (CNNs) for image analysis, where it is known they are equivariant with respect to translations. They naturally encode the idea that a picture of a dog is symmetrically related to the same picture slid to the left by n pixels, and they do this by having neural network layers that are equivariant maps. With our focus on unitary representations (and so quantum circuits) we are looking to extend this idea to quantum machine learning.\n" ] }, { "cell_type": "markdown", "source": [ "## Categories of Geometric Deep Learning\n", "\n", "In Bronstein’s recent book [Bronstein, Bruna, Cohen, Velickovic, Geometric Deep Learning: Grids, Groups, Graphs, Geodesics, and Gauges (2021), arXix:2104.13478], geometric deep learning is classified into four fundamental categories, as illustrated in the diagram below.\n", "\n", "![](images/gdl-categories.png)\n", "\n", "The grid category captures regularly sampled, or gridded, data such as 2D images. These data would perhaps typically be the purveyance of classical deep learning. However, it is also possible to interpret many of the classical deep learning models in a geometric perspective (such as CNNs an their translational equivariance, as discussed above).\n", "\n", "The group category covers homogenous spaces with global symmetries. The canonical example of this category is the sphere (covered in greater detail in our previous article [3]). Spherical data arise in myrad applications, not only when data is acquired directly on the sphere (such as over the Earth or by 360° cameras that capture panoramic photos and videos), but also when considering spherical symmetries (such as in molecular chemistry or magnetic resonance imaging). While the sphere is the most common group setting, other groups and their corresponding symmetries can also be considered.\n", "\n", "The graph category covers data that may be represented by a computational graph, with nodes and edges. Networks are well-suited to such representations, hence graph deep learning has found wide application in the study of social networks. The graph approach to geometric deep learning provides great flexibility since much data can be represented by a graph. However, this flexibility can come with a loss in specificity and the advantages that affords. For example, the group setting can often be considered with a graph approach but in this case one loses the underlying knowledge of the group, which can otherwise be leveraged.\n", "\n", "The final geodesics and gauges category involves deep learning on more complex shapes, such as more general maniolds and 3D meshes. Such approaches can be of great use in computer vision and graphics, for example, where one can perform deep learning with 3D models and their deformations.\n" ], "metadata": { "collapsed": false } }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Noughts and Crosses\n", "\n", "\n", "Let\\'s look at the game of noughts and crosses, as inspired by. Two players take turns to place a O or an X, depending on which player they are, in a 3x3 grid. The aim is to get three of your symbols in a row, column, or diagonal. As this is not always possible depending on the choices of the players, there could be a draw. Our learning task is to take a set of completed games labelled with their outcomes and teach the algorithm to identify these correctly.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This board of nine elements has the symmetry of the square, also known as the *dihedral group*. This means it is symmetric under $\\frac{\\pi}{2}$ rotations and flips about the lines of symmetry of a square (vertical, horizontal,and both diagonals).\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/NandC_sym.png)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**The question is, how do we encode this in our QML problem?**\n", "\n", "First, let us encode this problem classically. We will consider a nine-element vector $v$, each element of which identifies a square of the board. The entries themselves can be $+1$,$0$,$-1,$ representing a nought, no symbol, or a cross. The label is one-hot encoded in a vector $y=(y_O,y_- , y_X)$ with $+1$ in the correct label and $-1$ in the others. For instance (-1,-1,1) would represent an X in the relevant position.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To create the quantum model let us take nine qubits and let them represent squares of our board. We\\'ll initialise them all as $|0\\rangle$, which we note leaves the board invariant under the symmetries of the problem (flip and rotate all you want, it\\'s still going to be zeroes whatever your mapping). We will then look to apply single qubit $R_x(\\theta)$ rotations on individual qubits, encoding each of the possibilities in the board squares at an angle of $\\frac{2\\pi}{3}$ from each other. For our parameterised gates we will have a single-qubit $R_x(\\theta_1)$ and $R_y(\\theta_2)$ rotation at each point. We will then use $CR_y(\\theta_3)$ for two-qubit entangling gates.\n", "\n", "This implies that, for each encoding, crudely, we\\'ll need 18 single-qubit rotation parameters and $\\binom{9}{2}=36$ two-qubit gate rotations. Let\\'s see how, by using symmetries, we can reduce this." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![..](images/grid.jpg)\n", "\n", "The indexing of our game board.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The secret will be to encode the symmetries into the gate set so the observables we are interested in inherently respect the symmetries. How do we do this? We need to select the collections of gates that commute with the symmetries. In general, we can use the twirling formula for this:\n", "\n", "\n", "**Tip**\n", "\n", "Let $\\mathcal{S}$ be the group that encodes our symmetries and $U$ be a unitary representation of $\\mathcal{S}$. Then,\n", "\n", "$$\\mathcal{T}_{U}[X]=\\frac{1}{|\\mathcal{S}|} \\sum_{s \\in \\mathcal{S}} U(s) X U(s)^{\\dagger}$$\n", "\n", "defines a projector onto the set of operators commuting with all elements of the representation, i.e.,\n", "\n", "$\\left[\\mathcal{T}_{U}[X], U(s)\\right]=$ 0 for all $X$ and $s \\in \\mathcal{S}$.\n", "\n", "\n", "The twirling process applied to an arbitrary unitary will give us a new unitary that commutes with the group as we require. We remember that unitary gates typically have the form $W = \\exp(-i\\theta H)$, where $H$ is a Hermitian matrix called a *generator*, and $\\theta$ may be fixed or left as a free parameter. A recipe for creating a unitary that commutes with our symmetries is to *twirl the generator of the gate*, i.e., we move from the gate $W = \\exp(-i\\theta H)$ to the gate $W' = \\exp(-i\\theta\\mathcal{T}_U[H])$. When each term in the twirling formula acts on different qubits, then this unitary would further simplify to\n", "\n", "$$W' = \\bigotimes_{s\\in\\mathcal{S}}U(s)\\exp(-i\\tfrac{\\theta}{\\vert\\mathcal{S}\\vert})U(s)^\\dagger.$$\n", "\n", "For simplicity, we can absorb the normalization factor $\\vert\\mathcal{S}\\vert$ into the free parameter $\\theta$.\n", "\n", "So let\\'s look again at our choice of gates: single-qubit $R_x(\\theta)$ and $R_y(\\theta)$ rotations, and entangling two-qubit $CR_y(\\phi)$ gates. What will we get by twirling these?\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this particular instance we can see the action of the twirling operation geometrically as the symmetries involved are all permutations. Let\\'s consider the $R_x$ rotation acting on one qubit. Now if this qubit is in the centre location on the grid, then we can flip around any symmetry axis we like, and this operation leaves the qubit invariant, so we\\'ve identified one equivariant gate immediately. If the qubit is on the corners, then the flipping will send this qubit rotation to each of the other corners. Similarly, if a qubit is on the central edge then the rotation gate will be sent round the other edges. So we can see that the twirling operation is a sum over all the possible outcomes of performing the symmetry action (the sum over the symmetry group actions). Having done this we can see that for a single-qubit rotation the invariant maps are rotations on the central qubit, at all the corners, and at all the central edges (when their rotation angles are fixed to be the same).\n", "\n", "As an example consider the following figure, where we take a $R_x$ gate in the corner and then apply all the symmetries of a square. The result of this twirling leads us to have the same gate at all the corners.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/twirl.jpeg)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For entangling gates the situation is similar. There are three invariant classes, the centre entangled with all corners, with all edges, and the edges paired in a ring.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The prediction of a label is obtained via a one-hot-encoding by measuring the expectation values of three invariant observables:\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$$O_{-}=Z_{\\text {middle }}=Z_{4}$$\n", "\n", "$$O_{\\circ}=\\frac{1}{4} \\sum_{i \\in \\text { corners }} Z_{i}=\\frac{1}{4}\\left[Z_{0}+Z_{2}+Z_{6}+Z_{8}\\right]$$\n", "\n", "$$O_{\\times}=\\frac{1}{4} \\sum_{i \\in \\text { edges }} Z_{i}=\\frac{1}{4}\\left[Z_{1}+Z_{3}+Z_{5}+Z_{7}\\right]$$\n", "\n", "$$\\hat{\\boldsymbol{y}}=\\left(\\left\\langle O_{\\circ}\\right\\rangle,\\left\\langle O_{-}\\right\\rangle,\\left\\langle O_{\\times}\\right\\rangle\\right)$$\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This is the quantum encoding of the symmetries into a learning problem. A prediction for a given data point will be obtained by selecting the class for which the observed expectation value is the largest.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we have a specific encoding and have decided on our observables we need to choose a suitable cost function to optimise. We will use an $l_2$ loss function acting on pairs of games and labels $D={(g,y)}$,\n", "where $D$ is our dataset.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let\\'s now implement this!\n", "\n", "First let\\'s generate some games. Here we are creating a small program that will play Noughts and Crosses against itself in a random fashion. On completion, it spits out the winner and the winning board, with noughts as +1, draw as 0, and crosses as -1. There are 26,830 different possible games but we will only sample a few hundred.\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import torch\n", "import random\n", "\n", "# Fix seeds for reproducability\n", "torch.backends.cudnn.deterministic = True\n", "torch.manual_seed(16)\n", "random.seed(16)\n", "\n", "# create an empty board\n", "def create_board():\n", " return torch.tensor([[0, 0, 0], [0, 0, 0], [0, 0, 0]])\n", "\n", "\n", "# Check for empty places on board\n", "def possibilities(board):\n", " l = []\n", " for i in range(len(board)):\n", " for j in range(3):\n", " if board[i, j] == 0:\n", " l.append((i, j))\n", " return l\n", "\n", "\n", "# Select a random place for the player\n", "def random_place(board, player):\n", " selection = possibilities(board)\n", " current_loc = random.choice(selection)\n", " board[current_loc] = player\n", " return board\n", "\n", "\n", "# Check if there is a winner by having 3 in a row\n", "def row_win(board, player):\n", " for x in range(3):\n", " lista = []\n", " win = True\n", "\n", " for y in range(3):\n", " lista.append(board[x, y])\n", "\n", " if board[x, y] != player:\n", " win = False\n", "\n", " if win:\n", " break\n", "\n", " return win\n", "\n", "\n", "# Check if there is a winner by having 3 in a column\n", "def col_win(board, player):\n", " for x in range(3):\n", " win = True\n", "\n", " for y in range(3):\n", " if board[y, x] != player:\n", " win = False\n", "\n", " if win:\n", " break\n", "\n", " return win\n", "\n", "\n", "# Check if there is a winner by having 3 along a diagonal\n", "def diag_win(board, player):\n", " win1 = True\n", " win2 = True\n", " for x, y in [(0, 0), (1, 1), (2, 2)]:\n", " if board[x, y] != player:\n", " win1 = False\n", "\n", " for x, y in [(0, 2), (1, 1), (2, 0)]:\n", " if board[x, y] != player:\n", " win2 = False\n", "\n", " return win1 or win2\n", "\n", "\n", "# Check if the win conditions have been met or if a draw has occurred\n", "def evaluate_game(board):\n", " winner = None\n", " for player in [1, -1]:\n", " if row_win(board, player) or col_win(board, player) or diag_win(board, player):\n", " winner = player\n", "\n", " if torch.all(board != 0) and winner == None:\n", " winner = 0\n", "\n", " return winner\n", "\n", "\n", "# Main function to start the game\n", "def play_game():\n", " board, winner, counter = create_board(), None, 1\n", " while winner == None:\n", " for player in [1, -1]:\n", " board = random_place(board, player)\n", " counter += 1\n", " winner = evaluate_game(board)\n", " if winner != None:\n", " break\n", "\n", " return [board.flatten(), winner]\n", "\n", "\n", "def create_dataset(size_for_each_winner):\n", " game_d = {-1: [], 0: [], 1: []}\n", "\n", " while min([len(v) for k, v in game_d.items()]) < size_for_each_winner:\n", " board, winner = play_game()\n", " if len(game_d[winner]) < size_for_each_winner:\n", " game_d[winner].append(board)\n", "\n", " res = []\n", " for winner, boards in game_d.items():\n", " res += [(board, winner) for board in boards]\n", "\n", " return res\n", "\n", "\n", "NUM_TRAINING = 450\n", "NUM_VALIDATION = 600\n", "\n", "# Create datasets but with even numbers of each outcome\n", "with torch.no_grad():\n", " dataset = create_dataset(NUM_TRAINING // 3)\n", " dataset_val = create_dataset(NUM_VALIDATION // 3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now let\\'s create the relevant circuit expectation values that respect the symmetry classes we defined over the single-site and two-site measurements.\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import pennylane as qml\n", "import matplotlib.pyplot as plt\n", "\n", "# Set up a nine-qubit system\n", "dev = qml.device(\"default.qubit.torch\", wires=9)\n", "\n", "ob_center = qml.PauliZ(4)\n", "ob_corner = (qml.PauliZ(0) + qml.PauliZ(2) + qml.PauliZ(6) + qml.PauliZ(8)) * (1 / 4)\n", "ob_edge = (qml.PauliZ(1) + qml.PauliZ(3) + qml.PauliZ(5) + qml.PauliZ(7)) * (1 / 4)\n", "\n", "# Now let's encode the data in the following qubit models, first with symmetry\n", "@qml.qnode(dev, interface=\"torch\")\n", "def circuit(x, p):\n", "\n", " qml.RX(x[0], wires=0)\n", " qml.RX(x[1], wires=1)\n", " qml.RX(x[2], wires=2)\n", " qml.RX(x[3], wires=3)\n", " qml.RX(x[4], wires=4)\n", " qml.RX(x[5], wires=5)\n", " qml.RX(x[6], wires=6)\n", " qml.RX(x[7], wires=7)\n", " qml.RX(x[8], wires=8)\n", "\n", " # Centre single-qubit rotation\n", " qml.RX(p[0], wires=4)\n", " qml.RY(p[1], wires=4)\n", "\n", " # Corner single-qubit rotation\n", " qml.RX(p[2], wires=0)\n", " qml.RX(p[2], wires=2)\n", " qml.RX(p[2], wires=6)\n", " qml.RX(p[2], wires=8)\n", "\n", " qml.RY(p[3], wires=0)\n", " qml.RY(p[3], wires=2)\n", " qml.RY(p[3], wires=6)\n", " qml.RY(p[3], wires=8)\n", "\n", " # Edge single-qubit rotation\n", " qml.RX(p[4], wires=1)\n", " qml.RX(p[4], wires=3)\n", " qml.RX(p[4], wires=5)\n", " qml.RX(p[4], wires=7)\n", "\n", " qml.RY(p[5], wires=1)\n", " qml.RY(p[5], wires=3)\n", " qml.RY(p[5], wires=5)\n", " qml.RY(p[5], wires=7)\n", "\n", " # Entagling two-qubit gates\n", " # circling the edge of the board\n", " qml.CRY(p[6], wires=[0, 1])\n", " qml.CRY(p[6], wires=[2, 1])\n", " qml.CRY(p[6], wires=[2, 5])\n", " qml.CRY(p[6], wires=[8, 5])\n", " qml.CRY(p[6], wires=[8, 7])\n", " qml.CRY(p[6], wires=[6, 7])\n", " qml.CRY(p[6], wires=[6, 3])\n", " qml.CRY(p[6], wires=[0, 3])\n", "\n", " # To the corners from the centre\n", " qml.CRY(p[7], wires=[4, 0])\n", " qml.CRY(p[7], wires=[4, 2])\n", " qml.CRY(p[7], wires=[4, 6])\n", " qml.CRY(p[7], wires=[4, 8])\n", "\n", " # To the centre from the edges\n", " qml.CRY(p[8], wires=[1, 4])\n", " qml.CRY(p[8], wires=[3, 4])\n", " qml.CRY(p[8], wires=[5, 4])\n", " qml.CRY(p[8], wires=[7, 4])\n", "\n", " return [qml.expval(ob_center), qml.expval(ob_corner), qml.expval(ob_edge)]\n", "\n", "\n", "fig, ax = qml.draw_mpl(circuit)([0] * 9, 18 * [0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let\\'s also look at the same series of gates but this time they are applied independently from one another, so we won\\'t be preserving the symmetries with our gate operations. Practically this also means more parameters, as previously groups of gates were updated together.\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "output_type": "display_data" } ], "source": [ "@qml.qnode(dev, interface=\"torch\")\n", "def circuit_no_sym(x, p):\n", "\n", " qml.RX(x[0], wires=0)\n", " qml.RX(x[1], wires=1)\n", " qml.RX(x[2], wires=2)\n", " qml.RX(x[3], wires=3)\n", " qml.RX(x[4], wires=4)\n", " qml.RX(x[5], wires=5)\n", " qml.RX(x[6], wires=6)\n", " qml.RX(x[7], wires=7)\n", " qml.RX(x[8], wires=8)\n", "\n", " # Centre single-qubit rotation\n", " qml.RX(p[0], wires=4)\n", " qml.RY(p[1], wires=4)\n", "\n", " # Note in this circuit the parameters aren't all the same.\n", " # Previously they were identical to ensure they were applied\n", " # as one combined gate. The fact they can all vary independently\n", " # here means we aren't respecting the symmetry.\n", "\n", " # Corner single-qubit rotation\n", " qml.RX(p[2], wires=0)\n", " qml.RX(p[3], wires=2)\n", " qml.RX(p[4], wires=6)\n", " qml.RX(p[5], wires=8)\n", "\n", " qml.RY(p[6], wires=0)\n", " qml.RY(p[7], wires=2)\n", " qml.RY(p[8], wires=6)\n", " qml.RY(p[9], wires=8)\n", "\n", " # Edge single-qubit rotation\n", " qml.RX(p[10], wires=1)\n", " qml.RX(p[11], wires=3)\n", " qml.RX(p[12], wires=5)\n", " qml.RX(p[13], wires=7)\n", "\n", " qml.RY(p[14], wires=1)\n", " qml.RY(p[15], wires=3)\n", " qml.RY(p[16], wires=5)\n", " qml.RY(p[17], wires=7)\n", "\n", " # Entagling two-qubit gates\n", " # circling the edge of the board\n", " qml.CRY(p[18], wires=[0, 1])\n", " qml.CRY(p[19], wires=[2, 1])\n", " qml.CRY(p[20], wires=[2, 5])\n", " qml.CRY(p[21], wires=[8, 5])\n", " qml.CRY(p[22], wires=[8, 7])\n", " qml.CRY(p[23], wires=[6, 7])\n", " qml.CRY(p[24], wires=[6, 3])\n", " qml.CRY(p[25], wires=[0, 3])\n", "\n", " # To the corners from the centre\n", " qml.CRY(p[26], wires=[4, 0])\n", " qml.CRY(p[27], wires=[4, 2])\n", " qml.CRY(p[28], wires=[4, 6])\n", " qml.CRY(p[29], wires=[4, 8])\n", "\n", " # To the centre from the edges\n", " qml.CRY(p[30], wires=[1, 4])\n", " qml.CRY(p[31], wires=[3, 4])\n", " qml.CRY(p[32], wires=[5, 4])\n", " qml.CRY(p[33], wires=[7, 4])\n", "\n", " return [qml.expval(ob_center), qml.expval(ob_corner), qml.expval(ob_edge)]\n", "\n", "\n", "fig, ax = qml.draw_mpl(circuit_no_sym)([0] * 9, [0] * 34)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note again how, though these circuits have a similar form to before, they are parameterised differently. We need to feed the vector $\\boldsymbol{y}$ made up of the expectation value of these three operators into the loss function and use this to update our parameters.\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import math\n", "\n", "def encode_game(game):\n", " board, res = game\n", " x = board * (2 * math.pi) / 3\n", " if res == 1:\n", " y = [-1, -1, 1]\n", " elif res == -1:\n", " y = [1, -1, -1]\n", " else:\n", " y = [-1, 1, -1]\n", " return x, y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Recall that the loss function we\\'re interested in is\n", "$\\mathcal{L}(\\mathcal{D})=\\frac{1}{|\\mathcal{D}|} \\sum_{(\\boldsymbol{g}, \\boldsymbol{y}) \\in \\mathcal{D}}\\|\\hat{\\boldsymbol{y}}(\\boldsymbol{g})-\\boldsymbol{y}\\|_{2}^{2}$.\n", "We need to define this and then we can begin our optimisation.\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# calculate the mean square error for this classification problem\n", "def cost_function(params, input, target):\n", " output = torch.stack([circuit(x, params) for x in input])\n", " vec = output - target\n", " sum_sqr = torch.sum(vec * vec, dim=1)\n", " return torch.mean(sum_sqr)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let\\'s now train our symmetry-preserving circuit on the data.\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy without training = 0.2383333295583725\n", "Epoch: 1 | Loss: 2.996221 | Validation accuracy: 0.153333\n", "Epoch: 2 | Loss: 2.838961 | Validation accuracy: 0.415000\n", "Epoch: 3 | Loss: 2.721652 | Validation accuracy: 0.535000\n", "Epoch: 4 | Loss: 2.686487 | Validation accuracy: 0.553333\n", "Epoch: 5 | Loss: 2.608699 | Validation accuracy: 0.548333\n", "Epoch: 6 | Loss: 2.648471 | Validation accuracy: 0.591667\n", "Epoch: 7 | Loss: 2.630698 | Validation accuracy: 0.585000\n", "Epoch: 8 | Loss: 2.544674 | Validation accuracy: 0.585000\n", "Epoch: 9 | Loss: 2.630653 | Validation accuracy: 0.570000\n", "Epoch: 10 | Loss: 2.595081 | Validation accuracy: 0.576667\n", "Epoch: 11 | Loss: 2.586225 | Validation accuracy: 0.578333\n", "Epoch: 12 | Loss: 2.600443 | Validation accuracy: 0.578333\n", "Epoch: 13 | Loss: 2.652541 | Validation accuracy: 0.576667\n", "Epoch: 14 | Loss: 2.585265 | Validation accuracy: 0.580000\n", "Epoch: 15 | Loss: 2.598611 | Validation accuracy: 0.580000\n" ] } ], "source": [ "from torch import optim\n", "import numpy as np\n", "\n", "params = 0.01 * torch.randn(9)\n", "params.requires_grad = True\n", "opt = optim.Adam([params], lr=1e-2)\n", "\n", "\n", "max_epoch = 15\n", "max_step = 30\n", "batch_size = 10\n", "\n", "encoded_dataset = list(zip(*[encode_game(game) for game in dataset]))\n", "encoded_dataset_val = list(zip(*[encode_game(game) for game in dataset_val]))\n", "\n", "\n", "def accuracy(p, x_val, y_val):\n", " with torch.no_grad():\n", " y_val = torch.tensor(y_val)\n", " y_out = torch.stack([circuit(x, p) for x in x_val])\n", " acc = torch.sum(torch.argmax(y_out, axis=1) == torch.argmax(y_val, axis=1))\n", " return acc / len(x_val)\n", "\n", "\n", "print(f\"accuracy without training = {accuracy(params, *encoded_dataset_val)}\")\n", "\n", "x_dataset = torch.stack(encoded_dataset[0])\n", "y_dataset = torch.tensor(encoded_dataset[1], requires_grad=False)\n", "\n", "saved_costs_sym = []\n", "saved_accs_sym = []\n", "for epoch in range(max_epoch):\n", " rand_idx = torch.randperm(len(x_dataset))\n", " # Shuffled dataset\n", " x_dataset = x_dataset[rand_idx]\n", " y_dataset = y_dataset[rand_idx]\n", "\n", " costs = []\n", "\n", " for step in range(max_step):\n", " x_batch = x_dataset[step * batch_size : (step + 1) * batch_size]\n", " y_batch = y_dataset[step * batch_size : (step + 1) * batch_size]\n", "\n", " def opt_func():\n", " opt.zero_grad()\n", " loss = cost_function(params, x_batch, y_batch)\n", " costs.append(loss.item())\n", " loss.backward()\n", " return loss\n", "\n", " opt.step(opt_func)\n", "\n", " cost = np.mean(costs)\n", " saved_costs_sym.append(cost)\n", "\n", " if (epoch + 1) % 1 == 0:\n", " # Compute validation accuracy\n", " acc_val = accuracy(params, *encoded_dataset_val)\n", " saved_accs_sym.append(acc_val)\n", "\n", " res = [epoch + 1, cost, acc_val]\n", " print(\"Epoch: {:2d} | Loss: {:3f} | Validation accuracy: {:3f}\".format(*res))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we train the non-symmetry preserving circuit.\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "accuracy without training = 0.22166666388511658\n", "Epoch: 1 | Loss: 3.025290 | Validation accuracy: 0.235000\n", "Epoch: 2 | Loss: 2.918151 | Validation accuracy: 0.280000\n", "Epoch: 3 | Loss: 2.824333 | Validation accuracy: 0.385000\n", "Epoch: 4 | Loss: 2.747958 | Validation accuracy: 0.501667\n", "Epoch: 5 | Loss: 2.693046 | Validation accuracy: 0.466667\n", "Epoch: 6 | Loss: 2.659418 | Validation accuracy: 0.446667\n", "Epoch: 7 | Loss: 2.641402 | Validation accuracy: 0.460000\n", "Epoch: 8 | Loss: 2.626516 | Validation accuracy: 0.481667\n", "Epoch: 9 | Loss: 2.616884 | Validation accuracy: 0.480000\n", "Epoch: 10 | Loss: 2.610851 | Validation accuracy: 0.496667\n", "Epoch: 11 | Loss: 2.606585 | Validation accuracy: 0.508333\n", "Epoch: 12 | Loss: 2.599107 | Validation accuracy: 0.506667\n", "Epoch: 13 | Loss: 2.592962 | Validation accuracy: 0.505000\n", "Epoch: 14 | Loss: 2.589474 | Validation accuracy: 0.515000\n", "Epoch: 15 | Loss: 2.584630 | Validation accuracy: 0.518333\n" ] } ], "source": [ "params = 0.01 * torch.randn(34)\n", "params.requires_grad = True\n", "opt = optim.Adam([params], lr=1e-2)\n", "\n", "# calculate mean square error for this classification problem\n", "\n", "\n", "def cost_function_no_sym(params, input, target):\n", " output = torch.stack([circuit_no_sym(x, params) for x in input])\n", " vec = output - target\n", " sum_sqr = torch.sum(vec * vec, dim=1)\n", " return torch.mean(sum_sqr)\n", "\n", "\n", "max_epoch = 15\n", "max_step = 30\n", "batch_size = 15\n", "\n", "encoded_dataset = list(zip(*[encode_game(game) for game in dataset]))\n", "encoded_dataset_val = list(zip(*[encode_game(game) for game in dataset_val]))\n", "\n", "\n", "def accuracy_no_sym(p, x_val, y_val):\n", " with torch.no_grad():\n", " y_val = torch.tensor(y_val)\n", " y_out = torch.stack([circuit_no_sym(x, p) for x in x_val])\n", " acc = torch.sum(torch.argmax(y_out, axis=1) == torch.argmax(y_val, axis=1))\n", " return acc / len(x_val)\n", "\n", "\n", "print(f\"accuracy without training = {accuracy_no_sym(params, *encoded_dataset_val)}\")\n", "\n", "\n", "x_dataset = torch.stack(encoded_dataset[0])\n", "y_dataset = torch.tensor(encoded_dataset[1], requires_grad=False)\n", "\n", "saved_costs = []\n", "saved_accs = []\n", "for epoch in range(max_epoch):\n", " rand_idx = torch.randperm(len(x_dataset))\n", " # Shuffled dataset\n", " x_dataset = x_dataset[rand_idx]\n", " y_dataset = y_dataset[rand_idx]\n", "\n", " costs = []\n", "\n", " for step in range(max_step):\n", " x_batch = x_dataset[step * batch_size : (step + 1) * batch_size]\n", " y_batch = y_dataset[step * batch_size : (step + 1) * batch_size]\n", "\n", " def opt_func():\n", " opt.zero_grad()\n", " loss = cost_function_no_sym(params, x_batch, y_batch)\n", " costs.append(loss.item())\n", " loss.backward()\n", " return loss\n", "\n", " opt.step(opt_func)\n", "\n", " cost = np.mean(costs)\n", " saved_costs.append(costs)\n", "\n", " if (epoch + 1) % 1 == 0:\n", " # Compute validation accuracy\n", " acc_val = accuracy_no_sym(params, *encoded_dataset_val)\n", " saved_accs.append(acc_val)\n", "\n", " res = [epoch + 1, cost, acc_val]\n", " print(\"Epoch: {:2d} | Loss: {:3f} | Validation accuracy: {:3f}\".format(*res))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Finally let\\'s plot the results and see how the two training regimes differ.\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/tmp/ipykernel_41313/356678465.py:3: MatplotlibDeprecationWarning: The seaborn styles shipped by Matplotlib are deprecated since 3.6, as they no longer correspond to the styles shipped by seaborn. However, they will remain available as 'seaborn-v0_8-