predict_l16_other_range.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Activation, Dense, Dropout\n",
    "from keras.layers.core import Flatten, Dense\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras.metrics import categorical_crossentropy\n",
    "from keras.optimizers import Adam\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.convolutional import *\n",
    "from keras.models import load_model\n",
    "\n",
    "import keras\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import shutil\n",
    "import os\n",
    "import random\n",
    "\n",
    "from PIL import Image\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn import datasets\n",
    "\n",
    "import time\n",
    "from PIL import Image\n",
    "from numba import jit\n",
    "import pickle\n",
    "from pathlib import Path\n",
    "import skimage.measure\n",
    "%matplotlib inline\n",
    "\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "from keras.models import load_model\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check the nth ('n') of an integer 'num'\n",
    "def check_nth_bit(num, n):\n",
    "    return (num>>n)&1\n",
    "\n",
    "# flip the bit of the integer 'int' at a position 'p'  (staring at 0)\n",
    "def bitflip(int,p):\n",
    "    mask = 1 << p\n",
    "    return (int^ mask)\n",
    "\n",
    "# count the numbers of 1 on a binarie representetion of an interger n\n",
    "def CountBits(n):\n",
    "    n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)\n",
    "    n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)\n",
    "    n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)\n",
    "    n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)\n",
    "    n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)\n",
    "    n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32) \n",
    "    return n\n",
    "\n",
    "# defining n!\n",
    "@jit\n",
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)\n",
    "\n",
    "# finding the states that have the maginetization \"z\"\n",
    "@jit\n",
    "def statep(y,z):\n",
    "    a = 0\n",
    "    for x in range(0,2**l):\n",
    "        if (2* CountBits(x)-l) == z:\n",
    "            y[a] = x\n",
    "            a += 1\n",
    "    return (y)\n",
    "\n",
    "# numbers of states with magnatization x\n",
    "def num_mag(x):\n",
    "    y = p = int(factorial(l)//((factorial((x+l)/2))*(factorial(l -((x+l)/2)))))\n",
    "    return y\n",
    "            \n",
    "# find the position in the list of states \"s\" that are iqual to \"b\"\n",
    "@jit\n",
    "def find_state(s,b):\n",
    "    for z in range(0,p+1):\n",
    "        if s[z] == b:\n",
    "            return(z)\n",
    "\n",
    "# power method\n",
    "@jit\n",
    "def power_iteration(A):\n",
    "    # Choose a random vector\n",
    "    y_0 = np.random.rand(A.shape[0])\n",
    "    #erro precision\n",
    "    e= 0.000000001\n",
    "    #convergence constant\n",
    "    er= 1.0\n",
    "    it = 0\n",
    "    while (er >= e):\n",
    "        # calculate the matrix-by-vector product Ab\n",
    "        z_1 = np.dot(A, y_0)\n",
    "        # calculate the norm\n",
    "        z_1_norm = np.linalg.norm(z_1)\n",
    "        # renormalize the vector\n",
    "        y_1 = z_1 / z_1_norm\n",
    "        z_2 = np.dot(A, y_1)\n",
    "        z_2_norm = np.linalg.norm(z_2)\n",
    "        lamb_1 = np.dot(z_2,y_1)/np.dot(y_1,y_1)\n",
    "        y_2 = z_2/z_2_norm\n",
    "        z_3 = np.dot(A, y_2)\n",
    "        z_3_norm = np.linalg.norm(z_3)\n",
    "        lamb_2 = np.dot(z_3,y_2)/np.dot(y_2,y_2)\n",
    "        er = abs(lamb_1 - lamb_2)/abs(lamb_2)\n",
    "        y_0 = z_3/z_3_norm\n",
    "        it += 1\n",
    "        #if( it%10 == 0):print('# of interations:',it,';','Precision:', er)\n",
    "    return (y_0, lamb_2)\n",
    "\n",
    "@jit\n",
    "def POWER_METHOD(A,dim):\n",
    "    for x in range(0,dim):\n",
    "        A[x,x] -= 2*l\n",
    "        \n",
    "    C = np.asarray(power_iteration(A))\n",
    "    C[1] += 2*l\n",
    "    return (C)\n",
    "\n",
    "def chart_regression(pred,y,sort=True):\n",
    "    t = pd.DataFrame({'pred' : pred, 'y' : y.flatten()})\n",
    "    if sort:\n",
    "        t.sort_values(by=['y'],inplace=True)\n",
    "    a = plt.plot(t['y'].tolist(),label='expected')\n",
    "    b = plt.plot(t['pred'].tolist(),label='prediction')\n",
    "    plt.ylabel('output')\n",
    "    plt.legend()\n",
    "    plt.title('RMSE ='+ str(np.round(100000*score)/100000))\n",
    "    plt.savefig('predct_l16.png')\n",
    "    plt.show()\n",
    "    \n",
    "#plt.switch_backend('agg')\n",
    "\n",
    "def plot_history(history):\n",
    "    loss_list = [s for s in history.history.keys() if 'loss' in s and 'val' not in s]\n",
    "    val_loss_list = [s for s in history.history.keys() if 'loss' in s and 'val' in s]\n",
    "    acc_list = [s for s in history.history.keys() if 'mean_squared_error' in s and 'val' not in s]\n",
    "    val_acc_list = [s for s in history.history.keys() if 'val_mean_squared_error' in s and 'val' in s]\n",
    "\n",
    "    if len(loss_list) == 0:\n",
    "        print('Loss is missing in history')\n",
    "        return\n",
    "\n",
    "    ## As loss always exists\n",
    "    epochs = range(1,len(history.history[loss_list[0]]) + 1)\n",
    "\n",
    "    ## Loss\n",
    "    plt.figure(1)\n",
    "    for l in loss_list:\n",
    "        plt.plot(epochs, history.history[l], 'b', label='Training loss (' + str(str(format(history.history[l][-1],'.5f'))+')'))\n",
    "    for l in val_loss_list:\n",
    "        plt.plot(epochs, history.history[l], 'g', label='Validation loss (' + str(str(format(history.history[l][-1],'.5f'))+')'))\n",
    "\n",
    "    plt.title('Loss')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.savefig('loss_l16.png')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_folder = 'matrix_16/'\n",
    "\n",
    "if not os.path.exists(path_folder):\n",
    "    os.mkdir(path_folder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h: -16.0\n",
      "h: -14.4\n",
      "h: -12.8\n",
      "h: -11.200000000000001\n",
      "h: -9.600000000000001\n",
      "h: -8.000000000000002\n",
      "h: -6.400000000000002\n",
      "h: -4.8000000000000025\n",
      "h: -3.2000000000000024\n",
      "h: -1.6000000000000023\n",
      "h: -2.220446049250313e-15\n",
      "h: 1.5999999999999979\n",
      "h: 3.199999999999998\n",
      "h: 4.799999999999998\n",
      "h: 6.399999999999999\n",
      "h: 7.999999999999998\n",
      "h: 9.599999999999998\n",
      "h: 11.199999999999998\n",
      "h: 12.799999999999997\n",
      "h: 14.399999999999997\n",
      "h: 15.999999999999996\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": [
    "# number of spins\n",
    "l = 16\n",
    "\n",
    "#dimension constant\n",
    "j = 1\n",
    "\n",
    "#anisotropy constant\n",
    "delt = -1\n",
    "\n",
    "   \n",
    "h = -16.\n",
    "row = []\n",
    "while h <= 16:\n",
    "    \n",
    "    Hxxz = np.zeros((2**l , 2**l ))\n",
    "\n",
    "    # constructing the full xxz hamiltonian (2^L, 2^L) \n",
    "    for x in range(0,2**l):\n",
    "        for y in range(0,l):\n",
    "            k = (y+1)%l\n",
    "            if check_nth_bit(x,y) == 0:\n",
    "                Hxxz[x,x] += -j*h/2\n",
    "            else:\n",
    "                Hxxz[x,x] += j*h/2\n",
    "            #if y != l-1:    \n",
    "            if check_nth_bit(x,y) == check_nth_bit(x,k):\n",
    "                Hxxz[x,x] += -(j*delt)/2\n",
    "            else:\n",
    "                Hxxz[x,x] += (j*delt)/2\n",
    "                b = bitflip(x,y)\n",
    "                c = bitflip(b,k)\n",
    "                Hxxz[x,c] += -j\n",
    "\n",
    "    \n",
    "    \n",
    "    mag_array = np.zeros(l+1)\n",
    "    E_array = np.zeros(l+1)\n",
    "    a = 0\n",
    "    for mag in range(-l,l+1,2):\n",
    "    \n",
    "        p = num_mag(mag)\n",
    "        state = np.array(range(p))\n",
    "        s = statep(state,mag)\n",
    "        \n",
    "        Hxxz_p = np.zeros((p,p))\n",
    "        for x in range(0,p):\n",
    "            for y in range(0,l):\n",
    "                if check_nth_bit(s[x],y) == 0:\n",
    "                    Hxxz_p[x,x] += -(j*h)/2\n",
    "                else:\n",
    "                    Hxxz_p[x,x] += (j*h)/2\n",
    "                k = (y+1)%l\n",
    "                #if y != l-1:\n",
    "                if check_nth_bit(s[x],y) == check_nth_bit(s[x],k):\n",
    "                    Hxxz_p[x,x] += -(j*delt)/2\n",
    "                else:\n",
    "                    Hxxz_p[x,x] += (j*delt)/2\n",
    "                    b = bitflip(s[x],y)\n",
    "                    c = bitflip(b,k)\n",
    "                    D = np.where(s == c)\n",
    "                    Hxxz_p[x,D] = -j\n",
    "                        #if mag == 0:\n",
    "                            #print('[',x,D,']','k:',k,'s[x]:',s[x],'y:',y,'b:',b,'c:',c,'s[5]',s[5])\n",
    "                    \n",
    "        #print(Hxxz_p)\n",
    "        mag_array[a] = mag\n",
    "        A = POWER_METHOD(Hxxz_p,p)\n",
    "        E_array[a] = A[1] \n",
    "        psi_s = -mag_array[np.where(E_array == np.min(E_array))]\n",
    "        a += 1\n",
    "    ex = '.npy'\n",
    "    Hxxz_pool = skimage.measure.block_reduce(Hxxz,(256,256), np.average)\n",
    "    np.save(os.path.abspath(path_folder + str(h)), Hxxz_pool)\n",
    "    row.append([str(h) + ex, psi_s[0], np.min(E_array)/l, h])\n",
    "            \n",
    "        \n",
    "    print('h:',h)\n",
    "    #print('MAG_GS:', psi_s[0])\n",
    "    #print('rhoE_array:', np.min(E_array)/l)\n",
    "    h += 1.6\n",
    "    \n",
    "row = np.asarray(row)\n",
    "\n",
    "a_h = np.array(row[:,3]).astype(np.float) #h\n",
    "b_e = np.array(row[:,2]).astype(np.float) #E_GS/l\n",
    "c_m = np.array(row[:,1]).astype(np.float) #mag_GS\n",
    "\n",
    "plt.plot(a_h,b_e,'-')\n",
    "plt.title('GS-Energy density distribution (L='+str(l)+')')\n",
    "plt.xlabel(r'$h$')\n",
    "plt\n",
    "plt.ylabel(r'$E_{GS}/L$')\n",
    "plt.grid()\n",
    "plt.savefig('GS-Energy_l16.png')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "plt.plot(a_h,c_m)\n",
    "plt.title('GS-Magnetization distribution')\n",
    "plt.xlabel(r'$h$')\n",
    "plt.ylabel('GS-Mag')\n",
    "plt.grid()\n",
    "plt.savefig('GS-Mag_l16.png')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "data_set = pd.DataFrame(row)\n",
    "data_set.to_csv(\"pool_l16.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test = row[:,0]\n",
    "y_test = np.array(row[:,2]).astype(np.float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = []\n",
    "\n",
    "load_test_data = []\n",
    "for file in x_test:\n",
    "        path = os.path.abspath(path_folder + file)\n",
    "        H = np.load(path)\n",
    "        load_test_data.append(H)\n",
    "load_test_data = np.array(load_test_data)\n",
    "test_data = load_test_data[:,:,:,np.newaxis]\n",
    "test_data -= np.mean(test_data)\n",
    "test_data /= np.std(test_data)\n",
    "\n",
    "test_label = []\n",
    "for file in y_test:\n",
    "    test_label.append(file)\n",
    "test_label = np.array(test_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(21, 256, 256, 1) (21,)\n"
     ]
    }
   ],
   "source": [
    "print(test_data.shape,test_label.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21/21 [==============================] - 3s 129ms/step\n",
      "Score (RMSE): 2.877833810337885\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"
    }
   ],
   "source": [
    "model = load_model('my_model.h5')\n",
    "\n",
    "pred = model.predict(test_data, verbose=1)\n",
    "score = np.sqrt(metrics.mean_squared_error(pred,test_label))\n",
    "print(\"Score (RMSE): {}\".format(score))\n",
    "\n",
    "chart_regression(pred.flatten(),test_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}