examples/qae_h2_demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Demo: Compressing ground states of molecular hydrogen\n",
    "\n",
    "In this demo, we will try to compress ground states of molecular hydrogen at various bond lengths. We start with expressing each state using 4 qubits and try to compress the information to 1 qubit (i.e. implement a 4-1-4 quantum autoencoder).\n",
    "\n",
    "In the following section, we review both the full and halfway training schemes. However, in the notebook, we execute the halfway training case.\n",
    "\n",
    "## Full cost function training\n",
    "\n",
    "The QAE circuit for full cost function training looks like the following:\n",
    "\n",
    "<img src=\"../images/qae_setup.png\" width=\"400\">\n",
    "\n",
    "We note that our setup is different from what was proposed in the original paper. As shown in the figure above, we use 7 total qubits for the 4-1-4 autoencoder, using the last 3 qubits (qubits $q_6$, $q_5$, and $q_4$) as refresh qubits. The unitary $S$ represents the state preparation circuit, gates implemented to produce the input data set. The unitary $U$ represents the training circuit that will be responsible for representing the data set using a fewer number of qubits, in this case using a single qubit. The tilde symbol above the daggered operations indicates that the qubit indexing has been adjusted such that $q_0 \\rightarrow q_6$, $q_1 \\rightarrow q_5$, $q_2 \\rightarrow q_4$, and $q_3 \\rightarrow q_3$. For clarity, refer to the figure below for an equivalent circuit with the refresh qubits moved around. So qubit $q_3$ is to be the \"latent space qubit,\" or qubit to hold the compressed information. Using the circuit structure above (applying  $S$ and $U$ then effectively __un__-applying $S$ and $U$), we train the autoencoder by propagating the QAE circuit with proposed parameters and computing the probability of obtaining measurements of 0000 for the latent space and refresh qubits ($q_3$ to $q_6$). We negate this value for casting as a minimization problem and average over the training set to compute a single loss value.\n",
    "\n",
    "<img src=\"../images/qae_adjusted.png\" width=\"500\">\n",
    "\n",
    "## Halfway cost function training\n",
    "\n",
    "In the halfway cost function training case, the circuit looks like the following:\n",
    "\n",
    "<img src=\"../images/h2_halfway_circuit.png\" width=\"300\">\n",
    "\n",
    "Here, the cost function is the negated probability of obtaining the measurement 000 for the trash qubits.\n",
    "\n",
    "\n",
    "## Demo Outline\n",
    "\n",
    "We break down this demo into the following steps:\n",
    "1. Preparation of the quantum data\n",
    "2. Initializing the QAE\n",
    "2. Setting up the Forest connection\n",
    "3. Dividing the dataset into training and test sets\n",
    "4. Training the network\n",
    "5. Testing the network\n",
    "\n",
    "__NOTE__: While the QCompress framework was developed to execute on both the QVM and the QPU (i.e. simulator and quantum device, respectively), this particular demo runs a simulation (i.e. uses QVM).\n",
    "\n",
    "Let us begin! __Note that this tutorial requires installation of [OpenFermion](https://github.com/quantumlib/OpenFermion)!__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import modules\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "from openfermion.hamiltonians import MolecularData\n",
    "from openfermion.transforms import get_sparse_operator, jordan_wigner\n",
    "from openfermion.utils import get_ground_state\n",
    "\n",
    "from pyquil.api import WavefunctionSimulator\n",
    "from pyquil.gates import *\n",
    "from pyquil import Program\n",
    "\n",
    "import demo_utils\n",
    "\n",
    "from qcompress.qae_engine import *\n",
    "from qcompress.utils import *\n",
    "from qcompress.config import DATA_DIRECTORY\n",
    "\n",
    "global pi\n",
    "pi = np.pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QAE Settings\n",
    "\n",
    "In the cell below, we enter the settings for the QAE.\n",
    "\n",
    "__NOTE__: Because QCompress was designed to run on the quantum device (as well as the simulator), we need to anticipate nontrival mappings between abstract qubits and physical qubits. The dictionaries `q_in`,  `q_latent`, and `q_refresh` are abstract-to-physical qubit mappings for the input, latent space, and refresh qubits respectively. A cool plug-in/feature to add would be to have an automated \"qubit mapper\" to determine the optimal or near-optimal abstract-to-physical qubit mappings for a particular QAE instance.\n",
    "\n",
    "In this simulation, we will skip the circuit compilation step by turning off `compile_program`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "### QAE setup options\n",
    "\n",
    "# Abstract-to-physical qubit mapping\n",
    "q_in = {'q0': 0, 'q1': 1, 'q2': 2, 'q3': 3} # Input qubits\n",
    "q_latent = {'q3': 3}                        # Latent space qubits\n",
    "q_refresh = None\n",
    "\n",
    "# Training scheme: Halfway\n",
    "trash_training = True\n",
    "\n",
    "# Simulator settings\n",
    "cxn_setting = '4q-qvm'\n",
    "compile_program = False\n",
    "n_shots = 3000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Qubit labeling\n",
    "\n",
    "In the cell below, we produce lists of __ordered__ physical qubit indices involved in the compression and recovery maps of the quantum autoencoder. Depending on the training and reset schemes, we may use different qubits for the compression vs. recovery.\n",
    "\n",
    "Since we're employing the halfway training scheme, we don't need to assign the qubit labels for the recovery process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Physical qubit indices for compression : [0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "compression_indices = order_qubit_labels(q_in).tolist()\n",
    "\n",
    "if not trash_training:\n",
    "    q_out = merge_two_dicts(q_latent, q_refresh)\n",
    "    recovery_indices = order_qubit_labels(q_out).tolist()\n",
    "\n",
    "    if not reset:\n",
    "        recovery_indices = recovery_indices[::-1]\n",
    "\n",
    "print(\"Physical qubit indices for compression : {0}\".format(compression_indices))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generating input data\n",
    "\n",
    "We use routines from `OpenFermion`, `forestopenfermion`, and `grove` to generate the input data set. We've provided the molecular data files for you, which were generated using `OpenFermion`'s plugin `OpenFermion-Psi4`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "qvm = WavefunctionSimulator()\n",
    "\n",
    "# MolecularData settings\n",
    "molecule_name = \"H2\"\n",
    "basis = \"sto-3g\"\n",
    "multiplicity = \"singlet\"\n",
    "dist_list = np.arange(0.2, 4.2, 0.1)\n",
    "\n",
    "# Lists to store HF and FCI energies\n",
    "hf_energies = []\n",
    "fci_energies = []\n",
    "check_energies = []\n",
    "\n",
    "# Lists to store state preparation circuits\n",
    "list_SP_circuits = []\n",
    "list_SP_circuits_dag = []\n",
    "\n",
    "for dist in dist_list:\n",
    "    \n",
    "    # Fetch file path\n",
    "    dist = \"{0:.1f}\".format(dist)\n",
    "    file_path = os.path.join(DATA_DIRECTORY, \"{0}_{1}_{2}_{3}.hdf5\".format(molecule_name,\n",
    "                                                                    basis,\n",
    "                                                                    multiplicity,\n",
    "                                                                    dist))\n",
    "    \n",
    "    # Extract molecular info\n",
    "    molecule = MolecularData(filename=file_path)\n",
    "    n_qubits = molecule.n_qubits\n",
    "    hf_energies.append(molecule.hf_energy)\n",
    "    fci_energies.append(molecule.fci_energy)\n",
    "    molecular_ham = molecule.get_molecular_hamiltonian()\n",
    "    \n",
    "    # Set up hamiltonian in qubit basis\n",
    "    qubit_ham = jordan_wigner(molecular_ham)\n",
    "\n",
    "    # Convert from OpenFermion's to PyQuil's data type (QubitOperator to PauliTerm/PauliSum)\n",
    "    qubit_ham_pyquil = demo_utils.qubitop_to_pyquilpauli(qubit_ham)\n",
    "\n",
    "    # Sanity check: Obtain ground state energy and check with MolecularData's FCI energy\n",
    "    molecular_ham_sparse = get_sparse_operator(operator=molecular_ham, n_qubits=n_qubits)\n",
    "    ground_energy, ground_state = get_ground_state(molecular_ham_sparse)\n",
    "    assert np.isclose(molecule.fci_energy, ground_energy)\n",
    "    \n",
    "    # Generate unitary to prepare ground states\n",
    "    state_prep_unitary = demo_utils.create_arbitrary_state(\n",
    "                            ground_state,\n",
    "                            qubits=compression_indices)\n",
    "\n",
    "    if not trash_training:\n",
    "        if reset:\n",
    "            # Generate daggered state prep unitary (WITH NEW/ADJUSTED INDICES!)\n",
    "            state_prep_unitary_dag = demo_utils.create_arbitrary_state(\n",
    "                                        ground_state,\n",
    "                                        qubits=compression_indices).dagger()\n",
    "        else:\n",
    "            # Generate daggered state prep unitary (WITH NEW/ADJUSTED INDICES!)\n",
    "            state_prep_unitary_dag = demo_utils.create_arbitrary_state(\n",
    "                                        ground_state,\n",
    "                                        qubits=recovery_indices).dagger()\n",
    "    \n",
    "    # Sanity check: Compute energy wrt wavefunction evolved under state_prep_unitary\n",
    "    wfn = qvm.wavefunction(state_prep_unitary)\n",
    "    ket = wfn.amplitudes\n",
    "    bra = np.transpose(np.conjugate(wfn.amplitudes))\n",
    "    ham_matrix = molecular_ham_sparse.toarray()\n",
    "    energy_expectation = np.dot(bra, np.dot(ham_matrix, ket))\n",
    "    check_energies.append(energy_expectation)\n",
    "    \n",
    "    # Store circuits\n",
    "    list_SP_circuits.append(state_prep_unitary)\n",
    "    if not trash_training:\n",
    "        list_SP_circuits_dag.append(state_prep_unitary_dag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try plotting the energies of the input data set.\n",
    "\n",
    "To (visually) check our state preparation circuits, we run these circuits and plot the energies. The \"check\" energies overlay nicely with the FCI energies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "imag_components = np.array([E.imag for E in check_energies])\n",
    "assert np.isclose(imag_components, np.zeros(len(imag_components))).all()\n",
    "check_energies = [E.real for E in check_energies]\n",
    "\n",
    "plt.plot(dist_list, fci_energies, 'ko-', markersize=6, label='FCI')\n",
    "plt.plot(dist_list, check_energies, 'ro', markersize=4, label='Check energies')\n",
    "plt.title(\"Dissociation Profile, $H_2$\")\n",
    "plt.xlabel(\"Bond Length, Angstroms\")\n",
    "plt.ylabel(\"Energy, Hartrees\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training circuit for QAE\n",
    "\n",
    "Now we want to choose a parametrized circuit with which we hope to train to compress the input quantum data set.\n",
    "\n",
    "For this demonstration, we use a simple two-parameter circuit, as shown below.\n",
    "\n",
    "__NOTE__: For more general data sets (and general circuits), we may need to run multiple instances of the QAE with different initial guesses to find a good compression circuit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _training_circuit(theta, qubit_indices):\n",
    "    \"\"\"\n",
    "    Returns parametrized/training circuit.\n",
    "    \n",
    "    :param theta: (list or numpy.array, required) Vector of training parameters\n",
    "    :param qubit_indices: (list, required) List of qubit indices\n",
    "    :returns: Training circuit\n",
    "    :rtype: pyquil.quil.Program\n",
    "    \"\"\"\n",
    "    circuit = Program()\n",
    "    circuit.inst(Program(RX(theta[0], qubit_indices[2]),\n",
    "                         RX(theta[1], qubit_indices[3])))\n",
    "    circuit.inst(Program(CNOT(qubit_indices[2], qubit_indices[0]),\n",
    "                         CNOT(qubit_indices[3], qubit_indices[1]),\n",
    "                         CNOT(qubit_indices[3], qubit_indices[2])))\n",
    "    return circuit\n",
    "\n",
    "def _training_circuit_dag(theta, qubit_indices):\n",
    "    \"\"\"\n",
    "    Returns the daggered parametrized/training circuit.\n",
    "    \n",
    "    :param theta: (list or numpy.array, required) Vector of training parameters\n",
    "    :param qubit_indices: (list, required) List of qubit indices\n",
    "    :returns: Daggered training circuit\n",
    "    :rtype: pyquil.quil.Program\n",
    "    \"\"\"\n",
    "    circuit = Program()\n",
    "    circuit.inst(Program(CNOT(qubit_indices[3], qubit_indices[2]),\n",
    "                         CNOT(qubit_indices[3], qubit_indices[1]),\n",
    "                         CNOT(qubit_indices[2], qubit_indices[0])))\n",
    "    circuit.inst(Program(RX(-theta[1], qubit_indices[3]),\n",
    "                         RX(-theta[0], qubit_indices[2])))\n",
    "    return circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_circuit = lambda param : _training_circuit(param, compression_indices)\n",
    "\n",
    "if not trash_training:\n",
    "    if reset:\n",
    "        training_circuit_dag = lambda param : _training_circuit_dag(param,\n",
    "                                                                    compression_indices)\n",
    "    else:\n",
    "        training_circuit_dag = lambda param : _training_circuit_dag(param,\n",
    "                                                                    recovery_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize the QAE engine\n",
    "\n",
    "Here we create an instance of the `quantum_autoencoder` class. \n",
    "\n",
    "\n",
    "Leveraging the features of the `Forest` platform, this quantum autoencoder \"engine\" allows you to run a noisy version of the QVM to get a sense of how the autoencoder performs under noise (but qvm is noiseless in this demo). In addition, the user can also run this instance on the quantum device (assuming the user is given access to one of Rigetti Computing's available QPUs)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "qae = quantum_autoencoder(state_prep_circuits=list_SP_circuits,\n",
    "                          training_circuit=training_circuit,\n",
    "                          q_in=q_in,\n",
    "                          q_latent=q_latent,\n",
    "                          q_refresh=q_refresh,\n",
    "                          trash_training=trash_training,\n",
    "                          compile_program=compile_program,\n",
    "                          n_shots=n_shots, \n",
    "                          print_interval=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After defining the instance, we set up the Forest connection (in this case, a simulator)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "qae.setup_forest_cxn(cxn_setting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's split the data set into training and test set. If we don't input the argument `train_indices`, the data set will be randomly split. However, knowing our quantum data set, we may want to choose various regions along the PES (the energy curve shown above) to train the entire function. Here, we pick 6 out of 40 data points for our training set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "qae.train_test_split(train_indices=[3, 10, 15, 20, 30, 35])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's print some information about the QAE instance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "QCompress Setting\n",
      "=================\n",
      "QAE type: 4-1-4\n",
      "Data size: 40\n",
      "Training set size: 6\n",
      "Training mode: halfway cost function\n",
      "Compile program: False\n",
      "Forest connection: 4q-qvm\n",
      "  Connection type: QVM\n"
     ]
    }
   ],
   "source": [
    "print(qae)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "The autoencoder is trained in the cell below, where the default optimization algorithm is Constrained Optimization BY Linear Approximation (COBYLA). The lowest possible mean loss value is -1.000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter    0 Mean Loss: -0.0000000\n",
      "Iter    1 Mean Loss: -0.0000000\n",
      "Iter    2 Mean Loss: -0.0011667\n",
      "Iter    3 Mean Loss: -0.0043333\n",
      "Iter    4 Mean Loss: -0.0111667\n",
      "Iter    5 Mean Loss: -0.0157778\n",
      "Iter    6 Mean Loss: -0.0258889\n",
      "Iter    7 Mean Loss: -0.0393889\n",
      "Iter    8 Mean Loss: -0.0510556\n",
      "Iter    9 Mean Loss: -0.0647778\n",
      "Iter   10 Mean Loss: -0.0860556\n",
      "Iter   11 Mean Loss: -0.1017778\n",
      "Iter   12 Mean Loss: -0.1266111\n",
      "Iter   13 Mean Loss: -0.1475000\n",
      "Iter   14 Mean Loss: -0.1716667\n",
      "Iter   15 Mean Loss: -0.2078889\n",
      "Iter   16 Mean Loss: -0.2444444\n",
      "Iter   17 Mean Loss: -0.2815000\n",
      "Iter   18 Mean Loss: -0.3136667\n",
      "Iter   19 Mean Loss: -0.3497778\n",
      "Iter   20 Mean Loss: -0.3960556\n",
      "Iter   21 Mean Loss: -0.4407778\n",
      "Iter   22 Mean Loss: -0.4816667\n",
      "Iter   23 Mean Loss: -0.5263333\n",
      "Iter   24 Mean Loss: -0.5710556\n",
      "Iter   25 Mean Loss: -0.6225000\n",
      "Iter   26 Mean Loss: -0.6395556\n",
      "Iter   27 Mean Loss: -0.6777778\n",
      "Iter   28 Mean Loss: -0.7205556\n",
      "Iter   29 Mean Loss: -0.7716667\n",
      "Iter   30 Mean Loss: -0.7977222\n",
      "Iter   31 Mean Loss: -0.8250556\n",
      "Iter   32 Mean Loss: -0.8601111\n",
      "Iter   33 Mean Loss: -0.8893333\n",
      "Iter   34 Mean Loss: -0.9110556\n",
      "Iter   35 Mean Loss: -0.9350556\n",
      "Iter   36 Mean Loss: -0.9600000\n",
      "Iter   37 Mean Loss: -0.9718333\n",
      "Iter   38 Mean Loss: -0.9843333\n",
      "Iter   39 Mean Loss: -0.9901111\n",
      "Iter   40 Mean Loss: -0.9892222\n",
      "Iter   41 Mean Loss: -0.9955556\n",
      "Iter   42 Mean Loss: -0.9981111\n",
      "Iter   43 Mean Loss: -0.9992222\n",
      "Iter   44 Mean Loss: -1.0000000\n",
      "Iter   45 Mean Loss: -0.9997222\n",
      "Iter   46 Mean Loss: -0.9996667\n",
      "Iter   47 Mean Loss: -1.0000000\n",
      "Iter   48 Mean Loss: -1.0000000\n",
      "Iter   49 Mean Loss: -1.0000000\n",
      "Iter   50 Mean Loss: -1.0000000\n",
      "Iter   51 Mean Loss: -1.0000000\n",
      "Iter   52 Mean Loss: -1.0000000\n",
      "Mean loss for training data: -1.0\n",
      "CPU times: user 3.74 s, sys: 78.5 ms, total: 3.82 s\n",
      "Wall time: 2min 17s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "initial_guess = [pi/2., 0.]\n",
    "avg_loss_train = qae.train(initial_guess)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing the optimized parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.1337883  3.14026142]\n"
     ]
    }
   ],
   "source": [
    "print(qae.optimized_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot training losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(6, 4))\n",
    "plt.plot(qae.train_history, 'o-', linewidth=1)\n",
    "plt.title(\"Training Loss\", fontsize=16)\n",
    "plt.xlabel(\"Function Evaluation\",fontsize=20)\n",
    "plt.ylabel(\"Loss Value\", fontsize=20)\n",
    "plt.xticks(fontsize=16)\n",
    "plt.yticks(fontsize=16)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing\n",
    "\n",
    "Now test the optimized network against the rest of the data set (i.e. use the optimized parameters to try to compress then recover each test data point)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter   53 Mean Loss: -0.9999804\n",
      "Mean loss for test data: -0.9999803921568627\n"
     ]
    }
   ],
   "source": [
    "avg_loss_test = qae.predict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}