code_rbm_sr.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0155005b-2500-4ad1-a04d-dbcebcbd1da1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RBM solver using stochastic reconfiguration (SR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04caf96b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.linalg\n",
    "import copy\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from numba import jit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "665ccaea",
   "metadata": {},
   "outputs": [],
   "source": [
    "## https://stackoverflow.com/questions/26560726/python-binomial-coefficient\n",
    "@jit(nopython=True)\n",
    "def binomial(n,r):\n",
    "    p = 1\n",
    "    for i in range(1,min(r,n-r) + 1):\n",
    "        p *= n\n",
    "        p //= i\n",
    "        n -= 1\n",
    "    return p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cc1cb51f",
   "metadata": {},
   "outputs": [],
   "source": [
    "## https://web.archive.org/web/20190109000030/http://www.hackersdelight.org/hdcodetxt/snoob.c.txt\n",
    "@jit(nopython=True)\n",
    "def get_next_same_nup_state(state):\n",
    "    next = 0\n",
    "    if(state>0):\n",
    "        smallest = state & -(state)\n",
    "        ripple = state + smallest\n",
    "        ones = state ^ ripple\n",
    "        ones = (ones >> 2) // smallest\n",
    "        next = ripple | ones\n",
    "    return next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "48d37570",
   "metadata": {},
   "outputs": [],
   "source": [
    "def num2bit(state,L):\n",
    "    return np.binary_repr(state,L)\n",
    "\n",
    "def bit2num(bit):\n",
    "    return int(bit,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9a1d3b17",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_xlist(L,nup,D):\n",
    "    state = (1<<(L-nup))-1\n",
    "    xlist = []\n",
    "    for i in range(D):\n",
    "#        print(i,state,num2bit(state,L))\n",
    "        xlist.append([int(x)*2-1 for x in str(num2bit(state,L))])\n",
    "        state = get_next_same_nup_state(state)\n",
    "    return np.array(xlist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f7c7f30b",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Subroutine for calculating theta \n",
    "##  see Eq.(S9) in Supplementary Materials, Carleo and Troyer, Science (2017)\n",
    "##  \\theta_j = \\sum_i  W_ij * \\sigma_i \n",
    "##\n",
    "## input: sigma[N]\n",
    "## output: theta[M]\n",
    "@jit(nopython=True)\n",
    "def calc_theta(\n",
    "    sigma, theta,\n",
    "    alpha, N, M, Wirr,\n",
    "    ):\n",
    "#\n",
    "    W = np.zeros((M,N),dtype=np.float64)\n",
    "    j = 0\n",
    "    for f in range(alpha):## loop for independent neuron\n",
    "        for jj in range(1,N+1):## we have N copies of hidden units because of translational symmetry\n",
    "            j += 1\n",
    "            theta[j-1] = 0.0\n",
    "            for i in range(1,N+1):\n",
    "                ## set W_ij using translational symmetry\n",
    "                iw = i - jj\n",
    "                if iw<0:\n",
    "                    iw += N\n",
    "                W[j-1,i-1] = Wirr[f-1,iw]\n",
    "                ## calculate theta\n",
    "                theta[j-1] += W[j-1,i-1] * sigma[i-1]\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c000356e",
   "metadata": {},
   "outputs": [],
   "source": [
    "## input: M ## number of hidden units\n",
    "## input: theta[M] ## \\theta_j = \\sum_i  W_ij * \\sigma_i\n",
    "## output: psi_x ## <x|psi> (|x> = |sigma_1, sigma_2, ..., sigma_N>) \n",
    "@jit(nopython=True)\n",
    "def calc_amplitude_RBM(M,theta,psi_x,ix):\n",
    "    ## When bias terms are zero, wave function is given by \n",
    "    ##  psi_x = \\prod_j 2 * cosh(\\theta_j)\n",
    "    tmp = 1.0\n",
    "    for j in range(M):\n",
    "        tmp = tmp * np.cosh(theta[j]) ## neglect irrelevant factor of 2\n",
    "    psi_x[ix] = tmp\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f9339085",
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit(nopython=True)\n",
    "def RBM_solver(\n",
    "    alpha, Nstep, delta_tau,\n",
    "    L, D,\n",
    "    xlist,\n",
    "    ):\n",
    "#\n",
    "    N  = L          # number of visible units \n",
    "    M  = alpha * N  # number of hidden units\n",
    "    Nv = alpha * N  # number of variational parameters\n",
    "    theta = np.zeros(M,dtype=np.float64)\n",
    "    thetap = np.zeros(M,dtype=np.float64)\n",
    "    gvec = np.zeros(Nv,dtype=np.float64)\n",
    "    Ovec = np.zeros(Nv,dtype=np.float64)\n",
    "    Ovec_loc_x = np.zeros(Nv,dtype=np.float64)\n",
    "    Smat = np.zeros((Nv,Nv),dtype=np.float64)\n",
    "    Es = np.zeros(Nstep,dtype=np.float64)\n",
    "#\n",
    "## initialize W (variational parameters)   \n",
    "## put random numbers between -0.01 and 0.01\n",
    "## [original code: Wirr(0:N-1,alpha)]\n",
    "    rnd_amp = 0.01\n",
    "##----\n",
    "## without numba: read file \n",
    "#    Wirr = np.loadtxt(\"_input_initial_W.txt\")[:,2].reshape(alpha,N)\n",
    "#    print(Wirr)\n",
    "## without numba\n",
    "#    rng = np.random.default_rng(12345)\n",
    "#    Wirr = rng.uniform(-rnd_amp,rnd_amp,(alpha,N))\n",
    "#    print(Wirr)\n",
    "## with numba\n",
    "    np.random.seed(1234567)\n",
    "    Wirr = np.random.uniform(-rnd_amp,rnd_amp,(alpha,N))\n",
    "#    print(Wirr)\n",
    "##----\n",
    "    init_f_iw_Wirr = [[f,iw,Wirr[f,iw]] for f in range(alpha) for iw in range(N)]\n",
    "#    np.savetxt(\"initial_W.txt\",f_iw_Wirr,\n",
    "#        header=\"index for interaction (iw), index for independent neurons (f), irreducible interaction Wirr(f,iw)\")\n",
    "#\n",
    "## initial wave function\n",
    "    psi = np.zeros(D,dtype=np.float64)\n",
    "    psip = np.zeros(D,dtype=np.float64)\n",
    "    for ix in range(D):\n",
    "        calc_theta(xlist[ix],theta,alpha,N,M,Wirr)\n",
    "        calc_amplitude_RBM(M,theta,psi,ix)\n",
    "    psi = psi/np.linalg.norm(psi)\n",
    "#    print(psi)\n",
    "#    init_psi = copy.deepcopy(psi) ## not working with numba\n",
    "    init_psi = np.zeros(D,dtype=np.float64)\n",
    "    init_psi[:] = psi[:]\n",
    "#    print(init_psi)\n",
    "#    np.savetxt(\"initial_wf.txt\",psi,\n",
    "#        header=\"initial wave function psi(x), order of x follows that in Fock_state_list.txt\")\n",
    "#\n",
    "## start optimization\n",
    "    for iteration in range(Nstep):\n",
    "        gvec = np.zeros(Nv,dtype=np.float64)\n",
    "        Ovec = np.zeros(Nv,dtype=np.float64)\n",
    "        E = 0.0\n",
    "        for ix in range(D):\n",
    "            ## calculate wave function psi(x)\n",
    "            calc_theta(xlist[ix],theta,alpha,N,M,Wirr)\n",
    "            calc_amplitude_RBM(M,theta,psi,ix)\n",
    "            p_x = psi[ix]**2\n",
    "            ## calculate Eloc(x) and take sum over x for E\n",
    "            ## H = J ( SzSz - SxSx - SySy ) after the gauge transformation\n",
    "            Eloc_x = 0.0\n",
    "            for i1 in range(N):\n",
    "                i2 = (i1+1)%N\n",
    "                ## SzSz\n",
    "                Eloc_x += xlist[ix,i1] * xlist[ix,i2]\n",
    "                ## - SxSx - SySy\n",
    "                if xlist[ix,i1] != xlist[ix,i2]:\n",
    "                    xlist[ix,i1] *= -1\n",
    "                    xlist[ix,i2] *= -1\n",
    "                    calc_theta(xlist[ix],thetap,alpha,N,M,Wirr)\n",
    "#                    print(thetap)\n",
    "                    calc_amplitude_RBM(M,thetap,psip,ix)\n",
    "                    Eloc_x -= 2.0*psip[ix]/psi[ix]\n",
    "#                    print(psi[ix],psip[ix],2.0*psip[ix]/psi[ix],Eloc_x)\n",
    "                    xlist[ix,i1] *= -1\n",
    "                    xlist[ix,i2] *= -1\n",
    "            E += p_x * Eloc_x\n",
    "            ## calculate Ovec_loc_x\n",
    "            k = 0\n",
    "            for f in range(1,alpha+1):\n",
    "                for iw in range(N):\n",
    "                    k += 1\n",
    "                    Ovec_loc_x[k-1] = 0.0\n",
    "                    for jj in range(1,N+1):\n",
    "                        j = (f-1)*N + jj\n",
    "                        i = jj + iw\n",
    "                        if i > N:\n",
    "                            i -= N\n",
    "                        Ovec_loc_x[k-1] += np.tanh(theta[j-1])*xlist[ix,i-1]\n",
    "            if k!= Nv:\n",
    "                print(\"# error: k!=Nv\",k,Nv)\n",
    "                break\n",
    "            ## summation over x for gvec and ovec\n",
    "            for k in range(Nv):\n",
    "                gvec[k] += 2.0 * p_x * Eloc_x * Ovec_loc_x[k]\n",
    "                Ovec[k] += p_x * Ovec_loc_x[k]\n",
    "            ## summation over x for Smat\n",
    "            for k1 in range(Nv):\n",
    "                for k2 in range(Nv):\n",
    "                    Smat[k1,k2] += p_x * Ovec_loc_x[k1] * Ovec_loc_x[k2]\n",
    "        ## Dividing by <psi|psi> (=norm), we get\n",
    "        ##  gvec(k) = 2 <H*O_k>\n",
    "        ##  Ovec(k) = <O_k>\n",
    "        ##  E = <H>\n",
    "        ##  Smat(k1,k2) = <O_k1*O_k2>\n",
    "        norm = np.linalg.norm(psi)**2\n",
    "#        print(norm)\n",
    "        gvec /= norm\n",
    "        Ovec /= norm\n",
    "        E /= norm\n",
    "        Smat /= norm\n",
    "#        print(iteration,E)\n",
    "        Es[iteration] = E\n",
    "        ## gvec(k) = 2 <H*O_k> - 2 <H> <O_k>\n",
    "        for k in range(Nv):\n",
    "            gvec[k] -= 2.0 * E * Ovec[k]\n",
    "        ## Smat(k1,k2) = <O_k1*O_k2> - <O_k1><O_k2>\n",
    "        for k1 in range(Nv):\n",
    "            for k2 in range(Nv):\n",
    "                Smat[k1,k2] -= Ovec[k1] * Ovec[k2]\n",
    "                if k2==k1 and Smat[k1,k2] < 1e-12:\n",
    "                    print(\"# error: diagonal element of S matrix is not positive\")\n",
    "                    break\n",
    "        Sdiag_min = np.diag(Smat).min()\n",
    "        ## stabilization factor \n",
    "        ##  For details, see Appendix C in Nomura et al., Phys. Rev. B 96, 205152 (2017) \n",
    "        ##  Here, we add small uniform constant to diagonal elements of S matrix.\n",
    "        ##  A more aggresive optimization sometimes helps to lower the energy.\n",
    "        Sdiag_min_eps = 0.001\n",
    "        for k in range(Nv):\n",
    "            Smat[k,k] += Sdiag_min * Sdiag_min_eps\n",
    "        ## update W (variational parameters)\n",
    "        #print(Smat)\n",
    "        #gvec_new = scipy.linalg.solve(Smat,gvec,assume_a=\"pos\") ## without numba\n",
    "        gvec_new = np.linalg.solve(Smat,gvec) ## with numba\n",
    "        gvec[:] = gvec_new[:]\n",
    "        delW_max_eps = 0.003\n",
    "        delW_max = np.max(np.abs(delta_tau*gvec))\n",
    "#        print(delW_max)\n",
    "#        print(Wirr)\n",
    "        k = 0\n",
    "        for f in range(alpha):\n",
    "            for iw in range(N):\n",
    "                k += 1\n",
    "                if delW_max > delW_max_eps:\n",
    "                    Wirr[f,iw] -= delta_tau * gvec[k-1] * delW_max_eps/delW_max\n",
    "                else:\n",
    "                    Wirr[f,iw] -= delta_tau * gvec[k-1]\n",
    "#        print(Wirr)\n",
    "#        print()\n",
    "#        print(gvec)\n",
    "#\n",
    "## optimzed W\n",
    "    opt_f_iw_Wirr = [[f,iw,Wirr[f,iw]] for f in range(alpha) for iw in range(N)]\n",
    "#\n",
    "## optimzed wave function\n",
    "    for ix in range(D):\n",
    "        calc_theta(xlist[ix],theta,alpha,N,M,Wirr)\n",
    "        calc_amplitude_RBM(M,theta,psi,ix)\n",
    "    psi = psi/np.linalg.norm(psi)\n",
    "#    print(psi)\n",
    "#\n",
    "    return init_f_iw_Wirr, init_psi, opt_f_iw_Wirr, psi, Es"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "32548962",
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    # hidden variable density, number of optimization step, delta_tau\n",
    "    alpha = 1\n",
    "    #Nstep = 5000\n",
    "    Nstep = 1000\n",
    "    delta_tau = 0.001\n",
    "    print(\"alpha\",alpha)\n",
    "    print(\"Nstep\",Nstep)\n",
    "    print(\"delta_tau\",delta_tau)\n",
    "\n",
    "    # system size, dimension of Hilbert space (total_Sz=0 sector)\n",
    "    L = 8\n",
    "    nup = L//2\n",
    "    D = binomial(L,nup)\n",
    "    print(\"L\",L)\n",
    "    print(\"D\",D)\n",
    "\n",
    "    # make xlist for total_Sz=0 sector\n",
    "    xlist = make_xlist(L,nup,D)\n",
    "    #print(\"xlist\",xlist)\n",
    "    print(\"xlist.shape\",xlist.shape)\n",
    "    #print(\"xlist[D-1]\",xlist[D-1])\n",
    "    #print(\"xlist[:,0]\",xlist[:,0])\n",
    "    np.savetxt(\"dat_rbm_sr_Fock_state_list.txt\",xlist,fmt=\"%i\",\n",
    "        header=\"system size, dimension of Hibert space: \"+\"{}, \".format(L)+\"{}\".format(D))\n",
    "\n",
    "    init_f_iw_Wirr, init_psi, opt_f_iw_Wirr, opt_psi, Es = RBM_solver(alpha,Nstep,delta_tau,L,D,xlist)\n",
    "    #print(Es)\n",
    "    print(\"energy\",Es[Nstep-1])\n",
    "    np.savetxt(\"dat_rbm_sr_energy.txt\",Es)\n",
    "    np.savetxt(\"dat_rbm_sr_initial_W.txt\",init_f_iw_Wirr,\n",
    "        header=\"index for interaction (iw), index for independent neurons (f), irreducible interaction Wirr(f,iw)\")\n",
    "    np.savetxt(\"dat_rbm_sr_initial_wf.txt\",init_psi,\n",
    "        header=\"initial wave function psi(x), order of x follows that in Fock_state_list.txt\")\n",
    "    np.savetxt(\"dat_rbm_sr_optimized_W.txt\",opt_f_iw_Wirr,\n",
    "        header=\"index for interaction (iw), index for independent neurons (f), irreducible interaction Wirr(f,iw)\")\n",
    "    np.savetxt(\"dat_rbm_sr_optimized_wf.txt\",opt_psi,\n",
    "        header=\"optimized wave function psi(x), order of x follows that in Fock_state_list.txt\")\n",
    "\n",
    "    plt.xlabel(\"Nstep\")\n",
    "    plt.ylabel(\"E\")\n",
    "    plt.plot(np.arange(Nstep),Es)\n",
    "    plt.show()\n",
    "    plt.close()\n",
    "\n",
    "#    exact_psi = np.loadtxt(\"dat_exact_ref_exact_ground_state.txt\")\n",
    "    exact_psi = np.array([0.007469660603699186,0.03474208920086307,0.05454485719432777,0.03474208920086304,0.007469660603699169,0.05454485719432794,0.16440627939276697,0.1371338507956024,0.034742089200862976,0.09005865420497404,0.16440627939276575,0.054544857194327404,0.05454485719432748,0.03474208920086299,0.007469660603699175,0.03474208920086324,0.13713385079560247,0.16440627939276584,0.05454485719432743,0.16440627939276606,0.39829673718725694,0.16440627939276561,0.16440627939276564,0.13713385079560225,0.03474208920086302,0.05454485719432754,0.1644062793927659,0.0900586542049739,0.13713385079560225,0.16440627939276675,0.05454485719432777,0.0347420892008631,0.05454485719432794,0.034742089200863156,0.007469660603699187,0.007469660603699139,0.03474208920086305,0.05454485719432737,0.03474208920086294,0.05454485719432746,0.16440627939276553,0.1371338507956021,0.09005865420497378,0.16440627939276647,0.05454485719432773,0.034742089200863045,0.13713385079560228,0.16440627939276684,0.16440627939276672,0.39829673718726066,0.16440627939276675,0.05454485719432781,0.1644062793927671,0.13713385079560253,0.03474208920086305,0.007469660603699138,0.03474208920086321,0.054544857194327875,0.05454485719432788,0.16440627939276714,0.09005865420497398,0.03474208920086324,0.1371338507956028,0.16440627939276609,0.05454485719432754,0.007469660603699172,0.034742089200863115,0.05454485719432755,0.03474208920086305,0.007469660603699139])\n",
    "    plt.xlabel(\"basis index\")\n",
    "    plt.ylabel(\"amplitude\")\n",
    "    plt.plot(np.arange(D),exact_psi,label=\"exact\")\n",
    "    plt.plot(np.arange(D),init_psi,label=\"init\")\n",
    "    plt.plot(np.arange(D),opt_psi,label=\"opt\",marker=\"o\",ls=\"none\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a1a9021b-44f7-42bf-a9e3-ab9eb12aea2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha 1\n",
      "Nstep 1000\n",
      "delta_tau 0.001\n",
      "L 8\n",
      "D 70\n",
      "xlist.shape (70, 8)\n",
      "energy -14.60428144688315\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33a805d3-0d8c-458b-bea5-165b6550b8a4",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}