NB_CVII-logreg_ising.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook 6: Phases of the Ising Model with Logistic Regression\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Learning Goal\n",
    "The goal of this notebook is to show how one can employ Logistic Regression to classify the states of the 2D Ising model according to their phase. We will discuss overfitting, regularization, and learn how to use the scikit-learn library. We will also examine the role of the optimizer in making predictions.\n",
    "\n",
    "## Overview\n",
    "\n",
    "The energy function of the classical Ising model is given by\n",
    "\n",
    "$$ H = -J\\sum_{\\langle ij\\rangle}S_{i}S_j,\\qquad \\qquad S_j\\in\\{\\pm 1\\} $$\n",
    "\n",
    "where the lattice site indices $i,j$ run over all nearest neighbors of a 2D square lattice, and $J$ is some arbitrary interaction energy scale. We adopt periodic boundary conditions. Onsager proved that this model undergoes a thermal phase transition in the thermodynamic limit from an ordered ferromagnet with all spins aligned to a disordered phase at the critical temperature $T_c/J=2/\\log(1+\\sqrt{2})\\approx 2.26$. For any finite system size, this critical point is expanded to a critical region around $T_c$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An interesting question to ask is whether one can train a statistical model to distinguish between the two phases of the Ising model. If successful, this can be used to locate the position of the critical point in more complicated models where an exact analytical solution has so far remained elusive. \n",
    "\n",
    "In other words, given an Ising state, we would like to classify whether it belongs to the ordered or the disordered phase, without any additional information other than the spin configuration itself. This categorical machine learning problem is well suited for logistic regression. Notice that, for the purposes of applying logistic regression, the 2D spin state of the Ising model will be flattened out to a 1D array, so it will not be easy to learn information about the structure of the contiguous ordered 2D domains [see figure below]. Such information can be incorporated using other methods such as multi-layer deep convolutional neural networks (CNNs), see Secs. IX, X and XI of the review and the corresponding notebooks.\n",
    "\n",
    "## The 2D Ising Dataset\n",
    "\n",
    "To this end, we consider the 2D Ising model on a $40\\times 40$ square lattice, and use Monte-Carlo (MC) sampling to prepare $10^4$ states at every fixed temperature $T$ out of a pre-defined set $T\\in[0.25,0.5,\\cdots,4.0]$. Using Onsager's criterion, we can assign a label to each state according to its phase: $0$ if the state is disordered, and $1$ if it is ordered. Our goal is to predict the phase of a sample given the spin configuration.\n",
    "\n",
    "It is well-known that, near the critical temperature $T_c$, the ferromagnetic correlation length diverges which, among other things, leads to a critical slowing down of the MC algorithm. Therefore, we expect identifying the phases to be harder in the critical region. With this in mind, consider the following three types of states: ordered ($T/J<2.0$), critical ($2.0\\leq T/J\\leq 2.5)$ and disordered ($T/J>2.5$). We use both ordered and disordered states to train the logistic regressor and once the supervised training procedure is complete, we evaluate the performance of our classification model on unseen ordered, disordered and critical states. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "import warnings\n",
    "#Comment this to turn on warnings\n",
    "#warnings.filterwarnings('ignore')\n",
    "\n",
    "np.random.seed() # shuffle random seed generator\n",
    "\n",
    "# Ising model parameters\n",
    "L=40 # linear system size\n",
    "J=-1.0 # Ising interaction\n",
    "T=np.linspace(0.25,4.0,16) # set of temperatures\n",
    "T_c=2.26 # Onsager critical temperature in the TD limit"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading in the Ising dataset\n",
    "We now load in the data which is hosted on Pankaj Mehta's [website](http://physics.bu.edu/~pankajm/MLnotebooks.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle, os\n",
    "from urllib.request import urlopen \n",
    "\n",
    "# url to data\n",
    "url_main = 'https://physics.bu.edu/~pankajm/ML-Review-Datasets/isingMC/';\n",
    "\n",
    "######### LOAD DATA\n",
    "# The data consists of 16*10000 samples taken in T=np.arange(0.25,4.0001,0.25):\n",
    "data_file_name = \"Ising2DFM_reSample_L40_T=All.pkl\" \n",
    "# The labels are obtained from the following file:\n",
    "label_file_name = \"Ising2DFM_reSample_L40_T=All_labels.pkl\"\n",
    "\n",
    "\n",
    "#DATA\n",
    "data = pickle.load(urlopen(url_main + data_file_name)) # pickle reads the file and returns the Python object (1D array, compressed bits)\n",
    "data = np.unpackbits(data).reshape(-1, 1600) # Decompress array and reshape for convenience\n",
    "data=data.astype('int')\n",
    "data[np.where(data==0)]=-1 # map 0 state to -1 (Ising variable can take values +/-1)\n",
    "\n",
    "#LABELS (convention is 1 for ordered states and 0 for disordered states)\n",
    "labels = pickle.load(urlopen(url_main + label_file_name)) # pickle reads the file and returns the Python object (here just a 1D array with the binary labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constructing the training and the test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (65000, 1600)\n",
      "Y_train shape: (65000,)\n",
      "\n",
      "65000 train samples\n",
      "26000 critical samples\n",
      "65000 test samples\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "###### define ML parameters\n",
    "num_classes=2\n",
    "train_to_test_ratio=0.5 # training samples\n",
    "\n",
    "# divide data into ordered, critical and disordered\n",
    "X_ordered=data[:70000,:]\n",
    "Y_ordered=labels[:70000]\n",
    "\n",
    "X_critical=data[70000:96000,:] # 100000\n",
    "Y_critical=labels[70000:96000] # 100000\n",
    "\n",
    "X_disordered=data[100000:,:]\n",
    "Y_disordered=labels[100000:]\n",
    "\n",
    "del data,labels\n",
    "\n",
    "# define training and test data sets\n",
    "X=np.concatenate((X_ordered,X_disordered))\n",
    "Y=np.concatenate((Y_ordered,Y_disordered))\n",
    "\n",
    "# pick random data points from ordered and disordered states \n",
    "# to create the training and test sets\n",
    "X_train,X_test,Y_train,Y_test=train_test_split(X,Y,train_size=train_to_test_ratio,test_size=1.0-train_to_test_ratio)\n",
    "\n",
    "# full data set\n",
    "X=np.concatenate((X_critical,X))\n",
    "Y=np.concatenate((Y_critical,Y))\n",
    "\n",
    "print('X_train shape:', X_train.shape)\n",
    "print('Y_train shape:', Y_train.shape)\n",
    "print()\n",
    "print(X_train.shape[0], 'train samples')\n",
    "print(X_critical.shape[0], 'critical samples')\n",
    "print(X_test.shape[0], 'test samples')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualizing the states"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABOkAAAGxCAYAAAA3ROJPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABEOElEQVR4nO3de5BdZZko7neHviQh6Q4EyAWaSEKGi0AgEGASBVQCB0gFUWGQ8YAjZFAYLzUDeKhRsYQySpwqKB0UWkTmCDpmZgBTBYoMcUYIMJwBcXIwEi4JjVzkJNAdLrn29/uDX+9J093Zu7vX3mvv7uep2kWxru/3rbW+d623V/YupJRSAAAAAAC5GZN3AAAAAAAw2inSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdNS197znPVEoFGLdunV5hzJs1WxLoVCIQqFQ8f0AjBbDGcPzzmV57z8rI6UdQP0baDyq93Gq3uPfmWcvapUiHQBAhVx33XXx1a9+NV5//fW8QwEAoMY15B0AAEC9mzVrVowdOzYaGxt7Tb/uuuti/fr18clPfjImTZo0qHUZHP0I1DrjFFCKIh0AwDD967/+ay7r8t/0I1DrjFNAKf65KwAAAADkTJGOzGzYsCGuuOKKOOigg2LcuHGxxx57xEknnRS33XZbpJT6LL/zF2j+8z//c5xwwgkxadKkPl/guX79+vjEJz4R++yzT4wfPz6OOOKI+Pu///t+t7mz7du3x/e+97143/veF5MmTYqxY8fGwQcfHF/60peiq6ur33XKjWko2x5OWwayc7y33357HHvssTFhwoTYc88948Mf/nCsXr265DbuueeeOOGEE2LixInR2toap512Wjz++OP9Lrt69eq46qqr4k//9E9j2rRp0dTUFNOmTYuPfOQjsWrVql22++KLL46ZM2dGc3NzTJw4MWbOnBlnnXVW/OQnP+l3naH2MUA5tm/fHu3t7fGBD3wgJk+eHGPHjo2ZM2fGRz/60bjrrrt6LVtObnj3F1D/8Ic/jEKhEOvXr4+IiAMOOKC4nUKhEL/61a+K29/Vl1cPJs6hjtFDUel8+cwzz8THP/7x2HvvvWP8+PFx5JFHxve+972IGNoXsg/2HuXdbRxMrgRGh6Hc1w80Tg32Xnm4Y5pnL89eO/PcVWMSZGDt2rWpra0tRURqampKc+fOTTNnzkwRkSIinX/++am7u7vXOj3zvvGNb6SISFOmTEnz5s1Le++9d3ruuedSSik9+eSTafLkySki0tixY9PRRx+d9t9//xQR6ZJLLkkzZsxIEVFcvkdnZ2c64YQTUkSkMWPGpBkzZqTDDjssNTU1pYhIhxxySHrllVf6tKOcmIa67aG2ZVd64v3mN7+ZIiJNnTo1HXPMMWnixIkpItK4cePSr3/96wHX++53v5sKhUKaNm1amjt3btp9991TRKQJEyak3/3ud33W+9CHPpQiIk2aNCkdcsghae7cuWmvvfZKEZF22223dNttt/VZ57nnnisuM378+HT44YenI488Mu25554pItKcOXP6rDPUPgYox8aNG9OCBQuKY+GMGTPSMccck/bZZ5/i/++snNzw7jH87rvvTgsWLEjNzc0pItIxxxyTFixYUPw89thjxe0PNP4PNs6hjNG72v+uVDJfPvHEE2nSpEnFPHb00UcXY/zc5z43YLwDTR/KPcrObRxsrgRGvqHe1/c3fbD3ysMd0zx7efbameeu2qNIx7B1d3enY445JkVEOvHEE9PLL79cnHfPPfcUB58bbrih13o9g1VTU1O66aabislk27Ztadu2bam7uzvNnTs3RUQ69dRT04YNG4rr/vjHP06NjY2poaGh38H13HPPTRGRPvShD6VnnnmmOH3jxo3pIx/5SIqI9LGPfaxPW0rFNNRtD6ctu9ITb2NjY/q7v/u7tGPHjpRSSm+++Wb68z//8+JD3FtvvdXveuPHj0+33HJLcXpXV1cxGfzZn/1Zn/0tX748/fa3v+3TtjvvvDNNmDAhtbS0pK6url7z/+qv/ipFRLrgggvSpk2bes373e9+l2688cY++xnq8QMox4c//OEUEWnWrFnp4Ycf7jVv7dq16dprr+01rZzcMNjCUTnLDDbOoYzR5cb4bpXKlzt27EiHH354ioh02mmnpY0bNxbn/dM//VNqbm5OjY2NZff1UO9Rdm7jYHMlMLIN576+v3FqMPfKWYxpnr08e+3Mc1ftUaRj2H75y1+miEjNzc3ppZde6jP/2muvLQ5YO/9Vp2ew+uxnP9vvdu+7777iXyReffXVPvM/97nPFbex8+D6xBNPFPfX38PIm2++mdra2lKhUEjr1q3rNa9UTEPd9lDbUkrPOosXL+4zb8uWLWnq1KkpItIPfvCDstv529/+NkVEam1tLTuOlFL60pe+lCKiz190Tj311BQR6YknnihrO8M5fgCl/Md//EcxZz311FNlrVMqN6SUfZFuKHHuykBjdLkxvlul8uXPf/7zFBFp8uTJ6fXXX++z3lVXXTVgvuyvHUO9RynVxqHmSqD+Dee+vr9xajD3ypUa04bTLs9e76jHZy/PXbXJd9IxbPfee29ERJx99tkxderUPvM//elPR3Nzc6xfvz5+//vf95l//vnn97vdX/ziF8Xt7rXXXn3mX3LJJf2ud8cdd0RExDnnnBMTJ07sM3/8+PFx8sknR0opfv3rX/e7jYFiGuq2h9qWcl166aV9pjU1NcVFF13Ua//v1jN/Z4cffniMHTs2Ojs7Y8OGDX3mP//88/GNb3wjzjnnnPjgBz8Y73vf++J973tf/OM//mNERDzxxBO9lm9ra4uIiH/6p38q6/sfsjh+AAPp+R63s846K2bPnj2odQfKDZUw1DgHO0YPV9b58pe//GVERHzkIx+J1tbWPuv9xV/8xaDiG+49SsTQciUwcmV9Xz+Ye+UsxjTPXp69enjuqk0NeQdA/XvqqaciIuLQQw/td/7EiROjra0tnn766Xjqqafi4IMP7jX/kEMO2eV2B5o/e/bsaGhoiO3bt/ea/l//9V8R8c6gM9AXavZ8kfcf/vCHfucPtM+hbnuobSnXQNvtmd6z/3ebNWtWv9P33nvv6OjoiDfeeCMmT55cnH7rrbfGpz/96di8efOAsWzcuLHX/1966aVx6623xtVXXx3/8A//EP/jf/yPeP/73x8f+MAHYvr06X3Wz+L4AQzkd7/7XUREHH/88YNed6CxthKGEudQxujhyjpfrl27NiIijjjiiH7XmTFjRrS0tJT9RdbDvUeJGHyuBEa2rO/rB3OvnMWY5tnLs1cPz121SZGOYXvjjTciImKfffYZcJkpU6bE008/HZs2beozb/fdd9/ldvfee+9+548ZMyb22muvePnll3tN7+zsjIiIp59+Op5++uldxv7222/3O32gmIa67aG2pVwD9f2UKVMiIvrt94iB2zlmzDsv2e7815dnnnkmlixZEtu2bYu/+Zu/iU984hMxa9asmDBhQhQKhfj+979fnL+zI488Mv793/89rrrqqrj//vvjxhtvjBtvvDEKhUIsXLgwrrvuul6JLovjBzCQnuLOpEmTBr3uQGNmJQw2zqGO0cOVdb588803IyL6/Yt+j4kTJ5ZdpBvuPUrE4HIlMPJlfV8/mHvlSo5pnr3KN1KevTx31SZFOoZtwoQJERHxxz/+ccBlXnnllYjY9U33QNt99dVX+53f3d3d7yvBPeu1t7f3+0rxcAx120NtS7leffXV2G+//fpM7zkmg+n3gfz0pz+Nbdu2xbnnnhvf+ta3+szv6OgYcN3jjz8+fvGLX8Qbb7wRDz74YKxcuTJuv/32uPfee2PhwoWxevXq4oNoJY8fQM94+Prrr+cbSAmDjXM4Y3QlDHUs73mA6XnA6s9ADz+7iiPrexRg9KrEfX2598qVHNM8e5VvpDx7ee6qTb6TjmH7kz/5k4iIePLJJ/udv2nTpuIg0rPsYLa7Zs2afuc//fTT/b4R0PP69+rVq8veV7mGuu2htqVcPf8saqDpg+n3gaxbty4iIubPn9/v/HK+52jChAlx6qmnxje+8Y1Ys2ZNzJo1K/7whz/EPffcU1ymkscP4L3vfW9ERDz88MNV2V+hUBjSeoONM4sxOkvDzZe//e1v+53//PPPl/0W3c7by/oeBRi9KnlfX+peuZJjmmev8o2UZy/PXbVJkY5hO/XUUyMiYvny5f2+MnzjjTfGli1bYsaMGXHQQQeVvd1TTjmluN3+/tJxww039LveWWedFRERP/rRjzL/MuehbnuobSlXf+tv3bo1br755l77H45x48ZFxH//dW5na9asiRUrVgxqe+PHj4/DDz88IiJefPHF4vRKHj+AD3/4wxERceedd8YzzzxT8f31jJ2D/Wcig40z6zF6uIY6li9cuDAiIv7lX/6l3zfmfvjDHw4qjkrdowCjV6Xv63v0d69cyTHNs1f5Rsqzl+euGpXLb8oyonR3d6d58+aliEgnnXRSeuWVV4rzfvGLX6QJEyakiEjf/e53e60X//9PUe9qu0cddVSKiHTaaaeljRs3Fuf94z/+Y2pqakoNDQ39/nT2OeeckyIiHXXUUemxxx7rNW/79u1p5cqV6bzzzkubN28eVExD3fZw2rIrPfE2Njam6667rvhT62+99VY6//zzU0Sktra29Oabbw6qnf39PPzy5ctTRKQ99tgjPf7448Xpv//979Nhhx2Wxo4dmyIiXXDBBb229elPfzr95Cc/6RPDv/3bv6WJEyemiEj3339/r3lDPX4A5TjrrLNSRKTZs2en//iP/+g1b+3atWnZsmW9ppWTG/obN1NK6Ywzzug3B5az7mDiHOoYvav970ql8uWOHTvSEUcckSIiLVq0KL322mvFeXfccUcaO3Zsamxs7Dfe/tox1HuUcto4lH4D6t9w7uv7GzcGc69cyTHNs1dpI/HZy3NX7VGkIxNr165N++23X4qI1NzcnObOnZsOPPDA4oD0P//n/ywOYj3KGZRXr16d9txzzxQRady4cemYY44pDmKXXHLJgDfImzZtSgsXLizuY//990/HHXdcOvzww9O4ceOK099+++1BxzTUbQ+1LbvSs69vfvObKSLS1KlT07x581JLS0uKiDR27Nj0b//2bwOuN5D+Ytm2bVs6/vjjU0Sk3XbbLR1yyCHpsMMOS4VCIU2bNi1dc801/SaKOXPmpIhIDQ0N6ZBDDknHHntscfsRkT7xiU9k1scA5di4cWP60z/90+JY8p73vCcdc8wxacqUKSki0owZM3otP5wi3T/8wz8U1z/ssMPSiSeemE488cReN9wDrTuYOIc6Ru9q/7tSyXz5xBNPpEmTJqWISOPHj0/HHHNMes973pMiIn32s58txvv888+X1Y6h3KOU00ZFOhi9hnpf39/0wd4rV2pMG067PHvV77OX567ao0hHZl599dV02WWXpdmzZ6fm5ubU0tKSTjjhhPS///f/HnKiSCmlZ599Np133nlp8uTJaezYsenwww9P3/72t1N3d/cuB9cdO3ak2267LZ166qlpr732So2NjWnatGnpuOOOS1/84hf7vJUwmJiGsu3htGUgO8d72223pXnz5qXx48en1tbWtHjx4vTEE0+UXK8/A8XS2dmZPvvZz6bp06enxsbGtN9++6WLLroovfjii+mWW27pN1Hcf//96fOf/3yaO3du2nvvvVNTU1OaMWNGOvXUU9PPfvazfs+NlIbexwDl2Lp1a/r7v//7tGDBgtTa2prGjh2bDjjggPSxj30srVixoteywynSpZTS9ddfn4444oheN7srV64sa93BxDmUMbrU/gdS6Xz59NNPp3PPPbdXvvzOd76TUkppr732ShHR6y27Uu0Y7D1KOW1UpIPRbSj39f1NH8q9ciXGtOG0KyXPXvX87OW5q7YUUvK78VCver6Q3GUMwGiwYcOG2GuvvWLSpEnx2muv5R0OAKOIZy+qwQ9HAABQF2655ZaIGPjX7gAA6pkiHQAANeO//uu/4qabboo33nijOC2lFD/60Y/iy1/+ckREfPrTn84rPACAivHPXaGOeeUagJHmV7/6VXzgAx+I3XbbLWbMmBGTJ0+OZ599NjZs2BARERdffHF873vfyzlKAEYbz15UgyId1DGJAoCR5o9//GP83d/9Xdx7773R0dERnZ2d0dLSEkcddVQsWbIk/uzP/izvEAEYhTx7UQ25/HPXu+++O04++eTYc889Y/fdd4+5c+fGt7/97eju7s4jHKhb6Z1faM47DBgR5CaoDfvss09885vfjMcffzz+3//7f7Ft27bYsGFD3HfffQp0jEryE9QGz15UQ9XfpPvGN74RV155ZUREzJw5MyZMmBCrV6+O7u7uWLx4cdxxxx0xZkx5tcPu7u548cUXY+LEicWqNgDVkVKKTZs2xfTp08set2tVlrkpQn4CyMtIyk0Rnp0ARoqy81OqolWrVqVCoZDGjBmTbr/99uL03/zmN2nKlCkpItKyZcvK3l5HR0eKCB8fHx+fHD8dHR2VSBlVk3VuSkl+8vHx8cn7U++5KSXPTj4+Pj4j8VMqP1X1Tbozzjgj7r777vjLv/zLuPHGG3vNu/322+PP//zPY/LkyfHSSy9FY2Njye11dnbGpEmTYvUzbTFxYv3/pQygnmza1B2HzeqI119/PVpbW/MOZ8iyzk0R5eenQ/e7oOS2nnzh1l3Oz2IbtWYktqnelHMMyuE4UW0jJTdFVO7ZaXzjF6NQaK5U2HUri/Eqq7GzHOXEW614shrrq9l/pdRSm2opllpTS9dBKSltibe2fbNkfmqoVkBdXV1x3333RUTEhRde2Gf+2WefHZ/5zGdiw4YNsXLlyjjllFNKbrPnNe2JE8dES4siHUAe6vmfzFQiN0WUn58KhbElt1Uqv2WxjVozEttUb8o5BuVwnMhLPeemiMo+OxUKzZld4yNJFuNVNfu1nHirFU9WY30tnZe11KZaiqXW1NJ1UK5S+alqd06PP/54bN26NcaOHRtz587tM7+xsTHmzZsXERGPPPJItcICYBSTmwCoRfITwOhUtSLd2rVrIyJi//33j4aG/l/gmzlzZq9l323Lli3R1dXV6wMAQ5VFboqQnwDIlmcngNGpakW61157LSIi9thjjwGX6ZnXs+y7LV26NFpbW4uftra27AMFYNTIIjdFyE8AZMuzE8DoVLUi3ebNmyMioqmpacBlmpvf+QLTt99+u9/5V155ZXR2dhY/HR0d2QcKwKiRRW6KkJ8AyJZnJ4DRqWo/HDF27Dtf1rd169YBl9myZUtERIwbN67f+c3NzcVkBADDlUVuipCfAMiWZyeA0alqb9KV88+FynmtGwCyIjcBUIvkJ4DRqWpv0s2ePTsiIp5//vnYvn17v1+A+uyzz/ZaFgAqKe/c1NHZnvk2R4J67Je21iXD3ka9tbve4oV6kmd+yuLazmJMrEdZjYv11n/lxFtvOaOWjkFW/VvOMrXU7no7Z0rF29XVHTP2Kb2dqr1Jd9RRR0VjY2Ns3rw5HnvssT7zt23bFo8++mhERBx33HHVCguAUUxuAqAWyU8Ao1PVinQtLS1x8sknR0TEzTff3Gf+8uXLo6urKyZPnhwnnXRStcICYBSTmwCoRfITwOhUtSJdRMTf/u3fRqFQiO9///vx4x//uDj9iSeeiL/+67+OiIgrrrhil79iBABZkpsAqEXyE8DoU9Ui3YIFC+Lqq6+O7u7uOO+882LWrFkxZ86cmDt3brzyyitxxhlnxN/8zd9UMyQARjm5CYBaJD8BjD5VLdJFvPMXoRUrVsQHP/jB2LBhQzz99NNx+OGHx3XXXRd33XVX7LbbbtUOCYBRTm4CoBbJTwCjS9V+3XVnixYtikWLFuWxawDol9wEQC2SnwBGj6q/SQcAAAAA9KZIBwAAAAA5y+WfuwIA2ejobC+5TFvrkipE8o5aiycL5bSpnGWyUG99B1AL6m2MrqVcmlXf1Vv+qtYxqKVjHZFNPNVsU71dB+XwJh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQs4a8AwAAKqujs73kMm2tS6oQyTtKxVNLsQDlK+fadc3l78kXbo2WloHf1ajWcazmuVDNvJKFasXrehxYvZ0z5ailNlXz3jSL8zyLWFLaHBFfK7mcN+kAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOGvIOAADIX0dne9X21da6pGr7KiWrWLLov1rql2qeD4wczpv6cOh+F0ShMHbA+eUcx1LjVRbbKFc5+6pWPFntp5rbyUK1jmUt5eysZNWmkdg3WcVSS9dKObxJBwAAAAA5U6QDAAAAgJwp0gEAAABAzhTpAAAAACBninQAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAActaQdwAAALWso7O9ZvbT1rqkavuCPJRzjjt/h+fJF26NlpaB39XIYpyptbEqq3iqtZ9qbSer/q23a7Ja50NE/fVNOarZf1nI4hhU8x7Nm3QAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAAcqZIBwAAAAA5U6QDAAAAgJwp0gEAAABAzhTpAAAAACBnDXkHAAAj1aH7XRCFwtgB53d0tlcxmvpRzX5pa11Sle1Us01Z7KucfnH+UgnOKwYrq/Eqq3yQhayug1JtquZYX6191dqxrta+qnmc6k293dN4kw4AAAAAcqZIBwAAAAA5U6QDAAAAgJwp0gEAAABAzhTpAAAAACBninQAAAAAkDNFOgAAAADImSIdAAAAAOSsIe8AAGCkevKFW6OlpT7+HtbWuqTkMh2d7ZnsK6vtVEs5fZPFNsrpl2r1Xb0dI6C66m2MyGIMziIXVNtIbFMpWbUpq3O8Wn1cb/cZ1Tz3smhTNeOtjycHAAAAABjBFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnDXkHQAAkL+Ozva8QxiUttYleYfQS731X7WUc5z0HdSWWromsxrra6lN5aildtdSvi2nPbUUb62pVk6u5jGo1rVdzXPPm3QAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAAcqZIBwAAAAA5U6QDAAAAgJwp0gEAAABAzhryDgAAYGdtrUvyDqGXjs72vEMAGJXKGX/LyRm1lleqpVS7s+rfrGQRbzlqrd3VMlrvZ8o5lqX6JottdHV1x4x9Sm7Gm3QAAAAAkDdFOgAAAADImSIdAAAAAORMkQ4AAAAAcqZIBwAAAAA5U6QDAAAAgJwNukj33HPPRXt7eyxZsiTmzJkTDQ0NUSgU4pprrim57kMPPRRnnnlm7L333jFu3Lg49NBD4+qrr47NmzcPKXgA6CE/AVBr5CYABqNhsCtcf/31cf311w96R7fddltccMEFsWPHjth3332jra0tVq9eHV/5yldixYoV8atf/SrGjx8/6O0CQIT8BEDtkZsAGIxBF+n22muvWLRoURx77LExb968+P73vx///M//vMt11q1bFxdeeGHs2LEjrr322rjsssuiUCjE+vXr49RTT41HH300rrjiivjOd74z5IYAMLrJT/WjrXVJVfbT0dmeyXbKiTeLfVVrP9VUTrxZnQ/11jeMDnJTbajmWFQt1WpTNXNpNbaR5XbKUar/qhnLSMy3tXRPWSqWlDZHxNdKbmfQRbovfelLvf7/Jz/5Scl1li1bFlu2bIlTTjklLr/88uL0GTNmxA9+8INYsGBB3HTTTfHlL385pkyZMtiQAEB+AqDmyE0ADEbFfzgipRR33HFHRERceOGFfebPnz8/Dj744Ni2bVvcddddlQ4HACJCfgKg9shNAKNbxYt0zz//fLz00ksREbFgwYJ+l+mZ/sgjj1Q6HACICPkJgNojNwGMboP+566DtXbt2oiIaG5ujunTp/e7zMyZM3stO5AtW7bEli1biv/f1dWVUZQAjDbyEwC1Rm4CGN0q/ibda6+9FhERkyZNikKh0O8ye+yxR69lB7J06dJobW0tftra2rINFoBRQ34CoNbITQCjW8WLdJs3b46IiKampgGXaW5ujoiIt99+e5fbuvLKK6Ozs7P46ejoyC5QAEYV+QmAWiM3AYxuFf/nrmPHjo2IiK1btw64TM9r2OPGjdvltpqbm4tJCQCGQ34CoNbITQCjW8XfpOt5Hfv111+PlFK/y/S8qt2zLABUmvwEQK2RmwBGt4q/STd79uyIeOcvPi+++GLsu+++fZZ59tlney0LAJUmP1VGW+uSquyno7O9KvuppnLalFX/1lv/1Vu8MFTVyE2H7ndBFApjhx5k1NY1mVUspbZTzvibVSzVGuurlbOpDdW8zyillmIpRzVjqfibdPvvv39MnTo1IiIefPDBfpfpmX7cccdVOhwAiAj5CYDaIzcBjG4VL9IVCoU466yzIiLi5ptv7jN/1apVsWbNmmhsbIzFixdXOhwAiAj5CYDaIzcBjG4VL9JFRFx++eXR1NQU9957byxbtqz4/Qrr16+PT33qUxERcdFFFxX/agQA1SA/AVBr5CaA0WvQRboHH3ww9tprr+LnJz/5SURELF26tNf0nX/i+4ADDoj29vYYM2ZMXHHFFdHW1hZz586N2bNnx+9///s4+uijY9myZdm1CoBRR34CoNbITQAMxqB/OGLbtm2xYcOGPtPfeuuteOutt4r/v2PHjl7zzz///DjwwANj6dKlsWrVqnjyySdj5syZ8fGPfzy++MUvFn9uHACGQn4CoNbITQAMxqCLdCeddNKAPwdeyvz582PFihVDWhcAdkV+AqDWyE0ADEZVvpMOAAAAABiYIh0AAAAA5GzQ/9wVACjPoftdEIVCfXxvUEdne01tp1raWpeUXKaW2lROLOW0qZbUUv+OVvV2HVBZI/FYZ3GOZ9Uv1Ryjs9hXNdtdrXOv3o5BNdXSMajmuVdLx8mbdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGcNeQcAAJCXjs72vEMYlLbWJXmHkIty2l1vx7Le1Mu5l9LmiPha3mHUtVq63rKKZSSOD9W6Juvl2h+Map4PpfqvlmIpV6mYy2lTNc+rWounFG/SAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnDXkHQAAjFYdne0ll2lrXVKFSLLbTzltorLq7RjU2zlejno7BrU0FsHOaulaKucaqKV4I0rHU29tqrV4R+u4WKrd5RyDrI5Ttc6JLLbR1dUdM/YpvZw36QAAAAAgZ4p0AAAAAJAzRToAAAAAyJkiHQAAAADkTJEOAAAAAHKmSAcAAAAAOVOkAwAAAICcNeQdAACMVm2tS/IOYVA6OtvzDoEylHNeVetYVvMcr9a+XAfUuydfuDVaWob3rkap662c66Sa40OtxVNKVuNMLbWpWrmplnJgOWrpGNWjrI5lLZ0T3qQDAAAAgJwp0gEAAABAzhTpAAAAACBninQAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAAcqZIBwAAAAA5a8g7AABgYB2d7XmHAEPm/B05sjqWba1LKrqfrq7umLHPsDZBGbI4H6p1TpW7TLVUs93V2k85bZIPRo+szplq7qvSuWkwvEkHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABy1pB3AAAwUj35wq3R0jLw38PaWpdUMZr6UU6/dHS2VyGS2jNa283Q1dr15BweGbLIX7V2LtRaPKWUE2+p45TFNrJUrX3V0v1XVuddVm2q1nlVjqzalEUerGYu9SYdAAAAAORMkQ4AAAAAcqZIBwAAAAA5U6QDAAAAgJwp0gEAAABAzhTpAAAAACBninQAAAAAkDNFOgAAAADIWUPeAQDAaNXR2Z53CIPS1rqk5DJZtKne+gVqmeuJWlVOTilHOed4OfsqtUxW+6nmNVlqX1kdg2rJqu/qrd0MT73lQW/SAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnDXkHQAAUB86Otsz2U5b65Jhb6OcWMrZT1ZtgpEui+s2wjVXCw7d74IoFMbmHUZVZZEzsroGRmtuyqL/suq7rO4hqqWasVTrOFVTrcVTijfpAAAAACBninQAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAAcjboIl1KKR544IG4/PLL4/jjj49JkyZFU1NTTJ8+PT760Y/GypUrd7n+Qw89FGeeeWbsvffeMW7cuDj00EPj6quvjs2bNw+5EQCMbnITALVIfgJgMAZdpLv//vvj/e9/f3zrW9+KRx99NKZMmRKHHXZYbNq0Kf7lX/4lPvjBD8aXv/zlfte97bbb4v3vf3/87Gc/i+bm5jjkkEPi6aefjq985StxwgknxFtvvTXsBgEw+shNANQi+QmAwWgY7AoppTjwwAPjr//6r+Pcc8+NPfbYIyIitm7dGl/96ldj6dKlcc0118Rxxx0XixYtKq63bt26uPDCC2PHjh1x7bXXxmWXXRaFQiHWr18fp556ajz66KNxxRVXxHe+853sWgfAqCA31ZeOzvYRtR+olLbWJbucX81z3PU0NPWYn7I41qXOXXat3vqvluItJ5asxrN6u5+pZt+UUkvnTETpdpcTb6llUtocEV8ruZ1Bv0l37LHHxu9+97v4zGc+U0wyERFNTU3x9a9/PU477bSIiGhv793IZcuWxZYtW+KUU06Jyy+/PAqFQkREzJgxI37wgx9ERMRNN90Ur7zyymBDAmCUk5sAqEXyEwCDMegiXUtLSzQ0DPwC3sKFCyMi4qmnnipOSynFHXfcERERF154YZ915s+fHwcffHBs27Yt7rrrrsGGBMAoJzcBUIvkJwAGI/Nfd+35EtNx48YVpz3//PPx0ksvRUTEggUL+l2vZ/ojjzySdUgAjHJyEwC1SH4CYGeD/k66XUkpxfLlyyOid0JZu3ZtREQ0NzfH9OnT+1135syZvZbtz5YtW2LLli3F/+/q6hp2zACMbJXOTRHyEwCD59kJgHfL9E269vb2ePzxx6OpqSm+8IUvFKe/9tprERExadKk4vcpvFvPdzT0LNufpUuXRmtra/HT1taWXfAAjEiVzk0R8hMAg+fZCYB3y6xI99hjj8XnP//5iIi45pprYtasWcV5Pa9xNzU1Dbh+c3NzRES8/fbbAy5z5ZVXRmdnZ/HT0dGRRegAjFDVyE0R8hMAg+PZCYD+ZPLPXZ977rlYtGhRbN68Oc4777y47LLLes0fO3ZsRLzzU+MD6XkVe+fvY3i35ubmYkICgF2pVm6KkJ8AKJ9nJwAGMuw36V5++eVYuHBhvPTSS3HGGWfED3/4wz6vZfe8jv36669HSqnf7fS8qr3zT5MDwFDITQDUIvkJgF0Z1pt0GzdujIULF8YzzzwTJ554YixfvjwaGxv7LDd79uyIeOcvPi+++GLsu+++fZZ59tlney0LAENRS7np0P0uiEJh7IDzOzrbh7RdGK621iW7nO/crA1ZHIdSxzqr/VTTrtqU0uaI+Fr1ghmEWspPw1XOeVVKOeddFvspdzvVug6yalMtyarvaum8quZ2slBv51U1r/9y1FL/DflNujfeeCNOP/30WL16dcybNy9WrFgx4OvW+++/f0ydOjUiIh588MF+l+mZftxxxw01JABGObkJgFokPwFQjiEV6bZs2RJnnnlmPPLII/He9743fv7zn8fEiRMHXL5QKMRZZ50VERE333xzn/mrVq2KNWvWRGNjYyxevHgoIQEwyslNANQi+QmAcg26SLdjx44499xz4/77749Zs2bFL3/5y9hzzz1Lrnf55ZdHU1NT3HvvvbFs2bLi9yusX78+PvWpT0VExEUXXVT8qxEAlEtuAqAWyU8ADMagv5Pupz/9adx5550RETFmzJg4++yz+11u2rRpsXz58uL/H3DAAdHe3h5/8Rd/EVdccUVcf/31sc8++8Tq1atj27ZtcfTRR8eyZcuG1goARjW5CYBaJD8BMBiDLtL1/Nx3RMTatWtj7dq1/S43Y8aMPtPOP//8OPDAA2Pp0qWxatWqePLJJ2PmzJnx8Y9/PL74xS8Wf24cAAZDbgKgFslPAAzGoIt0n/zkJ+OTn/zkkHc4f/78WLFixZDXB4B3k5sAqEXyEwCDMeRfdwUAAAAAsqFIBwAAAAA5G/Q/dwUAqKS21iWZbKejsz2T7YxE+mb0GInHeldt6urqjhn7VDGYUSqL8yqrsb5a28nqWqrmNVmtNpVzDLLYVznbcF4NPZZyZdGmrGIpR7Wuuaza5E06AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQs4a8AwCAkerJF26NlpbR9fewttYlJZfp6Gwf1nygfpUaI1z/lZdFbqq341hr8VRLLbW7nPuDWpJV35Vqdxb3TeWq1vlQzTZlpZbOz9H15AAAAAAANUiRDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMhZQ94BAAAjR0dne94hADXMGJG/Q/e7IAqFsQPOH4nHqK11ScllSrU7i23Uo3LaXS1ZxZLVcarWeVVr595IPM+r0aauru6YsU/p5bxJBwAAAAA5U6QDAAAAgJwp0gEAAABAzhTpAAAAACBninQAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAActaQdwAAAPWurXXJLud3dLZXKRLqRalzphzOK/IyEs+9LK7Jaqq3eEcr9wf9K+f8zapv6i3fepMOAAAAAHKmSAcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyFlD3gEAANS7js72vEOgzjhnyMuTL9waLS318a5GNa+TttYlVdlGOW3KIpZy9pVVvNWSVb9kpZrHcqSp5nmVxXGq5rVSH6MzAAAAAIxginQAAAAAkDNFOgAAAADImSIdAAAAAORMkQ4AAAAAcqZIBwAAAAA5U6QDAAAAgJwp0gEAAABAzhryDgAAAADIVlvrkprZT0dneybbgcGqlesgpc0R8bWS2/EmHQAAAADkTJEOAAAAAHKmSAcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyFlD3gEAAKNLW+uSXc7v6GyvUiSMJqXOuwjnHqPDoftdEIXC2AHnZ3EdlHO9ZbWd0Xrd1tJxyuoYlNpOVvGWo1r7qrVjUI5q3cdldf2Xs0w1z61SvEkHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABy1pB3AADA6NLR2Z53CNSQttYlJZfJ4pxx3sE7nnzh1mhpqey7Glldb+WMD1kpFXNWsdTadqq1n3obg2sp3mpeB+XIom/q7TooR6l+6erqjhn7lN6ON+kAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAAByNqQi3Z133hkXX3xxHH300TFt2rRoamqKSZMmxfz58+P666+PrVu3DrjuQw89FGeeeWbsvffeMW7cuDj00EPj6quvjs2bNw+5EQAgNwFQi+QnAMo1pCLdt771rbjpppvi//7f/xvjxo2LOXPmxIQJE+Khhx6KL3zhCzF//vx4/fXX+6x32223xfvf//742c9+Fs3NzXHIIYfE008/HV/5ylfihBNOiLfeemu47QFglJKbAKhF8hMA5RpSke6iiy6KlStXxqZNm+LZZ5+NRx99NF544YV46KGHYr/99ov//M//jL/927/ttc66deviwgsvjB07dsS1114bHR0d8dhjj8XatWvjoIMOikcffTSuuOKKTBoFwOgjNwFQi+QnAMpVSCmlLDe4fPnyOOecc2L69Onxhz/8oTj90ksvjRtuuCFOOeWU+MUvftFrnVWrVsWCBQuisbExOjo6YsqUKWXtq6urK1pbW2P9H2dES4uv1wOopq6u7pixz/ro7OyMlpaWvMPZpWrmpgj5qVa0tS7JZDsdne2ZbAeovHrKTRH5PDvt3vSVKBTGZtqOoRitY2s5uSmrvskqD2YhizbVY17PIuaReK3U0rmZlVLHqdz8lPmTw8EHHxwR0ev165RS3HHHHRERceGFF/ZZZ/78+XHwwQfHtm3b4q677so6JABGObkJgFokPwGws8yLdA899FBERMydO7c47fnnn4+XXnopIiIWLFjQ73o90x955JGsQwJglJObAKhF8hMAO2vIYiM7duyIl156KX72s5/F//pf/yt23333WLp0aXH+2rVrIyKiubk5pk+f3u82Zs6c2WvZ/mzZsiW2bNlS/P+urq4swgdgBKpWboqQnwAon2cnAAYyrDfprrvuuigUCtHQ0BBtbW1x6aWXxoc+9KF4+OGH49hjjy0u99prr0VExKRJk6JQKPS7rT322KPXsv1ZunRptLa2Fj9tbW3DCR+AEajauSlCfgKgNM9OAJQyrCLdvvvuGwsWLIhjjz22+IWlK1eujB//+MexY8eO4nKbN2+OiIimpqYBt9Xc3BwREW+//faAy1x55ZXR2dlZ/HR0dAwnfABGoGrnpgj5CYDSPDsBUMqw/rnr2WefHWeffXbx/x955JG4+OKL4+tf/3ps3Lgxvvvd70ZExNix7/x60NatWwfcVs+r2OPGjRtwmebm5mJCAoD+VDs3RchPAJTm2QmAUjL94Yjjjjsu7r777mhubo6bbrop1q9fHxH//Tr266+/HimlftfteVW7Z1kAyILcBEAtkp8AeLfMf911+vTpceSRR0Z3d3c88cQTERExe/bsiHjnLz4vvvhiv+s9++yzvZYFgKzITQDUIvkJgJ1l8uuu77Z9+/Ze/91///1j6tSp8fLLL8eDDz4Y55xzTp91HnzwwYh45y9KAJC1WsxNba1LSi7T0dlekX2PBvqOSnDdkrVazE/DVc41UGvXUjnxlJJVvNXqm1rr31LxZHVeVVO95YMsjlNWx6Aej3cWMn+Tbt26dcW/As2ZMyciIgqFQpx11lkREXHzzTf3WWfVqlWxZs2aaGxsjMWLF2cdEgCjnNwEQC2SnwDY2aCLdP/5n/8ZV111VfEV6539/Oc/j9NOOy22b98ep59+esyaNas47/LLL4+mpqa49957Y9myZcXvV1i/fn186lOfioiIiy66KKZOnTrUtgAwSslNANQi+QmAwRh0kW7Tpk3xta99LWbNmhXTpk2LefPmxZw5c2KPPfaI0047LdasWRPz5s2LW2+9tdd6BxxwQLS3t8eYMWPiiiuuiLa2tpg7d27Mnj07fv/738fRRx8dy5Yty6xhAIwechMAtUh+AmAwBl2kmzNnTlx//fWxePHi2H333WPNmjWxZs2aGDduXJx22mlxyy23xKpVq2Kvvfbqs+75558fv/71r2PRokXx9ttvx5NPPhkzZ86Mr371q/HAAw/E7rvvnkmjABhd5CYAapH8BMBgDPqHI/bYY4/43Oc+F5/73OeGtMP58+fHihUrhrQuAPRHbgKgFslPAAxG5j8cAQAAAAAMjiIdAAAAAORs0P/cFQDIRkdne94h1KS21iUll9F35MW5B7Ulq5xRaply9lOOcmIpZ19ZxFPNNo3EsTOr/iulmn1XrX3V2/lQzXi9SQcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyJkiHQAAAADkTJEOAAAAAHLWkHcAAEBltbUuyWQ7HZ3tmWynVDxZ7Yf6UM75Wc45kcV5Xm/nXlZ9BzvL4pzJKu9ktZ1a2lctjXmjVTXHzlLbKSeWah7rauWMejt/s4g3pc0R8bWSy3mTDgAAAABypkgHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5KyQUkp5BzFUXV1d0draGuv/OCNaWtQbAaqpq6s7ZuyzPjo7O6OlpSXvcGpKPeanttYlJZfp6GyvQiTZGYltqjflHINqcawHNpKuFblpYLWWm7IaH+rl3ByMao2d5fTdSDxO1WxTqX1ldQxqqX+zUs17iFL9l0UsKW2ON7d+rWR+yn90BgAAAIBRTpEOAAAAAHKmSAcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyFlD3gEAAPnr6GzPO4TMjcQ21ZK21iV5h9BLtY53Oe2upXOv3uKFnZVzbmY1FpXa10i8lmptHK8lWR3LWspN5cgi3mrGktV1WWo71RyLvEkHAAAAADlTpAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABy1pB3AAAA1Ja21iV5h1CzOjrb8w5hUOotXkaPkXhuljN2jsR2lyOLvqlm/9bSsSxnP1nl7Sy2k1W8tdSmavImHQAAAADkTJEOAAAAAHKmSAcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyFlD3gEAAFB/Ojrb8w6hl7bWJbucX2vxQq0qdS1F1Nb1VK1YytlPOX3HwLLov2oeA8e7srK65rLYThb76erqjhn7lNyMN+kAAAAAIG+KdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADlTpAMAAACAnDXkHQAAkL+21iUll+nobK9CJPWpVP/VW9/VW7xAdZWTM0rJapzJKn/VUptGoiz6JotjRG3I6lrJ6toutZ1qnnvepAMAAACAnCnSAQAAAEDOFOkAAAAAIGeKdAAAAACQM0U6AAAAAMiZIh0AAAAA5EyRDgAAAABypkgHAAAAADkrpJRS3kEMVVdXV7S2tsb6P86Ilhb1RoBq6urqjhn7rI/Ozs5oaWnJO5yaUs381Na6pOQyHZ3tFY2Bkaec86oczr2Ro17GGrlpYD25afemr0ShMLai+yrnXMhqnKk31bxOsujjrOKtlzEka6P1PK8ltTIepbQ53tz6tZL5SWULAAAAAHKmSAcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyFlD3gEMR0opIiI2berOORKA0adn7O0Zi/lv1cxPKW0uuUxXlzzJ4JRzXpXDuTdy1MtYIzcNrKdPUtpS8X2Vcy5kNc7Um2peJ1n0cVbx1ssYkrXRep7XkloZj3rG3lL5qZDqOIO98MIL0dbWlncYAKNaR0dH7LfffnmHUVPkJ4B8yU19yU0A+SuVn+q6SNfd3R0vvvhiTJw4MQqFQnR1dUVbW1t0dHRES0tL3uGNSPq4svRvZenfbKWUYtOmTTF9+vQYM8a3J+xMfqou/VtZ+rfy9HF25KaByU3Vp48rS/9Wlv7NVrn5qa7/ueuYMWP6rUC2tLQ4iSpMH1eW/q0s/Zud1tbWvEOoSfJTPvRvZenfytPH2ZCb+ic35UcfV5b+rSz9m51y8pM/LwEAAABAzhTpAAAAACBnI6pI19zcHFdddVU0NzfnHcqIpY8rS/9Wlv4lL869ytK/laV/K08fkwfnXeXp48rSv5Wlf/NR1z8cAQAAAAAjwYh6kw4AAAAA6pEiHQAAAADkTJEOAAAAAHKmSAcAAAAAOVOkAwAAAICcjZgi3d133x0nn3xy7LnnnrH77rvH3Llz49vf/nZ0d3fnHVrNe+6556K9vT2WLFkSc+bMiYaGhigUCnHNNdeUXPehhx6KM888M/bee+8YN25cHHrooXH11VfH5s2bqxB57UspxQMPPBCXX355HH/88TFp0qRoamqK6dOnx0c/+tFYuXLlLtfXv+W588474+KLL46jjz46pk2bFk1NTTFp0qSYP39+XH/99bF169YB19XHVJLcNHRyU2XJT5UnN1HL5Kehk58qR26qDvmpxqURYOnSpSkiUkSkmTNnpiOOOCKNGTMmRURavHhx2rFjR94h1rTPf/7zxf7b+XP11Vfvcr0f/ehHabfddksRkfbdd9901FFHpcbGxhQRad68eenNN9+sUgtq13333VfszzFjxqQ/+ZM/SUcddVSaMGFCcfqXvvSlftfVv+VbsGBBiojU3NycDjjggHTMMcekfffdt9jHRx99dHrttdf6rKePqSS5aXjkpsqSnypPbqJWyU/DIz9VjtxUHfJTbav7It2qVatSoVBIY8aMSbfffntx+m9+85s0ZcqUFBFp2bJlOUZY+66++uq0aNGi9LWvfS3dc8896aMf/WjJRPPcc8+l5ubmFBHp2muvTd3d3SmllNatW5cOOuigFBHp0ksvrVYTatYvf/nLdOCBB6Ybbrghbdy4sTh9y5Yt6corrywOhCtWrOi1nv4dnFtuuSWtXLkybd26tdf0hx56KO23334pItIll1zSa54+ppLkpuGTmypLfqo8uYlaJD8Nn/xUOXJTdchPta3ui3Snn356ioj0l3/5l33m3XbbbSki0uTJk/ucgAzsggsuKJloLrnkkhQR6ZRTTukz78EHH0wRkRobG9PLL79cyVBrXmdnZ9q2bduA80877bTiXy13pn+z89Of/jRFRJo+fXqv6fqYSpKbsic3ZUt+ypfcRF7kp+zJT9mRm/InP+Wvrr+TrqurK+67776IiLjwwgv7zD/77LOjpaUlNmzYUPLfr1O+lFLccccdEdF/v8+fPz8OPvjg2LZtW9x1113VDq+mtLS0RENDw4DzFy5cGBERTz31VHGa/s3WwQcfHBERb731VnGaPqaS5KZ8uK4HR37Kl9xEHuSnfLi2yyc35U9+yl9dF+kef/zx2Lp1a4wdOzbmzp3bZ35jY2PMmzcvIiIeeeSRaoc3Yj3//PPx0ksvRUTEggUL+l2mZ7p+37WeL9gcN25ccZr+zdZDDz0UEdFrjNDHVJLclA/Xdbbkp8qSm8iD/JQP13Z25KbKk5/yV9dFurVr10ZExP777z9gxX3mzJm9lmX4evqyubk5pk+f3u8y+r20lFIsX748InoPdvp3+Hbs2BEvvPBC3HDDDXHZZZfF7rvvHkuXLi3O18dUktyUD9d1duSnypCbyJv8lA/XdjbkpsqRn2pLXRfpXnvttYiI2GOPPQZcpmdez7IMX09fTpo0KQqFQr/L6PfS2tvb4/HHH4+mpqb4whe+UJyuf4fuuuuui0KhEA0NDdHW1haXXnppfOhDH4qHH344jj322OJy+phKkpvy4brOjvyULbmJWiE/5cO1nQ25KXvyU22q6yJdz+uuTU1NAy7T3NwcERFvv/12VWIaDfT78D322GPx+c9/PiIirrnmmpg1a1Zxnv4dun333TcWLFgQxx57bEyZMiUiIlauXBk//vGPY8eOHcXl9DGV5PzKh37PhvyUPbmJWuEcy4d+Hz65qTLkp9pU10W6sWPHRkTE1q1bB1xmy5YtEdH7360zPPp9eJ577rlYtGhRbN68Oc4777y47LLLes3Xv0N39tlnxwMPPBCPPPJIvPzyy/Hwww/He97znvj6178ef/VXf1VcTh9TSc6vfOj34ZOfKkNuolY4x/Kh34dHbqoc+ak21XWRrpxXKst5rZvB6enL119/PVJK/S6j3/v38ssvx8KFC+Oll16KM844I374wx/2eWVY/2bnuOOOi7vvvjuam5vjpptuivXr10eEPqay5KZ8uK6HR36qHrmJvMhP+XBtD53cVF3yU22o6yLd7NmzI+KdXxvZvn17v8s8++yzvZZl+Hr6csuWLfHiiy/2u4x+72vjxo2xcOHCeOaZZ+LEE0+M5cuXR2NjY5/l9G+2pk+fHkceeWR0d3fHE088ERH6mMqSm/Lhuh46+an65CbyID/lw7U9NHJTPuSn/NV1ke6oo46KxsbG2Lx5czz22GN95m/bti0effTRiHinKkw29t9//5g6dWpERDz44IP9LtMzXb+/44033ojTTz89Vq9eHfPmzYsVK1YM+Cqw/s1ez41oz3/1MZUkN+XDdT008lN+5CaqTX7Kh2t78OSmfMlP+arrIl1LS0ucfPLJERFx880395m/fPny6OrqismTJ8dJJ51U5ehGrkKhEGeddVZE9N/vq1atijVr1kRjY2MsXry42uHVnC1btsSZZ54ZjzzySLz3ve+Nn//85zFx4sQBl9e/2Vq3bl3xr0Bz5syJCH1MZclN+XBdD578lB+5iTzIT/lwbQ+O3JQv+akGpDr3wAMPpEKhkMaMGZNuv/324vTf/OY3acqUKSki0je/+c0cI6w/F1xwQYqIdPXVVw+4zLPPPpuamppSRKRrr702dXd3p5RSWrduXTrooINSRKTPfOYz1Qq5Zm3fvj19+MMfThGRZs2alV588cWy1tO/5fs//+f/pK985SvpmWee6TPvnnvuSQcffHCKiHT66af3mqePqSS5KXtyU7bkp8qSm6hV8lP25KfsyE2VJz/Vvrov0qWU0jXXXJMiIkVEmjlzZjriiCPSmDFjUkSkM844I23fvj3vEGvaAw88kCZPnlz8NDc3p4hI48eP7zX9+eef77XerbfeWuznfffdNx111FGpsbExRUQ6+uij0xtvvJFTi2rH7bffXjw3Z8+enRYsWNDv52Mf+1ifdfVveVauXFns46lTp6ZjjjkmHXHEEWnSpEnF6fPmzUuvvvpqn3X1MZUkNw2P3FRZ8lNlyU3UMvlpeOSnypGbKk9+qn0jokiXUkorVqxIH/zgB1Nra2saP358mjNnTrruuuskmTLsfKHu6vPcc8/1WffBBx9MixYtSnvuuWdqbm5OBx10UPrqV7+a3n777eo3pAbdcsstZfXtjBkz+l1f/5a2cePGdP3116fFixenWbNmpQkTJqSmpqY0bdq0dNppp6Vbbrklbdu2bcD19TGVJDcNndxUWfJTZclN1Dr5aejkp8qRmypPfqp9hZQG+A1dAAAAAKAq6vqHIwAAAABgJFCkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJAzRToAAAAAyJkiHQAAAADkTJEOAAAAAHKmSAcAAAAAOVOkAwAAAICcKdIBAAAAQM4U6QAAAAAgZ4p0AAAAAJCz/w90hNvKjMihLwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "##### plot a few Ising states\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "\n",
    "# set colourbar map\n",
    "cmap_args=dict(cmap='plasma_r')\n",
    "\n",
    "# plot states\n",
    "fig, axarr = plt.subplots(nrows=1, ncols=3)\n",
    "\n",
    "axarr[0].imshow(X_ordered[20001].reshape(L,L),**cmap_args)\n",
    "axarr[0].set_title('$\\\\mathrm{ordered\\\\ phase}$',fontsize=16)\n",
    "axarr[0].tick_params(labelsize=16)\n",
    "\n",
    "axarr[1].imshow(X_critical[10001].reshape(L,L),**cmap_args)\n",
    "axarr[1].set_title('$\\\\mathrm{critical\\\\ region}$',fontsize=16)\n",
    "axarr[1].tick_params(labelsize=16)\n",
    "\n",
    "im=axarr[2].imshow(X_disordered[50001].reshape(L,L),**cmap_args)\n",
    "axarr[2].set_title('$\\\\mathrm{disordered\\\\ phase}$',fontsize=16)\n",
    "axarr[2].tick_params(labelsize=16)\n",
    "\n",
    "fig.subplots_adjust(right=2.0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cost function, optimizers, regularizers, and performance metrics\n",
    "\n",
    "In Sec. VII of the review, we have shown that the cross-entropy is a natural cost function used for training a logistic regressor. As we already mentioned, minimizing it requires the use of numerical toolboxes. Here, we compare the performance of two different optimization routines: a `liblinear` [the default one for scikit's logistic regression], and stochastic gradient descent (SGD) [see Sec. IV of the review for more details].\n",
    "\n",
    "It is important to note that all these methods have built-in regularizers. Indeed, we did not discuss the role of the regularisor explicitly in the context of Logistic Regression extensively, yet this concept is crucial in order to prevent overfitting, and we encourage the interested reader to play with the different regularization types and regularization strengths and compare model performances. \n",
    "\n",
    "Below, we define the accuracy of a classification model on a given data set as the percentage of correctly classified data points. Comparing the accuracy on the training and test data, we obtain a good estimate of the degree of overfitting. Well-trained models do not overfit the data, which is reflected in an almost equal performance on the training and test data sets [recall that the test set consists of samples which the model has not been trained on]. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run the cell below (this may take several minutes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6861, 0.6684\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7278, 0.6861, 0.6683\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\HU_local\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_stochastic_gradient.py:696: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD: 0.4853, 0.4713, 0.5335\n",
      "finished computing 1/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6861, 0.6684\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7278, 0.6861, 0.6683\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\HU_local\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_stochastic_gradient.py:696: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SGD: 0.4978, 0.4758, 0.5257\n",
      "finished computing 2/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6861, 0.6684\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7278, 0.6861, 0.6684\n",
      "SGD: 0.4843, 0.4515, 0.5309\n",
      "finished computing 3/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6861, 0.6684\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7278, 0.6861, 0.6685\n",
      "SGD: 0.6993, 0.6558, 0.6481\n",
      "finished computing 4/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6861, 0.6684\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7279, 0.6861, 0.6684\n",
      "SGD: 0.6760, 0.6394, 0.7266\n",
      "finished computing 5/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6861, 0.6684\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7277, 0.6861, 0.6684\n",
      "SGD: 0.5887, 0.5723, 0.7613\n",
      "finished computing 6/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7278, 0.6860, 0.6686\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7278, 0.6861, 0.6686\n",
      "SGD: 0.4599, 0.4631, 0.2308\n",
      "finished computing 7/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7274, 0.6856, 0.6702\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7270, 0.6856, 0.6710\n",
      "SGD: 0.4599, 0.4631, 0.2308\n",
      "finished computing 8/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7231, 0.6819, 0.6818\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.7190, 0.6790, 0.6888\n",
      "SGD: 0.4599, 0.4631, 0.2308\n",
      "finished computing 9/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.7032, 0.6664, 0.7192\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.6528, 0.6205, 0.7637\n",
      "SGD: 0.4599, 0.4631, 0.2308\n",
      "finished computing 10/11 iterations\n",
      "accuracy: train, test, critical\n",
      "liblin: 0.6958, 0.6620, 0.7132\n",
      "accuracy: train, test, critical\n",
      "lbfgs: 0.5401, 0.5369, 0.7692\n",
      "SGD: 0.4599, 0.4631, 0.2308\n",
      "finished computing 11/11 iterations\n"
     ]
    }
   ],
   "source": [
    "###### apply logistic regression\n",
    "from sklearn import linear_model\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "\n",
    "\n",
    "# define regularisation parameter\n",
    "lmbdas=np.logspace(-5,5,11)\n",
    "\n",
    "# preallocate data\n",
    "train_accuracy=np.zeros(lmbdas.shape,np.float64)\n",
    "test_accuracy=np.zeros(lmbdas.shape,np.float64)\n",
    "critical_accuracy=np.zeros(lmbdas.shape,np.float64)\n",
    "\n",
    "train_accuracy_SGD=np.zeros(lmbdas.shape,np.float64)\n",
    "test_accuracy_SGD=np.zeros(lmbdas.shape,np.float64)\n",
    "critical_accuracy_SGD=np.zeros(lmbdas.shape,np.float64)\n",
    "\n",
    "train_accuracy2=np.zeros(lmbdas.shape,np.float64)\n",
    "test_accuracy2=np.zeros(lmbdas.shape,np.float64)\n",
    "critical_accuracy2=np.zeros(lmbdas.shape,np.float64)\n",
    "\n",
    "# loop over regularisation strength\n",
    "for i,lmbda in enumerate(lmbdas):\n",
    "\n",
    "    # define logistic regressor\n",
    "    logreg=linear_model.LogisticRegression(C=1.0/lmbda,random_state=1,verbose=0,max_iter=1E3,tol=1E-5,\n",
    "                                           solver='liblinear', penalty='l2') # saga  liblinear\n",
    "\n",
    "    # fit training data\n",
    "    logreg.fit(X_train, Y_train)\n",
    "\n",
    "    # check accuracy\n",
    "    train_accuracy[i]=logreg.score(X_train,Y_train)\n",
    "    test_accuracy[i]=logreg.score(X_test,Y_test)\n",
    "    critical_accuracy[i]=logreg.score(X_critical,Y_critical)\n",
    "    \n",
    "    print('accuracy: train, test, critical')\n",
    "    print('liblin: %0.4f, %0.4f, %0.4f' %(train_accuracy[i],test_accuracy[i],critical_accuracy[i]) )\n",
    "    \n",
    "    ## define logistic regressor\n",
    "    logreg2=linear_model.LogisticRegression(C=1.0/lmbda,random_state=1,verbose=0,max_iter=1E3,tol=1E-5,\n",
    "                                           solver='lbfgs', penalty='l2') # saga  liblinear      newton-cg, sag, saga\n",
    "\n",
    "    ## fit training data\n",
    "    logreg2.fit(X_train, Y_train)\n",
    "\n",
    "    ## check accuracy\n",
    "    train_accuracy2[i]=logreg2.score(X_train,Y_train)\n",
    "    test_accuracy2[i]=logreg2.score(X_test,Y_test)\n",
    "    critical_accuracy2[i]=logreg2.score(X_critical,Y_critical)\n",
    "    \n",
    "    print('accuracy: train, test, critical')\n",
    "    print('lbfgs: %0.4f, %0.4f, %0.4f' %(train_accuracy2[i],test_accuracy2[i],critical_accuracy2[i]) )\n",
    "\n",
    "\n",
    "    # define SGD-based logistic regression\n",
    "    logreg_SGD = linear_model.SGDClassifier(loss='log', penalty='l2', alpha=lmbda, max_iter=100, \n",
    "                                           shuffle=True, random_state=1, learning_rate='optimal')\n",
    "\n",
    "    # fit training data\n",
    "    logreg_SGD.fit(X_train,Y_train)\n",
    "\n",
    "    # check accuracy\n",
    "    train_accuracy_SGD[i]=logreg_SGD.score(X_train,Y_train)\n",
    "    test_accuracy_SGD[i]=logreg_SGD.score(X_test,Y_test)\n",
    "    critical_accuracy_SGD[i]=logreg_SGD.score(X_critical,Y_critical)\n",
    "    \n",
    "    print('SGD: %0.4f, %0.4f, %0.4f' %(train_accuracy_SGD[i],test_accuracy_SGD[i],critical_accuracy_SGD[i]) )\n",
    "\n",
    "    print('finished computing %i/11 iterations' %(i+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot accuracy against regularisation strength\n",
    "plt.semilogx(lmbdas,train_accuracy,'*-b',label='liblinear train') # liblinear\n",
    "plt.semilogx(lmbdas,test_accuracy,'*-r',label='liblinear test')\n",
    "plt.semilogx(lmbdas,critical_accuracy,'*-g',label='liblinear critical')\n",
    "\n",
    "plt.semilogx(lmbdas,train_accuracy2,'b', marker=\"|\", label='lbfgs train') # newton-cg 0.6830 // \n",
    "plt.semilogx(lmbdas,test_accuracy2,'r', marker=\"|\", label='lbfgs test')\n",
    "plt.semilogx(lmbdas,critical_accuracy2,'g', marker=\"|\", label='lbfgs critical')\n",
    "\n",
    "plt.semilogx(lmbdas,train_accuracy_SGD,'*--b',label='SGD train')\n",
    "plt.semilogx(lmbdas,test_accuracy_SGD,'*--r',label='SGD test')\n",
    "plt.semilogx(lmbdas,critical_accuracy_SGD,'*--g',label='SGD critical')\n",
    "\n",
    "plt.xlabel('$\\\\lambda$')\n",
    "plt.ylabel('$\\\\mathrm{accuracy}$')\n",
    "\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Interpreting the results\n",
    "\n",
    "The first thing we can read off the figure above is the relative degree of overfitting. This information is contained in the difference in accuracy of our model on the training (blue) and test (red) datasets. Notice that the accuracy difference between test and training sets is significant but not unreasonable, within $10\\%$. Interestingly, which optimizer performs better depends on the value of the regularization strength. Moreover, similar to the Linear Regression examples, we find that there exists a sweet spot for the regularization strength $\\lambda$ that results in optimal performance of the logistic regressor, at about $\\lambda\\sim 10^{-1}$.\n",
    "\n",
    "Due to the physics of the Ising model close to criticality, we expect that predicting the phase of a sample will become much more difficult close to the critical point. We can visually see this by looking at the states in the critical region, (see Fig. above and plot other examples). Notice that it is no longer easy even for a trained human eye to distinguish between the ferromagnetic and the disordered phases close to $T_c$. \n",
    "\n",
    "It is an interesting exercise to compare the training and test accuracies in the ordered and disordered phases to the accuracy of the model near the critical point (i.e. critical states). Recall that the model is not trained on critical states. Notice that the accuracy is about $10\\%$ smaller for the critical states (green curves). \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises: ###  \n",
    "<ul>\n",
    "<li> Change the regularization to $L^1$, or $L^1+L^2$ (i.e. elastic net, see Notebook 2 for more details), and study the performance of the model.\n",
    "<br><span style=\"color:blue\">  \n",
    " </span>\n",
    "    \n",
    "<img src=\"https://github.com/DBustamante98/ML/blob/main/NB6_3.jpg?raw=true\"  width=\"500\" height=\"300\">\n",
    "\n",
    "<br><span style=\"color:blue\">      \n",
    "For non-critical data, the elastic net regularization seems to provide very good results for $\\lambda=10^{-3}$. With the correct value of $\\lambda$, all regularization methods seem to have the same predictive performance with critical data.\n",
    "  </span>  \n",
    "<li> Try out different solvers supported by `LogisticRegression()`, [see online scikit documentation](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html). How do they compare to `liblinear` and `SGD`?\n",
    "\n",
    " <img src=\"https://github.com/DBustamante98/ML/blob/main/NB6_4.png?raw=true\"  width=\"500\" height=\"300\">   \n",
    "    \n",
    "<br><span style=\"color:blue\">  \n",
    "For values of $\\lambda<10^2$, the performance of the other models (<code>lbfgs</code>, <code>newton-cg</code>, <code>sag</code>, <code>saga</code>) is identical to that of <code>liblinear</code>. However, there is an improvement in predictive power for critical data when $\\lambda = 10^4$.   \n",
    "</span>\n",
    "\n",
    "<li> One can expect the regressor to be maximally confused exactly at the critical point. Take the data states for the closest temperature, i.e. $T/J=2.5$, and check the performance of the model. Do we get an accuracy of about $50\\%$? Does this depend on the proportion of ordered to disordered states in the training set?\n",
    "<br><span style=\"color:blue\">  \n",
    "An accuracy of 0.6843 can be obtained when 66.7% of the critical data corresponds to ordered states. Similarly, an accuracy of 0.7692 is obtained when 76.9% of the critical data is ordered states and an accuracy of 1 when all critical data is ordered states. Therefore, the accuracy of a model in the critical regime is sensitive to the proportion of ordered states in the dataset that is used to estimate that accuracy.\n",
    "</span>\n",
    "\n",
    "<li> Take the regressor trained on the square lattice Ising model, and try to predict the phases on a different lattice geometry (e.g. triangular or honeycomb). What accuracy do you obtain? Can you roughly locate the critical point in this new model? Note that this requires you to generate your own dataset using Monte-Carlo sampling.\n",
    " <br><span style=\"color:blue\"> \n",
    "   The model does not seem to have a good performance for the new (triangular) structure; it only allows one to estimate a critical temperature of $T \\sim 5-6$.\n",
    "</span>\n",
    " <img src=\"https://github.com/DBustamante98/ML/blob/main/NB6_5.png?raw=true\"  width=\"500\" height=\"300\">   \n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.768332481826996\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax1 = plt.subplots()\n",
    "ax2 = ax1.twinx()\n",
    "\n",
    "TV1 = []; PV1 = []; TV2 = []; PV2 = [];\n",
    "for i in range(len(PHASE_vector)):\n",
    "    if PHASE_vector[i] == 1:\n",
    "        TV1.append( TEMPERATURE_vector[i]  )\n",
    "        PV1.append( PHASE_vector[i] )\n",
    "    else:\n",
    "        TV2.append( TEMPERATURE_vector[i]  )\n",
    "        PV2.append( PHASE_vector[i] )            \n",
    "\n",
    "ax1.scatter(TV1, PV1, color=\"b\", s=0.01)\n",
    "ax1.scatter(TV2, PV2, color=\"b\", s=0.3)\n",
    "ax2.scatter(TEMPERATURE_vector, MAGNETIZATION_vector, color=\"g\", s=0.3)\n",
    "ax1.set_xlabel(\"$T$\"); ax1.set_ylabel(\"Phase\", color=\"blue\"); ax2.set_ylabel(\"Magnetization\", color=\"green\"); \n",
    "print(min(TV2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1], [-1, 1], [1, 1, 1], [1, 1, -1, -1], [1, 1, -1, -1, -1], [1, -1, 1, 1, 1, -1], [-1, 1, 1, 1, 1, 1, 1], [1, 1, -1, 1, -1, -1, -1, -1], [1, 1, 1, 1, -1, 1, -1, -1, 1], [1, 1, -1, 1, 1, -1, -1, -1, -1, 1], [-1, 1, 1, -1, -1, 1, -1, 1, -1, 1, -1], [-1, -1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1], [1, -1, 1, 1, -1, -1, 1, 1, 1, 1, -1, 1, -1], [-1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1], [1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, 1, -1, -1, 1], [-1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, -1, 1, 1, 1, 1], [1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, -1, -1, -1, -1], [-1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1], [-1, 1, -1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, 1, 1, 1, -1], [-1, 1, -1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, -1, -1], [-1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1], [1, -1, -1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1], [1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1], [-1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, 1], [1, 1, -1, 1, 1, -1, 1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1], [-1, -1, -1, 1, -1, -1, 1, -1, -1, 1, 1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, 1, 1, -1, 1], [-1, 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1], [-1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1], [1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1], [1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, -1, -1, 1, -1, 1, -1, 1, 1], [1, -1, -1, 1, 1, -1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, -1, 1], [-1, 1, 1, 1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, -1], [-1, -1, -1, -1, 1, 1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1], [-1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1, 1, -1, 1, 1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, -1, 1, -1], [-1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, 1], [-1, 1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, 1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, -1], [1, 1, 1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1], [1, 1, 1, -1, -1, 1, 1, 1, 1, 1, -1, -1, 1, -1, -1, -1, -1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1], [-1, 1, 1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1], [-1, 1, -1, -1, -1, 1, -1, 1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, -1, -1, -1, 1, 1]]\n",
      "[[-1], [-1, -1], [-1, -1, -1], [-1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "logreg=linear_model.LogisticRegression(C=1.0/1e+4,random_state=1,verbose=0,max_iter=1E3,tol=1E-5,\n",
    "                                           solver='lbfgs')\n",
    "logreg.fit(X_train, Y_train)\n",
    "\n",
    "TEMPERATURE_vector = np.random.uniform(low=0.5, high=20, size=1) # 2000\n",
    "PHASE_vector = []\n",
    "MAGNETIZATION_vector = []\n",
    "\n",
    "for temp in TEMPERATURE_vector:\n",
    "    sample = IsingTriangle(40).basicIter(iters=110000, temp=temp, plot=True); # IsingSquare IsingHexagon IsingTriangle\n",
    "    sample = [0 if i==8 else i for i in np.concatenate(sample[-1])]\n",
    "    PHASE_vector.append( logreg.predict([ sample ])[0]  )\n",
    "    MAGNETIZATION_vector.append( 2*sum(sample)/len(sample)  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import math\n",
    "from matplotlib import colors\n",
    "import copy\n",
    "import random\n",
    "\n",
    "class IsingSquare:\n",
    "\n",
    "    # initialise a spin lattice and populate with random spins\n",
    "    def __init__(self, order, interactionVal=1, magMoment=1):\n",
    "\n",
    "        if order < 3:\n",
    "            raise ValueError('Order number needs to be greater than 2.')\n",
    "\n",
    "        self.temp = 0.0\n",
    "        self.beta = 0.0\n",
    "        self.boltzmann = 1.38064852 * (10 ** -23)\n",
    "        self.order = order\n",
    "\n",
    "        self.J = float(interactionVal)\n",
    "        self.h = float(magMoment)\n",
    "\n",
    "        self.magList = []\n",
    "        self.specHeatList = []\n",
    "        self.energyList = []\n",
    "        self.suscepList = []\n",
    "\n",
    "        self.spins = []\n",
    "        self.resetSpins()\n",
    "\n",
    "    # reset the spin lattice to a random configuration\n",
    "    def resetSpins(self):\n",
    "        vals = np.array([-1, 1])\n",
    "\n",
    "        self.spins = np.random.choice(vals, size=(self.order, self.order))\n",
    "\n",
    "    # returns an array of an atom's 4 nearest neighbours\n",
    "    def neighbours(self, row, col):\n",
    "\n",
    "        return np.asarray([self.spins[row][col - 1],                 #left\n",
    "                           self.spins[row][(col + 1) % self.order],  #right\n",
    "                           self.spins[row - 1][col],                 #up\n",
    "                           self.spins[(row + 1) % self.order][col]]) #down\n",
    "\n",
    "    # calculates the energy of a single atom, using the Hamiltonian\n",
    "    def singleEnergy(self, row, col):\n",
    "\n",
    "        neighbours = self.neighbours(row, col)\n",
    "        selfSpin = self.spins[row][col]\n",
    "        return self.J * selfSpin * np.sum(np.sum(neighbours)) - self.h * selfSpin\n",
    "\n",
    "    # calculates the magnitude of the entire energy of the lattice\n",
    "    def totalEnergy(self):\n",
    "\n",
    "        energy = 0.0\n",
    "        for i in np.arange(self.order):\n",
    "            for j in np.arange(self.order):\n",
    "                energy += self.singleEnergy(i, j)\n",
    "\n",
    "        # to avoid counting pairs twice, divide by two\n",
    "        # divide by maximum possible energy to normalise\n",
    "        return math.fabs(energy) / (self.order * self.order * (-4 * self.J - self.h) )\n",
    "\n",
    "    # calculates the magnitude of the residual magnetic spin of the lattice\n",
    "    # normalise by dividing by order of lattice squared\n",
    "    def totalMag(self):\n",
    "        return math.fabs(np.sum(np.sum(self.spins)) / (self.order ** 2))\n",
    "\n",
    "    def specHeat(self, energy, energySquared, temp):\n",
    "        return (energySquared - energy ** 2) * (1 / (self.order * self.order * 2 * temp * temp))\n",
    "\n",
    "    def suscep(self, mag, magSquared, temp):\n",
    "        return self.J * (magSquared - mag ** 2) * (1 / (self.order * self.order * 2 * temp))\n",
    "    # attempts to flip a random spin using the metropolis algorithm and the Boltzmann distribution\n",
    "    def tryFlip(self, row, col):\n",
    "        # energy change = -2 * E_initial\n",
    "        # so accept change if E_initial >= 0\n",
    "\n",
    "        energy = self.singleEnergy(row, col)\n",
    "\n",
    "        if energy <= 0 or np.random.random() <= math.exp(-self.beta * 2 * energy):\n",
    "            self.spins[row][col] *= -1\n",
    "\n",
    "    # closes plot window\n",
    "    def close_event(self):\n",
    "        plt.close()  # timer calls this function after 3 seconds and closes the window\n",
    "\n",
    "    # plots a meshgrid of the initial and final spin lattices\n",
    "    def plotStartEndSpins(self, spinsList, iters=1000000):\n",
    "\n",
    "        cmap = colors.ListedColormap(['red', 'yellow'])\n",
    "        bounds = [-1, 0, 1]\n",
    "        norm = colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "        plt.subplots(nrows=1, ncols=2)\n",
    "        plt.tight_layout()\n",
    "\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(spinsList[0], cmap=cmap, norm=norm)\n",
    "        plt.xticks([], [])\n",
    "        plt.yticks([], [])\n",
    "        plt.title('Initial Configuration')\n",
    "\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.imshow(spinsList[1], cmap=cmap, norm=norm)\n",
    "        plt.xticks([], [])\n",
    "        plt.yticks([], [])\n",
    "        plt.title('Final Configuration')\n",
    "\n",
    "        title = \"Temperature (J/K_B) = {0}, J = {1}, h = {2}, Iterations = {3}\".format(self.temp, self.J, self.h, iters) + \"\\n\" + \"Order: {0} x {1}\".format(self.order, self.order)\n",
    "        plt.suptitle(title)\n",
    "\n",
    "        plt.show()\n",
    "\n",
    "    # simulates the lattice at a constant temperature temp, for iters iterations, plots the resulting lattices, and returns the spin configurations\n",
    "    def basicIter(self, iters=1000000, temp=1, plot=False):\n",
    "\n",
    "        self.resetSpins()\n",
    "        spinsList = [copy.deepcopy(self.spins)];\n",
    "\n",
    "        self.temp = temp;\n",
    "        self.beta = 1.0 / self.temp;\n",
    "\n",
    "        for i in np.arange(iters + 1):\n",
    "            row, col = np.random.randint(self.order), np.random.randint(self.order);\n",
    "            self.tryFlip(row, col);\n",
    "\n",
    "        spinsList.append(self.spins);\n",
    "\n",
    "        if plot:\n",
    "            self.plotStartEndSpins(spinsList, iters);\n",
    "        else:\n",
    "            for i in np.arange(len(spinsList[0])):\n",
    "                spinsList[0][i] = np.asarray(spinsList[0][i]);\n",
    "\n",
    "            for i in np.arange(len(spinsList[1])):\n",
    "                spinsList[1][i] = np.asarray(spinsList[1][i]);\n",
    "\n",
    "            spinsList = np.array(spinsList);\n",
    "\n",
    "        return spinsList\n",
    "\n",
    "    # simulates the lattice oer a temperature range tempRange, with itersPerTemp iterations per temperature\n",
    "    # plotProperties: plot the residual spin, total energy, susceptibility and specific heat\n",
    "    def tempRangeIter(self, tempRange=np.arange(start=0.8, stop=3.2, step=0.05), itersPerTemp=100000, plotProperties=False):\n",
    "\n",
    "        self.resetSpins()\n",
    "\n",
    "        # store the averages here\n",
    "        energyList = []\n",
    "        magList = []\n",
    "        specHeatList = []\n",
    "        suscepList = []\n",
    "\n",
    "        for temp in tempRange:\n",
    "            self.beta = 1.0 / temp\n",
    "            print(\"Calculating temp:\", temp)\n",
    "\n",
    "            # allow to reach equilibrium\n",
    "            for i in np.arange(itersPerTemp + 1):\n",
    "                row, col = np.random.randint(0, self.order), np.random.randint(0, self.order)\n",
    "                self.tryFlip(row, col)\n",
    "\n",
    "            #do a further thousand iterations to get average, and every hundred iterations, store the properties\n",
    "            if plotProperties:\n",
    "\n",
    "                #store the values used to calculate averages here\n",
    "                magListEquilib = []\n",
    "                energyListEquilib = []\n",
    "\n",
    "                for i in np.arange(500000):\n",
    "\n",
    "                    if i % 5000 == 0:\n",
    "\n",
    "                        energy = self.totalEnergy()\n",
    "                        mag = self.totalMag()\n",
    "\n",
    "                        energyListEquilib.append(energy)\n",
    "                        magListEquilib.append(mag)\n",
    "\n",
    "                    row, col = np.random.randint(0, self.order), np.random.randint(0, self.order)\n",
    "                    self.tryFlip(row, col)\n",
    "\n",
    "                energyAvg = np.average(energyListEquilib)\n",
    "                energySquaredAvg = np.average(np.square(energyListEquilib))\n",
    "                magAvg = np.average(magListEquilib)\n",
    "                magSquaredAvg = np.average(np.square(magListEquilib))\n",
    "\n",
    "                energyList.append(energyAvg)\n",
    "                magList.append(magAvg)\n",
    "                specHeatList.append(self.specHeat(energyAvg, energySquaredAvg, temp))\n",
    "                suscepList.append(self.suscep(magAvg, magSquaredAvg, temp))\n",
    "\n",
    "            # reset the spins for the next temperature\n",
    "            self.resetSpins()\n",
    "\n",
    "        if plotProperties:\n",
    "\n",
    "            plt.tight_layout()\n",
    "\n",
    "            plt.subplot(2, 2, 1)\n",
    "            plt.plot(tempRange, energyList)\n",
    "            plt.title(\"Total Energy\")\n",
    "            plt.axvline(x=2.269185, c='r', linestyle='--')\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "\n",
    "            plt.subplot(2, 2, 2)\n",
    "            plt.plot(tempRange, magList)\n",
    "            plt.title(\"Residual Spin\")\n",
    "            plt.axvline(x=2.269185, c='r', linestyle='--')\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.subplot(2, 2, 3)\n",
    "            plt.plot(tempRange, specHeatList)\n",
    "            plt.title(\"Specific Heat Capacity\")\n",
    "            plt.axvline(x=2.269185, c='r', linestyle='--')\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.subplot(2, 2, 4)\n",
    "            plt.plot(tempRange, suscepList)\n",
    "            plt.title(\"Susceptibility\")\n",
    "            plt.axvline(x=2.269185, c='r', linestyle='--')\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.show()\n",
    "\n",
    "class IsingTriangle:\n",
    "\n",
    "    # initialise a spin lattice and populate with random spins\n",
    "    def __init__(self, order, interactionVal=1, magMoment=1):\n",
    "\n",
    "        if order < 4:\n",
    "            raise ValueError('Order number needs to be greater than 3.')\n",
    "\n",
    "        self.temp = 0.0\n",
    "        self.beta = 0.0\n",
    "        self.boltzmann = 1.38064852 * (10 ** -23)\n",
    "        self.order = order\n",
    "        self.J = float(interactionVal)\n",
    "        self.h = float(magMoment)\n",
    "\n",
    "        self.magList = []\n",
    "        self.specHeatList = []\n",
    "        self.energyList = []\n",
    "        self.suscepList = []\n",
    "\n",
    "        self.spins = []\n",
    "        self.resetSpins()\n",
    "\n",
    "    # reset the spin lattice to a random configuration\n",
    "    def resetSpins(self):\n",
    "        self.spins = []\n",
    "\n",
    "        vals = np.array([1, -1])\n",
    "\n",
    "        for i in np.arange(self.order):\n",
    "            self.spins.append(list(np.random.choice(vals, size=i + 1)))\n",
    "\n",
    "    # returns an array of an atom's 6 nearest neighbours\n",
    "    def neighbours(self, row, col):\n",
    "\n",
    "        # centre atoms\n",
    "        if 1 < row < self.order - 1 and 0 < col < row:\n",
    "            return np.asarray([self.spins[row - 1][col - 1],\n",
    "                              self.spins[row - 1][col],\n",
    "\n",
    "                              self.spins[row][col - 1],\n",
    "                              self.spins[row][col + 1],\n",
    "\n",
    "                              self.spins[row + 1][col],\n",
    "                              self.spins[row + 1][col + 1]])\n",
    "\n",
    "        # left side central\n",
    "        elif 0 < row < self.order - 1 and col == 0:\n",
    "            return np.asarray([self.spins[row - 1][0],\n",
    "                              self.spins[row][1],\n",
    "\n",
    "                              self.spins[row + 1][0],\n",
    "                              self.spins[row + 1][1],\n",
    "\n",
    "                              self.spins[row][row],\n",
    "                              self.spins[row - 1][row - 1]])\n",
    "\n",
    "        # right side central\n",
    "        elif 0 < row < self.order - 1 and col == row:\n",
    "            return np.asarray([self.spins[row - 1][row - 1],\n",
    "                              self.spins[row - 1][0],\n",
    "\n",
    "                              self.spins[row][row - 1],\n",
    "                              self.spins[row][0],\n",
    "\n",
    "                              self.spins[row + 1][row],\n",
    "                              self.spins[row + 1][row + 1]])\n",
    "\n",
    "        # bottom side central\n",
    "        elif row == self.order - 1 and 0 < col < row:\n",
    "            return np.asarray([self.spins[row - 1][col - 1],\n",
    "                               self.spins[row - 1][col],\n",
    "\n",
    "                               self.spins[row][col - 1],\n",
    "                               self.spins[row][col + 1],\n",
    "\n",
    "                               self.spins[0][0],\n",
    "                               self.spins[0][0]])\n",
    "\n",
    "        # very top\n",
    "        elif row == 0:\n",
    "            return np.asarray([self.spins[1][0],\n",
    "                              self.spins[1][1],\n",
    "\n",
    "                              self.spins[self.order - 1][0],\n",
    "                              self.spins[self.order - 1][self.order - 1],\n",
    "\n",
    "                              self.spins[self.order - 1][1],\n",
    "                              self.spins[self.order - 1][self.order - 2]])\n",
    "        # bottom left\n",
    "        elif row == self.order - 1 and col == 0:\n",
    "            return np.asarray([self.spins[row - 1][0],\n",
    "                               self.spins[row - 1][row - 1],\n",
    "\n",
    "                               self.spins[row][1],\n",
    "                               self.spins[row][row],\n",
    "\n",
    "                               self.spins[0][0],\n",
    "                               self.spins[0][0]])\n",
    "\n",
    "        # bottom right\n",
    "        elif row == self.order - 1 and (col == row):\n",
    "            return np.asarray([self.spins[row - 1][0],\n",
    "                               self.spins[row - 1][row - 1],\n",
    "\n",
    "                               self.spins[row][0],\n",
    "                               self.spins[row][row - 1],\n",
    "\n",
    "                               self.spins[0][0],\n",
    "                               self.spins[0][0]])\n",
    "\n",
    "    # calculates the energy of a single atom, using the Hamiltonian\n",
    "    def singleEnergy(self, row, col):\n",
    "\n",
    "        neighbours = self.neighbours(row, col)\n",
    "        selfSpin = self.spins[row][col]\n",
    "        return self.J * selfSpin * np.sum(np.sum(neighbours)) - self.h * selfSpin\n",
    "\n",
    "    # calculates the magnitude of the entire energy of the lattice\n",
    "    def totalEnergy(self):\n",
    "\n",
    "        energy = 0.0\n",
    "        for i in np.arange(self.order):\n",
    "            for j in np.arange(len(self.spins[i])):\n",
    "                energy += self.singleEnergy(i, j)\n",
    "\n",
    "        # to avoid counting pairs twice, divide by two\n",
    "        # divide by maximum possible energy to normalise\n",
    "        return -math.fabs(energy / ((-6 * self.J - self.h)  * ((self.order ** 2 + self.order) / 2)))\n",
    "\n",
    "    # calculates the magnitude of the residual magnetic spin of the lattice\n",
    "    # normalise by dividing by order of lattice squared\n",
    "    def totalMag(self):\n",
    "        return math.fabs((np.sum(np.sum(self.spins)) * 2) / (self.order ** 2 + self.order))\n",
    "\n",
    "    def specHeat(self, energy, energySquared, temp):\n",
    "        return (energySquared - energy ** 2) * (1 / (self.order * self.order * 2 * temp * temp))\n",
    "\n",
    "    def suscep(self, mag, magSquared, temp):\n",
    "        return self.J * (magSquared - mag ** 2) * (1 / (self.order * self.order * 2 * temp))\n",
    "    # attempts to flip a random spin using the metropolis algorithm and the Boltzmann distribution\n",
    "    def tryFlip(self, row, col):\n",
    "        # energy change = -2 * E_initial\n",
    "        # so accept change if E_initial <= 0\n",
    "\n",
    "        energy = self.singleEnergy(row, col)\n",
    "\n",
    "        if energy <= 0 or np.random.random() <= math.exp(-self.beta * 2 * energy):\n",
    "            self.spins[row][col] *= -1\n",
    "\n",
    "    # closes plot window\n",
    "    def close_event(self):\n",
    "        plt.close()  # timer calls this function after 3 seconds and closes the window\n",
    "\n",
    "    # plots a meshgrid of the initial and final spin lattices\n",
    "    def plotStartEndSpins(self, spinsList, iters=1000000):\n",
    "\n",
    "        for i in np.arange(self.order):\n",
    "            for j in np.arange(self.order - i - 1):\n",
    "\n",
    "                spinsList[0][i].append(8)\n",
    "                spinsList[1][i].append(8)\n",
    "\n",
    "        cmap = colors.ListedColormap(['red', 'yellow', 'white'])\n",
    "        bounds = [-1, 0, 2, 10]\n",
    "        norm = colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "        plt.subplots(nrows=1, ncols=2)\n",
    "        plt.tight_layout()\n",
    "        for i in np.arange(len(spinsList[0])):\n",
    "            spinsList[0][i] = np.asarray(spinsList[0][i])\n",
    "\n",
    "        for i in np.arange(len(spinsList[1])):\n",
    "            spinsList[1][i] = np.asarray(spinsList[1][i])\n",
    "\n",
    "        spinsList = np.array(spinsList)\n",
    "\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(spinsList[0], cmap=cmap, norm=norm)\n",
    "        plt.xticks([], [])\n",
    "        plt.yticks([], [])\n",
    "        plt.title('Initial Configuration')\n",
    "\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.imshow(spinsList[1], cmap=cmap, norm=norm)\n",
    "        plt.xticks([], [])\n",
    "        plt.yticks([], [])\n",
    "        plt.title('Final Configuration')\n",
    "\n",
    "        title = \"Temperature (J/K_B) = {0}, J = {1}, h = {2}, Iterations = {3}\".format(self.temp, self.J, self.h, iters) + \"\\n\" + \"Order: {0}\".format(self.order,)\n",
    "        plt.suptitle(title)\n",
    "\n",
    "        # timer = fig.canvas.new_timer(\n",
    "        #     interval=graphInterval)  # creating a timer object and setting an interval of 3000 milliseconds\n",
    "        # timer.add_callback(self.close_event)\n",
    "        # timer.start()\n",
    "        plt.show()\n",
    "\n",
    "    # simulates the lattice at a constant temperature temp, for iters iterations, and returns the spin configurations\n",
    "    def basicIter(self, iters=1000000, temp=1, plot=False):\n",
    "\n",
    "        self.resetSpins()\n",
    "        spinsList = [copy.deepcopy(self.spins)]\n",
    "\n",
    "        self.temp = temp\n",
    "        self.beta = 1.0 / self.temp\n",
    "\n",
    "        for i in np.arange(iters + 1):\n",
    "            row = np.random.randint(self.order)\n",
    "            col = np.random.randint(row + 1)\n",
    "            self.tryFlip(row, col)\n",
    "\n",
    "        spinsList.append(self.spins)\n",
    "\n",
    "        print(spinsList[0])\n",
    "        print(spinsList[1])\n",
    "\n",
    "        if plot:\n",
    "            self.plotStartEndSpins(spinsList, iters)\n",
    "        else:\n",
    "            for i in np.arange(len(spinsList[0])):\n",
    "                spinsList[0][i] = np.asarray(spinsList[0][i])\n",
    "\n",
    "            for i in np.arange(len(spinsList[1])):\n",
    "                spinsList[1][i] = np.asarray(spinsList[1][i])\n",
    "\n",
    "            spinsList = np.array(spinsList)\n",
    "        return spinsList\n",
    "\n",
    "    # simulates the lattice oer a temperature range tempRange, with itersPerTemp iterations per temperature\n",
    "    # plotProperties: plot the residual spin, total energy, susceptibility and specific heat\n",
    "    def tempRangeIter(self, tempRange=np.arange(start=1, stop=5, step=0.2), itersPerTemp=100000, plotProperties=False):\n",
    "\n",
    "        self.resetSpins()\n",
    "\n",
    "        # store the averages here\n",
    "        energyList = []\n",
    "        magList = []\n",
    "        specHeatList = []\n",
    "        suscepList = []\n",
    "\n",
    "        for temp in tempRange:\n",
    "            self.beta = 1.0 / temp\n",
    "            print(\"Calculating temp:\", temp)\n",
    "\n",
    "            # allow to reach equilibrium\n",
    "            for i in np.arange(itersPerTemp + 1):\n",
    "                row = np.random.randint(self.order)\n",
    "                col = np.random.randint(row + 1)\n",
    "                self.tryFlip(row, col)\n",
    "\n",
    "            #do a further ten thousand iterations to get average, and every two hundred iterations, store the properties\n",
    "            if plotProperties:\n",
    "\n",
    "                #store the values used to calculate averages here\n",
    "                magListEquilib = []\n",
    "                energyListEquilib = []\n",
    "\n",
    "                for i in np.arange(10000):\n",
    "\n",
    "                    if i % 200 == 0:\n",
    "\n",
    "                        energy = self.totalEnergy()\n",
    "                        mag = self.totalMag()\n",
    "\n",
    "                        energyListEquilib.append(energy)\n",
    "                        magListEquilib.append(mag)\n",
    "\n",
    "                    row = np.random.randint(self.order)\n",
    "                    col = np.random.randint(row + 1)\n",
    "                    self.tryFlip(row, col)\n",
    "\n",
    "                energyAvg = np.average(energyListEquilib)\n",
    "                energySquaredAvg = np.average(np.square(energyListEquilib))\n",
    "                magAvg = np.average(magListEquilib)\n",
    "                magSquaredAvg = np.average(np.square(magListEquilib))\n",
    "\n",
    "                energyList.append(energyAvg)\n",
    "                magList.append(magAvg)\n",
    "                specHeatList.append(self.specHeat(energyAvg, energySquaredAvg, temp))\n",
    "                suscepList.append(self.suscep(magAvg, magSquaredAvg, temp))\n",
    "\n",
    "            # reset the spins for the next temperature\n",
    "            self.resetSpins()\n",
    "\n",
    "        if plotProperties:\n",
    "\n",
    "            plt.tight_layout()\n",
    "\n",
    "            plt.subplot(2, 2, 1)\n",
    "            plt.plot(tempRange, energyList)\n",
    "            plt.title(\"Total Energy\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "\n",
    "            plt.subplot(2, 2, 2)\n",
    "            plt.plot(tempRange, magList)\n",
    "            plt.title(\"Residual Spin\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.subplot(2, 2, 3)\n",
    "            plt.plot(tempRange, specHeatList)\n",
    "            plt.title(\"Specific Heat Capacity\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.subplot(2, 2, 4)\n",
    "            plt.plot(tempRange, suscepList)\n",
    "            plt.title(\"Susceptibility\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.show()\n",
    "\n",
    "class IsingHexagon:\n",
    "\n",
    "    # initialise a spin lattice and populate with random spins\n",
    "    def __init__(self, order, interactionVal=1, magMoment=1):\n",
    "\n",
    "        if order < 2:\n",
    "            raise ValueError('Order number needs to be greater than 3.')\n",
    "\n",
    "        self.temp = 0.0\n",
    "        self.beta = 0.0\n",
    "        self.boltzmann = 1.38064852 * (10 ** -23)\n",
    "        self.order = order\n",
    "        self.J = float(interactionVal)\n",
    "        self.h = float(magMoment)\n",
    "\n",
    "        self.magList = []\n",
    "        self.specHeatList = []\n",
    "        self.energyList = []\n",
    "        self.suscepList = []\n",
    "\n",
    "        self.resetSpins()\n",
    "\n",
    "    # reset the spin lattice to a random configuration\n",
    "    def resetSpins(self):\n",
    "        self.spins = []\n",
    "\n",
    "        vals = np.array([1, -1])\n",
    "\n",
    "        if self.order == 1:\n",
    "            self.spins.append(list(np.random.choice(vals, size=2)))\n",
    "            self.spins.append(list(np.random.choice(vals, size=2)))\n",
    "            self.spins.append(list(np.random.choice(vals, size=2)))\n",
    "            self.spins = np.array(self.spins)\n",
    "            return\n",
    "\n",
    "        # top layers\n",
    "        iter = 2\n",
    "        while self.order >= iter / 2.0 and not iter == 2 * self.order:\n",
    "            self.spins.append(list(np.random.choice(vals, size=iter)))\n",
    "            iter += 2\n",
    "        # middle layers\n",
    "        for i in np.arange(5 + 2 * (self.order - 2)):\n",
    "            self.spins.append(list(np.random.choice(vals, size=2 * self.order)))\n",
    "        # bottom layers\n",
    "        iter = 2 * self.order - 2\n",
    "        while iter > 0:\n",
    "            self.spins.append(list(np.random.choice(vals, size= iter)))\n",
    "            iter -= 2\n",
    "\n",
    "    # returns the nearest neighbours for centre atoms, used in the main nearest neighbour function\n",
    "    def centreReturn(self, left, row, col): # left is boolean, when true, use atom to left, otherwise, use atom to right\n",
    "        if left:\n",
    "            return np.asarray([self.spins[row - 1][col],\n",
    "                          self.spins[row][col - 1],\n",
    "                          self.spins[row + 1][col]])\n",
    "        else:\n",
    "            return np.asarray([self.spins[row - 1][col],\n",
    "                              self.spins[row][col + 1],\n",
    "                              self.spins[row + 1][col]])\n",
    "\n",
    "    # returns an array of an atom's 3 nearest neighbours\n",
    "    def neighbours(self, row, col):\n",
    "        # centre atoms\n",
    "        if 1 < row < 4 * self.order - 3:\n",
    "            if self.order - 1 < row < 3 * self.order - 1 and 0 < col < len(self.spins[row]) - 1:\n",
    "                # handles centre atoms\n",
    "                if self.order % 2 == 0:\n",
    "                    if (row - col) % 2 == 0:\n",
    "                        return self.centreReturn(True, row, col)\n",
    "                    else:\n",
    "                        return self.centreReturn(False, row, col)\n",
    "                else:\n",
    "                    if (row - col) % 2 == 0:\n",
    "                        return self.centreReturn(False, row, col)\n",
    "                    else:\n",
    "                        return self.centreReturn(True, row, col)\n",
    "\n",
    "            elif (row < self.order or row > 3 * self.order - 2) and 1 < col < len(self.spins[row]) - 2:\n",
    "                # handles centre atoms\n",
    "                if self.order % 2 == 0:\n",
    "                    if (row - col) % 2 == 0:\n",
    "                        return self.centreReturn(True, row, col)\n",
    "                    else:\n",
    "                        return self.centreReturn(False, row, col)\n",
    "                else:\n",
    "                    if (row - col) % 2 == 0:\n",
    "                        return self.centreReturn(False, row, col)\n",
    "                    else:\n",
    "                        return self.centreReturn(True, row, col)\n",
    "\n",
    "        # left\n",
    "        # incorrect but works\n",
    "        if self.order - 1 < row < (3 * self.order - 1) and col < 2:\n",
    "            return np.asarray([self.spins[row - 1][0],\n",
    "                               self.spins[row + 1][0],\n",
    "                               self.spins[row][len(self.spins[row]) - 1]])\n",
    "        # right\n",
    "        # incorrect but works\n",
    "        elif self.order - 1 < row < (3 * self.order - 1) and col > len(self.spins[row]) - 3:\n",
    "            return np.asarray([self.spins[row - 1][col],\n",
    "                               self.spins[row + 1][col],\n",
    "                               self.spins[row][0]])\n",
    "        # annoying left corner atoms\n",
    "        elif (row < self.order or row > 3 * self.order - 2) and col < 2 and len(self.spins[row]) > 2:\n",
    "            if col == 0:\n",
    "                # top left corner\n",
    "                if row < 2 * (self.order - 1):\n",
    "                    return np.asarray([self.spins[row + 1][1],\n",
    "                                       self.spins[row][1],\n",
    "                                       self.spins[row][len(self.spins[row]) - 1]])\n",
    "                # bottom left corner\n",
    "                else:\n",
    "                    return np.asarray([self.spins[row - 1][1],\n",
    "                                       self.spins[row][1],\n",
    "                                       self.spins[row][len(self.spins[row]) - 1]])\n",
    "            else:\n",
    "                # top left corner\n",
    "                if row < 2 * (self.order - 1):\n",
    "                    return np.asarray([self.spins[row][0],\n",
    "                                       self.spins[row - 1][0],\n",
    "                                       self.spins[row + 1][2]])\n",
    "                # bottom left corner\n",
    "                else:\n",
    "                    return np.asarray([self.spins[row][0],\n",
    "                                       self.spins[row - 1][2],\n",
    "                                       self.spins[row + 1][0]])\n",
    "\n",
    "        # annoying right corner atoms\n",
    "        elif (row < self.order or row > 3 * self.order - 2) and col > len(self.spins[row]) - 3 and len(self.spins[row]) > 2:\n",
    "            if not col % 2 == 0:\n",
    "                # top right corner\n",
    "                if row < 2 * (self.order - 1):\n",
    "                    try:\n",
    "                        return np.asarray([self.spins[row + 1][col + 1],\n",
    "                                           self.spins[row][col - 1],\n",
    "                                           self.spins[row][0]])\n",
    "                    except IndexError:\n",
    "                        return np.asarray([self.spins[row + 1][col],\n",
    "                                           self.spins[row][col - 1],\n",
    "                                           self.spins[row][0]])\n",
    "                # bottom right corner\n",
    "                else:\n",
    "                    try:\n",
    "                        return np.asarray([self.spins[row - 1][col + 1],\n",
    "                                           self.spins[row][col - 1],\n",
    "                                           self.spins[row][0]])\n",
    "                    except IndexError:\n",
    "                        return np.asarray([self.spins[row - 1][col],\n",
    "                                           self.spins[row][col - 1],\n",
    "                                           self.spins[row][0]])\n",
    "            else:\n",
    "                # top right corner\n",
    "                if row < 2 * (self.order - 1):\n",
    "                    return np.asarray([self.spins[row][col + 1],\n",
    "                                       self.spins[row - 1][col - 1],\n",
    "                                       self.spins[row + 1][col]])\n",
    "                # bottom right corner\n",
    "                else:\n",
    "                    return np.asarray([self.spins[row][col + 1],\n",
    "                                       self.spins[row - 1][col + 1],\n",
    "                                       self.spins[row + 1][col - 1]])\n",
    "        # top\n",
    "        elif row == 0:\n",
    "            if col == 0:\n",
    "                return np.asarray([self.spins[0][1],\n",
    "                                   self.spins[1][1],\n",
    "                                   self.spins[4 * self.order - 2][0]])\n",
    "            else:\n",
    "                return np.asarray([self.spins[0][0],\n",
    "                                   self.spins[1][2],\n",
    "                                   self.spins[4 * self.order - 2][1]])\n",
    "        # bottom\n",
    "        # don't have to check for anything, only option remaining\n",
    "        elif col == 0:\n",
    "            return np.asarray([self.spins[row][1],\n",
    "                               self.spins[row - 1][1],\n",
    "                               self.spins[0][0]])\n",
    "        else:\n",
    "            return np.asarray([self.spins[row][0],\n",
    "                               self.spins[1][2],\n",
    "                               self.spins[0][1]])\n",
    "\n",
    "\n",
    "    # calculates the energy of a single atom, using the Hamiltonian\n",
    "    def singleEnergy(self, row, col):\n",
    "\n",
    "        neighbours = self.neighbours(row, col)\n",
    "        selfSpin = self.spins[row][col]\n",
    "        return self.J * selfSpin * np.sum(np.sum(neighbours)) - self.h * selfSpin\n",
    "\n",
    "    # calculates the magnitude of the entire energy of the lattice\n",
    "    def totalEnergy(self):\n",
    "\n",
    "        energy = 0.0\n",
    "        for i in np.arange(len(self.spins)):\n",
    "            for j in np.arange(len(self.spins[i])):\n",
    "                energy += self.singleEnergy(i, j)\n",
    "        # to avoid counting pairs twice, divide by two\n",
    "        # divide by maximum possible energy to normalise\n",
    "        return -math.fabs(energy / ((3 * self.J + self.h) * (6 * self.order * self.order))) #( * (-3 * self.J - self.h)\n",
    "\n",
    "    # calculates the magnitude of the residual magnetic spin of the lattice\n",
    "    # normalise by dividing by order of lattice squared\n",
    "    def totalMag(self):\n",
    "        sum = 0\n",
    "        for i in np.arange(len(self.spins)):\n",
    "            sum += np.sum(self.spins[i])\n",
    "\n",
    "        return math.fabs(float(sum) / (6 * self.order ** 2))\n",
    "\n",
    "    def specHeat(self, energy, energySquared, temp):\n",
    "        return (energySquared - energy ** 2) * (1 / (self.order * self.order * 2 * temp * temp))\n",
    "\n",
    "    def suscep(self, mag, magSquared, temp):\n",
    "        return self.J * (magSquared - mag ** 2) * (1 / (self.order * self.order * 2 * temp))\n",
    "    # attempts to flip a random spin using the metropolis algorithm and the Boltzmann distribution\n",
    "    def tryFlip(self, row, col):\n",
    "        # energy change = -2 * E_initial\n",
    "        # so accept change if E_initial <= 0\n",
    "\n",
    "        energy = self.singleEnergy(row, col)\n",
    "\n",
    "        if energy <= 0 or np.random.random() <= math.exp(-self.beta * 2 * energy):\n",
    "            self.spins[row][col] *= -1\n",
    "\n",
    "    # closes plot window\n",
    "    def close_event(self):\n",
    "        plt.close()  # timer calls this function after 3 seconds and closes the window\n",
    "\n",
    "    # plots a meshgrid of the initial and final spin lattices\n",
    "    def plotStartEndSpins(self, spinsList, iters=1000000):\n",
    "\n",
    "        for i in np.arange(2):\n",
    "            for j in spinsList[i]:\n",
    "                while len(j) < 2 * self.order:\n",
    "                    j.insert(0, 8)\n",
    "                    j.append(8)\n",
    "\n",
    "        cmap = colors.ListedColormap(['red', 'yellow', 'white'])\n",
    "        bounds = [-1, 0, 2, 10]\n",
    "        norm = colors.BoundaryNorm(bounds, cmap.N)\n",
    "\n",
    "        plt.subplots(nrows=1, ncols=2)\n",
    "        plt.tight_layout()\n",
    "        for i in np.arange(len(spinsList[0])):\n",
    "            spinsList[0][i] = np.asarray(spinsList[0][i])\n",
    "\n",
    "        for i in np.arange(len(spinsList[1])):\n",
    "            spinsList[1][i] = np.asarray(spinsList[1][i])\n",
    "\n",
    "        spinsList = np.array(spinsList)\n",
    "\n",
    "        plt.subplot(1,2,1)\n",
    "        plt.imshow(spinsList[0], cmap=cmap, norm=norm)\n",
    "        plt.xticks([], [])\n",
    "        plt.yticks([], [])\n",
    "        plt.title('Initial Configuration')\n",
    "\n",
    "        plt.subplot(1, 2, 2)\n",
    "        plt.imshow(spinsList[1], cmap=cmap, norm=norm)\n",
    "        plt.xticks([], [])\n",
    "        plt.yticks([], [])\n",
    "        plt.title('Final Configuration')\n",
    "\n",
    "        title = \"Temperature (J/K_B) = {0}, J = {1}, h = {2}, Iterations = {3}\".format(self.temp, self.J, self.h, iters) + \"\\n\" + \"Order: {0}\".format(self.order,)\n",
    "        plt.suptitle(title)\n",
    "\n",
    "        # timer = fig.canvas.new_timer(\n",
    "        #     interval=graphInterval)  # creating a timer object and setting an interval of 3000 milliseconds\n",
    "        # timer.add_callback(self.close_event)\n",
    "        # timer.start()\n",
    "        plt.show()\n",
    "\n",
    "    # simulates the lattice at a constant temperature temp, for iters iterations, and returns the spin configurations\n",
    "    def basicIter(self, iters=1000000, temp=1, plot=False):\n",
    "\n",
    "        self.resetSpins()\n",
    "        spinsList = [copy.deepcopy(self.spins)]\n",
    "\n",
    "        self.temp = temp\n",
    "        self.beta = 1.0 / self.temp\n",
    "\n",
    "        for i in np.arange(iters + 1):\n",
    "            row = np.random.randint(4 * self.order - 1)\n",
    "            col = np.random.randint(len(self.spins[row]))\n",
    "            self.tryFlip(row, col)\n",
    "\n",
    "        spinsList.append(self.spins)\n",
    "\n",
    "        if plot:\n",
    "            self.plotStartEndSpins(spinsList, iters)\n",
    "        else:\n",
    "            for i in np.arange(len(spinsList[0])):\n",
    "                spinsList[0][i] = np.asarray(spinsList[0][i])\n",
    "\n",
    "            for i in np.arange(len(spinsList[1])):\n",
    "                spinsList[1][i] = np.asarray(spinsList[1][i])\n",
    "\n",
    "            spinsList = np.array(spinsList)\n",
    "\n",
    "        return spinsList\n",
    "\n",
    "    # simulates the lattice oer a temperature range tempRange, with itersPerTemp iterations per temperature\n",
    "    # plotProperties: plot the residual spin, total energy, susceptibility and specific heat\n",
    "    def tempRangeIter(self, tempRange=np.arange(start=1, stop=5, step=0.2), itersPerTemp=100000, plotProperties=False):\n",
    "\n",
    "        self.resetSpins()\n",
    "\n",
    "        # store the averages here\n",
    "        energyList = []\n",
    "        magList = []\n",
    "        specHeatList = []\n",
    "        suscepList = []\n",
    "\n",
    "        for temp in tempRange:\n",
    "            self.beta = 1.0 / temp\n",
    "            print(\"Calculating temp:\", temp)\n",
    "\n",
    "            # allow to reach equilibrium\n",
    "            for i in np.arange(itersPerTemp + 1):\n",
    "                row = np.random.randint(4 * self.order - 1)\n",
    "                col = np.random.randint(len(self.spins[row]))\n",
    "                self.tryFlip(row, col)\n",
    "\n",
    "            #do a further thousand iterations to get average, and every hundred iterations, store the properties\n",
    "            if plotProperties:\n",
    "\n",
    "                #store the values used to calculate averages here\n",
    "                magListEquilib = []\n",
    "                energyListEquilib = []\n",
    "\n",
    "                for i in np.arange(20000):\n",
    "\n",
    "                    if i % 400 == 0:\n",
    "\n",
    "                        energy = self.totalEnergy()\n",
    "                        mag = self.totalMag()\n",
    "\n",
    "                        energyListEquilib.append(energy)\n",
    "                        magListEquilib.append(mag)\n",
    "\n",
    "                    row = np.random.randint(4 * self.order - 1)\n",
    "                    col = np.random.randint(len(self.spins[row]))\n",
    "                    self.tryFlip(row, col)\n",
    "\n",
    "                energyAvg = np.average(energyListEquilib)\n",
    "                energySquaredAvg = np.average(np.square(energyListEquilib))\n",
    "                magAvg = np.average(magListEquilib)\n",
    "                magSquaredAvg = np.average(np.square(magListEquilib))\n",
    "\n",
    "                energyList.append(energyAvg)\n",
    "                magList.append(magAvg)\n",
    "                specHeatList.append(self.specHeat(energyAvg, energySquaredAvg, temp))\n",
    "                suscepList.append(self.suscep(magAvg, magSquaredAvg, temp))\n",
    "\n",
    "            # reset the spins for the next temperature\n",
    "            self.resetSpins()\n",
    "\n",
    "        if plotProperties:\n",
    "\n",
    "            plt.tight_layout()\n",
    "\n",
    "            plt.subplot(2, 2, 1)\n",
    "            plt.plot(tempRange, energyList)\n",
    "            plt.title(\"Total Energy\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "\n",
    "            plt.subplot(2, 2, 2)\n",
    "            plt.plot(tempRange, magList)\n",
    "            plt.title(\"Residual Spin\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.subplot(2, 2, 3)\n",
    "            plt.plot(tempRange, specHeatList)\n",
    "            plt.title(\"Specific Heat Capacity\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.subplot(2, 2, 4)\n",
    "            plt.plot(tempRange, suscepList)\n",
    "            plt.title(\"Susceptibility\")\n",
    "            plt.tick_params(axis=\"x\", direction=\"in\")\n",
    "            plt.tick_params(axis=\"y\", direction=\"in\")\n",
    "            plt.xlim(tempRange[0], tempRange[len(tempRange) - 1])\n",
    "            plt.legend()\n",
    "\n",
    "            plt.show()"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}