noisy_experiment_BOW.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm\n",
    "from qiskit import IBMQ\n",
    "from lambeq import TketModel\n",
    "from discopy.rigid import Spider\n",
    "from lambeq import spiders_reader\n",
    "from discopro.grammar import tensor\n",
    "from lambeq import Rewriter, Dataset\n",
    "from qiskit_aer.noise import NoiseModel\n",
    "from pytket.extensions.qiskit import AerBackend\n",
    "from lambeq import AtomicType, IQPAnsatz, remove_cups\n",
    "from discopro.anaphora import connect_anaphora_on_top\n",
    "from lambeq import BobcatParser, NumpyModel, AtomicType\n",
    "from lambeq import QuantumTrainer, SPSAOptimizer, BinaryCrossEntropyLoss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parser = BobcatParser()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rewriter = Rewriter(['auxiliary','connector','coordination','determiner','object_rel_pronoun',\n",
    "                        'subject_rel_pronoun','postadverb','preadverb','prepositional_phrase'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = AtomicType.NOUN\n",
    "S = AtomicType.SENTENCE\n",
    "P = AtomicType.PREPOSITIONAL_PHRASE\n",
    "\n",
    "ansatz = IQPAnsatz({N: 1, S: 1, P:1}, n_layers=1, n_single_qubit_params=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_diagram(diagram, pro, ref):\n",
    "\n",
    "    pro_box_idx = next(i for i, box in enumerate(diagram.boxes) if box.name.casefold() == pro.casefold())\n",
    "    ref_box_idx = next(i for i, box in enumerate(diagram.boxes) if box.name.casefold() == ref.casefold())\n",
    "    final_diagram = connect_anaphora_on_top(diagram, pro_box_idx, ref_box_idx)\n",
    "    rewritten_diagram = rewriter(remove_cups(final_diagram)).normal_form()\n",
    "\n",
    "    return rewritten_diagram"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def anaphoraSent2dig(sentence1, sentence2, pro, ref):\n",
    "\n",
    "    diagram1 = spiders_reader.sentence2diagram(sentence1)\n",
    "    diagram2 = spiders_reader.sentence2diagram(sentence2)\n",
    "\n",
    "    diagram = tensor(diagram1,diagram2)\n",
    "    diagram = diagram >> Spider(2, 1, S)\n",
    "\n",
    "    diag = generate_diagram(diagram, pro, ref)\n",
    "\n",
    "    return diag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_diag_labels(df):\n",
    "\n",
    "    circuits, labels, diagrams = [],[],[]\n",
    "\n",
    "    for i, row in tqdm(df.iterrows(), total=len(df)):\n",
    "\n",
    "        l = row['label']\n",
    "        ref = row['referent']\n",
    "\n",
    "        label = [1.0, 0.0] if l == 1 else [0.0, 1.0]\n",
    "        sent1, sent2, pro = row[['sent1', 'sent2', 'pronoun']]\n",
    "\n",
    "        try:\n",
    "            diagram = anaphoraSent2dig(sent1.strip(), sent2.strip(), pro.strip(), ref.strip())\n",
    "            diagrams.append(diagram)\n",
    "            discopy_circuit = ansatz(diagram)\n",
    "            circuits.append(discopy_circuit)\n",
    "            labels.append(label)\n",
    "        except Exception as e:\n",
    "            # Print an error message if an exception occurs\n",
    "            print(\"An error occurred:\", e)\n",
    "\n",
    "    return circuits, labels, diagrams"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_csv('train.csv', index_col=0)\n",
    "df_val = pd.read_csv('val.csv', index_col=0)\n",
    "df_test = pd.read_csv('test.csv', index_col=0)\n",
    "\n",
    "train_circuits, train_labels, train_diagrams = generate_diag_labels(df_train)\n",
    "val_circuits, val_labels, val_diagrams = generate_diag_labels(df_val)\n",
    "test_circuits, test_labels, test_diagrams = generate_diag_labels(df_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MY_API_TOKEN = ''\n",
    "IBMQ.save_account(MY_API_TOKEN)\n",
    "provider = IBMQ.load_account()\n",
    "backend = provider.get_backend('ibm_lagos')\n",
    "noise_model = NoiseModel.from_backend(backend)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_circuits = train_circuits + val_circuits + test_circuits\n",
    "\n",
    "backend = AerBackend()\n",
    "\n",
    "backend_config = {\n",
    " 'backend': backend,\n",
    " 'compilation': backend.default_compilation_pass(2),\n",
    " 'shots': 8192,\n",
    " 'noise_model':noise_model\n",
    "}\n",
    "\n",
    "model = TketModel.from_diagrams(all_circuits, backend_config=backend_config)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bce = BinaryCrossEntropyLoss()\n",
    "acc = lambda y_hat, y: np.sum(np.round(y_hat) == y) / len(y) / 2  # half due to double-counting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 36\n",
    "EPOCHS = 1000\n",
    "SEED = 0 # 1, 42, 100, 200\n",
    "\n",
    "trainer = QuantumTrainer(\n",
    "    model,\n",
    "    loss_function=bce,\n",
    "    epochs=EPOCHS,\n",
    "    optimizer=SPSAOptimizer,\n",
    "    optim_hyperparams={'a': 0.05, 'c': 0.06, 'A':0.05*EPOCHS},\n",
    "    evaluate_functions={'acc': acc},\n",
    "    evaluate_on_train=True,\n",
    "    verbose = 'text',\n",
    "    seed=SEED\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = Dataset(\n",
    "            train_circuits,\n",
    "            train_labels,\n",
    "            batch_size=BATCH_SIZE)\n",
    "\n",
    "val_dataset = Dataset(val_circuits, val_labels, shuffle=False)\n",
    "trainer.fit(train_dataset, val_dataset, evaluation_step=1, logging_step=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ((ax_tl, ax_tr), (ax_bl, ax_br)) = plt.subplots(2, 2, sharex=True, sharey='row', figsize=(10, 6))\n",
    "ax_tl.set_title('Training set')\n",
    "ax_tr.set_title('Development set')\n",
    "ax_bl.set_xlabel('Iterations')\n",
    "ax_br.set_xlabel('Iterations')\n",
    "ax_bl.set_ylabel('Accuracy')\n",
    "ax_tl.set_ylabel('Loss')\n",
    "\n",
    "colours = iter(plt.rcParams['axes.prop_cycle'].by_key()['color'])\n",
    "ax_tl.plot(trainer.train_epoch_costs, color=next(colours))\n",
    "ax_bl.plot(trainer.train_results['acc'], color=next(colours))\n",
    "ax_tr.plot(trainer.val_costs, color=next(colours))\n",
    "ax_br.plot(trainer.val_results['acc'], color=next(colours))\n",
    "\n",
    "# print test accuracy\n",
    "test_acc = acc(model(test_circuits), test_labels)\n",
    "print('Test accuracy:', test_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch-gpu",
   "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.8.13"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}