retrain.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lzmoraes/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import shutil\n",
    "import os\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": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "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_pool.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_retrain_pool.png')\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "    ## Accuracy\n",
    "    #plt.figure(2)\n",
    "    #for l in acc_list:\n",
    "        #plt.plot(epochs, history.history[l], 'b', label='Training Mean Square Error (' + str(format(history.history[l][-1],'.5f'))+')')\n",
    "    #for l in val_acc_list:\n",
    "        #plt.plot(epochs, history.history[l], 'g', label='Validation Mean Square Error (' + str(format(history.history[l][-1],'.5f'))+')')\n",
    "\n",
    "    #plt.title('Mean Square Error')\n",
    "    #plt.xlabel('Epochs')\n",
    "    #plt.ylabel('Mean Square Error')\n",
    "    #plt.legend()\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Retrain random local MF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 810 samples, validate on 90 samples\n",
      "Epoch 1/15\n",
      "810/810 [==============================] - 312s 385ms/step - loss: 3.1581 - val_loss: 2.4006\n",
      "Epoch 2/15\n",
      "810/810 [==============================] - 308s 380ms/step - loss: 1.2121 - val_loss: 1.0751\n",
      "Epoch 3/15\n",
      "810/810 [==============================] - 309s 382ms/step - loss: 0.8816 - val_loss: 0.4052\n",
      "Epoch 4/15\n",
      "810/810 [==============================] - 307s 379ms/step - loss: 0.5133 - val_loss: 0.8422\n",
      "Epoch 5/15\n",
      "810/810 [==============================] - 309s 381ms/step - loss: 0.4040 - val_loss: 0.2562\n",
      "Epoch 6/15\n",
      "810/810 [==============================] - 308s 380ms/step - loss: 0.2748 - val_loss: 0.2883\n",
      "Epoch 7/15\n",
      "810/810 [==============================] - 308s 380ms/step - loss: 0.2436 - val_loss: 0.3408\n",
      "Epoch 8/15\n",
      "810/810 [==============================] - 307s 379ms/step - loss: 0.2301 - val_loss: 0.2240\n",
      "Epoch 9/15\n",
      "810/810 [==============================] - 308s 380ms/step - loss: 0.2178 - val_loss: 0.3001\n",
      "Epoch 10/15\n",
      "810/810 [==============================] - 308s 380ms/step - loss: 0.2246 - val_loss: 0.3318\n",
      "Epoch 11/15\n",
      "810/810 [==============================] - 307s 379ms/step - loss: 0.2058 - val_loss: 0.2122\n",
      "Epoch 12/15\n",
      "810/810 [==============================] - 308s 381ms/step - loss: 0.2269 - val_loss: 0.2071\n",
      "Epoch 13/15\n",
      "810/810 [==============================] - 307s 380ms/step - loss: 0.1988 - val_loss: 0.3068\n",
      "Epoch 14/15\n",
      "810/810 [==============================] - 308s 380ms/step - loss: 0.2082 - val_loss: 0.2296\n",
      "Epoch 15/15\n",
      "810/810 [==============================] - 308s 381ms/step - loss: 0.1882 - val_loss: 0.2180\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score (RMSE): 0.37446958851517576\n"
     ]
    }
   ],
   "source": [
    "path_folder = 'matrix_del_rand/'\n",
    "ex = '.npy'\n",
    "\n",
    "if not os.path.exists(path_folder):\n",
    "    os.mkdir(path_folder)\n",
    "\n",
    "c_i = 8.\n",
    "\n",
    "l = 8\n",
    "j = 1\n",
    "delt = -1\n",
    "\n",
    "row = []\n",
    "for i in range(0,1000):\n",
    "    \n",
    "    h = c_i*np.random.randn(l)\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[y]/2\n",
    "            else:\n",
    "                Hxxz[x,x] += j*h[y]/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",
    "    #print(Hxxz)\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[y])/2\n",
    "                else:\n",
    "                    Hxxz_p[x,x] += (j*h[y])/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",
    "                                            \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",
    "   \n",
    "    row.append([str(i+1) + ex, np.min(E_array)/l])\n",
    "    np.save(os.path.abspath(path_folder+str(i+1)), Hxxz)   \n",
    "    #print('h:',h)\n",
    "    #print('MAG_GS:', psi_s[0])\n",
    "    #print('rhoE_array:', np.min(E_array)/l)\n",
    "    \n",
    "    \n",
    "row = np.asarray(row)\n",
    "\n",
    "data_set = pd.DataFrame(row)\n",
    "data_set.to_csv(\"rand.csv\")\n",
    "\n",
    "dataset = pd.read_csv('rand.csv')\n",
    "\n",
    "\n",
    "#writing the columns of the csv in an list\n",
    "X_1 = dataset.iloc[:,1].values\n",
    "Y_1 = dataset.iloc[:,2].values\n",
    "\n",
    "W = np.random.permutation(np.c_[X_1.reshape(len(X_1), -1), Y_1.reshape(len(Y_1), -1)])\n",
    "\n",
    "X = W[:, :X_1.size//len(X_1)].reshape(X_1.shape)\n",
    "Y = W[:, X_1.size//len(X_1):].reshape(Y_1.shape)\n",
    "\n",
    "x_train = np.array([X[i] for i in range((len(X)//10),len(X))])\n",
    "y_train = np.array([Y[i] for i in range((len(Y)//10),len(Y))])\n",
    "\n",
    "x_test = np.array([X[i] for i in range((len(X)//10))])\n",
    "y_test = np.array([Y[i] for i in range((len(Y)//10))])\n",
    "\n",
    "train_data = []\n",
    "\n",
    "load_train_data = []\n",
    "for file in x_train:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_train_data.append(H)\n",
    "load_train_data = np.array(load_train_data)\n",
    "train_data = load_train_data[:,:,:,np.newaxis]\n",
    "train_data -= np.mean(train_data)\n",
    "train_data /= np.std(train_data)\n",
    "\n",
    "train_label = []\n",
    "for file in y_train:\n",
    "    train_label.append(file)\n",
    "train_label = np.array(train_label)\n",
    "\n",
    "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)\n",
    "\n",
    "model = load_model('my_model.h5')\n",
    "\n",
    "model.compile(Adam(lr=.0001),loss='mean_squared_error')\n",
    "\n",
    "\n",
    "history = model.fit(train_data, train_label, epochs=15, batch_size=128, validation_split=0.1, verbose=1)\n",
    "\n",
    "model.save('rand_train.h5')\n",
    "plot_history(history)\n",
    "\n",
    "\n",
    "\n",
    "pred = model.predict(test_data, batch_size=128)\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": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)\n",
    "chart_regression(pred.flatten(),test_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Retrain Pooling dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "TypeError",
     "evalue": "must be str, not numpy.float64",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-ee61dd58c6a8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    133\u001b[0m \u001b[0mload_train_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    134\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mx_train\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 135\u001b[0;31m         \u001b[0mpath\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabspath\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath_folder\u001b[0m\u001b[0;34m+\u001b[0m \u001b[0mfile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    136\u001b[0m         \u001b[0mH\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    137\u001b[0m         \u001b[0mload_train_data\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mH\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not numpy.float64"
     ]
    }
   ],
   "source": [
    "# number of spins\n",
    "l = 12\n",
    "\n",
    "#dimension constant\n",
    "j = 1\n",
    "\n",
    "#anisotropy constant\n",
    "delt = -1\n",
    "\n",
    "path_folder = 'matrix_pool/'\n",
    "\n",
    "if not os.path.exists(path_folder):\n",
    "    os.mkdir(path_folder)\n",
    "    \n",
    "h = -8.\n",
    "row = []\n",
    "while h <= 8:\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,(16,16), 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 += .01\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_big.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_big.png')\n",
    "plt.show()\n",
    "\n",
    "\n",
    "data_set = pd.DataFrame(row)\n",
    "data_set.to_csv(\"pool.csv\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1296 samples, validate on 145 samples\n",
      "Epoch 1/15\n",
      "1296/1296 [==============================] - 500s 385ms/step - loss: 2.2387 - val_loss: 2.7312\n",
      "Epoch 2/15\n",
      "1296/1296 [==============================] - 498s 384ms/step - loss: 1.5703 - val_loss: 0.6251\n",
      "Epoch 3/15\n",
      "1296/1296 [==============================] - 497s 384ms/step - loss: 0.4632 - val_loss: 0.3551\n",
      "Epoch 4/15\n",
      "1296/1296 [==============================] - 498s 384ms/step - loss: 0.2275 - val_loss: 0.2368\n",
      "Epoch 5/15\n",
      "1296/1296 [==============================] - 498s 385ms/step - loss: 0.1385 - val_loss: 0.0890\n",
      "Epoch 6/15\n",
      "1296/1296 [==============================] - 498s 384ms/step - loss: 0.0738 - val_loss: 0.0450\n",
      "Epoch 7/15\n",
      "1296/1296 [==============================] - 500s 386ms/step - loss: 0.0401 - val_loss: 0.0278\n",
      "Epoch 8/15\n",
      "1296/1296 [==============================] - 498s 385ms/step - loss: 0.0245 - val_loss: 0.0313\n",
      "Epoch 9/15\n",
      "1296/1296 [==============================] - 497s 384ms/step - loss: 0.0217 - val_loss: 0.0288\n",
      "Epoch 10/15\n",
      "1296/1296 [==============================] - 497s 383ms/step - loss: 0.0183 - val_loss: 0.0444\n",
      "Epoch 11/15\n",
      "1296/1296 [==============================] - 500s 386ms/step - loss: 0.0161 - val_loss: 0.0123\n",
      "Epoch 12/15\n",
      "1296/1296 [==============================] - 499s 385ms/step - loss: 0.0120 - val_loss: 0.0058\n",
      "Epoch 13/15\n",
      "1296/1296 [==============================] - 499s 385ms/step - loss: 0.0136 - val_loss: 0.0089\n",
      "Epoch 14/15\n",
      "1296/1296 [==============================] - 498s 384ms/step - loss: 0.0114 - val_loss: 0.0205\n",
      "Epoch 15/15\n",
      "1296/1296 [==============================] - 497s 384ms/step - loss: 0.0107 - val_loss: 0.0221\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "160/160 [==============================] - 18s 115ms/step\n",
      "Score (RMSE): 0.10549530569528734\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataset = pd.read_csv('pool.csv')\n",
    "\n",
    "path_folder = 'matrix_pool/'\n",
    "\n",
    "#writing the columns of the csv in an list\n",
    "X_1 = dataset.iloc[:,1].values\n",
    "Y_1 = dataset.iloc[:,3].values\n",
    "\n",
    "W = np.random.permutation(np.c_[X_1.reshape(len(X_1), -1), Y_1.reshape(len(Y_1), -1)])\n",
    "\n",
    "X = W[:, :X_1.size//len(X_1)].reshape(X_1.shape)\n",
    "Y = W[:, X_1.size//len(X_1):].reshape(Y_1.shape)\n",
    "\n",
    "x_train = np.array([X[i] for i in range((len(X)//10),len(X))])\n",
    "y_train = np.array([Y[i] for i in range((len(Y)//10),len(Y))])\n",
    "\n",
    "x_test = np.array([X[i] for i in range((len(X)//10))])\n",
    "y_test = np.array([Y[i] for i in range((len(Y)//10))])\n",
    "\n",
    "train_data = []\n",
    "\n",
    "load_train_data = []\n",
    "for file in x_train:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_train_data.append(H)\n",
    "load_train_data = np.array(load_train_data)\n",
    "train_data = load_train_data[:,:,:,np.newaxis]\n",
    "train_data -= np.mean(train_data)\n",
    "train_data /= np.std(train_data)\n",
    "\n",
    "train_label = []\n",
    "for file in y_train:\n",
    "    train_label.append(file)\n",
    "train_label = np.array(train_label)\n",
    "\n",
    "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)\n",
    "\n",
    "model = load_model('my_model.h5')\n",
    "\n",
    "model.compile(Adam(lr=.0001),loss='mean_squared_error')\n",
    "\n",
    "history = model.fit(train_data, train_label, epochs=15, batch_size=128, validation_split=0.1, verbose=1)\n",
    "\n",
    "model.save('pool_train.h5')\n",
    "plot_history(history)\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": "markdown",
   "metadata": {},
   "source": [
    "# Retrain Pooling dimensions and random local MF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of spins\n",
    "l = 12\n",
    "\n",
    "#dimension constant\n",
    "j = 1\n",
    "\n",
    "#anisotropy constant\n",
    "delt = -1\n",
    "\n",
    "path_folder = 'matrix_pool_rand/'\n",
    "\n",
    "if not os.path.exists(path_folder):\n",
    "    os.mkdir(path_folder)\n",
    "    \n",
    "\n",
    "row = []\n",
    "for i in range(0,1000):\n",
    "    \n",
    "    h = np.random.randn(l)\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[y]/2\n",
    "            else:\n",
    "                Hxxz[x,x] += j*h[y]/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[y])/2\n",
    "                else:\n",
    "                    Hxxz_p[x,x] += (j*h[y])/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",
    "                        \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,(16,16), np.max)\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])\n",
    "            \n",
    "        \n",
    "    #print('h:',h)\n",
    "    #print('MAG_GS:', psi_s[0])\n",
    "    #print('rhoE_array:', np.min(E_array)/l)\n",
    "    \n",
    "    \n",
    "row = np.asarray(row)\n",
    "\n",
    "data_set = pd.DataFrame(row)\n",
    "data_set.to_csv(\"pool_rand.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv('pool_rand.csv')\n",
    "\n",
    "path_folder = 'matrix_pool_rand/'\n",
    "\n",
    "#writing the columns of the csv in an list\n",
    "X_1 = dataset.iloc[:,1].values\n",
    "Y_1 = dataset.iloc[:,3].values\n",
    "\n",
    "W = np.random.permutation(np.c_[X_1.reshape(len(X_1), -1), Y_1.reshape(len(Y_1), -1)])\n",
    "\n",
    "X = W[:, :X_1.size//len(X_1)].reshape(X_1.shape)\n",
    "Y = W[:, X_1.size//len(X_1):].reshape(Y_1.shape)\n",
    "\n",
    "x_train = np.array([X[i] for i in range((len(X)//10),len(X))])\n",
    "y_train = np.array([Y[i] for i in range((len(Y)//10),len(Y))])\n",
    "\n",
    "x_test = np.array([X[i] for i in range((len(X)//10))])\n",
    "y_test = np.array([Y[i] for i in range((len(Y)//10))])\n",
    "\n",
    "train_data = []\n",
    "\n",
    "load_train_data = []\n",
    "for file in x_train:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_train_data.append(H)\n",
    "load_train_data = np.array(load_train_data)\n",
    "train_data = load_train_data[:,:,:,np.newaxis]\n",
    "train_data -= np.mean(train_data)\n",
    "train_data /= np.std(train_data)\n",
    "\n",
    "train_label = []\n",
    "for file in y_train:\n",
    "    train_label.append(file)\n",
    "train_label = np.array(train_label)\n",
    "\n",
    "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 810 samples, validate on 90 samples\n",
      "Epoch 1/15\n",
      "810/810 [==============================] - 313s 386ms/step - loss: 0.4557 - val_loss: 0.3618\n",
      "Epoch 2/15\n",
      "810/810 [==============================] - 310s 383ms/step - loss: 0.1587 - val_loss: 0.0180\n",
      "Epoch 3/15\n",
      "810/810 [==============================] - 310s 382ms/step - loss: 0.0400 - val_loss: 0.0512\n",
      "Epoch 4/15\n",
      "810/810 [==============================] - 310s 382ms/step - loss: 0.0210 - val_loss: 0.0069\n",
      "Epoch 5/15\n",
      "810/810 [==============================] - 311s 384ms/step - loss: 0.0119 - val_loss: 0.0197\n",
      "Epoch 6/15\n",
      "810/810 [==============================] - 310s 383ms/step - loss: 0.0079 - val_loss: 0.0029\n",
      "Epoch 7/15\n",
      "810/810 [==============================] - 310s 383ms/step - loss: 0.0071 - val_loss: 0.0099\n",
      "Epoch 8/15\n",
      "810/810 [==============================] - 310s 383ms/step - loss: 0.0054 - val_loss: 0.0023\n",
      "Epoch 9/15\n",
      "810/810 [==============================] - 311s 384ms/step - loss: 0.0057 - val_loss: 0.0059\n",
      "Epoch 10/15\n",
      "810/810 [==============================] - 310s 382ms/step - loss: 0.0049 - val_loss: 0.0027\n",
      "Epoch 11/15\n",
      "810/810 [==============================] - 309s 382ms/step - loss: 0.0046 - val_loss: 0.0045\n",
      "Epoch 12/15\n",
      "810/810 [==============================] - 310s 382ms/step - loss: 0.0049 - val_loss: 0.0032\n",
      "Epoch 13/15\n",
      "810/810 [==============================] - 311s 383ms/step - loss: 0.0046 - val_loss: 0.0036\n",
      "Epoch 14/15\n",
      "810/810 [==============================] - 311s 384ms/step - loss: 0.0049 - val_loss: 0.0040\n",
      "Epoch 15/15\n",
      "810/810 [==============================] - 311s 384ms/step - loss: 0.0044 - val_loss: 0.0032\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100/100 [==============================] - 12s 117ms/step\n",
      "Score (RMSE): 0.055880651539055956\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = load_model('my_model.h5')\n",
    "\n",
    "model.compile(Adam(lr=.0001),loss='mean_squared_error')\n",
    "\n",
    "history = model.fit(train_data, train_label, epochs=15, batch_size=128, validation_split=0.1, verbose=1)\n",
    "\n",
    "model.save('pool_rand_train.h5')\n",
    "plot_history(history)\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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}