Q_Random_No.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 596
        },
        "id": "zxaKc3itTU1H",
        "outputId": "e0100b85-8fc9-4f43-b938-19ae4c0066db"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0, Loss: 0.9670284390449524, Accuracy: 0.5054166666666666\n",
            "Epoch 10, Loss: 0.7296294569969177, Accuracy: 0.6364583333333333\n",
            "Epoch 20, Loss: 0.6310625672340393, Accuracy: 0.6652083333333333\n",
            "Epoch 30, Loss: 0.33748117089271545, Accuracy: 0.6933333333333334\n",
            "Training is complete!\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA04AAAHWCAYAAABACtmGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbw0lEQVR4nO3dd3QUddvG8Ws3PaRQAgklEAmQUCQgJQakqEgoolhRH6VYUAQEscGDggXF8qiIoCh2LKBIUUMVpYP0ntBJaEkIJQkJabvz/oHkNRI2BJJMyvdzzp7jzv5m917Gdb2Y2fu2GIZhCAAAAABwSVazCwAAAACA0o7gBAAAAAAFIDgBAAAAQAEITgAAAABQAIITAAAAABSA4AQAAAAABSA4AQAAAEABCE4AAAAAUACCEwAAAAAUgOAEACg1+vfvr6CgoCva9+WXX5bFYinaggAA+BvBCQBQIIvFclm3pUuXml2qKfr37y8vLy+zywAAFCOLYRiG2UUAAEq3b7/9Ns/9b775RosXL9a0adPybL/lllvk7+9/xa+TnZ0tu90uNze3Qu+bk5OjnJwcubu7X/HrX6n+/ftr5syZOnv2bIm/NgCgZDibXQAAoPR78MEH89xfu3atFi9efNH2f0tPT5enp+dlv46Li8sV1SdJzs7Ocnbmaw0AUDy4VA8AUCQ6d+6sZs2aaePGjerYsaM8PT313//+V5I0d+5c9ezZU7Vq1ZKbm5uCg4P12muvyWaz5XmOf//G6dChQ7JYLPrf//6nTz/9VMHBwXJzc1ObNm20fv36PPvm9xsni8WiIUOGaM6cOWrWrJnc3NzUtGlTLViw4KL6ly5dqtatW8vd3V3BwcH65JNPivx3Uz/99JNatWolDw8P+fn56cEHH9TRo0fzrImPj9eAAQNUp04dubm5qWbNmrr99tt16NCh3DUbNmxQZGSk/Pz85OHhoWuuuUYPP/xwkdUJALgYfzUHACgyJ0+eVPfu3XXffffpwQcfzL1s76uvvpKXl5dGjBghLy8v/fHHHxozZoxSUlL0zjvvFPi833//vVJTU/X444/LYrHo7bff1p133qkDBw4UeJZq5cqVmjVrlp588kl5e3tr4sSJuuuuuxQXF6dq1apJkjZv3qxu3bqpZs2aeuWVV2Sz2fTqq6+qevXqV/+H8revvvpKAwYMUJs2bTR+/HglJCTogw8+0KpVq7R582ZVrlxZknTXXXdp586dGjp0qIKCgpSYmKjFixcrLi4u937Xrl1VvXp1jRw5UpUrV9ahQ4c0a9asIqsVAJAPAwCAQho8eLDx76+QTp06GZKMKVOmXLQ+PT39om2PP/644enpaWRkZORu69evn1GvXr3c+wcPHjQkGdWqVTNOnTqVu33u3LmGJOPXX3/N3TZ27NiLapJkuLq6Gvv27cvdtnXrVkOS8eGHH+Zu69Wrl+Hp6WkcPXo0d9vevXsNZ2fni54zP/369TMqVap0ycezsrKMGjVqGM2aNTPOnTuXu/23334zJBljxowxDMMwTp8+bUgy3nnnnUs+1+zZsw1Jxvr16wusCwBQdLhUDwBQZNzc3DRgwICLtnt4eOT+c2pqqpKSktShQwelp6crJiamwOft06ePqlSpknu/Q4cOkqQDBw4UuG+XLl0UHByce7958+by8fHJ3ddms+n3339X7969VatWrdx1DRo0UPfu3Qt8/suxYcMGJSYm6sknn8zTvKJnz54KDQ1VVFSUpPN/Tq6urlq6dKlOnz6d73NdODP122+/KTs7u0jqAwAUjOAEACgytWvXlqur60Xbd+7cqTvuuEO+vr7y8fFR9erVcxtLJCcnF/i8devWzXP/Qoi6VLhwtO+F/S/sm5iYqHPnzqlBgwYXrctv25WIjY2VJIWEhFz0WGhoaO7jbm5ueuuttzR//nz5+/urY8eOevvttxUfH5+7vlOnTrrrrrv0yiuvyM/PT7fffru+/PJLZWZmFkmtAID8EZwAAEXmn2eWLjhz5ow6deqkrVu36tVXX9Wvv/6qxYsX66233pIk2e32Ap/Xyckp3+3GZUzUuJp9zTB8+HDt2bNH48ePl7u7u1566SU1btxYmzdvlnS+4cXMmTO1Zs0aDRkyREePHtXDDz+sVq1a0Q4dAIoRwQkAUKyWLl2qkydP6quvvtKwYcN06623qkuXLnkuvTNTjRo15O7urn379l30WH7brkS9evUkSbt3777osd27d+c+fkFwcLCeeeYZLVq0SDt27FBWVpbefffdPGuuv/56vf7669qwYYO+++477dy5U9OnTy+SegEAFyM4AQCK1YUzPv88w5OVlaWPPvrIrJLycHJyUpcuXTRnzhwdO3Ysd/u+ffs0f/78InmN1q1bq0aNGpoyZUqeS+rmz5+v6Oho9ezZU9L5uVcZGRl59g0ODpa3t3fufqdPn77obFmLFi0kicv1AKAY0Y4cAFCs2rVrpypVqqhfv3566qmnZLFYNG3atFJ1qdzLL7+sRYsWqX379ho0aJBsNpsmTZqkZs2aacuWLZf1HNnZ2Ro3btxF26tWraonn3xSb731lgYMGKBOnTrp/vvvz21HHhQUpKefflqStGfPHt18882699571aRJEzk7O2v27NlKSEjQfffdJ0n6+uuv9dFHH+mOO+5QcHCwUlNTNXXqVPn4+KhHjx5F9mcCAMiL4AQAKFbVqlXTb7/9pmeeeUYvvviiqlSpogcffFA333yzIiMjzS5PktSqVSvNnz9fzz77rF566SUFBgbq1VdfVXR09GV1/ZPOn0V76aWXLtoeHBysJ598Uv3795enp6fefPNNvfDCC6pUqZLuuOMOvfXWW7md8gIDA3X//fdryZIlmjZtmpydnRUaGqoff/xRd911l6TzzSHWrVun6dOnKyEhQb6+vmrbtq2+++47XXPNNUX2ZwIAyMtilKa/8gMAoBTp3bu3du7cqb1795pdCgDAZPzGCQAASefOnctzf+/evZo3b546d+5sTkEAgFKFM04AAEiqWbOm+vfvr/r16ys2NlYff/yxMjMztXnzZjVs2NDs8gAAJuM3TgAASOrWrZt++OEHxcfHy83NTREREXrjjTcITQAASZxxAgAAAIAC8RsnAAAAACgAwQkAAAAAClDhfuNkt9t17NgxeXt7y2KxmF0OAAAAAJMYhqHU1FTVqlVLVqvjc0oVLjgdO3ZMgYGBZpcBAAAAoJQ4fPiw6tSp43BNhQtO3t7eks7/4fj4+JhcDQAAAACzpKSkKDAwMDcjOFLhgtOFy/N8fHwITgAAAAAu6yc8NIcAAAAAgAIQnAAAAACgAAQnAAAAACgAwQkAAAAACkBwAgAAAIACEJwAAAAAoAAEJwAAAAAoAMEJAAAAAApAcAIAAACAAhCcAAAAAKAABCcAAAAAKADBCQAAAAAKQHAykWEYSsvMMbsMAAAAAAUgOJlo6e4T6vD2n5q25pBybHazywEAAABwCQQnE01fH6dTaVl6ae5Odftghf6MSZRhGGaXBQAAAOBfCE4mmvTAdXrt9qaqWslV+xLPasBX69X3i3WKiU8xuzQAAAAA/2AxKtgpjpSUFPn6+io5OVk+Pj5mlyNJSj6XrY/+3KcvVx1Sls0uq0Xq0yZQT9/SSDW83c0uDwAAACiXCpMNCE6lSNzJdL21IEZR249Lkiq5OmlQ52A92qG+3F2cTK4OAAAAKF8ITg6U5uB0wYZDp/RaVLS2Hj4jSarl667nu4XqtrBaslot5hYHAAAAlBMEJwfKQnCSJLvd0K/bjuntBbt19Mw5SVJYHV+9eGsTtQmqanJ1AAAAQNlHcHKgrASnCzKybfp85UF99Oc+pWXZJEk9rg3QC91CVa9aJZOrAwAAAMougpMDZS04XXAiNVPvLd6jGevjZDckVyer+rcP0uAbG8jXw8Xs8gAAAIAyh+DkQFkNThfExKfo9ahordibJEmq4umi4V0a6YHwunJxors8AAAAcLkITg6U9eAkSYZhaOmeE3ojKlp7E89KkupXr6TRPRrrptAaslhoIAEAAAAUhODkQHkIThfk2Oyavv6w3l+8RyfTsiRJ7RtU0+geTdSkVtl+bwAAAEBxIzg5UJ6C0wUpGdn66M/9+mLlQWXZ7LJYpHtbBeqZro1Uw4cBugAAAEB+CE4OlMfgdMHhU+cH6P627fwAXU9XJz3RKViPdagvD1cG6AIAAAD/RHByoDwHpws2xp7WuKhd2hx3RpIU4OOu57uFqHeL2gzQBQAAAP5GcHKgIgQn6XwDid+2Hdeb82NyB+heW9tXL/ZsrPD61UyuDgAAADAfwcmBihKcLsjItunLVYc0+c99OpuZI0nq1jRAI7uHKsiPAboAAACouAhODlS04HRB0tlMvb94j35Yd36ArouTRX0jgvTUTQ3l68kAXQAAAFQ8BCcHKmpwumBPQqremBetpbtPSJIqe7po2M0N9eD19RigCwAAgAqF4ORARQ9OFyzbc0KvR+3SnoS/B+j6VdKoHo3VpTEDdAEAAFAxEJwcIDj9vxybXT9uOKL3Fu9W0tnzA3Qj6lfT6J6N1ay2r8nVAQAAAMWL4OQAweliqRnZ+njpfn228qCycs4P0L37ujp6NjJE/gzQBQAAQDlFcHKA4HRpR06n652FuzV3yzFJkoeLkx7vVF8DO9aXp6uzydUBAAAARYvg5ADBqWCb405rXFS0NsaeliT5+7jpuchQ3dmSAboAAAAoPwhODhCcLo9hGJq3PV7j50fryOnzA3Sb1fbR6B5NFBHMAF0AAACUfQQnBwhOhZORbdPXqw9p0h/7lPr3AN2uTfw1qkdjXcMAXQAAAJRhBCcHCE5X5uTZTE34fa++Xxcnm92Qs9WihyLqadjNDVXZ09Xs8gAAAIBCIzg5QHC6OvsSU/XGvBj9EZMoSfL1cNFTNzfUQ9fXk6szA3QBAABQdhCcHCA4FY0Ve0/o9ahoxcSnSpKCqnlqVI/G6trEnwG6AAAAKBMITg4QnIqOzW7opw2H9b9Fe5R0NlOSFH5NVb10axMG6AIAAKDUIzg5QHAqemczczRl6X5NXXFAmX8P0L2jZW09Fxmimr4eZpcHAAAA5Ivg5ADBqfgcPXNO7yyI0Zy/B+i6u1g1sGOwHu9YX5XcGKALAACA0oXg5ADBqfhtPXxG46J2af2h8wN0a3i76dnIEN11XR05MUAXAAAApQTByQGCU8kwDEMLdsRr/PwYxZ1KlyQ1qemjF3s2VrsGfiZXBwAAABCcHCI4lazMHJu+WR2riX/sVWrG+QG6XRr7a1SPUAVX9zK5OgAAAFRkhckGpg/emTx5soKCguTu7q7w8HCtW7fukmuzs7P16quvKjg4WO7u7goLC9OCBQtKsFoUlpuzkx7rWF/LnrtR/dsFyclq0e/RCYp8f7le/mWnTqdlmV0iAAAAUCBTg9OMGTM0YsQIjR07Vps2bVJYWJgiIyOVmJiY7/oXX3xRn3zyiT788EPt2rVLTzzxhO644w5t3ry5hCtHYVWt5KqXb2uqhcM7qkvjGsqxG/pq9SF1eudPfbbigDJzbGaXCAAAAFySqZfqhYeHq02bNpo0aZIkyW63KzAwUEOHDtXIkSMvWl+rVi2NHj1agwcPzt121113ycPDQ99++22+r5GZmanMzMzc+ykpKQoMDORSPZOt2pekcVHRij6eIkmqV81To7qHKrJpAAN0AQAAUCLKxKV6WVlZ2rhxo7p06fL/xVit6tKli9asWZPvPpmZmXJ3d8+zzcPDQytXrrzk64wfP16+vr65t8DAwKJ5A7gq7Rv46behN+jtu5qrurebYk+m64lvN6nPJ2u17cgZs8sDAAAA8jAtOCUlJclms8nf3z/Pdn9/f8XHx+e7T2RkpN577z3t3btXdrtdixcv1qxZs3T8+PFLvs6oUaOUnJycezt8+HCRvg9cOSerRfe2CdTSZzvrqZsbyt3FqnWHTum2Sav09IwtOnbmnNklAgAAAJJKQXOIwvjggw/UsGFDhYaGytXVVUOGDNGAAQNktV76bbi5ucnHxyfPDaVLJTdnjbilkf58trPuvK62JGn25qO68X9L9e6i3UrLzDG5QgAAAFR0pgUnPz8/OTk5KSEhIc/2hIQEBQQE5LtP9erVNWfOHKWlpSk2NlYxMTHy8vJS/fr1S6JkFLOavh56794W+mVIe7W9pqoyc+z68I996vy/pZqxPk42e4XqnA8AAIBSxLTg5OrqqlatWmnJkiW52+x2u5YsWaKIiAiH+7q7u6t27drKycnRzz//rNtvv724y0UJal6nsmYMvF5THmyletU8dSI1Uy/8vF09J67Qyr1JZpcHAACACsjUrnozZsxQv3799Mknn6ht27aaMGGCfvzxR8XExMjf3199+/ZV7dq1NX78eEnSX3/9paNHj6pFixY6evSoXn75ZR08eFCbNm1S5cqVL+s1GYBbtmTl2PXNmkOauGSvUv4eoHtzaA2N6tFYDWowQBcAAABXrjDZwLmEaspXnz59dOLECY0ZM0bx8fFq0aKFFixYkNswIi4uLs/vlzIyMvTiiy/qwIED8vLyUo8ePTRt2rTLDk0oe1ydrXq0Q33ddV0dTfxjr6atidWSmEQt3XNC/wmvq+FdGqlqJVezywQAAEA5Z+oZJzNwxqlsO3DirMbPj9HiXed/G+ft7qyhNzVQv3ZBcnN2Mrk6AAAAlCWFyQYEJ5RJq/cnadxv0dr19wDdwKoeGtW9sbo3Y4AuAAAALg/ByQGCU/lhsxuatemI3lm4W4mpmZKk1vWq6MVbm6hFYGVziwMAAECpR3BygOBU/qRn5eiTZQf06fIDOpdtkyTd3qKWnu8WqtqVPUyuDgAAAKUVwckBglP5FZ+cof8t2q2fNx2RYUhuzlY92uEaDercQF5upvZBAQAAQClEcHKA4FT+7TiarHFRu7T2wClJkp+Xq57pGqJ7WwfKycrvnwAAAHAewckBglPFYBiGFu9K0Pj5MTqYlCZJCg3w1n97NFbHRtVNrg4AAAClAcHJAYJTxZKVY9d3f8Vqwu97lXwuW5LUOaS6RvdorIb+3iZXBwAAADMRnBwgOFVMZ9Kz9OEf+/TNmkPKthlyslp0f9tADe/SSH5ebmaXBwAAABMQnBwgOFVsB5PS9Ob8aC3c+fcAXTdnDb6pgfq3C5K7CwN0AQAAKhKCkwMEJ0jS2gMnNS5ql3YcPT9At04VD73QLVS3Nq/JAF0AAIAKguDkAMEJF9jthuZsOaq3F+xWfEqGJOm6upX14q1NdF3dKiZXBwAAgOJGcHKA4IR/O5dl09QVB/Tx0v25A3R7hdXS85EhCqzqaXJ1AAAAKC4EJwcITriUhJQMvbtot37aeH6ArquzVY/ccI2e7Bwsb3cXs8sDAABAESM4OUBwQkF2HkvW61HRWr3/pCSpWiVXjejaSH1aB8rZyWpydQAAACgqBCcHCE64HIZhaEl0ot6YF60Dfw/QbeTvpdE9m6gTA3QBAADKBYKTAwQnFEa2za7v1sZqwpK9OpN+foBux0bnB+iGBDBAFwAAoCwjODlAcMKVSE7P1qQ/9+qr1ecH6Fot0n1t6+rpLo1U3ZsBugAAAGURwckBghOuRuzJNL05P0bzd8RLkrzcnPXkjcF6uP01DNAFAAAoYwhODhCcUBTWHTylcVG7tO1IsiSpdmUPvdA9VL0YoAsAAFBmEJwcIDihqNjthuZuPT9A93jy+QG6LetW1os9m6hVPQboAgAAlHYEJwcITihq57Js+nzlAX20dL/Ss84P0O3ZvKZGdgtlgC4AAEApRnBygOCE4pKYkqH3Fu/RjA2Hzw/QdbJqwA1BGnxjA/kwQBcAAKDUITg5QHBCcdt1LEVvzIvWyn1JkqSqlVz19C2NdH8bBugCAACUJgQnBwhOKAmGYWjp7hMaF7VL+0+cH6DboIaXRvdorM4h1WkgAQAAUAoQnBwgOKEkZdvsmr4uTu//vlen0rIkSR0a+ml0z8YKDeDfPwAAADMRnBwgOMEMyeey9dGf+/TlqkPKstlltUh92gTq6VsaqYa3u9nlAQAAVEgEJwcITjBT3Ml0vbUgRlHbj0uSKrk66ckbG+iRGxigCwAAUNIITg4QnFAabDh0Sq9FRWvr4TOSpFq+7nq+W6huC6slq5XfPwEAAJQEgpMDBCeUFna7oV+3HdPbC3br6JlzkqSwOr568dYmahNU1eTqAAAAyj+CkwMEJ5Q2Gdk2fb7yoD76c5/S/h6g2+PaAI3s1lh1qzFAFwAAoLgQnBwgOKG0OpGaeX6A7vo42f8eoNu//fkBur4eDNAFAAAoagQnBwhOKO1i4lP0elS0Vuw9P0C3iqfL+QG6bevKhQG6AAAARYbg5ADBCWWBYRhauueE3oiK1t7Es5Kk+tUraXSPxroptAYDdAEAAIoAwckBghPKkhybXdPXH9b7i/fo5N8DdNs3qKbRPZqoSS3+/QUAALgaBCcHCE4oi1IysvXRn/v1xcqDyrLZZbFI97YK1DNdG6mGDwN0AQAArgTByQGCE8qyw6fOD9D9bdv5Abqerk4a1ClYj3aoLw9XBugCAAAUBsHJAYITyoONsac1LmqXNsedkSTV9HXXc5Eh6t2iNgN0AQAALhPByQGCE8oLwzD027bjenN+TO4A3Wtr++rFno0VXr+aydUBAACUfgQnBwhOKG8ysm36ctUhTf5zn85m5kiSujUN0MjuoQryq2RydQAAAKUXwckBghPKq6SzmXp/8R79sO78AF0XJ4v6RQRp6E0N5evJAF0AAIB/Izg5QHBCebcnIVVvzIvW0t0nJEmVPV007OaGevD6egzQBQAA+AeCkwMEJ1QUy/ac0OtRu7Qn4e8Bun6VNKpHY3VpzABdAAAAieDkEMEJFUmOza4fNxzRe4t3K+ns+QG6EfWraXTPxmpW29fk6gAAAMxFcHKA4ISKKDUjWx8v3a/PVh5UVs75Abp3X1dHz0aGyJ8BugAAoIIqTDYw/QcPkydPVlBQkNzd3RUeHq5169Y5XD9hwgSFhITIw8NDgYGBevrpp5WRkVFC1QJlk7e7i57vFqo/numk21vUkmFIP208os7vLNUHv+9VelaO2SUCAACUaqYGpxkzZmjEiBEaO3asNm3apLCwMEVGRioxMTHf9d9//71GjhypsWPHKjo6Wp9//rlmzJih//73vyVcOVA21aniqQ/ua6nZT7ZTq3pVdC7bpvd/36Ob/rdMP288Iru9Qp2ABgAAuGymXqoXHh6uNm3aaNKkSZIku92uwMBADR06VCNHjrxo/ZAhQxQdHa0lS5bkbnvmmWf0119/aeXKlZf1mlyqB5xnGIbmbY/X+PnROnL6/ADdZrV9NLpHE0UEM0AXAACUf2XiUr2srCxt3LhRXbp0+f9irFZ16dJFa9asyXefdu3aaePGjbmX8x04cEDz5s1Tjx49Lvk6mZmZSklJyXMDIFksFvVsXlO/j+ikUd1D5e3mrB1HU3T/1LUa+M0GHUxKM7tEAACAUsO04JSUlCSbzSZ/f/882/39/RUfH5/vPg888IBeffVV3XDDDXJxcVFwcLA6d+7s8FK98ePHy9fXN/cWGBhYpO8DKOvcXZz0eKdgLX2usx66vp6crBYt2pWgW95bpld/3aUz6VlmlwgAAGA605tDFMbSpUv1xhtv6KOPPtKmTZs0a9YsRUVF6bXXXrvkPqNGjVJycnLu7fDhwyVYMVB2VPNy02u9m2nh8A66KbSGcuyGvlh1UJ3eWarP/+7GBwAAUFGZ9hunrKwseXp6aubMmerdu3fu9n79+unMmTOaO3fuRft06NBB119/vd55553cbd9++60GDhyos2fPymotOAfyGyfg8qzYe0KvR0UrJj5VkhRUzVOjejRW1yb+DNAFAADlQpn4jZOrq6tatWqVp9GD3W7XkiVLFBERke8+6enpF4UjJycnSed/6A6g6HRoWF1RT3XQm3deKz8vNx06ma7Hp23UfZ+u1Y6jyWaXBwAAUKJMvVRvxIgRmjp1qr7++mtFR0dr0KBBSktL04ABAyRJffv21ahRo3LX9+rVSx9//LGmT5+ugwcPavHixXrppZfUq1ev3AAFoOg4WS26r21dLX2us4bc2EBuzlb9dfCUek1aqWd+3Kr4ZGaoAQCAisHZzBfv06ePTpw4oTFjxig+Pl4tWrTQggULchtGxMXF5TnD9OKLL8pisejFF1/U0aNHVb16dfXq1Uuvv/66WW8BqBC83Jz1bGSI7g+vq3cWxGjOlmP6edMRRW0/poEdg/V4x/qq5Gbqf04AAACKlalznMzAb5yAq7f18BmNi9ql9YdOS5JqeLvp2cgQ3XVdHTlZ+f0TAAAoGwqTDQhOAK6IYRhasCNe4+fHKO5UuiSpSU0fvdizsdo18DO5OgAAgIIRnBwgOAFFKzPHpm9Wx2riH3uVmpEjSerS2F+jeoQquLqXydUBAABcGsHJAYITUDxOpWVp4pK9mrY2Vja7IWerRQ9eX0/Dbm6oKpVczS4PAADgIgQnBwhOQPHal3hWb86P1u/RiZIkH3dnPXVzQ/WNCJKrc5mauQ0AAMo5gpMDBCegZKzal6RxUdGKPp4iSapXzVOjuocqsmkAA3QBAECpQHBygOAElByb3dDPG4/onUW7dSI1U5LUNqiqXry1sZrXqWxucQAAoMIjODlAcAJKXlpmjj5ZfkCfLt+vjGy7JOnOlrX1bGSIalX2MLk6AABQURGcHCA4AeY5nnxO7yzcrVmbjkqS3F2sGtihvh7vFMwAXQAAUOIITg4QnADzbTtyRuOiorXu4ClJUnVvNz3btZHubhXIAF0AAFBiCE4OEJyA0sEwDC3cmaDx86MVe/L8AN3QAG+9dGsTtWeALgAAKAEEJwcITkDpkpVj1zdrDmnikr1K+XuA7s2hNTSqR2M1qMEAXQAAUHwITg4QnIDS6XRalib+sVfT1sQqx27IyWrRg+F1NaxLI1VlgC4AACgGBCcHCE5A6XbgxFmNnx+jxbsSJEne7s4aelMD9WsXJDdnJ5OrAwAA5QnByQGCE1A2rN6fpHG/RWvX3wN0A6t6aFT3xurejAG6AACgaBCcHCA4AWWHzW5o1qYjemfhbiX+PUC3db0qevHWJmoRWNnc4gAAQJlHcHKA4ASUPelZOfpk2QF9uvyAzmXbJEm9W9TSc91CVZsBugAA4AoRnBwgOAFlV3xyhv63aLd+3nREhiG5OVv1aIdrNKhzA3kxQBcAABQSwckBghNQ9u04mqxxUbu09sD5Abp+Xm56pmsj3duaAboAAODyEZwcIDgB5YNhGFq8K0Hj58foYFKapPMDdEf3bKwODaubXB0AACgLCE4OEJyA8iUrx65v18bqgyV7lXwuW5J0Y0h1/bdHYzX09za5OgAAUJoRnBwgOAHl05n0LH34xz59s+aQsm3nB+je3zZQT3dppGpebmaXBwAASiGCkwMEJ6B8O5iUpjfnR2vhzr8H6Lo5a/BNDdS/XZDcXRigCwAA/h/ByQGCE1AxrD1wUuOidmnH0fMDdOtU8dDI7qHqeW1NBugCAABJBCeHCE5AxWG3G5qz5ajeXrBb8SkZkqTr6lbWi7c20XV1q5hcHQAAMBvByQGCE1DxnMuyaeqKA/p46f7cAbq3hdXS891CVKeKp8nVAQAAsxCcHCA4ARVXQkqG3l20Wz9tPD9A19XZqkduuEZPdg6Wt7uL2eUBAIASRnBygOAEYOexZL0eFa3V+09KkqpVctWIro3Up3WgnJ2sJlcHAABKCsHJAYITAOn8AN0l0Yl6Y160Dvw9QLeRv5dG92yiTo0YoAsAQEVAcHKA4ATgn7Jtdn23NlYTluzVmfTzA3Q7Naqu0T0bqxEDdAEAKNcITg4QnADkJzk9W5P+3KuvVp8foGu1SPe1raunuzRSdW8G6AIAUB4RnBwgOAFwJPZkmt6cH6P5O+IlSV5uznryxmA93P4aBugCAFDOEJwcIDgBuBzrDp7SuKhd2nYkWZJU09ddnUNqqE1QFbUJqqo6VTwYpAsAQBlHcHKA4ATgctnthuZuPT9A93hyRp7Hani7qU1QVbX+O0iFBnjTkQ8AgDKG4OQAwQlAYWVk27R8zwltjD2t9YdOafvRZGXb8v6ns5Krk1rWrZIbpFoEVlYlN2eTKgYAAJeD4OQAwQnA1crItmnbkWStP3RKGw6d0obY00rNyMmzxslqUZOaPmodVEWt61VVm6AqquHjblLFAAAgPwQnBwhOAIqa3W5ob+LZ3CC1/tBpHT1z7qJ1dat65glSwdW9ZLXyOykAAMxCcHKA4ASgJBxPPqcNh07nBqmY+BTZ//Vf28qeLmpdr4pa/R2krq3jKzdnOvcBAFBSCE4OEJwAmCE1I1ub487kBqkth8/oXLYtzxpXZ6vC6vjmBqlW9aqosqerSRUDAFD+EZwcIDgBKA2ybXbtOpby9+V9p7Uh9rSSzmZetK5hDS+1DqpKG3QAAIoBwckBghOA0sgwDMWeTP9HkDql/SfSLlr3zzboretVVeOatEEHAOBKEZwcIDgBKCtOns3UxtjTDtuge7o66bq/26C3rldVLevSBh0AgMtFcHKA4ASgrMrItmnr4TPaEHuaNugAABQBgpMDBCcA5YXdbmhPYmqe7n20QQcA4PIRnBwgOAEoz2iDDgDA5SM4OUBwAlCRXG4b9Oa1fXO799EGHQBQUZS54DR58mS98847io+PV1hYmD788EO1bds237WdO3fWsmXLLtreo0cPRUVFFfhaBCcAFdmVtEFvXa+qAqvSBh0AUP6UqeA0Y8YM9e3bV1OmTFF4eLgmTJign376Sbt371aNGjUuWn/q1CllZWXl3j958qTCwsL02WefqX///gW+HsEJAP4fbdABABVZmQpO4eHhatOmjSZNmiRJstvtCgwM1NChQzVy5MgC958wYYLGjBmj48ePq1KlSgWuJzgBgGO0QQcAVBSFyQamfstlZWVp48aNGjVqVO42q9WqLl26aM2aNZf1HJ9//rnuu+++S4amzMxMZWb+/2UoKSkpV1c0AJRz1bzc1LVpgLo2DZB06TboK/claeW+JEm0QQcAlH+mBqekpCTZbDb5+/vn2e7v76+YmJgC91+3bp127Nihzz///JJrxo8fr1deeeWqawWAisrdxUnh9aspvH41SZdug779aLK2H03Wl6sOSfq7DXq9Krm/laINOgCgLCvT11V8/vnnuvbaay/ZSEKSRo0apREjRuTeT0lJUWBgYEmUBwDlktVqUWiAj0IDfPTg9fUk5d8GPe5UuuJOpWvW5qOSzrdBb1X3/4MUbdABAGWJqcHJz89PTk5OSkhIyLM9ISFBAQEBDvdNS0vT9OnT9eqrrzpc5+bmJjc3t6uuFQBwaTV9PdQrzEO9wmpJyr8N+pn0bC2JSdSSmERJtEEHAJQtpgYnV1dXtWrVSkuWLFHv3r0lnW8OsWTJEg0ZMsThvj/99JMyMzP14IMPlkClAIDC8HZ3UcdG1dWxUXVJl26DviH2/D9P+XvKBG3QAQClleld9WbMmKF+/frpk08+Udu2bTVhwgT9+OOPiomJkb+/v/r27avatWtr/Pjxefbr0KGDateurenTpxfq9eiqBwDmow06AKA0KDNd9SSpT58+OnHihMaMGaP4+Hi1aNFCCxYsyG0YERcXJ6s175fk7t27tXLlSi1atMiMkgEAV8lisSjIr5KC/Crpntbnf3eaXxv0xNRMRW0/rqjtxyXRBh0AYB7TzziVNM44AUDZcKk26P90oQ16q3pVcs9M+dMGHQBwmcrUANySRnACgLLpUm3Q/4026ACAy0VwcoDgBADlR35t0O3/+lajDToA4FIITg4QnACg/Pp3G/TNh08rI9ueZw1t0AEAFxCcHCA4AUDFcXEb9FNKOpt10TraoANAxURwcoDgBAAVF23QAQD/RHBygOAEAPin/NqgZ9vyfjVeaIN+oXsfbdABoHwgODlAcAIAOEIbdACoOAhODhCcAACFQRt0ACi/ij04HT58WBaLRXXq1JEkrVu3Tt9//72aNGmigQMHXlnVJYTgBAC4WrRBB4DyodiDU4cOHTRw4EA99NBDio+PV0hIiJo2baq9e/dq6NChGjNmzBUXX9wITgCAokYbdAAom4o9OFWpUkVr165VSEiIJk6cqBkzZmjVqlVatGiRnnjiCR04cOCKiy9uBCcAQHErbBv01n//Voo26ABQsgqTDa6oJVB2drbc3NwkSb///rtuu+02SVJoaKiOHz9+JU8JAEC54eJkVVhgZYUFVtajHS7dBn1v4lntTTyrH9bFSfr/NugXmk7QBh0ASo8rOuMUHh6uG2+8UT179lTXrl21du1ahYWFae3atbr77rt15MiR4qi1SHDGCQBQGlxog36hex9t0AGg5BX7pXpLly7VHXfcoZSUFPXr109ffPGFJOm///2vYmJiNGvWrCurvAQQnAAApRFt0AGg5JVIO3KbzaaUlBRVqVIld9uhQ4fk6empGjVqXMlTlgiCEwCgLKANOgAUv2IPTufOnZNhGPL09JQkxcbGavbs2WrcuLEiIyOvrOoSQnACAJRVl9MG3dfDJU+QalbbV+4utEEHgPwUe3Dq2rWr7rzzTj3xxBM6c+aMQkND5eLioqSkJL333nsaNGjQFRdf3AhOAIDy4rLaoDtZ1bwObdABID/FHpz8/Py0bNkyNW3aVJ999pk+/PBDbd68WT///LPGjBmj6OjoKy6+uBGcAADlFW3QAaBwir0deXp6ury9vSVJixYt0p133imr1arrr79esbGxV/KUAADgKtEGHQCKzxUFpwYNGmjOnDm64447tHDhQj399NOSpMTERM7iAABQSlgsFgX5VVKQXyXd0zpQUv5t0BNTMxW1/biitp+fxUgbdAC42BVdqjdz5kw98MADstlsuummm7R48WJJ0vjx47V8+XLNnz+/yAstKlyqBwDA/6MNOoCKrETakcfHx+v48eMKCwuT1Xr+dP66devk4+Oj0NDQK3nKEkFwAgDg0i60QV9/6LQ2OmiDHljVQ23qVaUNOoAyrUSC0wVHjhyRJNWpU+dqnqbEEJwAACicY2fOaUPs/wcp2qADKC+KPTjZ7XaNGzdO7777rs6ePStJ8vb21jPPPKPRo0fnnoEqjQhOAABcHdqgAygvir2r3ujRo/X555/rzTffVPv27SVJK1eu1Msvv6yMjAy9/vrrV/K0AACgDPB2d1HHRtXVsVF1SZdug77h7yYUU5ad34826ADKsis641SrVi1NmTJFt912W57tc+fO1ZNPPqmjR48WWYFFjTNOAAAUr0u1Qf832qADMFuxX6rn7u6ubdu2qVGjRnm27969Wy1atNC5cxf/iLS0IDgBAFDy8muDnm3L+78gnq5Oalm3slrXq0obdAAlotiDU3h4uMLDwzVx4sQ824cOHap169bpr7/+KuxTlhiCEwAA5rvcNuiNa3rnBinaoAMoasUenJYtW6aePXuqbt26ioiIkCStWbNGhw8f1rx589ShQ4crq7wEEJwAACh9aIMOwAwl0o782LFjmjx5smJiYiRJjRs31sCBAzVu3Dh9+umnV/KUJYLgBABA2fDvNujR8Sn69/+1/LMNeuugKrqWNugACqFE5zj909atW3XdddfJZrMV1VMWOYITAABlU8rfbdA3OmiD7uPurJdva6o7WtamYx+AAhV7O3IAAICS5uPuok6NqqvTP9qg7zyWcv43Uv9ogz7ix636PTpBr/e+VlUqMTsKQNEgOAEAgDLJxcmqFoGV1SKwsh7tIOXY7JqybL8m/L5X87bHa/2h03rn7ubqHFLD7FIBlAMMSwAAAOWCs5NVQ25qqNlPtldw9Uo6kZqp/l+u10tzdig9K6fgJwAABwr1G6c777zT4eNnzpzRsmXL+I0TAAAwVUa2TW/Oj9FXqw9Jkq7xq6T37g1Ty7pVzC0MQKlSbL9x8vX1LfDxvn37FuYpAQAAipy7i5Nevq2pujT217M/bdXBpDTdPWWNhtzYQENuaiAXJy66AVA4RdpVryzgjBMAABVLcnq2Xpy7Q79uPSZJCqvjq/f6tFBwdS+TKwNgtsJkA/66BQAAlGu+ni768P6W+uC+FvJxd9bWI8nqOXGFpq05pAr298cArgLBCQAAVAi3t6ithU93VPsG1ZSRbddLc3eq35frlZCSYXZpAMoAghMAAKgwavp6aNrD4Rrbq4ncnK1avueEIics17ztx80uDUApR3ACAAAVitVq0YD21+i3oTeoWW0fnUnP1pPfbdKIGVuUkpFtdnkASimCEwAAqJAa+ntr1qD2GnJjA1kt0qzNR9Xt/eVas/+k2aUBKIUITgAAoMJydbbq2cgQ/fREhOpW9dSx5Aw98NlavR61SxnZpXcuJYCSR3ACAAAVXqt6VTV/WAfd3zZQhiFNXXFQt09apZ3Hks0uDUApYXpwmjx5soKCguTu7q7w8HCtW7fO4fozZ85o8ODBqlmzptzc3NSoUSPNmzevhKoFAADlVSU3Z42/s7k+79dafl6u2p2Qqt6TV+njpftls9O2HKjoTA1OM2bM0IgRIzR27Fht2rRJYWFhioyMVGJiYr7rs7KydMstt+jQoUOaOXOmdu/eralTp6p27dolXDkAACivbm7sr4XDO6prE39l2wy9tSBG9326RodPpZtdGgATWQwTJ7+Fh4erTZs2mjRpkiTJbrcrMDBQQ4cO1ciRIy9aP2XKFL3zzjuKiYmRi4vLFb1mYaYDAwCAisswDP208Yhe+WWn0rJsquTqpLG3NdU9rerIYrGYXR6AIlCYbGDaGaesrCxt3LhRXbp0+f9irFZ16dJFa9asyXefX375RRERERo8eLD8/f3VrFkzvfHGG7LZLv3jzczMTKWkpOS5AQAAFMRiseje1oFaMLyj2gRVUVqWTc/P3KbHp23UybOZZpcHoISZFpySkpJks9nk7++fZ7u/v7/i4+Pz3efAgQOaOXOmbDab5s2bp5deeknvvvuuxo0bd8nXGT9+vHx9fXNvgYGBRfo+AABA+RZY1VPTB0bohW6hcnGyaNGuBEVOWK4l0QlmlwagBJneHKIw7Ha7atSooU8//VStWrVSnz59NHr0aE2ZMuWS+4waNUrJycm5t8OHD5dgxQAAoDxwslo0qHOw5gxur0b+Xko6m6VHvt6gUbO2Ky0zx+zyAJQA04KTn5+fnJyclJCQ929rEhISFBAQkO8+NWvWVKNGjeTk5JS7rXHjxoqPj1dWVla++7i5ucnHxyfPDQAA4Eo0reWrX4bcoEdvuEaS9MO6OPWYuEIbY0+bXBmA4mZacHJ1dVWrVq20ZMmS3G12u11LlixRREREvvu0b99e+/btk91uz922Z88e1axZU66ursVeMwAAgLuLk168tYm+fyxctXzdFXsyXfdMWa13F+1Wts1e8BMAKJNMvVRvxIgRmjp1qr7++mtFR0dr0KBBSktL04ABAyRJffv21ahRo3LXDxo0SKdOndKwYcO0Z88eRUVF6Y033tDgwYPNegsAAKCCahfsp/nDO+rOlrVlN6QP/9inOz5apX2JqWaXBqAYOJv54n369NGJEyc0ZswYxcfHq0WLFlqwYEFuw4i4uDhZrf+f7QIDA7Vw4UI9/fTTat68uWrXrq1hw4bphRdeMOstAACACszXw0Xv9Wmhmxv7a/Sc7dpxNEU9J67UyO6h6hcRJKuVtuVAeWHqHCczMMcJAAAUh4SUDD03c5uW7zkhSbqhgZ/euae5avp6mFwZgEspE3OcAAAAyhN/H3d9PaCNXru9qdxdrFq5L0mR7y/XL1uPmV0agCJAcAIAACgiFotFD0UEKeqpDgqr46uUjBw99cNmPfXDZiWnZ5tdHoCrQHACAAAoYsHVvTRzUDsNu7mhnKwW/bL1mCInLNfKvUlmlwbgChGcAAAAioGLk1VP39JIM5+I0DV+lRSfkqEHP/9LL/+yUxnZNrPLA1BIBCcAAIBi1LJuFUU9dYMevL6uJOmr1Yd064crteNossmVASgMghMAAEAx83R11rje1+rLAW1U3dtN+xLPqvfkVZr0x17lMDQXKBMITgAAACXkxpAaWji8o7o3C1CO3dD/Fu3RvZ+sUezJNLNLA1AAghMAAEAJqlrJVR/95zq9d2+YvN2ctSnujLp/sEI/rItTBRuvCZQpBCcAAIASZrFYdOd1dTR/eAeFX1NV6Vk2jZq1XY9+vUEnUjPNLg9APghOAAAAJqlTxVM/PHa9RvdoLFcnq5bEJCpywnIt3BlvdmkA/oXgBAAAYCKr1aLHOtbXL0PbKzTAW6fSsvT4tI16fuZWnc3MMbs8AH8jOAEAAJQCoQE+mjukvR7vVF8Wi/TjhiPq/sFyrT90yuzSAIjgBAAAUGq4OTtpVPfGmv7Y9apd2UOHT53TvZ+s0VsLYpSVQ9tywEwEJwAAgFImvH41LRjeQXe3qiPDkD5eul+3T16l3fGpZpcGVFgEJwAAgFLI291F/7snTFMebKWqlVwVfTxFvSat1GcrDshup205UNIITgAAAKVYt2YBWjC8g24KraGsHLvGRUXrP5/9paNnzpldGlChEJwAAABKuRre7vq8X2u9cce18nBx0poDJ9Xt/eWavfkIQ3OBEkJwAgAAKAMsFoseCK+r+cM6qGXdykrNzNHTM7ZqyPebdToty+zygHKP4AQAAFCGBPlV0k+PR+iZWxrJ2WpR1PbjipywXMv2nDC7NKBcIzgBAACUMc5OVg29uaFmPdlOwdUrKTE1U/2+WKcxc3foXJbN7PKAcongBAAAUEY1r1NZvw3toP7tgiRJ36yJVc+JK7T18BlT6wLKI4ITAABAGebh6qSXb2uqbx5uK38fNx1IStOdH6/WB7/vVY6NoblAUSE4AQAAlAMdG1XXwuEddWvzmrLZDb3/+x7dNWWNDpw4a3ZpQLlAcAIAACgnKnu6atID1+mD+1rI291ZWw+fUY+JKzRtbSxty4GrRHACAAAoZ25vUVsLh3dUu+Bqysi266U5OzTgq/VKTMkwuzSgzCI4AQAAlEO1Knvo20fCNebWJnJ1tmrp7hOKnLBc87cfN7s0oEwiOAEAAJRTVqtFD99wjaKG3qCmtXx0Oj1bg77bpBE/blFKRrbZ5QFlCsEJAACgnGvo763ZT7bX4BuDZbVIszYdVfcJK7T2wEmzSwPKDIITAABABeDqbNVzkaH68fEI1a3qqaNnzun+qWv1xrxoZWQzNBcoCMEJAACgAmkdVFXzhnXQfW0CZRjSp8sPqPfkVYo+nmJ2aUCpRnACAACoYLzcnPXmXc01tW9r+Xm5KiY+VbdPWqVPlu2XzU7bciA/BCcAAIAK6pYm/lowvKO6NPZXls2u8fNjdP+na3X4VLrZpQGlDsEJAACgAvPzctPUvq309l3NVcnVSesOnVL3D1bopw2HGZoL/APBCQAAoIKzWCy6t02g5g/rqNb1quhsZo6em7lNT3y7USfPZppdHlAqEJwAAAAgSapbzVMzHo/Q891C5OJk0cKdCYqcsEJ/xCSYXRpgOoITAAAAcjlZLXqycwPNfrK9GtbwUtLZTD381Qb9d/Z2pWXmmF0eYBqCEwAAAC7SrLavfh16gx654RpJ0vd/xannxBXaFHfa5MoAcxCcAAAAkC93Fye9dGsTff9ouGr6uuvQyXTd/fFqvbdot7JtdrPLA0oUwQkAAAAOtWvgpwXDO6p3i1qyG9LEP/bpzo9Wa1/iWbNLA0oMwQkAAAAF8vVw0YT7WmrSAy3l6+Gi7UeT1XPiCn29+pDsDM1FBUBwAgAAwGW7tXktLRzeUR0a+ikzx66xv+xUvy/XKT45w+zSgGJFcAIAAEChBPi665uH2+rV25vKzdmqFXuTFDlhuX7deszs0oBiQ3ACAABAoVksFvWNCFLUUx3UvI6vks9la+gPmzVs+mYlp2ebXR5Q5AhOAAAAuGINanjp50Ht9NTNDeVktWjulmPq9sFyrdqXZHZpQJEiOAEAAOCquDhZNeKWRvrpiQgFVfPU8eQM/eezv/Tqr7uUkW0zuzygSJSK4DR58mQFBQXJ3d1d4eHhWrdu3SXXfvXVV7JYLHlu7u7uJVgtAAAA8nNd3SqaN6yD/hNeV5L0xaqD6vXhSu04mmxyZcDVMz04zZgxQyNGjNDYsWO1adMmhYWFKTIyUomJiZfcx8fHR8ePH8+9xcbGlmDFAAAAuBRPV2e9fse1+rJ/G/l5uWlv4ln1nrxKk//cJxtty1GGmR6c3nvvPT322GMaMGCAmjRpoilTpsjT01NffPHFJfexWCwKCAjIvfn7+5dgxQAAACjIjaE1tOjpjurWNEA5dkPvLNytez9Zo7iT6WaXBlwRU4NTVlaWNm7cqC5duuRus1qt6tKli9asWXPJ/c6ePat69eopMDBQt99+u3bu3HnJtZmZmUpJSclzAwAAQPGrWslVHz94nd69J0xebs7aGHta3T5Yrunr4mQYnH1C2WJqcEpKSpLNZrvojJG/v7/i4+Pz3SckJERffPGF5s6dq2+//VZ2u13t2rXTkSNH8l0/fvx4+fr65t4CAwOL/H0AAAAgfxaLRXe1qqP5wzqo7TVVlZ5l08hZ2/XYNxt0IjXT7PKAy2b6pXqFFRERob59+6pFixbq1KmTZs2aperVq+uTTz7Jd/2oUaOUnJycezt8+HAJVwwAAIDAqp764bHr9d8eoXJ1sur36ER1m7Bci3clmF0acFlMDU5+fn5ycnJSQkLeD0xCQoICAgIu6zlcXFzUsmVL7du3L9/H3dzc5OPjk+cGAACAkudktWhgx2DNHdJeoQHeOpmWpce+2aAXZm7T2cwcs8sDHDI1OLm6uqpVq1ZasmRJ7ja73a4lS5YoIiLisp7DZrNp+/btqlmzZnGVCQAAgCLUuKaP5g5pr8c71pfFIs3YcFjdP1iuDYdOmV0acEmmX6o3YsQITZ06VV9//bWio6M1aNAgpaWlacCAAZKkvn37atSoUbnrX331VS1atEgHDhzQpk2b9OCDDyo2NlaPPvqoWW8BAAAAheTm7KRRPRrrh8euV+3KHjp86pzu/WSN3l4Qo6wcu9nlARdxNruAPn366MSJExozZozi4+PVokULLViwILdhRFxcnKzW/893p0+f1mOPPab4+HhVqVJFrVq10urVq9WkSROz3gIAAACu0PX1q2nB8A56+Zdd+nnTEX20dL+W7j6hCfe1UCN/b7PLA3JZjArWCzIlJUW+vr5KTk7m904AAAClyPztx/Xf2dt1Oj1brs5WPR8ZoofbXyOr1WJ2aSinCpMNTL9UDwAAAJCk7tfW1MLhHXVjSHVl5dg1LipaD37+l46dOWd2aQDBCQAAAKVHDR93fdG/jV6/o5k8XJy0ev9JRU5YrjmbjzI0F6YiOAEAAKBUsVgs+k94Pc0b1kEtAisrNSNHw2ds0ZAfNutMepbZ5aGCIjgBAACgVLrGr5JmPhGhEbc0kpPVoqhtxxU5YbmW7zlhdmmogAhOAAAAKLWcnax66uaGmjWonepXr6SElEz1/WKdxs7doXNZNrPLQwVCcAIAAECpFxZYWVFDO6hfRD1J0tdrYtXzwxXaduSMuYWhwiA4AQAAoEzwcHXSK7c30zcPt5W/j5sOnEjTnR+t1sQle5VjY2guihfBCQAAAGVKx0bVtXB4R/W8tqZy7IbeW7xHd09Zo4NJaWaXhnKM4AQAAIAyp7KnqyY90FIT+rSQt7uzthw+ox4frNB3f8XSthzFguAEAACAMslisah3y9paOLyj2gVX07lsm0bP3qGHv1qvxNQMs8tDOUNwAgAAQJlWq7KHvn0kXC/d2kSuzlb9ufuEIt9frgU7jptdGsoRghMAAADKPKvVokduuEa/Db1BTWr66HR6tp74dpOe+XGrUjKyzS4P5QDBCQAAAOVGI39vzRncXk92DpbVIv286Yi6T1ihtQdOml0ayjiCEwAAAMoVV2ernu8WqhmPRyiwqoeOnjmn+6eu1fh50crMYWgurgzBCQAAAOVSm6Cqmj+so/q0DpRhSJ8sP6DbJ61S9PEUs0tDGURwAgAAQLnl5east+5urql9W6taJVfFxKfq9kmr9Mmy/bLZaVuOy0dwAgAAQLl3SxN/LRjeUV0a11CWza7x82N0/9S1Onwq3ezSUEYQnAAAAFAhVPd209S+rfXmndfK09VJ6w6eUvcPVujnjUcYmosCEZwAAABQYVgsFt3Xtq7mD+ugVvWq6Gxmjp75aasGfbtJp9KyzC4PpRjBCQAAABVOvWqV9OPjEXouMkTOVosW7IxX1/eX68+YRLNLQylFcAIAAECF5GS1aPCNDTRncHs1rOGlpLOZGvDVeo2evV3pWTlml4dShuAEAACACq1ZbV/9OvQGPdz+GknSd3/FqefEldocd9rkylCaEJwAAABQ4bm7OGlMryb67tFw1fR118GkNN09ZY3eW7xH2Ta72eWhFCA4AQAAAH9r38BPC4Z3VO8WtWSzG5q4ZK/u+ni19p84a3ZpMBnBCQAAAPgHXw8XTbivpT68v6V83J217Uiyek5coa9XH6JteQVGcAIAAADy0SuslhY93UkdGvopI9uusb/sVN8v1ikhJcPs0mACghMAAABwCQG+7vp6QFu9cltTuTlbtWJvkrq+v1xR246bXRpKGMEJAAAAcMBqtahfuyBFPdVB19b2VfK5bA3+fpOGT9+s5HPZZpeHEkJwAgAAAC5DgxpemvVkOz11UwNZLdKcLcfUbcJyrd6XZHZpKAEEJwAAAOAyuThZNaJriGYOaqegap46npyhBz77S6/9tksZ2Tazy0MxIjgBAAAAhXRd3SqKeqqDHgivK0n6fOVB3TZppXYcTTa5MhQXghMAAABwBSq5OeuNO67VF/1by8/LTXsSzuqOj1bpo6X7ZLPTtry8ITgBAAAAV+GmUH8tHN5BkU39lW0z9PaC3erzyRrFnUw3uzQUIYITAAAAcJWqeblpyoOt9M7dzeXl5qwNsafV/YPlmrE+jqG55QTBCQAAACgCFotF97QO1PxhHdQ2qKrSsmx64eftGjhto5LOZppdHq4SwQkAAAAoQoFVPfXDwOs1qnuoXJwsWrwrQd0mLNfiXQlml4arQHACAAAAipiT1aLHOwVr7uAbFOLvraSzWXrsmw0a+fM2nc3MMbs8XAGCEwAAAFBMmtTy0dwh7TWwY31ZLNL09YfV44MV2hh7yuzSUEgEJwAAAKAYubs46b89Guv7R69X7coeijuVrnumrNE7C2OUlWM3uzxcJoITAAAAUAIigqtp/vAOuvO62rIb0uQ/9+uOj1Zpb0Kq2aXhMhCcAAAAgBLi4+6i9+5toY//c52qeLpo57EU9fxwpb5YeVB2huaWagQnAAAAoIR1v7amFg7vqM4h1ZWVY9erv+3SQ1/8pWNnzpldGi6B4AQAAACYoIaPu77s30bjejeTh4uTVu07qcgJyzV3y1GzS0M+CE4AAACASSwWix68vp6inrpBYYGVlZqRo2HTt2joD5t1Jj3L7PLwDwQnAAAAwGT1q3vp5yci9HSXRnKyWvTr1mOKnLBcK/aeMLs0/K1UBKfJkycrKChI7u7uCg8P17p16y5rv+nTp8tisah3797FWyAAAABQzJydrBrWpaFmDWqn+n6VlJCSqYc+X6eXf9mpc1k2s8ur8EwPTjNmzNCIESM0duxYbdq0SWFhYYqMjFRiYqLD/Q4dOqRnn31WHTp0KKFKAQAAgOIXFlhZUU91UN+IepKkr1Yf0q0frtD2I8kmV1axWQzDMLXvYXh4uNq0aaNJkyZJkux2uwIDAzV06FCNHDky331sNps6duyohx9+WCtWrNCZM2c0Z86cfNdmZmYqMzMz935KSooCAwOVnJwsHx+fIn8/AAAAQFFZujtRz8/cpsTUTDlbLRp2c0MN6hwsZyfTz3+UCykpKfL19b2sbGDqn3hWVpY2btyoLl265G6zWq3q0qWL1qxZc8n9Xn31VdWoUUOPPPJIga8xfvx4+fr65t4CAwOLpHYAAACguHUOqaGFwzuq57U1lWM39O7iPbrnkzU6lJRmdmkVjqnBKSkpSTabTf7+/nm2+/v7Kz4+Pt99Vq5cqc8//1xTp069rNcYNWqUkpOTc2+HDx++6roBAACAklKlkqsmPdBSE/q0kLe7szbHnVH3D1bo+7/iZPLFYxVKmTrHl5qaqoceekhTp06Vn5/fZe3j5uYmHx+fPDcAAACgLLFYLOrdsrYWDO+oiPrVdC7bpv/O3q5Hvt6gxNQMs8urEJzNfHE/Pz85OTkpISEhz/aEhAQFBARctH7//v06dOiQevXqlbvNbrdLkpydnbV7924FBwcXb9EAAACASWpX9tB3j4bri1UH9fbC3fojJlGR7y/X+Dubq1uzi///GUXH1DNOrq6uatWqlZYsWZK7zW63a8mSJYqIiLhofWhoqLZv364tW7bk3m677TbdeOON2rJlC79fAgAAQLlntVr0aIf6+nXIDWpc00en07P1xLcb9dxPW5WakW12eeWWqWecJGnEiBHq16+fWrdurbZt22rChAlKS0vTgAEDJEl9+/ZV7dq1NX78eLm7u6tZs2Z59q9cubIkXbQdAAAAKM9CArw1Z3A7Tfh9r6Ys26+fNh7RmgMn9e49YQqvX83s8sod04NTnz59dOLECY0ZM0bx8fFq0aKFFixYkNswIi4uTlZrmfopFgAAAFAi3Jyd9EK3UN0YUkMjftyiI6fP6b6pazWwY32NuKWR3JydzC6x3DB9jlNJK0yvdgAAAKCsSM3I1mu/7dKPG45IkkIDvDXhvhYKDeD/eS+lzMxxAgAAAFA0vN1d9PbdYfrkoVaqWslVMfGpuu3DVZq6/IDs9gp1rqRYEJwAAACAciSyaYAWDu+om0NrKMtm1+vzovXAZ2t15HS62aWVaQQnAAAAoJyp7u2mz/q11pt3XitPVyetPXBK3Ses0M8bjzA09woRnAAAAIByyGKx6L62dTV/WAddV7eyUjNz9MxPW/Xkd5t0Ki3L7PLKHIITAAAAUI7Vq1ZJPz4eoeciQ+RstWj+jnhFTliupbsTzS6tTCE4AQAAAOWcs5NVg29soDmD26tBDS+dSM1U/y/X68U525WelWN2eWUCwQkAAACoIJrV9tVvQ2/QgPZBkqRv18ap58SV2hx32tzCygCCEwAAAFCBuLs4aWyvpvr2kXAF+LjrYFKa7p6yRu8v3qNsm93s8kotghMAAABQAd3Q0E8Lh3fUbWG1ZLMb+mDJXt398WrtP3HW7NJKJYITAAAAUEH5erpo4v0tNfH+lvJxd9bWI8nqOXGFpq05RNvyfyE4AQAAABXcbWG1tPDpjrqhgZ8ysu16ae5O9ftyvRJSMswurdQgOAEAAABQTV8PffNwW73cq4ncnK1avueEIicsV9S242aXVioQnAAAAABIkqxWi/q3v0ZRT92gZrV9dCY9W4O/36SnZ2xR8rlss8szFcEJAAAAQB4Nanhr1qD2GnpTA1kt0uzNR9V9wnKt2X/S7NJMQ3ACAAAAcBFXZ6ue6Rqin55op3rVPHUsOUMPfLZW437bpYxsm9nllTiCEwAAAIBLalWviuY91UH3t60rw5A+W3lQt01aqZ3Hks0urUQRnAAAAAA4VMnNWePvvFaf92stPy9X7Uk4q96TV+njpftls1eMtuUEJwAAAACX5ebG/lo4vKO6NvFXts3QWwtidN+na3T4VLrZpRU7ghMAAACAy1bNy02fPNRKb9/dXF5uzlp/6LS6TViuHzccLtdDcwlOAAAAAArFYrHo3taBmj+sg9oEVVFalk3Pz9ymx6dt1MmzmWaXVywITgAAAACuSGBVT00fGKGR3UPl4mTRol0JipywXEuiE8wurcgRnAAAAABcMSerRU90CtbcwTcoxN9bSWez9MjXGzRq1jalZeaYXV6RITgBAAAAuGpNavlo7pD2eqzDNbJYpB/WHVaPiSu0Mfa02aUVCYITAAAAgCLh7uKk0T2b6LtHw1XL112xJ9N1z5TV+t/C3crKsZtd3lUhOAEAAAAoUu2C/bTg6Y66s2Vt2Q1p0p/7dOfHq7QvMdXs0q4YwQkAAABAkfNxd9F7fVpo8gPXqbKni3YcTVHPiSv15aqDspfBobkEJwAAAADFpmfzmlo4vKM6NqquzBy7Xvl1l/p+sU7Hk8+ZXVqhEJwAAAAAFCt/H3d9PaCNXuvdTO4uVq0/dEpnM8pWxz1nswsAAAAAUP5ZLBY9dH09tQuuppjjqWro7212SYVCcAIAAABQYoKreym4upfZZRQal+oBAAAAQAEITgAAAABQAIITAAAAABSA4AQAAAAABSA4AQAAAEABCE4AAAAAUACCEwAAAAAUgOAEAAAAAAUgOAEAAABAAQhOAAAAAFAAghMAAAAAFIDgBAAAAAAFIDgBAAAAQAEITgAAAABQAGezCyhphmFIklJSUkyuBAAAAICZLmSCCxnBkQoXnFJTUyVJgYGBJlcCAAAAoDRITU2Vr6+vwzUW43LiVTlit9t17NgxeXt7y2KxmF2OUlJSFBgYqMOHD8vHx8fsclAEOKblD8e0fOK4lj8c0/KJ41r+lKZjahiGUlNTVatWLVmtjn/FVOHOOFmtVtWpU8fsMi7i4+Nj+r84KFoc0/KHY1o+cVzLH45p+cRxLX9KyzEt6EzTBTSHAAAAAIACEJwAAAAAoAAEJ5O5ublp7NixcnNzM7sUFBGOafnDMS2fOK7lD8e0fOK4lj9l9ZhWuOYQAAAAAFBYnHECAAAAgAIQnAAAAACgAAQnAAAAACgAwQkAAAAACkBwKmaTJ09WUFCQ3N3dFR4ernXr1jlc/9NPPyk0NFTu7u669tprNW/evBKqFIVRmOP61VdfyWKx5Lm5u7uXYLUoyPLly9WrVy/VqlVLFotFc+bMKXCfpUuX6rrrrpObm5saNGigr776qtjrxOUr7DFdunTpRZ9Ti8Wi+Pj4kikYBRo/frzatGkjb29v1ahRQ71799bu3bsL3I/v1dLtSo4r36ul28cff6zmzZvnDreNiIjQ/PnzHe5TVj6nBKdiNGPGDI0YMUJjx47Vpk2bFBYWpsjISCUmJua7fvXq1br//vv1yCOPaPPmzerdu7d69+6tHTt2lHDlcKSwx1U6Pxn7+PHjubfY2NgSrBgFSUtLU1hYmCZPnnxZ6w8ePKiePXvqxhtv1JYtWzR8+HA9+uijWrhwYTFXistV2GN6we7du/N8VmvUqFFMFaKwli1bpsGDB2vt2rVavHixsrOz1bVrV6WlpV1yH75XS78rOa4S36ulWZ06dfTmm29q48aN2rBhg2666Sbdfvvt2rlzZ77ry9Tn1ECxadu2rTF48ODc+zabzahVq5Yxfvz4fNffe++9Rs+ePfNsCw8PNx5//PFirROFU9jj+uWXXxq+vr4lVB2uliRj9uzZDtc8//zzRtOmTfNs69OnjxEZGVmMleFKXc4x/fPPPw1JxunTp0ukJly9xMREQ5KxbNmyS67he7XsuZzjyvdq2VOlShXjs88+y/exsvQ55YxTMcnKytLGjRvVpUuX3G1Wq1VdunTRmjVr8t1nzZo1edZLUmRk5CXXo+RdyXGVpLNnz6pevXoKDAx0+LcuKBv4rJZfLVq0UM2aNXXLLbdo1apVZpcDB5KTkyVJVatWveQaPqtlz+UcV4nv1bLCZrNp+vTpSktLU0RERL5rytLnlOBUTJKSkmSz2eTv759nu7+//yWvmY+Pjy/UepS8KzmuISEh+uKLLzR37lx9++23stvtateunY4cOVISJaMYXOqzmpKSonPnzplUFa5GzZo1NWXKFP3888/6+eefFRgYqM6dO2vTpk1ml4Z82O12DR8+XO3bt1ezZs0uuY7v1bLlco8r36ul3/bt2+Xl5SU3Nzc98cQTmj17tpo0aZLv2rL0OXU2uwCgvIuIiMjztyzt2rVT48aN9cknn+i1114zsTIAF4SEhCgkJCT3frt27bR//369//77mjZtmomVIT+DBw/Wjh07tHLlSrNLQRG63OPK92rpFxISoi1btig5OVkzZ85Uv379tGzZskuGp7KCM07FxM/PT05OTkpISMizPSEhQQEBAfnuExAQUKj1KHlXclz/zcXFRS1bttS+ffuKo0SUgEt9Vn18fOTh4WFSVShqbdu25XNaCg0ZMkS//fab/vzzT9WpU8fhWr5Xy47CHNd/43u19HF1dVWDBg3UqlUrjR8/XmFhYfrggw/yXVuWPqcEp2Li6uqqVq1aacmSJbnb7Ha7lixZcslrPCMiIvKsl6TFixdfcj1K3pUc13+z2Wzavn27atasWVxlopjxWa0YtmzZwue0FDEMQ0OGDNHs2bP1xx9/6JprrilwHz6rpd+VHNd/43u19LPb7crMzMz3sTL1OTW7O0V5Nn36dMPNzc346quvjF27dhkDBw40KleubMTHxxuGYRgPPfSQMXLkyNz1q1atMpydnY3//e9/RnR0tDF27FjDxcXF2L59u1lvAfko7HF95ZVXjIULFxr79+83Nm7caNx3332Gu7u7sXPnTrPeAv4lNTXV2Lx5s7F582ZDkvHee+8ZmzdvNmJjYw3DMIyRI0caDz30UO76AwcOGJ6ensZzzz1nREdHG5MnTzacnJyMBQsWmPUW8C+FPabvv/++MWfOHGPv3r3G9u3bjWHDhhlWq9X4/fffzXoL+JdBgwYZvr6+xtKlS43jx4/n3tLT03PX8L1a9lzJceV7tXQbOXKksWzZMuPgwYPGtm3bjJEjRxoWi8VYtGiRYRhl+3NKcCpmH374oVG3bl3D1dXVaNu2rbF27drcxzp16mT069cvz/off/zRaNSokeHq6mo0bdrUiIqKKuGKcTkKc1yHDx+eu9bf39/o0aOHsWnTJhOqxqVcaEX979uF49ivXz+jU6dOF+3TokULw9XV1ahfv77x5ZdflnjduLTCHtO33nrLCA4ONtzd3Y2qVasanTt3Nv744w9zike+8juekvJ89vheLXuu5LjyvVq6Pfzww0a9evUMV1dXo3r16sbNN9+cG5oMo2x/Ti2GYRgld34LAAAAAMoefuMEAAAAAAUgOAEAAABAAQhOAAAAAFAAghMAAAAAFIDgBAAAAAAFIDgBAAAAQAEITgAAAABQAIITAAAAABSA4AQAKNcsFovmzJlT6P12796tgIAApaamFn1RDkyZMkW9evUq0dcEABSM4AQAKBb9+/eXxWK56NatWzezS7sso0aN0tChQ+Xt7X3Z+7z++utq166dPD09Vbly5XzXxMXFqWfPnvL09FSNGjX03HPPKScnJ/fxhx9+WJs2bdKKFSuu9i0AAIqQs9kFAADKr27duunLL7/Ms83Nzc2kai5fXFycfvvtN3344YeF2i8rK0v33HOPIiIi9Pnnn1/0uM1mU8+ePRUQEKDVq1fr+PHj6tu3r1xcXPTGG29IklxdXfXAAw9o4sSJ6tChQ5G8HwDA1eOMEwCg2Li5uSkgICDPrUqVKrmPWywWffzxx+revbs8PDxUv359zZw5M89zbN++XTfddJM8PDxUrVo1DRw4UGfPns2z5osvvlDTpk3l5uammjVrasiQIXkeT0pK0h133CFPT081bNhQv/zyi8O6f/zxR4WFhal27dq52x5++GE1b95cmZmZks6HpJYtW6pv3765a1555RU9/fTTuvbaa/N93kWLFmnXrl369ttv1aJFC3Xv3l2vvfaaJk+erKysrNx1vXr10i+//KJz5845rBMAUHIITgAAU7300ku66667tHXrVv3nP//Rfffdp+joaElSWlqaIiMjVaVKFa1fv14//fSTfv/99zzB6OOPP9bgwYM1cOBAbd++Xb/88osaNGiQ5zVeeeUV3Xvvvdq2bZt69Oih//znPzp16tQla1qxYoVat26dZ9vEiROVlpamkSNHSpJGjx6tM2fOaNKkSZf9XtesWaNrr71W/v7+udsiIyOVkpKinTt35m5r3bq1cnJy9Ndff132cwMAihfBCQBQbH777Td5eXnluV24JO2Ce+65R48++qgaNWqk1157Ta1bt869RO77779XRkaGvvnmGzVr1kw33XSTJk2apGnTpikhIUGSNG7cOD3zzDMaNmyYGjVqpDZt2mj48OF5XqN///66//771aBBA73xxhs6e/as1q1bd8m6Y2NjVatWrTzbvLy89O2332ry5MkaM2aMJkyYoGnTpsnHx+ey/zzi4+PzhCZJuffj4+Nzt3l6esrX11exsbGX/dwAgOLFb5wAAMXmxhtv1Mcff5xnW9WqVfPcj4iIuOj+li1bJEnR0dEKCwtTpUqVch9v37697Ha7du/eLYvFomPHjunmm292WEfz5s1z/7lSpUry8fFRYmLiJdefO3dO7u7uF22PiIjQs88+q9dee00vvPCCbrjhBoevezU8PDyUnp5ebM8PACgcghMAoNhUqlTposvmipKHh8dlrXNxcclz32KxyG63X3K9n5+fTp8+fdF2u92uVatWycnJSfv27StcsZICAgIuOtN14cxZQEBAnu2nTp1S9erVC/0aAIDiwaV6AABTrV279qL7jRs3liQ1btxYW7duVVpaWu7jq1atktVqVUhIiLy9vRUUFKQlS5YUaU0tW7bUrl27Ltr+zjvvKCYmRsuWLdOCBQsu6hhYkIiICG3fvj3P2a7FixfLx8dHTZo0yd22f/9+ZWRkqGXLllf+JgAARYrgBAAoNpmZmYqPj89zS0pKyrPmp59+0hdffKE9e/Zo7NixWrduXW7zh//85z9yd3dXv379tGPHDv35558aOnSoHnroodzfBr388st69913NXHiRO3du1ebNm0qdBvxf4uMjNSaNWtks9lyt23evFljxozRZ599pvbt2+u9997TsGHDdODAgdw1cXFx2rJli+Li4mSz2bRlyxZt2bIltwtg165d1aRJEz300EPaunWrFi5cqBdffFGDBw/O06Z9xYoVql+/voKDg6/qfQAAipABAEAx6NevnyHpoltISEjuGknG5MmTjVtuucVwc3MzgoKCjBkzZuR5nm3bthk33nij4e7ublStWtV47LHHjNTU1DxrpkyZYoSEhBguLi5GzZo1jaFDh+Z5jdmzZ+dZ7+vra3z55ZeXrD07O9uoVauWsWDBAsMwDOPcuXNGkyZNjIEDB+ZZd9tttxnt2rUzcnJyHL7nP//8M3efQ4cOGd27dzc8PDwMPz8/45lnnjGys7PzPG/Xrl2N8ePHX7I+AEDJsxiGYZgT2QAAFZ3FYtHs2bPVu3dvs0u5yOTJk/XLL79o4cKFJfq6O3fu1E033aQ9e/bI19e3RF8bAHBpNIcAACAfjz/+uM6cOaPU1FR5e3uX2OseP35c33zzDaEJAEoZzjgBAExTms84AQDwT5xxAgCYhr+7AwCUFXTVAwAAAIACEJwAAAAAoAAEJwAAAAAoAMEJAAAAAApAcAIAAACAAhCcAAAAAKAABCcAAAAAKADBCQAAAAAK8H/LOFovmhu+2wAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on test data: 51 %\n"
          ]
        }
      ],
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, TensorDataset, random_split\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "torch.manual_seed(42)\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(100, 20)\n",
        "        self.dropout1 = nn.Dropout(0.2)\n",
        "        self.fc3 = nn.Linear(20, 20)\n",
        "        self.dropout2 = nn.Dropout(0.2)\n",
        "        self.fc4 = nn.Linear(20, 3)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        self.dropout1(x)\n",
        "        x = torch.relu(self.fc3(x))\n",
        "        self.dropout2(x)\n",
        "        x = self.fc4(x)\n",
        "        return x\n",
        "\n",
        "def binary_to_bits(binary_list):\n",
        "    return [[[int(i) for i in str(bit)] for bit in binary_string][0] for binary_string in binary_list]\n",
        "\n",
        "data = np.loadtxt(\"AI_2qubits_training_data.txt\", dtype = str)\n",
        "X = torch.tensor(np.array(binary_to_bits(data[:,:-1])))\n",
        "Y = torch.tensor(data[:,-1].astype(int))-1\n",
        "\n",
        "net = Net().to(device)\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001, weight_decay=0.0005)  # Add L2 regularization here\n",
        "\n",
        "dataset = TensorDataset(X.float(), Y.long())\n",
        "\n",
        "train_size = int(0.8 * len(dataset))\n",
        "test_size = len(dataset) - train_size\n",
        "\n",
        "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
        "\n",
        "train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False)\n",
        "\n",
        "def get_accuracy(loader, model):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in loader:\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            _, predicted = torch.max(outputs, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "    return correct / total\n",
        "\n",
        "losses = []\n",
        "accuracies = []\n",
        "\n",
        "for epoch in range(40):\n",
        "    for inputs, labels in train_loader:\n",
        "        inputs, labels = inputs.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    if epoch % 10 == 0:\n",
        "        train_acc = get_accuracy(train_loader, net)\n",
        "        print(f\"Epoch {epoch}, Loss: {loss.item()}, Accuracy: {train_acc}\")\n",
        "        losses.append(loss.item())\n",
        "        accuracies.append(train_acc)\n",
        "\n",
        "print(\"Training is complete!\")\n",
        "\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(losses)\n",
        "plt.title('Training Loss')\n",
        "plt.xlabel('Epoch (x10)')\n",
        "plt.ylabel('Loss')\n",
        "plt.show()\n",
        "\n",
        "net.eval()\n",
        "test_acc = get_accuracy(test_loader, net)\n",
        "print('Accuracy of the network on test data: %d %%' % (100 * test_acc))\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "GvC8EXFFT5QQ"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "8kVGwaY7X9Cy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, TensorDataset, random_split\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "torch.manual_seed(0)\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Define the network architecture\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(100, 30)\n",
        "        self.dropout1 = nn.Dropout(0.2)\n",
        "        self.fc3 = nn.Linear(30, 20)\n",
        "        self.dropout2 = nn.Dropout(0.2)\n",
        "        self.fc4 = nn.Linear(20, 3)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        self.dropout1(x)\n",
        "        x = torch.relu(self.fc3(x))\n",
        "        self.dropout2(x)\n",
        "        x = self.fc4(x)\n",
        "        return x\n",
        "\n",
        "def binary_to_bits(binary_list):\n",
        "    return [[[int(i) for i in str(bit)] for bit in binary_string][0] for binary_string in binary_list]\n",
        "data = np.loadtxt(\"AI_2qubits_training_data.txt\", dtype = str)\n",
        "X = torch.tensor(np.array(binary_to_bits(data[:,:-1])))\n",
        "Y = torch.tensor(data[:,-1].astype(int))-1\n",
        "\n",
        "# Create the network\n",
        "net = Net().to(device)\n",
        "\n",
        "# Define the loss function and the optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
        "\n",
        "# Create a dataset from X and y\n",
        "dataset = TensorDataset(X.float(), Y.long())\n",
        "\n",
        "# Decide on the sizes of the splits\n",
        "train_size = int(0.8 * len(dataset))  # 50% for training\n",
        "test_size = len(dataset) - train_size  # 50% for testing\n",
        "\n",
        "# Use random_split to split the dataset\n",
        "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
        "\n",
        "# Create data loaders for the train and test datasets\n",
        "train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=4, shuffle=False)\n",
        "\n",
        "# Function to calculate accuracy\n",
        "def get_accuracy(loader, model):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in loader:\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            _, predicted = torch.max(outputs, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "    return correct / total\n",
        "\n",
        "# Lists to store losses and accuracies for plotting\n",
        "losses = []\n",
        "accuracies = []\n",
        "\n",
        "# Train the network\n",
        "for epoch in range(100):  # 500 epochs\n",
        "    for inputs, labels in train_loader:\n",
        "        inputs, labels = inputs.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        #Add regularization\n",
        "        l1_norm = sum(p.abs().sum() for p in net.parameters())\n",
        "        loss+=0.002*l1_norm\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    # Print loss and accuracy every 10 epochs\n",
        "    if epoch % 10 == 0:\n",
        "        train_acc = get_accuracy(train_loader, net)\n",
        "        print(f\"Epoch {epoch}, Loss: {loss.item()}, Accuracy: {train_acc}\")\n",
        "        losses.append(loss.item())\n",
        "        accuracies.append(train_acc)\n",
        "\n",
        "print(\"Training is complete!\")\n",
        "\n",
        "# Plot the training loss\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(losses)\n",
        "plt.title('Training Loss')\n",
        "plt.xlabel('Epoch (x10)')\n",
        "plt.ylabel('Loss')\n",
        "plt.show()\n",
        "\n",
        "# Test the network\n",
        "net.eval()  # Set the network to evaluation mode\n",
        "test_acc = get_accuracy(test_loader, net)\n",
        "print('Accuracy of the network on test data: %d %%' % (100 * test_acc))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 706
        },
        "id": "7FRl1h7RX9OB",
        "outputId": "6915b19a-ad31-43b4-fa7f-b3922263d790"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0, Loss: 1.1199370622634888, Accuracy: 0.529375\n",
            "Epoch 10, Loss: 0.8308830261230469, Accuracy: 0.568125\n",
            "Epoch 20, Loss: 0.7620842456817627, Accuracy: 0.5697916666666667\n",
            "Epoch 30, Loss: 0.9773595929145813, Accuracy: 0.5689583333333333\n",
            "Epoch 40, Loss: 1.198759913444519, Accuracy: 0.565\n",
            "Epoch 50, Loss: 1.0454446077346802, Accuracy: 0.5683333333333334\n",
            "Epoch 60, Loss: 0.862614631652832, Accuracy: 0.568125\n",
            "Epoch 70, Loss: 0.6810250878334045, Accuracy: 0.56375\n",
            "Epoch 80, Loss: 1.0372484922409058, Accuracy: 0.569375\n",
            "Epoch 90, Loss: 1.3495291471481323, Accuracy: 0.5714583333333333\n",
            "Training is complete!\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on test data: 54 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, TensorDataset, random_split\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "torch.manual_seed(0)\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Define the network architecture\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(100, 30)\n",
        "        self.dropout1 = nn.Dropout(0.2)\n",
        "        self.fc3 = nn.Linear(30, 20)\n",
        "        self.dropout2 = nn.Dropout(0.2)\n",
        "        self.fc4 = nn.Linear(20, 3)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        self.dropout1(x)\n",
        "        x = torch.relu(self.fc3(x))\n",
        "        self.dropout2(x)\n",
        "        x = self.fc4(x)\n",
        "        return x\n",
        "\n",
        "def binary_to_bits(binary_list):\n",
        "    return [[[int(i) for i in str(bit)] for bit in binary_string][0] for binary_string in binary_list]\n",
        "data = np.loadtxt(\"AI_2qubits_training_data.txt\", dtype = str)\n",
        "X = torch.tensor(np.array(binary_to_bits(data[:,:-1])))\n",
        "Y = torch.tensor(data[:,-1].astype(int))-1\n",
        "\n",
        "# Create the network\n",
        "net = Net().to(device)\n",
        "\n",
        "# Define the loss function and the optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
        "\n",
        "# Create a dataset from X and y\n",
        "dataset = TensorDataset(X.float(), Y.long())\n",
        "\n",
        "# Decide on the sizes of the splits\n",
        "train_size = int(0.8 * len(dataset))  # 50% for training\n",
        "test_size = len(dataset) - train_size  # 50% for testing\n",
        "\n",
        "# Use random_split to split the dataset\n",
        "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
        "\n",
        "# Create data loaders for the train and test datasets\n",
        "train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=4, shuffle=False)\n",
        "\n",
        "# Function to calculate accuracy\n",
        "def get_accuracy(loader, model):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in loader:\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            _, predicted = torch.max(outputs, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "    return correct / total\n",
        "\n",
        "# Lists to store losses and accuracies for plotting\n",
        "losses = []\n",
        "accuracies = []\n",
        "\n",
        "# Train the network\n",
        "for epoch in range(72):  # 500 epochs\n",
        "    for inputs, labels in train_loader:\n",
        "        inputs, labels = inputs.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        #Add regularization\n",
        "        l1_norm = sum(p.abs().sum() for p in net.parameters())\n",
        "        loss+=0.002*l1_norm\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    # Print loss and accuracy every 10 epochs\n",
        "    if epoch % 10 == 0:\n",
        "        train_acc = get_accuracy(train_loader, net)\n",
        "        print(f\"Epoch {epoch}, Loss: {loss.item()}, Accuracy: {train_acc}\")\n",
        "        losses.append(loss.item())\n",
        "        accuracies.append(train_acc)\n",
        "\n",
        "print(\"Training is complete!\")\n",
        "\n",
        "# Plot the training loss\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(losses)\n",
        "plt.title('Training Loss')\n",
        "plt.xlabel('Epoch (x10)')\n",
        "plt.ylabel('Loss')\n",
        "plt.show()\n",
        "\n",
        "# Test the network\n",
        "net.eval()  # Set the network to evaluation mode\n",
        "test_acc = get_accuracy(test_loader, net)\n",
        "print('Accuracy of the network on test data: %d %%' % (100 * test_acc))\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 669
        },
        "id": "CotsMhfVX9Qu",
        "outputId": "e21d5b42-61a8-4bdb-ad02-84b9c089ffd1"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0, Loss: 1.1199370622634888, Accuracy: 0.529375\n",
            "Epoch 10, Loss: 0.8308830261230469, Accuracy: 0.568125\n",
            "Epoch 20, Loss: 0.7620842456817627, Accuracy: 0.5697916666666667\n",
            "Epoch 30, Loss: 0.9773595929145813, Accuracy: 0.5689583333333333\n",
            "Epoch 40, Loss: 1.198759913444519, Accuracy: 0.565\n",
            "Epoch 50, Loss: 1.0454446077346802, Accuracy: 0.5683333333333334\n",
            "Epoch 60, Loss: 0.862614631652832, Accuracy: 0.568125\n",
            "Epoch 70, Loss: 0.6810250878334045, Accuracy: 0.56375\n",
            "Training is complete!\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on test data: 54 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "P6kmFVwyX9Ty"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "SagS91l9eUAZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "pmk5x5D7eUD7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "from torch.utils.data import DataLoader, TensorDataset, random_split\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "torch.manual_seed(42)\n",
        "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
        "# Define the network architecture\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(100, 20)\n",
        "        self.dropout1 = nn.Dropout(0.2)\n",
        "        self.fc3 = nn.Linear(20, 10)\n",
        "        self.dropout2 = nn.Dropout(0.2)\n",
        "        self.fc4 = nn.Linear(10, 3)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        self.dropout1(x)\n",
        "        x = torch.relu(self.fc3(x))\n",
        "        self.dropout2(x)\n",
        "        x = self.fc4(x)\n",
        "        return x\n",
        "\n",
        "def binary_to_bits(binary_list):\n",
        "    return [[[int(i) for i in str(bit)] for bit in binary_string][0] for binary_string in binary_list]\n",
        "data = np.loadtxt(\"AI_2qubits_training_data.txt\", dtype = str)\n",
        "X = torch.tensor(np.array(binary_to_bits(data[:,:-1])))\n",
        "Y = torch.tensor(data[:,-1].astype(int))-1\n",
        "\n",
        "# Create the network\n",
        "net = Net().to(device)\n",
        "\n",
        "# Define the loss function and the optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
        "\n",
        "# Create a dataset from X and y\n",
        "dataset = TensorDataset(X.float(), Y.long())\n",
        "\n",
        "# Decide on the sizes of the splits\n",
        "train_size = int(0.3 * len(dataset))  # 50% for training\n",
        "test_size = len(dataset) - train_size  # 50% for testing\n",
        "\n",
        "# Use random_split to split the dataset\n",
        "train_dataset, test_dataset = random_split(dataset, [train_size, test_size])\n",
        "\n",
        "# Create data loaders for the train and test datasets\n",
        "train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)\n",
        "test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False)\n",
        "\n",
        "# Function to calculate accuracy\n",
        "def get_accuracy(loader, model):\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    with torch.no_grad():\n",
        "        for inputs, labels in loader:\n",
        "            inputs, labels = inputs.to(device), labels.to(device)\n",
        "            outputs = model(inputs)\n",
        "            _, predicted = torch.max(outputs, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "    return correct / total\n",
        "\n",
        "# Lists to store losses and accuracies for plotting\n",
        "losses = []\n",
        "accuracies = []\n",
        "\n",
        "# Train the network\n",
        "for epoch in range(51):  # 500 epochs\n",
        "    for inputs, labels in train_loader:\n",
        "        inputs, labels = inputs.to(device), labels.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "\n",
        "        #Add regularization\n",
        "        l1_norm = sum(p.abs().sum() for p in net.parameters())\n",
        "        loss+=0.001*l1_norm\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "    # Print loss and accuracy every 10 epochs\n",
        "    if epoch % 10 == 0:\n",
        "        train_acc = get_accuracy(train_loader, net)\n",
        "        print(f\"Epoch {epoch}, Loss: {loss.item()}, Accuracy: {train_acc}\")\n",
        "        losses.append(loss.item())\n",
        "        accuracies.append(train_acc)\n",
        "\n",
        "print(\"Training is complete!\")\n",
        "\n",
        "# Plot the training loss\n",
        "plt.figure(figsize=(10, 5))\n",
        "plt.plot(losses)\n",
        "plt.title('Training Loss')\n",
        "plt.xlabel('Epoch (x10)')\n",
        "plt.ylabel('Loss')\n",
        "plt.show()\n",
        "\n",
        "# Test the network\n",
        "net.eval()  # Set the network to evaluation mode\n",
        "test_acc = get_accuracy(test_loader, net)\n",
        "print('Accuracy of the network on test data: %d %%' % (100 * test_acc))\n",
        "#lambda = 0.001 gave 50%"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 633
        },
        "id": "rjKf0_VQeUPD",
        "outputId": "f078fec6-6d37-4d9c-a579-7bb610ceb293"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 0, Loss: 1.1797254085540771, Accuracy: 0.3422222222222222\n",
            "Epoch 10, Loss: 1.1112927198410034, Accuracy: 0.5683333333333334\n",
            "Epoch 20, Loss: 0.9477442502975464, Accuracy: 0.5916666666666667\n",
            "Epoch 30, Loss: 1.1219295263290405, Accuracy: 0.6061111111111112\n",
            "Epoch 40, Loss: 1.095760703086853, Accuracy: 0.6183333333333333\n",
            "Epoch 50, Loss: 0.5893382430076599, Accuracy: 0.6238888888888889\n",
            "Training is complete!\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on test data: 53 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "G3P3OkhbeZJ8"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}