scratch-nb-training-neel.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## import essential modules \n",
    "import qumcmc \n",
    "from qumcmc.basic_utils import *\n",
    "from qumcmc.energy_models import IsingEnergyFunction, Exact_Sampling\n",
    "\n",
    "from qumcmc.classical_mcmc_routines import *\n",
    "from qumcmc.quantum_mcmc_routines_qulacs import *     #for Qulacs Simulator backend\n",
    "# from qumcmc.quantum_mcmc_routines_qulacs import quantum_enhanced_mcmc   #for qiskit Aer's Simulator backend \n",
    "from typing import Union\n",
    "from qumcmc.trajectory_processing import *\n",
    "import seaborn as sns\n",
    "\n",
    "#\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = random.sample(range(1, 50), 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def kl_divergence(dict_p: dict, dict_q: dict):\n",
    "    ''' \n",
    "    Returns KL divergence KL(p||q);\n",
    "\n",
    "    Args:\n",
    "\n",
    "    dict_p: distribution p ({random_variable: prob}),\n",
    "\n",
    "    dict_q: distribution q ({random_variable: prob}),\n",
    "\n",
    "    prelim_check: default 'True'. \n",
    "    If user is completely sure that \n",
    "    dict_p and dict_q have same keys and that both the distributions are\n",
    "    normalised then user can set it to 'False'.\n",
    "    '''\n",
    "    # if prelim_check:\n",
    "    #     #check for whether or not dict_p and dict_q have same keys\n",
    "    #     keys_p,keys_q=list(dict_p.keys()),list(dict_q.keys())# reason why not inplace\n",
    "    #     keys_p.sort();keys_q.sort()\n",
    "    #     assert keys_p==keys_q, \"keys of both the dictionaries dont match!\"\n",
    "\n",
    "    #     # check for whether values add to 1.\n",
    "    #     eps=1e-6\n",
    "    #     sum_vals_p=np.sum(list(dict_p.values()))\n",
    "    #     assert np.abs(sum_vals_p-1.0)<=eps, \"sum of values of dict_p must be 1.\"\n",
    "    #     sum_vals_q=np.sum(list(dict_q.values()))\n",
    "    #     assert np.abs(sum_vals_q-1.0)<=eps, \"sum of values of dict_q must be 1.\"\n",
    "    \n",
    "    # #prep for caln\n",
    "    # p=DiscreteProbabilityDistribution(dict_p).index_sorted_dict()\n",
    "    # q=DiscreteProbabilityDistribution(dict_q).index_sorted_dict()\n",
    "    # p_arr,q_arr=np.array(list(p.values())).reshape((len(p))), np.array(list(q.values())).reshape((len(q)))\n",
    "    # return np.sum(np.where(p_arr>10**-6,p_arr*np.log2(p_arr/q_arr),0.))\n",
    "\n",
    "    KL = 0\n",
    "    for bitstring, p_data in dict_p.items():\n",
    "        if bitstring in dict_q.keys() and p_data!=0:\n",
    "            KL += p_data * np.log(p_data) - p_data * np.log(\n",
    "                max(1e-6, dict_q[bitstring])\n",
    "            )\n",
    "            # print(\"1. kl is:\",p_data * np.log(p_data) - p_data * np.log(\n",
    "            #     max(1e-6, dict_q[bitstring])))\n",
    "        elif bitstring in dict_q.keys() and p_data==0:\n",
    "            KL+=0\n",
    "        else:\n",
    "            KL += p_data * np.log(p_data) - p_data * np.log(1e-6)\n",
    "            #print(\"2: KL is:\",p_data * np.log(p_data) - p_data * np.log(1e-6))\n",
    "    return KL\n",
    "    #     else:\n",
    "    #         KL += p_data * np.log(p_data) - p_data * np.log(1e-6)\n",
    "    #         print(\"2: KL is:\",p_data * np.log(p_data) - p_data * np.log(1e-6))\n",
    "    # return KL\n",
    "\n",
    "def js_divergence(dict_p:dict,dict_q:dict, prelim_check=True):\n",
    "    ''' \n",
    "    Returns JS divergence JS(p||q);\n",
    "    \n",
    "    Args:\n",
    "    dict_p: distribution p ({random_variable: prob}),\n",
    "\n",
    "    dict_q: distribution q ({random_variable: prob}),\n",
    "\n",
    "    prelim_check: default 'True'. \n",
    "    If user is completely sure that \n",
    "    dict_p and dict_q have same keys and that both the distributions are\n",
    "    normalised then user can set it to 'False'.\n",
    "    '''\n",
    "    if prelim_check:\n",
    "        #check for whether or not dict_p and dict_q have same keys\n",
    "        keys_p,keys_q=list(dict_p.keys()),list(dict_q.keys())\n",
    "        keys_p.sort();keys_q.sort()\n",
    "        assert keys_p==keys_q, \"keys of both the dictionaries dont match!\"\n",
    "        \n",
    "        # check for whether values add to 1.\n",
    "        eps=1e-6\n",
    "        sum_vals_p=np.sum(list(dict_p.values()))\n",
    "        assert np.abs(sum_vals_p-1.0)<=eps, \"sum of values of dict_p must be 1.\"\n",
    "        sum_vals_q=np.sum(list(dict_q.values()))\n",
    "        assert np.abs(sum_vals_q-1.0)<=eps, \"sum of values of dict_q must be 1.\"\n",
    "\n",
    "    #prep for caln\n",
    "    p=DiscreteProbabilityDistribution(dict_p).index_sorted_dict()\n",
    "    q=DiscreteProbabilityDistribution(dict_q).index_sorted_dict()\n",
    "    p_arr,q_arr=np.array(list(p.values())).reshape((len(p))), np.array(list(q.values())).reshape((len(q)))\n",
    "    val_m = np.round(0.5 * (p_arr + q_arr),decimals=8)\n",
    "    #print(\"val_m:\");print(val_m)\n",
    "    m=dict(zip(list(p.keys()),val_m))\n",
    "    print(\"m:\");print(m)\n",
    "    return 0.5 * (kl_divergence(p, m) +  kl_divergence(q, m ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. kl is: 0.0\n",
      "1. kl is: -0.029150791058373815\n",
      "1. kl is: 0.055451774444795626\n",
      "KL: 0.02630098338642181\n",
      "1. kl is: 0.0\n",
      "1. kl is: -0.014783643805358737\n",
      "1. kl is: 0.018800145169829446\n",
      "1. kl is: 0.0\n",
      "1. kl is: 0.015212273562015988\n",
      "1. kl is: -0.009162907318741545\n",
      "JS: 0.005032933803872576\n"
     ]
    }
   ],
   "source": [
    "dict_p={0:0.45,1:0.51,2:0.04}\n",
    "dict_q={0:0.45,1:0.54,2:0.01}\n",
    "print(\"KL:\",kl_divergence(dict_p=dict_p,dict_q=dict_q))# correct one with 10^(-20)\n",
    "print(\"JS:\",js_divergence(dict_p=dict_p,dict_q=dict_q))# correct one with 10^(-20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. kl is: 0.0\n",
      "1. kl is: -0.038508851779154085\n",
      "2: KL is: 0.423865389323843\n",
      "KL: 0.3853565375446889\n",
      "m:\n",
      "{0: 0.45, 1: 0.53, 2: 0.02}\n",
      "1. kl is: 0.0\n",
      "1. kl is: -0.019617803222176045\n",
      "1. kl is: 0.027725887222397827\n",
      "1. kl is: 0.0\n",
      "1. kl is: 0.02037269942419201\n",
      "JS: 0.014240391712206896\n"
     ]
    }
   ],
   "source": [
    "dict_p={0:0.45,1:0.51,2:0.04}\n",
    "dict_q={0:0.45,1:0.55}\n",
    "print(\"KL:\",kl_divergence(dict_p=dict_p,dict_q=dict_q))# with 10^(-20)\n",
    "dict_q={0:0.45,1:0.55,2:0}\n",
    "print(\"JS:\",js_divergence(dict_p=dict_p,dict_q=dict_q))# with 10^(-20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. kl is: 0.0\n",
      "1. kl is: -0.038508851779154085\n",
      "2: KL is: 0.7922790042028903\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.7537701524237362"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_p={0:0.45,1:0.51,2:0.04}\n",
    "dict_q={0:0.45,1:0.55}\n",
    "kl_divergence(dict_p=dict_p,dict_q=dict_q)# 10^(-10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. kl is: 0.0\n",
      "1. kl is: -0.038508851779154085\n",
      "2: KL is: 0.423865389323843\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.3853565375446889"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_p={0:0.45,1:0.51,2:0.04}\n",
    "dict_q={0:0.45,1:0.55}\n",
    "kl_divergence(dict_p=dict_p,dict_q=dict_q)# 10^(-6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[1,2,3,4,5]\n",
    "a[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============================================\n",
      "            MODEL : my_model\n",
      "=============================================\n",
      "Non-zero Interactions (J) : 6 / 6\n",
      "Non-zero Bias (h) : 3 / 4\n",
      "---------------------------------------------\n",
      "Average Interaction Strength <|J|> :  0.5205\n",
      "Average Bias Strength <|h|>:  0.2425\n",
      "alpha :  0.9929399759718381\n",
      "---------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1152x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define the model\n",
    "np.random.seed(2) ##l lucky-seed: 610358\n",
    "n_spins = 4\n",
    "\n",
    "## construct problem Hamiltonian ##\n",
    "shape_of_J=(n_spins,n_spins)\n",
    "\n",
    "## defining J matrix (mutual 1-1 interaction)\n",
    "# J =  np.round(np.random.choice([+1, 0, -1], size=(n_spins, n_spins)), decimals=2) \n",
    "J =  np.random.uniform(low= -2, high= 2, size= shape_of_J )\n",
    "\n",
    "J = 0.5 * (J + J.transpose() )\n",
    "J = np.round( J - np.diag(np.diag(J)) , decimals= 3)\n",
    "\n",
    "# defining h\n",
    "h = np.round(0.5 * np.random.randn(n_spins), decimals=2)\n",
    "#h = np.round(np.random.uniform(low= -1, high = 1, size= (n_spins)), decimals=2)\n",
    "\n",
    "# instantiate the model\n",
    "model = IsingEnergyFunction(J, h, name= 'my_model')\n",
    "\n",
    "model.model_summary()\n",
    "## set current beta\n",
    "beta = 2\n",
    "\n",
    "## run exact sampling over all possible configurations \n",
    "esm = Exact_Sampling(model, beta)\n",
    "# esm.run_exact_sampling(beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============================================\n",
      "     MODEL : my_model |  beta : 2\n",
      "=============================================\n",
      "Num Most Probable States : 2\n",
      "Entropy : 1.0155590341443856\n",
      "---------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "esm.sampling_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "esm.boltzmann_pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "cl_mcmc_chain=classical_mcmc(n_hops=500000,\n",
    "model=model,temperature=1/beta,initial_state='0000',\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_mcmc_chain=quantum_enhanced_mcmc(n_hops=20000,\n",
    "model=model,temperature=1/beta,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "cl_sampling=dict(cl_mcmc_chain.emp_distn_markov_chain_dict(normalize=True))\n",
    "q_sampling=dict(q_mcmc_chain.emp_distn_markov_chain_dict(normalize=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_multiple_bargraphs([esm.boltzmann_pd,cl_sampling,q_sampling],[\"exact\",\"sampled-cl\",\"sampled-Q\"],list_normalise=[False,False,False],plot_first_few=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "cl_accepted=dict(cl_mcmc_chain.get_accepted_dict(normalize=True))\n",
    "q_accepted=dict(q_mcmc_chain.get_accepted_dict(normalize=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_multiple_bargraphs([esm.boltzmann_pd,q_sampling,q_accepted],\n",
    "[\"exact\",\"sampled-Q-corrected\",\"distn from q-get_accepted_dict(previous/incorrect)\"],\n",
    "list_normalise=[False,False,False],plot_first_few=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_multiple_bargraphs([esm.boltzmann_pd,cl_sampling,q_sampling,cl_accepted,q_accepted],\n",
    "[\"exact\",\"sampled-cl-corrected\",\"sampled-Q-corrected\",\"distn from cl-get_accepted_dict (incorrect)\",\"distn from q-get_accepted_dict(incorrect)\"],\n",
    "list_normalise=[False,False,False,False,False],plot_first_few=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# steps = 10000\n",
    "# cl_chain =classical_mcmc(\n",
    "#     n_hops=steps,\n",
    "#     model=model,\n",
    "#     temperature=1/beta,\n",
    "# )\n",
    "# steps = 1000\n",
    "# qamcmc_chain =quantum_enhanced_mcmc(\n",
    "#     n_hops=steps,\n",
    "#     model=model,\n",
    "#     temperature=1/beta,\n",
    "#     verbose = False\n",
    "# )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class IsingEnergyFunction:\n",
    "#     \"\"\" A class to build the Ising Energy Function from data  \n",
    "#     \"\"\"\n",
    "\n",
    "#     def __init__(self, J: np.array, h: np.array, name:str = None) -> None:\n",
    "#         \"\"\"\n",
    "#             ARGS:\n",
    "#             ----\n",
    "#             J: weight-matrix of the interactions between the spins \n",
    "#             h: local field to the spins \n",
    "\n",
    "#         \"\"\"\n",
    "#         self.J = J\n",
    "#         self.h = h\n",
    "#         # self.beta = beta\n",
    "#         self.num_spins = len(h)\n",
    "#         # self.exact_sampling_status = False\n",
    "#         self.alpha = np.sqrt(self.num_spins) / np.sqrt( sum([J[i][j]**2 for i in range(self.num_spins) for j in range(i)]) + sum([h[j]**2 for j in range(self.num_spins)])  )\n",
    "\n",
    "#         if name == None: \n",
    "#             self.name = 'JK_random'\n",
    "#         else : self.name = name \n",
    "    \n",
    "#     @property\n",
    "#     def get_J(self):\n",
    "#         return self.J\n",
    "    \n",
    "#     @property\n",
    "#     def get_h(self):\n",
    "#         return self.h\n",
    "\n",
    "#     # @property\n",
    "#     def model_summary(self, plot= True) :\n",
    "        \n",
    "#         print(\"=============================================\")\n",
    "#         print(\"            MODEL : \"+str(self.name) )\n",
    "#         print(\"=============================================\")\n",
    "        \n",
    "        \n",
    "#         print(\"Non-zero Interactions (J) : \"+ str( int(np.count_nonzero(self.J) /2)) + ' / '+str( int( 0.5 * self.num_spins * (self.num_spins - 1))) )\n",
    "#         print(\"Non-zero Bias (h) : \"+ str( int(np.count_nonzero(self.h) )) + ' / ' + str( self.num_spins ) )\n",
    "#         print(\"---------------------------------------------\")\n",
    "\n",
    "#         print(\"Average Interaction Strength <|J|> : \", np.mean(np.abs(self.J)))\n",
    "#         print(\"Average Bias Strength <|h|>: \", np.mean(np.abs(self.h)))\n",
    "#         print(\"alpha : \", self.alpha )\n",
    "    \n",
    "#         print(\"---------------------------------------------\")\n",
    "\n",
    "\n",
    "#         # sns.set()\n",
    "#         if plot:\n",
    "#             plt.figure(figsize=(16,10))\n",
    "#             sns.heatmap(self.J, square= True, annot= False, cbar= True)\n",
    "            \n",
    "\n",
    "#     def get_energy(self, state: Union[str, np.array]) -> float:\n",
    "#         \"\"\" Returns the energy of a given state\n",
    "\n",
    "#             ARGS:\n",
    "#             ----\n",
    "#             state : configuration of spins for which the energy is requrieed to be calculated.\n",
    "#                     NOTE:  if input is an numpy array then it should only consist of bipolar values -> {+1, -1}\n",
    "\n",
    "#         \"\"\"\n",
    "\n",
    "#         if isinstance(state, str):\n",
    "#             state = np.array([-1 if elem == \"0\" else 1 for elem in state])\n",
    "#             # state = np.array( [int(list(state)[i]) for i in range(len(state))])\n",
    "#             energy = 0.5 * np.dot(state.transpose(), self.J.dot(state)) + np.dot(\n",
    "#                 self.h.transpose(), state\n",
    "#             )\n",
    "#             return energy\n",
    "#         else:\n",
    "#             return 0.5 * np.dot(state.transpose(), self.J.dot(state)) + np.dot(\n",
    "#                 self.h.transpose(), state\n",
    "#             )\n",
    "\n",
    "\n",
    "#     def get_boltzmann_factor(\n",
    "#         self, state: Union[str, np.array], beta: float = 1.0\n",
    "#     ) -> float:\n",
    "\n",
    "#         \"\"\" Get un-normalised boltzmann probability of a given state \n",
    "\n",
    "#             ARGS:\n",
    "#             ----\n",
    "#             state : configuration of spins for which probability is to be calculated \n",
    "#             beta : inverse temperature (1/T) at which the probability is to be calculated.\n",
    "        \n",
    "#         \"\"\"\n",
    "#         return np.exp(-1 * beta * self.get_energy(state))\n",
    "    \n",
    "#     from typing import List\n",
    "#     def _update_J(self, new_param:float, index: Union[tuple, List]):\n",
    "\n",
    "#         assert len(index) == 2\n",
    "#         self.J[index[0], index[1]] = new_param\n",
    "#         self.J[index[1], index[0]] = new_param\n",
    "    \n",
    "#     def _update_h(self, new_param: float, index: int):\n",
    "\n",
    "#         self.h[index] = new_param\n",
    "\n",
    "# class DiscreteProbabilityDistribution(dict):\n",
    "#     \"\"\" A class for handling discrete probability distributions \"\"\"\n",
    "\n",
    "#     def __init__(self, distribution:dict) -> None :\n",
    "\n",
    "#         super().__init__(distribution) \n",
    "    \n",
    "#     def _normalise(self, print_normalisation:bool= False):\n",
    "#         \"\"\" Normalise the given disribution \n",
    "#             NOTE: works inplace \n",
    "#         \"\"\"\n",
    "        \n",
    "#         r_sum = np.sum(list(self.values()))\n",
    "#         if print_normalisation : print('Normalisation : ', r_sum)\n",
    "#         for k in list(self.keys()) :\n",
    "#             self[k] = self[k] / r_sum\n",
    "\n",
    "#     def value_sorted_dict(self, reverse=False):\n",
    "#         \"\"\" Sort the dictionary in ascending or descending(if reverse=True) order of values. \"\"\"\n",
    "#         sorted_dict = {\n",
    "#             k: v\n",
    "#             for k, v in sorted(self.items(), key=lambda item: item[1], reverse=reverse)\n",
    "#         }\n",
    "#         return sorted_dict\n",
    "\n",
    "#     def index_sorted_dict(self, reverse= False):\n",
    "#         \"\"\" Sort the dictionary in ascending or descending(if reverse=True) order of index. \"\"\"\n",
    "#         sorted_dict = {\n",
    "#             k: v\n",
    "#             for k, v in sorted(self.items(), key=lambda item: item[0], reverse=reverse)\n",
    "#         }\n",
    "#         return sorted_dict\n",
    "   \n",
    "#     def get_truncated_distribution(self, epsilon:float = 0.00001, inplace:bool = False):\n",
    "        \n",
    "#         return_dict = {}\n",
    "#         index_probable_elements = [ indx for indx, b in enumerate( np.array(list(self.values())) > epsilon ) if b ]\n",
    "#         states = list(self.keys())\n",
    "#         probs = list(self.values())\n",
    "\n",
    "#         for indx in index_probable_elements:\n",
    "#             return_dict[states[indx]] = probs[indx]\n",
    "        \n",
    "#         if not inplace:\n",
    "#             return DiscreteProbabilityDistribution(return_dict)\n",
    "#         else :\n",
    "#             self.__init__(return_dict)\n",
    "            \n",
    "#     def expectation(self, dict_observable_val_at_states: dict):\n",
    "#         \"\"\"\n",
    "#         new version:\n",
    "#         Returns average of any observable of interest\n",
    "\n",
    "#         Args:\n",
    "#         self= {state: probability}\n",
    "#         dict_observable_val_at_states={state (same as that of self): observable's value at that state}\n",
    "\n",
    "#         Returns:\n",
    "#         avg\n",
    "#         \"\"\"\n",
    "#         ##TODO: A faster implementation is possible by using numpy \n",
    "#         len_dict = len(self)\n",
    "#         temp_list = [\n",
    "#             self[j] * dict_observable_val_at_states[j]\n",
    "#             for j in (list(self.keys()))\n",
    "#         ]\n",
    "#         avg = np.sum(\n",
    "#             temp_list\n",
    "#         )  # earlier I had np.mean here , which is wrong (obviously! duh!)\n",
    "#         return avg\n",
    "\n",
    "#     def get_entropy(self):\n",
    "#         tmp = sorted(np.array(list(self.values())), reverse= True)\n",
    "#         entropy = 0\n",
    "#         for val in tmp :\n",
    "#             if val > 0.00001 :\n",
    "#                 entropy += -1 * val * np.log2(val)\n",
    "#             else: \n",
    "#                 return entropy\n",
    "    \n",
    "#     def get_observable_expectation(self, observable) -> float:\n",
    "#         \"\"\" Return expectation value of a classical observables\n",
    "\n",
    "#             ARGS :\n",
    "#             ----\n",
    "#             observable: Must be a function of the spin configuration which takes an 'np.array' / 'str' of binary elements as input argument and returns a 'float'\n",
    "#             beta: inverse temperature\n",
    "\n",
    "#         \"\"\"\n",
    "#         # all_configs = np.array(list(itertools.product([1, 0], repeat=self.num_spins)))\n",
    "#         # all_configs = [f\"{k:0{self.num_spins}b}\" for k in range(0, 2 ** (self.num_spins))]\n",
    "        \n",
    "\n",
    "#         return np.sum(\n",
    "#             [\n",
    "#                 self[config]\n",
    "#                 * observable(config)\n",
    "\n",
    "#                 for config in self.keys()\n",
    "#             ]\n",
    "#         )\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### HELPER FUNCTIONS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "int_to_binary = lambda state_obtained, n_spins : f\"{state_obtained:0{n_spins}b}\"\n",
    "binary_to_bipolar = lambda string : 2.0 * float(string) - 1.0\n",
    "\n",
    "def get_observable_expectation(observable: callable, mcmc_chain: MCMCChain, skip_init:int= 100) :\n",
    "\n",
    "    sample_observable = []\n",
    "    for s in mcmc_chain.accepted_states :\n",
    "\n",
    "        sample_observable.append(observable(s) )\n",
    "    \n",
    "    sample_observable = np.array(sample_observable)\n",
    "        \n",
    "    return sample_observable.mean(dtype= float)#, sample_observable.var(dtype= float)\n",
    "\n",
    "\n",
    "def correlation_spins(state: str, indices : Union[tuple, List] ):\n",
    "\n",
    "    assert len(indices) <= len(state)\n",
    "    \n",
    "    \n",
    "    prod = 1.0\n",
    "    for j in indices :\n",
    "        prod *= binary_to_bipolar(state[j])\n",
    "\n",
    "    return prod\n",
    "\n",
    "def cd_J(index, data_distribution:DiscreteProbabilityDistribution, mcmc_chain: MCMCChain):\n",
    "\n",
    "    assert len(index) == 2\n",
    "    observable = lambda s: correlation_spins(s, [index[0], index[1]])\n",
    "    r = data_distribution.get_observable_expectation(observable) - get_observable_expectation(observable, mcmc_chain, skip_init= 100)\n",
    "\n",
    "    return r\n",
    "\n",
    "def cd_h(index:int, data_distribution:DiscreteProbabilityDistribution, mcmc_chain: MCMCChain):\n",
    "\n",
    "    assert isinstance(index, int)\n",
    "    observable = lambda s: correlation_spins(s, [index])\n",
    "    r = data_distribution.get_observable_expectation(observable) - get_observable_expectation(observable, mcmc_chain, skip_init= 100)\n",
    "\n",
    "    return r"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Class for Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "from copy import deepcopy\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# @dataclass\n",
    "class cd_training():\n",
    "    ''' \n",
    "    model: initial model = (J init, h init) at some temp T\n",
    "    beta: 1/Temperature\n",
    "    data_dist: empirical data which we want to learn!\n",
    "    \n",
    "    '''\n",
    "\n",
    "    def __init__(self, model: IsingEnergyFunction, beta:float ,data_dist: DiscreteProbabilityDistribution) -> None:\n",
    "        self.model = deepcopy(model)\n",
    "        self.model_beta = beta\n",
    "        self.data_distribution = data_dist\n",
    "        self.training_history = {}\n",
    "        self.list_pair_of_indices=[[i,j] for i in range(1,self.model.num_spins) for j in range(i,self.model.num_spins) if j!=i]\n",
    "        \n",
    "\n",
    "    def cd_J(self, index, mcmc_chain: MCMCChain):\n",
    "\n",
    "        assert len(index) == 2\n",
    "        observable = lambda s: correlation_spins(s, [index[0], index[1]])\n",
    "        r = self.data_distribution.get_observable_expectation(observable) - get_observable_expectation(observable, mcmc_chain, skip_init= 100)\n",
    "\n",
    "        return r\n",
    "\n",
    "    def cd_h(self, index:int, mcmc_chain: MCMCChain):\n",
    "\n",
    "        assert isinstance(index, int)\n",
    "        observable = lambda s: correlation_spins(s, [index])\n",
    "        r = self.data_distribution.get_observable_expectation(observable) - get_observable_expectation(observable, mcmc_chain, skip_init= 100)\n",
    "\n",
    "        return r\n",
    "\n",
    "    # @setattr\n",
    "    # def data_distribution()\n",
    "    \n",
    "    def _train_on_mcmc_chain(self, lr:float= 0.01, \n",
    "    method = 'quantum-enhanced', \n",
    "    iterations: int = 100, # rename this iterations to something else\n",
    "    num_random_Jij: int=10,\n",
    "    mcmc_steps:int =1000 ):# we will try to increase mcmc steps. \n",
    "\n",
    "        if method == 'quantum-enhanced' :\n",
    "            self.mcmc_chain = quantum_enhanced_mcmc(\n",
    "            n_hops=mcmc_steps,\n",
    "            model=self.model,\n",
    "            temperature=1/self.model_beta,\n",
    "            verbose= False\n",
    "            )\n",
    "        elif method == 'classical-uniform' : \n",
    "            self.mcmc_chain = classical_mcmc(\n",
    "            n_hops=mcmc_steps,\n",
    "            model=self.model,\n",
    "            temperature=1/self.model_beta,\n",
    "            verbose= False\n",
    "            )\n",
    "        \n",
    "        ## random update strategy ##\n",
    "        ## just realised that even this is not a good thing! \n",
    "        assert iterations<=self.model.num_spins, f\"iterations should be <= num_spins (which is= {self.model.num_spins}) \"\n",
    "        assert num_random_Jij<=len(self.list_pair_of_indices), f\"num_random_Jij should be <=len(self.list_pair_of_indices) (which is= {len(self.list_pair_of_indices)})\"\n",
    "        \n",
    "        list_random_indices=random.sample(range(0,self.model.num_spins), iterations)\n",
    "        #list_pair_of_indices=[[i,j] for i in range(1,self.model.num_spins) for j in range(i,self.model.num_spins) if j!=i]\n",
    "        #list_pair_of_different_indices=random.sample(self.list_pair_of_indices,k=num_random_Jij)\n",
    "\n",
    "        list_pair_of_different_indices=[[list_random_indices[j],\n",
    "                    random.choice(list(range(0,list_random_indices[j]))+list(range(list_random_indices[j]+1,self.model.num_spins)))] \n",
    "                    for j in range(0,iterations)]\n",
    "        \n",
    "        # ## Update J\n",
    "        for k in range(len(list_pair_of_different_indices)):\n",
    "            indices_J=list_pair_of_different_indices[k]\n",
    "            updated_param_j=model.J[indices_J[0],indices_J[1]] - lr * self.cd_J(indices_J, self.mcmc_chain)\n",
    "            self.model._update_J(updated_param_j, indices_J)\n",
    "\n",
    "        for k in range(iterations):\n",
    "            #indices_J=list_pair_of_different_indices[k]\n",
    "            #updated_param_j = model.J[indices_J[0],indices_J[1]] - lr * self.cd_J(indices_J, self.mcmc_chain)\n",
    "\n",
    "            # update h\n",
    "            index_h=list_random_indices[k]\n",
    "            updated_param_h=model.h[index_h] - lr*self.cd_h(index_h,self.mcmc_chain)\n",
    "\n",
    "            #self.model._update_J(updated_param_j, indices_J)\n",
    "            self.model._update_h(updated_param_h, index_h)\n",
    "\n",
    "        # for _ in range(iterations):\n",
    "            \n",
    "        #     ## update J ##\n",
    "        #     index_J = [np.random.randint(0, self.model.num_spins), np.random.randint(0, self.model.num_spins)]\n",
    "\n",
    "        #     updated_param_j = model.J[index_J[0], index_J[1]] - lr * self.cd_J(index_J, self.mcmc_chain) \n",
    "        #     ## comment by neel: we need to update both Jij as well as Jji\n",
    "        #     # already updating J first.\n",
    "        #     #self.model._update_J(updated_param_j, index)\n",
    "\n",
    "        #     ## update h ##\n",
    "        #     index_h = np.random.randint(0, self.model.num_spins)\n",
    "\n",
    "        #     updated_param_h = model.h[index_h] - lr * self.cd_h(index_h, self.mcmc_chain) \n",
    "\n",
    "        #     self.model._update_J(updated_param_j, index_J)\n",
    "        #     self.model._update_h(updated_param_h, index_h)\n",
    "\n",
    "            \n",
    "\n",
    "    def train(self, lr:float= 0.01, method = 'quantum-enhanced', \n",
    "    epochs:int = 10, iterations: int = 100, num_random_Jij:int=5,\n",
    "    mcmc_steps:int = 500, show_kldiv:bool = True ):\n",
    "\n",
    "        ## random update strategy ##\n",
    "        kl_div = []\n",
    "        iterator = tqdm(range(epochs), desc= 'training epochs')\n",
    "        iterator.set_postfix({'method': method})\n",
    "        for epoch in iterator:\n",
    "\n",
    "            self._train_on_mcmc_chain(lr= lr , \n",
    "            method = method, iterations= iterations, num_random_Jij=num_random_Jij,\n",
    "            mcmc_steps= mcmc_steps )\n",
    "\n",
    "            if show_kldiv:\n",
    "\n",
    "                \n",
    "                kl_div.append(kl_divergence(  self.data_distribution,self.mcmc_chain.get_accepted_dict(normalize= True)  ))\n",
    "                iterator.set_postfix( { 'method ': method, 'kl div ' : kl_div[-1] })\n",
    "        \n",
    "        if show_kldiv : self.training_history['kl_div']= kl_div\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TRIALS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============================================\n",
      "     MODEL : param_model |  beta : 1.0\n",
      "=============================================\n",
      "Num Most Probable States : 4\n",
      "Entropy : 2.016575422384969\n",
      "---------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## INITIALISE ANOTHER RANDOM MODEL ##\n",
    "\n",
    "np.random.seed(1)# should always be in the same cell!  \n",
    "n_spins = 8\n",
    "\n",
    "## construct problem Hamiltonian ##\n",
    "shape_of_J=(n_spins,n_spins)\n",
    "\n",
    "## defining J matrix (mutual 1-1 interaction)\n",
    "# J =  np.round(np.random.choice([+1, 0, -1], size=(n_spins, n_spins)), decimals=2) \n",
    "J =  np.random.uniform(low= -3, high= 3, size= shape_of_J )\n",
    "\n",
    "J = 0.5 * (J + J.transpose() )\n",
    "J = np.round( J - np.diag(np.diag(J)) , decimals= 3)\n",
    "\n",
    "# defining h\n",
    "h = np.round(0.4 * np.random.randn(n_spins), decimals=2)\n",
    "#h = np.round(np.random.uniform(low= -1, high = 1, size= (n_spins)), decimals=2)\n",
    "\n",
    "# instantiate the model\n",
    "beta_train = 1.0\n",
    "\n",
    "param_model = IsingEnergyFunction(J, h, name= 'param_model')\n",
    "param_model_esm = Exact_Sampling(param_model, beta= beta_train)\n",
    "\n",
    "param_model_esm.sampling_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.   ,  0.351, -1.748,  0.536,  0.314,  0.244, -1.578, -0.241],\n",
       "       [ 0.351,  0.   , -0.066,  1.739, -0.787,  1.879, -2.528, -0.548],\n",
       "       [-1.748, -0.066,  0.   , -2.151,  1.478,  0.746, -2.002,  0.845],\n",
       "       [ 0.536,  1.739, -2.151,  0.   , -1.544,  2.002, -0.668,  0.363],\n",
       "       [ 0.314, -0.787,  1.478, -1.544,  0.   , -0.186, -2.31 , -0.443],\n",
       "       [ 0.244,  1.879,  0.746,  2.002, -0.186,  0.   ,  0.522, -0.877],\n",
       "       [-1.578, -2.528, -2.002, -0.668, -2.31 ,  0.522,  0.   , -0.757],\n",
       "       [-0.241, -0.548,  0.845,  0.363, -0.443, -0.877, -0.757,  0.   ]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_model.get_J # before training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============================================\n",
      "     MODEL : my_model |  beta : 2\n",
      "=============================================\n",
      "Num Most Probable States : 9\n",
      "Entropy : 2.6583738777945\n",
      "---------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## COMPARE WITH THE DATA-DISTRIBUTION ##\n",
    "esm.sampling_summary()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TRAINING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_spins_prob=model.num_spins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training epochs:  60%|██████    | 36/60 [04:58<03:18,  8.28s/it, method =quantum-enhanced, kl div =0.603]\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-54-9bb872511dcd>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mtraining_quantum\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcd_training\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mparam_model\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbeta_train\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mesm\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mboltzmann_pd\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m training_quantum.train(lr = 0.05 ,method = 'quantum-enhanced' , \n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mepochs\u001b[0m\u001b[1;33m=\u001b[0m \u001b[1;36m60\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miterations\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0mnum_spins_prob\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mnum_random_Jij\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnum_spins_prob\u001b[0m \u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m mcmc_steps= 1000 , show_kldiv= True)# when i in hi and i in Jij are same\n",
      "\u001b[1;32m<ipython-input-41-62d9a767c09b>\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(self, lr, method, epochs, iterations, num_random_Jij, mcmc_steps, show_kldiv)\u001b[0m\n\u001b[0;32m    116\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[1;32min\u001b[0m \u001b[0miterator\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    117\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 118\u001b[1;33m             self._train_on_mcmc_chain(lr= lr , \n\u001b[0m\u001b[0;32m    119\u001b[0m             \u001b[0mmethod\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0miterations\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0miterations\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_random_Jij\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnum_random_Jij\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    120\u001b[0m             mcmc_steps= mcmc_steps )\n",
      "\u001b[1;32m<ipython-input-41-62d9a767c09b>\u001b[0m in \u001b[0;36m_train_on_mcmc_chain\u001b[1;34m(self, lr, method, iterations, num_random_Jij, mcmc_steps)\u001b[0m\n\u001b[0;32m     42\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     43\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mmethod\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'quantum-enhanced'\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 44\u001b[1;33m             self.mcmc_chain = quantum_enhanced_mcmc(\n\u001b[0m\u001b[0;32m     45\u001b[0m             \u001b[0mn_hops\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmcmc_steps\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     46\u001b[0m             \u001b[0mmodel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\Desktop\\QBM project with Manuel\\qumcmc_repo\\quMCMC\\qumcmc\\quantum_mcmc_routines_qulacs.py\u001b[0m in \u001b[0;36mquantum_enhanced_mcmc\u001b[1;34m(n_hops, model, initial_state, temperature, verbose)\u001b[0m\n\u001b[0;32m    200\u001b[0m         \u001b[1;31m# get sprime\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    201\u001b[0m         \u001b[0mqc_s\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minitialise_qc\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn_spins\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum_spins\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbitstring\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mcurrent_state\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbitstring\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 202\u001b[1;33m         s_prime = run_qc_quantum_step(\n\u001b[0m\u001b[0;32m    203\u001b[0m             \u001b[0mqc_initialised_to_s\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mqc_s\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0malpha\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn_spins\u001b[0m\u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum_spins\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    204\u001b[0m         )\n",
      "\u001b[1;32md:\\Desktop\\QBM project with Manuel\\qumcmc_repo\\quMCMC\\qumcmc\\quantum_mcmc_routines_qulacs.py\u001b[0m in \u001b[0;36mrun_qc_quantum_step\u001b[1;34m(qc_initialised_to_s, model, alpha, n_spins)\u001b[0m\n\u001b[0;32m    144\u001b[0m     \u001b[0mdelta_time\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0.8\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    145\u001b[0m     \u001b[0mnum_trotter_steps\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfloor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtime\u001b[0m \u001b[1;33m/\u001b[0m \u001b[0mdelta_time\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 146\u001b[1;33m     \u001b[0mqc_evol_h1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfn_qc_h1\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mn_spins\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgamma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mh\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdelta_time\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    147\u001b[0m     \u001b[0mqc_evol_h2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfn_qc_h2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mJ\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgamma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdelta_time\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdelta_time\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    148\u001b[0m     trotter_ckt = trottered_qc_for_transition(\n",
      "\u001b[1;32md:\\Desktop\\QBM project with Manuel\\qumcmc_repo\\quMCMC\\qumcmc\\quantum_mcmc_routines_qulacs.py\u001b[0m in \u001b[0;36mfn_qc_h1\u001b[1;34m(num_spins, gamma, alpha, h, delta_time)\u001b[0m\n\u001b[0;32m     61\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mj\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnum_spins\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     62\u001b[0m         unitary_gate=DenseMatrix(index=num_spins-1-j,\n\u001b[1;32m---> 63\u001b[1;33m                         \u001b[0mmatrix\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mround\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mexpm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1j\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mdelta_time\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mX\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_matrix\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m+\u001b[0m\u001b[0mb_list\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mZ\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_matrix\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mdecimals\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     64\u001b[0m                         )\n\u001b[0;32m     65\u001b[0m         \u001b[0mqc_h1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_gate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0munitary_gate\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32md:\\anaconda_neel\\lib\\site-packages\\scipy\\linalg\\_matfuncs.py\u001b[0m in \u001b[0;36mexpm\u001b[1;34m(A)\u001b[0m\n\u001b[0;32m    321\u001b[0m         \u001b[0meA\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m...\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meApD2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0ma2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0msinchMu\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    322\u001b[0m         \u001b[0meA\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m...\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meApD2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0ma3\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0msinchMu\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 323\u001b[1;33m         \u001b[0meA\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m...\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meApD2\u001b[0m \u001b[1;33m*\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mcoshMu\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mAmD2\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0msinchMu\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    324\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0misrealobj\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    325\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[0meA\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreal\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "training_quantum = cd_training(param_model, beta_train, esm.boltzmann_pd)\n",
    "training_quantum.train(lr = 0.05 ,method = 'quantum-enhanced' , \n",
    "epochs= 60, iterations= num_spins_prob,num_random_Jij=num_spins_prob ,\n",
    "mcmc_steps= 1000 , show_kldiv= True)# when i in hi and i in Jij are same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.   ,  0.351, -1.748,  0.536,  0.314,  0.244, -1.578, -0.241],\n",
       "       [ 0.351,  0.   , -0.066,  1.739, -0.787,  1.879, -2.528, -0.548],\n",
       "       [-1.748, -0.066,  0.   , -2.151,  1.478,  0.746, -2.002,  0.845],\n",
       "       [ 0.536,  1.739, -2.151,  0.   , -1.544,  2.002, -0.668,  0.363],\n",
       "       [ 0.314, -0.787,  1.478, -1.544,  0.   , -0.186, -2.31 , -0.443],\n",
       "       [ 0.244,  1.879,  0.746,  2.002, -0.186,  0.   ,  0.522, -0.877],\n",
       "       [-1.578, -2.528, -2.002, -0.668, -2.31 ,  0.522,  0.   , -0.757],\n",
       "       [-0.241, -0.548,  0.845,  0.363, -0.443, -0.877, -0.757,  0.   ]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_model.get_J "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "training epochs: 100%|██████████| 100/100 [00:09<00:00, 10.82it/s, method =classical-uniform, kl div =0.634]\n"
     ]
    }
   ],
   "source": [
    "training_cl = cd_training(param_model, beta_train, esm.boltzmann_pd)\n",
    "training_cl.train(lr = 0.01 ,method = 'classical-uniform' , epochs= 100, \n",
    "iterations= num_spins_prob, num_random_Jij=num_spins_prob, mcmc_steps= 1000 , show_kldiv= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.   ,  0.145, -1.045,  1.898,  1.051, -0.026, -0.955, -2.507],\n",
       "       [ 0.145,  0.   ,  0.394, -0.189, -0.425, -1.743,  0.088,  1.857],\n",
       "       [-1.045,  0.394,  0.   , -1.355, -0.101,  1.823, -1.042,  0.219],\n",
       "       [ 1.898, -0.189, -1.355,  0.   ,  1.521, -0.486, -1.106,  0.561],\n",
       "       [ 1.051, -0.425, -0.101,  1.521,  0.   , -0.681,  0.621,  0.695],\n",
       "       [-0.026, -1.743,  1.823, -0.486, -0.681,  0.   , -0.192,  1.768],\n",
       "       [-0.955,  0.088, -1.042, -1.106,  0.621, -0.192,  0.   , -2.836],\n",
       "       [-2.507,  1.857,  0.219,  0.561,  0.695,  1.768, -2.836,  0.   ]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "param_model.get_J"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Compare reconstructed model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# classical reconstructed model\n",
    "cl_mcmc_chain_after_train=classical_mcmc(n_hops=1000,model=training_cl.model, temperature=1,verbose=False)\n",
    "cl_reconstructed_distn=cl_mcmc_chain_after_train.emp_distn_markov_chain_dict(normalize=True)\n",
    "#print(cl_reconstructed_distn)\n",
    "# quantum reconstructed model\n",
    "q_mcmc_chain_after_train=quantum_enhanced_mcmc(n_hops=1000, model=training_quantum.model,temperature=1,verbose=False)\n",
    "q_reconstructed_distn=q_mcmc_chain_after_train.emp_distn_markov_chain_dict(normalize=True)\n",
    "#print(q_reconstructed_distn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# classical_reconstructed_model_esm = Exact_Sampling(training_cl.model, beta= beta_train)\n",
    "# quantum_reconstructed_model_esm = Exact_Sampling(training_quantum.model, beta= beta_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_multiple_bargraphs([esm.boltzmann_pd, cl_reconstructed_distn, q_reconstructed_distn],\n",
    " ['data','classical', 'quantum'], list_normalise=[False,False,False], plot_first_few= 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "#plot_multiple_bargraphs([esm.boltzmann_pd, classical_reconstructed_model_esm.boltzmann_pd, quantum_reconstructed_model_esm.boltzmann_pd], ['data','classical', 'quantum'], list_normalise=[False,False,False], plot_first_few= 15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============================================\n",
      "     MODEL : param_model |  beta : 1.001\n",
      "=============================================\n",
      "Num Most Probable States : 9\n",
      "Entropy : 2.690821820517544\n",
      "---------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "classical_reconstructed_model_esm.sampling_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=============================================\n",
      "     MODEL : param_model |  beta : 1.001\n",
      "=============================================\n",
      "Num Most Probable States : 9\n",
      "Entropy : 2.690821820517544\n",
      "---------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "quantum_reconstructed_model_esm.sampling_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'norma' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-94-f2e4513c6614>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mtraining_quantum\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmcmc_chain\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_accepted_dict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnorma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'norma' is not defined"
     ]
    }
   ],
   "source": [
    "training_quantum.mcmc_chain.get_accepted_dict(norma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.10.6 (main, Nov 14 2022, 16:10:14) [GCC 11.3.0]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}