diff --git a/learning/01 Introduction.ipynb b/learning/01 Introduction.ipynb index 892e7a3..295a036 100644 --- a/learning/01 Introduction.ipynb +++ b/learning/01 Introduction.ipynb @@ -65,7 +65,7 @@ "id": "e52245f1-8ecc-45f1-8d52-337916b0ce7c", "metadata": {}, "source": [ - "We're going to be working with arrays of numbers so it will make sense to work with `Numpy` and we'll also want to plot things, the standard choice for this is `matplotlib`, though there are other options, `pandas` and `plotly` being notable ones. If this gives you an error when you run it, you might want to run `pip install numpy matplotlib` either in a terminal or in a this notebook (with an exclamation mark at the start in the latter case).\n", + "We're going to be working with arrays of numbers so it will make sense to work with `Numpy` and we'll also want to plot things, the standard choice for this is `matplotlib`, though there are other options, `pandas` and `plotly` being notable ones.\n", "\n", "Let me quickly plot something to aid the imagination:" ] @@ -168,7 +168,10 @@ "source": [ "If you stare at the first two long enough you'll realise we can figure out the energy of all_up and all_down without writing any code at all:\n", "\n", - "![image.png](attachment:c7c0ca75-61b0-4c5a-b733-3e12532c8b00.png)\n", + "
\n", + "\n", + "
\n", + "\n", "So we know that for the first two:\n", "$$E = \\frac{1}{L^2} (4(L-2)^2 + 12(L-2) + 8)$$\n", "\n", @@ -337,7 +340,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -404,7 +407,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "40386cda-cc14-4fdd-8f9f-71840d1ebb40", "metadata": {}, "outputs": [ @@ -413,10 +416,10 @@ "output_type": "stream", "text": [ "Naive baseline implementation\n", - "73.4 ms ± 1.84 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "70.3 ms ± 1.04 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "\n", "Your version\n", - "72.3 ms ± 485 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "70.4 ms ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Your speedup: 1x !\n" ] } @@ -458,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "c96720d4-2c0b-4fa5-b9ce-4fc7be533a62", "metadata": {}, "outputs": [ @@ -467,15 +470,15 @@ "output_type": "stream", "text": [ "Naive baseline implementation\n", - "74.8 ms ± 2.06 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "72.3 ms ± 703 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "\n", "Numba version\n", - "184 µs ± 3.13 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "Numba Speedup: 409x !\n", + "188 µs ± 4.47 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "Numba Speedup: 391x !\n", "\n", "Numpy version\n", - "202 µs ± 13.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "Numpy Speedup: 388x !\n" + "172 µs ± 3.33 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", + "Numpy Speedup: 424x !\n" ] } ], @@ -549,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "755ec34c-4975-467f-a559-f585f9d6a42f", "metadata": {}, "outputs": [ @@ -559,7 +562,7 @@ "text": [ "\n", "Improved Naive version\n", - "33.2 ms ± 369 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", + "32.2 ms ± 986 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n", "Speedup: 2x !\n" ] } @@ -587,130 +590,18 @@ "print(f\"Speedup: {naive.best/e2.best :.0f}x !\")" ] }, - { - "cell_type": "markdown", - "id": "81a81a81-fae9-4767-9534-e32f49058ae8", - "metadata": {}, - "source": [ - "## Doing Monte Carlo!\n", - "\n", - "Now that we can evaluate the energy of a state there isn't that much more work to do MCMC on it.\n", - "\n", - "... very short explanation of the MCMC algorithm ...\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "2586a542-35f2-419e-9aa2-2bb9e9ab74b9", - "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'initial_state' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "Input \u001b[0;32mIn [13]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 25\u001b[0m ncols \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mlen\u001b[39m(Ts)\n\u001b[1;32m 26\u001b[0m f, axes \u001b[38;5;241m=\u001b[39m plt\u001b[38;5;241m.\u001b[39msubplots(ncols \u001b[38;5;241m=\u001b[39m ncols, figsize \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m5\u001b[39m\u001b[38;5;241m*\u001b[39mncols, \u001b[38;5;241m5\u001b[39m))\n\u001b[0;32m---> 28\u001b[0m show_state(\u001b[43minitial_state\u001b[49m, ax \u001b[38;5;241m=\u001b[39m axes[\u001b[38;5;241m0\u001b[39m])\n\u001b[1;32m 29\u001b[0m axes[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mset(title \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInitial state\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 31\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m T, ax \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(Ts, axes[\u001b[38;5;241m1\u001b[39m:]):\n\u001b[1;32m 32\u001b[0m \u001b[38;5;66;03m# initial_state = rng.choice([1,-1], size = (50,50))\u001b[39;00m\n", - "\u001b[0;31mNameError\u001b[0m: name 'initial_state' is not defined" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from numpy.random import default_rng\n", - "\n", - "rng = default_rng(42)\n", - "\n", - "\n", - "def mcmc(initial_state, steps, T, energy=numba_energy):\n", - " N, M = initial_state.shape\n", - " assert N == M\n", - "\n", - " current_state = initial_state.copy()\n", - " E = N**2 * energy(state)\n", - " for i in range(steps):\n", - " i, j = rng.integers(N, size=2)\n", - "\n", - " new_state = current_state.copy()\n", - " new_state[i, j] *= -1\n", - " new_E = N**2 * energy(new_state)\n", - "\n", - " if (new_E < E) or np.exp(-(new_E - E) / T) > rng.uniform():\n", - " current_state = new_state\n", - " E = new_E\n", - "\n", - " return current_state\n", - "\n", - "\n", - "Ts = [4, 5, 50]\n", - "\n", - "ncols = 1 + len(Ts)\n", - "f, axes = plt.subplots(ncols=ncols, figsize=(5 * ncols, 5))\n", - "\n", - "show_state(initial_state, ax=axes[0])\n", - "axes[0].set(title=\"Initial state\")\n", - "\n", - "for T, ax in zip(Ts, axes[1:]):\n", - " # initial_state = rng.choice([1,-1], size = (50,50))\n", - " initial_state = np.ones(shape=(50, 50))\n", - "\n", - " final_state = mcmc(initial_state, steps=100_000, T=T)\n", - " show_state(final_state, ax=ax)\n", - " ax.set(title=f\"T = {T}\")" - ] - }, { "cell_type": "markdown", "id": "5d1874d4-4585-49ed-bc6f-b11c22231669", "metadata": {}, - "source": [ - "These images give a flavour of why physicists find this model useful, it gives window into how thermal noise and spontaneous order interact. At low temperatures the energy cost of being different from your neighbours is the most important thing, while at high temperatures, it doesn't matter and you really just do your own thing.\n", - "\n", - "There's a special point somewhere in the middle called the critical point $T_c$ where all sorts of cool things happen, but my favourite is that for large system sizes you get a kind of fractal behaviour which I will demonstrate more once we've sped this code up and can simulate larger systems in a reasonable time." - ] - }, - { - "cell_type": "markdown", - "id": "5f728039-a975-4083-b68e-a13b4f2d1f87", - "metadata": {}, "source": [ "## Conclusion\n", + "So far we've discussed the problem we want to solve, written a little code, tested it a bit and made some speed improvements.\n", "\n", - "The code we have so far is really just a sketch of a solution. So this is a good time to step back and think about what are aims are and how this software will fulfil them. I see three broad areas on which it needs improvement:\n", - "\n", - "**Functionality**\n", - "Right now we can't really do much except print nice pictures of states, but (within the fiction of this project) we really want to be able to do science! So we need to think about what measurements and observations we might want to make and how that might affect the structure of our code.\n", - "\n", - "**Testing**\n", - "I've already missed at least one devastating bug in this code, and there are almost certainly more! Before we start adding too much new code we should think about how to increase our confidence that the individual components are working correctly. It's very easy to build a huge project out of hundreds of functions, realise there's a bug and then struggle to find the source of that bug. If we test our components individually and thoroughly, we can avoid some of that pain.\n", - "\n", - "**Performance**\n", - "Performance only matters in so far as it limits what we can do. And there is a real danger that trying to optimise for performance too early or in the wrong places will just lead to complexity that makes the code harder to read, harder to write and more likely to contain bugs. However I do want to show you the fractal states at the critical point, and I can't currently generate those images in a reasonable time, so some optimisation will happen!\n", - "\n", - "So which of these should happen first? In the next chapter we will first make a plan for going forward. We'll then start to move our code to a python package, to document it a little and to add some testing of the components we have so far. We'll then move on to adding new functionality and making performance improvements. " + "In the next notebook we will package the code up into a little python package, this is has two big benefits to use: \n", + "1. I won't have to redefine the energy function we just wrote in the next notebook \n", + "1. It will help with testing and documenting our code later" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b1880fc9-6670-429f-be34-2511feb0e771", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/learning/02 Expanding our codebase.ipynb b/learning/02 Expanding our codebase.ipynb deleted file mode 100644 index 78f1956..0000000 --- a/learning/02 Expanding our codebase.ipynb +++ /dev/null @@ -1,449 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "5ac56056-ca33-4f13-8e36-564b94144c1e", - "metadata": { - "tags": [] - }, - "source": [ - "

Markov Chain Monte Carlo for fun and profit

\n", - "

🎲 ⛓️ 👉 🧪

" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "eb5d773e-4cc0-48ae-bb71-7ece7ab5f936", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from numba import jit\n", - "\n", - "# This loads some custom styles for matplotlib\n", - "import json, matplotlib\n", - "\n", - "with open(\"assets/matplotlibrc.json\") as f:\n", - " matplotlib.rcParams.update(json.load(f))\n", - "\n", - "np.random.seed(\n", - " 42\n", - ") # This makes our random numbers reproducable when the notebook is rerun in order\n", - "\n", - "\n", - "def show_state(state, ax=None):\n", - " if ax is None:\n", - " f, ax = plt.subplots()\n", - " ax.matshow(state, cmap=\"Greys\", vmin=-1, vmax=1)\n", - " ax.set(xticks=[], yticks=[])" - ] - }, - { - "cell_type": "markdown", - "id": "337f1de8-d743-441f-bc15-387bcfff558d", - "metadata": { - "tags": [] - }, - "source": [ - "# Doing Monte Carlo!\n", - "\n", - "Now that we can evaluate the energy of a state there isn't that much more work to do Markov Chain Monte Carlo on it. I won't go into the details of how MCMC works but put very simply:\n", - "\n", - "We want to calculate thermal averages about a physical system. For example, is this bag of H20 molecules solid or liquid at T = -20C? Our Ising model is much simpler so the equivalent question would be what's the average color of this system at some T?\n", - "\n", - "It turns out that this question is pretty hard to answer using maths, it can be done for the 2D Ising model but for anything more complicated it's pretty much impossible. This is where MCMC comes in. MCMC is a numerical method that gives us a rule to probalistically jump from one state of the system to another. \n", - "\n", - "If we perform many such jumps many times we get a (Markov) chain of states. The great thing about this chain is that if we average a measurement over it, such as looking at the average proportion of white pixels, the answer we get will be close to the real answer for this system and will converge closer and closer to the true answer as we extend the chain. \n", - "\n", - "I've written a very basic MCMC sampler for the 2D Ising model below. It needs:\n", - "- an initial start to start the chain\n", - "- to know how many steps to take\n", - "- the temperature we want to simulate at\n", - "- a way to measure the energy of a state, which we wrote in a previous chapter\n", - "\n", - "It then loops over:\n", - "- modify the state a little, here we just flip one bond\n", - "- accepting $p = \\exp(-\\Delta_E / T)$ based on how the energy changed\n", - "- if we rejected, change the state back to how it was" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "2586a542-35f2-419e-9aa2-2bb9e9ab74b9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "@jit(nopython=True, nogil=True)\n", - "def energy(state):\n", - " E = 0\n", - " N, M = state.shape\n", - " for i in range(N):\n", - " for j in range(M):\n", - " # handle the north and south neighbours\n", - " if 0 <= (i + 1) < N:\n", - " E -= state[i, j] * state[i + 1, j]\n", - "\n", - " # handle the east and west neighbours\n", - " if 0 <= (j + 1) < M:\n", - " E -= state[i, j] * state[i, j + 1]\n", - "\n", - " return 2 * E / (N * M)\n", - "\n", - "\n", - "# While writing numba it's useful to keep the list of supported numpy functions open:\n", - "# https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html\n", - "@jit(nopython=True, nogil=True)\n", - "def mcmc(initial_state, steps, T, energy=energy):\n", - " N, M = initial_state.shape\n", - " assert N == M\n", - "\n", - " current_state = initial_state.copy()\n", - " E = N**2 * energy(current_state)\n", - " for i in range(steps):\n", - " i, j = np.random.randint(N), np.random.randint(N)\n", - "\n", - " # modify the state a little, here we just flip a random pixel\n", - " current_state[i, j] *= -1\n", - " new_E = N**2 * energy(current_state)\n", - "\n", - " if (new_E < E) or np.exp(-(new_E - E) / T) > np.random.random():\n", - " E = new_E\n", - " else:\n", - " current_state[i, j] *= -1 # reject the change we made\n", - "\n", - " return current_state\n", - "\n", - "\n", - "Ts = [4, 5, 50]\n", - "\n", - "ncols = 1 + len(Ts)\n", - "f, axes = plt.subplots(ncols=ncols, figsize=(5 * ncols, 5))\n", - "\n", - "initial_state = np.ones(shape=(50, 50))\n", - "axes[0].set(title=\"Initial state\")\n", - "show_state(initial_state, ax=axes[0])\n", - "\n", - "for T, ax in zip(Ts, axes[1:]):\n", - " # initial_state = rng.choice([1,-1], size = (50,50))\n", - "\n", - " final_state = mcmc(initial_state, steps=100_000, T=T)\n", - " show_state(final_state, ax=ax)\n", - " ax.set(title=f\"T = {T}\")" - ] - }, - { - "cell_type": "markdown", - "id": "5d1874d4-4585-49ed-bc6f-b11c22231669", - "metadata": {}, - "source": [ - "These images give a flavour of why physicists find this model useful, it gives window into how thermal noise and spontaneous order interact. At low temperatures the energy cost of being different from your neighbours is the most important thing, while at high temperatures, it doesn't matter and you really just do your own thing.\n", - "\n", - "There's a special point somewhere in the middle called the critical point $T_c$ where all sorts of cool things happen, but my favourite is that for large system sizes you get a kind of fractal behaviour which I will demonstrate more once we've sped this code up and can simulate larger systems in a reasonable time. You can kinda see it for 50x50 systesm at T = 5 but not really clearly." - ] - }, - { - "cell_type": "markdown", - "id": "5f728039-a975-4083-b68e-a13b4f2d1f87", - "metadata": {}, - "source": [ - "The code we have so far is really just a sketch of a solution. So this is a good time to step back and think about what are aims are and how this software will fulfil them. I see three broad areas on which it needs improvement:\n", - "\n", - "**Functionality**\n", - "Right now we can't really do much except print nice pictures of states, but (within the fiction of this project) we really want to be able to do science! So we need to think about what measurements and observations we might want to make and how that might affect the structure of our code.\n", - "\n", - "**Testing**\n", - "I've already missed at least one devastating bug in this code, and there are almost certainly more! Before we start adding too much new code we should think about how to increase our confidence that the individual components are working correctly. It's very easy to build a huge project out of hundreds of functions, realise there's a bug and then struggle to find the source of that bug. If we test our components individually and thoroughly, we can avoid some of that pain.\n", - "\n", - "**Performance**\n", - "Performance only matters in so far as it limits what we can do. And there is a real danger that trying to optimise for performance too early or in the wrong places will just lead to complexity that makes the code harder to read, harder to write and more likely to contain bugs. However I do want to show you the fractal states at the critical point, and I can't currently generate those images in a reasonable time, so some optimisation will happen!" - ] - }, - { - "cell_type": "markdown", - "id": "486f066c-f027-44e8-8937-8636a52f32fb", - "metadata": {}, - "source": [ - "## Functionality\n", - "\n", - "The main thing we want to be able to do is to take measurements, the code as I have writting it doesn't really allow that because it only returns the final state in the chain. Let's say we have a measurement called `average_color(state)` that we want to average over the whole chain. We could just stick that inside our definition of `mcmc` but we know that we will likely make other measurements too and we don't want to keep writing new versions of our core functionality!\n", - "\n", - "## Exercise 1\n", - "Have a think about how you would implement this and what options you have." - ] - }, - { - "cell_type": "markdown", - "id": "c28b0a86-28f8-426f-9013-70e962f02256", - "metadata": {}, - "source": [ - "## Solution 1\n", - "So I chatted with my mentors on this project on how to best do this and we came up with a few ideas:\n", - "\n", - "### Just save all the states and return them\n", - "\n", - "The problem with this is the states are very big and we don't want to waste all that memory. For an NxN state that uses 8 bit integers (the smallest we can use in numpy) 1000 samples would already use 2.5Gb of memory! We will see later that we'd really like to be able to go a bit bigger than 50x50 and 1000 samples!\n", - "\n", - "### Pass in a function to make measurements\n", - "```python\n", - "\n", - "def mcmc(initial_state, steps, T, measurement, energy=energy):\n", - " ...\n", - "\n", - " current_state = initial_state.copy()\n", - " E = N**2 * energy(current_state)\n", - " for i in range(steps):\n", - " measurements[i] = measurement(state)\n", - " ...\n", - "\n", - " return measurements\n", - "```\n", - "\n", - "This could work but it limits how we can store measurements and what shape and type they can be. What if we want to store our measurements in a numpy array? Or what if your measurement itself is a vector or and object that can't easily be stored in a numpy array? We would have to think carefully about what functionality we want." - ] - }, - { - "cell_type": "markdown", - "id": "c7c9575f-2450-4298-a507-90f0c1b9b284", - "metadata": { - "tags": [] - }, - "source": [ - "### Use Inheritance\n", - "```python\n", - "# This class would define the basic functionality of performing MCMC\n", - "class MCMCSampler(object):\n", - " def run(self, initial_state, steps, T):\n", - " ...\n", - " for i in range(steps):\n", - " self.measurement(state)\n", - "\n", - " \n", - "# This class would inherit from it and just implement the measurement\n", - "class AverageColorSampler(MCMCSampler):\n", - " measurements = np.zeros(10)\n", - " index = 0\n", - " \n", - " def measurement(self, state):\n", - " self.measurements[self.index] = some_function(state)\n", - " self.index += 1\n", - " \n", - "color_sampler = AverageColorSampler(...)\n", - "measurements = color_sampler.run(...)\n", - "```\n", - "\n", - "This would definitely work but I personally am not a huge fan of object oriented programming so I'm gonna skip this option!" - ] - }, - { - "cell_type": "markdown", - "id": "7d05d25d-c9ba-406d-9977-0ca4aeb430a7", - "metadata": {}, - "source": [ - "## Use a generator\n", - "This is the approach I ended up settling on, we will use [python generator function](https://peps.python.org/pep-0255/). While you may not have come across generator functions before, you almost certainly will have come across generators, `range(n)` is a generator, `(i for i in [1,2,3])` is a generator. Generator functions are a way to build your own generators, by way of example here is range implemented as a generator function:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5b17c054-230f-4188-98a6-51fd8fe5b437", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def my_range(n):\n", - " \"Behaves like the builtin range function of one argument\"\n", - " i = 0\n", - " while i < n:\n", - " yield i # sends i out to whatever function called us\n", - " i += 1\n", - " return # let's python know that we have nothing else to give\n", - "\n", - "\n", - "my_range(10), list(my_range(10))" - ] - }, - { - "cell_type": "markdown", - "id": "b74fadbe-80c2-4a20-b651-0e47188b005a", - "metadata": {}, - "source": [ - "This requires only a very small change to our mcmc function and suddenly we can do whatever we like with the states! While we're at it I'm going to add an aditional argument `stepsize` that allows us to only sample the state every `stepsize` MCMC steps. You'll see why we would want to set this to value greater than 1 in a moment." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f73d6335-6514-45b1-9128-d72122d8b0b7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "6.16 ms ± 16.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n", - "15.3 ms ± 406 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", - "2x slowdown!\n" - ] - } - ], - "source": [ - "@jit(nopython=True, nogil=True)\n", - "def mcmc_generator(initial_state, steps, T, stepsize=1000, energy=energy):\n", - " N, M = initial_state.shape\n", - " assert N == M\n", - "\n", - " current_state = initial_state.copy()\n", - " E = N**2 * energy(current_state)\n", - " for _ in range(steps):\n", - " for _ in range(stepsize):\n", - " i, j = np.random.randint(N), np.random.randint(N)\n", - "\n", - " # modify the state a little, here we just flip a random pixel\n", - " current_state[i, j] *= -1\n", - " new_E = N**2 * energy(current_state)\n", - "\n", - " if (new_E < E) or np.exp(-(new_E - E) / T) > np.random.random():\n", - " E = new_E\n", - " else:\n", - " current_state[i, j] *= -1 # reject the change we made\n", - " yield current_state.copy()\n", - " return\n", - "\n", - "\n", - "N_steps = 1000\n", - "stepsize = 1\n", - "without_yield = %timeit -o mcmc(initial_state, steps = N_steps, T = 5)\n", - "with_yield = %timeit -o [np.mean(s) for s in mcmc_generator(initial_state, T = 5, steps = N_steps, stepsize = 1)]\n", - "print(f\"{with_yield.best / without_yield.best:.0f}x slowdown!\")" - ] - }, - { - "cell_type": "markdown", - "id": "132bf8d1-d341-494a-9881-689605a104b7", - "metadata": {}, - "source": [ - "Fun fact: if you replace `yield current_state.copy()` with `yield current_state` your python kernel will crash when you run the code. I believe this is a bug in Numba that related to how pointers to numpy arrays work but let's not worry too much about it. \n", - "\n", - "We take a factor of two slowdown but that doesn't seem so much to pay for the fact we can now sample the state at every single step rather than just the last." - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "1b027d64-fc6a-45c0-804d-9785b5f8258a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 51, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def average_color(state):\n", - " return np.mean(state)\n", - "\n", - "\n", - "initial_state = np.ones(shape=(20, 20))\n", - "\n", - "fig, axes = plt.subplots(\n", - " figsize=(10, 5),\n", - " nrows=3,\n", - " ncols=2,\n", - " sharey=\"all\",\n", - " sharex=\"col\",\n", - " gridspec_kw=dict(hspace=0, wspace=0, width_ratios=(4, 1)),\n", - ")\n", - "\n", - "for T, ax, hist_ax in zip([10, 4.5, 3], axes[:, 0], axes[:, 1]):\n", - " m = np.array(\n", - " [\n", - " [\n", - " average_color(s)\n", - " for s in mcmc_generator(initial_state, steps=300, stepsize=200, T=T)\n", - " ]\n", - " for _ in range(10)\n", - " ]\n", - " ).T\n", - " indiv_line, *_ = ax.plot(m, alpha=0.4, color=\"k\", linewidth=0.9)\n", - " (mean_line,) = ax.plot(np.mean(m, axis=1))\n", - " hist_ax.hist(m.flatten(), orientation=\"horizontal\")\n", - "\n", - "\n", - "axes[-1, 0].set(xlabel=\"Monte Carlo step\", ylabel=\"Average Color\")\n", - "axes[-1, 0].legend([mean_line, indiv_line], [\"Mean\", \"Individual walker\"])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "40f469e2-ce18-4fca-8630-2d245adf78b3", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python [conda env:recode]", - "language": "python", - "name": "conda-env-recode-py" - }, - "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.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/learning/03 Packaging it up.ipynb b/learning/02 Packaging it up.ipynb similarity index 90% rename from learning/03 Packaging it up.ipynb rename to learning/02 Packaging it up.ipynb index 7721806..2103b96 100644 --- a/learning/03 Packaging it up.ipynb +++ b/learning/02 Packaging it up.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "6e51fe6c-a8b8-48ed-9e7f-70e18945e597", "metadata": {}, "outputs": [], @@ -31,12 +31,9 @@ "id": "5e745b48-9cde-49d1-b91b-b04282f6d30d", "metadata": {}, "source": [ - "Before we proceed I want to get some tests running. We'll use these to test the correctness of our code and also to check that we don't break anything that previously worked as we make changes and improvments. Checking you haven't broken something is called a regression test.\n", + "# Testing\n", "\n", - "Table of Contents:\n", - "- Setting up the directory structure of the project\n", - "- Creating a python package\n", - "- Testing!" + "Before we proceed with writing any more code I want to put what we already have in python file and make it into an installable module. This will be useful both for importing code into these notebooks and for testing later." ] }, { @@ -44,7 +41,7 @@ "id": "70c12053-ab4c-4a2b-a31a-16f01776419f", "metadata": {}, "source": [ - "# Directory Structure\n", + "## Directory Structure\n", "More info:\n", "- [General Python Packaging advice](https://packaging.python.org/en/latest/tutorials/packaging-projects/)\n", "- [Packaging for pytest](https://docs.pytest.org/en/6.2.x/goodpractices.html)\n", @@ -92,7 +89,7 @@ "\n", "```python\n", "from MCFF.ising_model import all_up_state, all_down_state, random_state\n", - "from MCFF import mcmc\n", + "from MCFF import mcmc #once we've written this that is!\n", "```\n", "\n", "`pyproject.toml` and `setup.cfg` are the current way to describe the metadat about a python package like how it should be installed and who the author is etc, but typically you just copy the standard layouts and build from there. The empty `__init__.py` file flags that this folder is a python module.\n", @@ -147,6 +144,14 @@ "```\n", "The dot means we should install MCFF from the current directory and `--editable` means to do it as an editable package so that we can edit the files in MCFF and not have to reinstall. This is really useful for development." ] + }, + { + "cell_type": "markdown", + "id": "3db75fb8-8229-41f4-8004-463b832cd4a4", + "metadata": {}, + "source": [ + "You can see what the files look like at this point at [this commit][add link here]. In the next notebook, we will finally write the Markov Chain Monte Carlo function!" + ] } ], "metadata": { diff --git a/learning/03 Writing a Markov Chain Monte Carlo sampler.ipynb b/learning/03 Writing a Markov Chain Monte Carlo sampler.ipynb new file mode 100644 index 0000000..5e72a38 --- /dev/null +++ b/learning/03 Writing a Markov Chain Monte Carlo sampler.ipynb @@ -0,0 +1,187 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ac56056-ca33-4f13-8e36-564b94144c1e", + "metadata": { + "tags": [] + }, + "source": [ + "

Markov Chain Monte Carlo for fun and profit

\n", + "

🎲 ⛓️ 👉 🧪

" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "eb5d773e-4cc0-48ae-bb71-7ece7ab5f936", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numba import jit\n", + "\n", + "# This loads some custom styles for matplotlib\n", + "import json, matplotlib\n", + "\n", + "with open(\"assets/matplotlibrc.json\") as f:\n", + " matplotlib.rcParams.update(json.load(f))\n", + "\n", + "np.random.seed(\n", + " 42\n", + ") # This makes our random numbers reproducable when the notebook is rerun in order" + ] + }, + { + "cell_type": "markdown", + "id": "337f1de8-d743-441f-bc15-387bcfff558d", + "metadata": { + "tags": [] + }, + "source": [ + "# Doing Monte Carlo!\n", + "Right now we have:\n", + "1. A function to evaluate the energy of a state\n", + "1. That code now lives in a python module called MCFF that we can import\n", + "1. We've also got some nice tests running that give us some confidence the code is right.\n", + "\n", + "\n", + "There isn't that much more work to do Markov Chain Monte Carlo. I won't go into the details of how MCMC works but put very simply MCMC lets us calculate thermal averages of a physical system at some temperature. For example, the physical system might be \"[$10^{23}$][wa] H20 molecules in a box\" and the thermal average we want is \"Are they organised like a solid or a liquid?\". We can ask that question at different temperatures and we will get different answers.\n", + "\n", + "\n", + "For our Ising model the equivalent question would be what's the average color of this system? At high temperatures we expect the pixels to be random and average out ot grey, while at low temperatures they will all be either black or while.\n", + "\n", + "What happens in between? This question is pretty hard to answer using maths, it can be done for the 2D Ising model but for anything more complicated it's pretty much impossible. This is where MCMC comes in.\n", + "\n", + "MCMC is a numerical method that lets us calculate these thermal averages. MCMC is essentially a description of how to probalistically step from one state of the system to another. \n", + "\n", + "If we perform these steps many times we get a (Markov) chain of states. The great thing about this chain is that if we average a measurement over it, such as looking at the average proportion of white pixels, the answer we get will be close to the real answer for this system and will converge closer and closer to the true answer as we extend the chain. \n", + "\n", + "I've written a very basic MCMC sampler for the 2D Ising model below. It needs:\n", + "- an initial place to start the chain from\n", + "- how many steps to take\n", + "- the temperature we want to simulate at\n", + "- a way to measure the energy of a state, which we wrote in a previous chapter\n", + "\n", + "It then loops over:\n", + "- modify the state a little, here we just flip one bond\n", + "- accepting $p = \\exp(-\\Delta_E / T)$ based on how the energy changed\n", + "- if we rejected, change the state back to how it was\n", + "\n", + "[wa]: https://www.wolframalpha.com/input?i=%28mass+of+1+litre+of+water+%29%2F%28molecular+weight+of+H2O+*+atomic+mass%29" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2586a542-35f2-419e-9aa2-2bb9e9ab74b9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from MCFF.ising_model import energy, show_state\n", + "\n", + "# While writing numba it's useful to keep the list of supported numpy functions open:\n", + "# https://numba.pydata.org/numba-doc/dev/reference/numpysupported.html\n", + "@jit(nopython=True, nogil=True)\n", + "def mcmc(initial_state, steps, T, energy=energy):\n", + " N, M = initial_state.shape\n", + " assert N == M\n", + "\n", + " current_state = initial_state.copy()\n", + " E = N**2 * energy(current_state)\n", + " for i in range(steps):\n", + " i, j = np.random.randint(N), np.random.randint(N)\n", + "\n", + " # modify the state a little, here we just flip a random pixel\n", + " current_state[i, j] *= -1\n", + " new_E = N**2 * energy(current_state)\n", + "\n", + " if (new_E < E) or np.exp(-(new_E - E) / T) > np.random.random():\n", + " E = new_E\n", + " else:\n", + " current_state[i, j] *= -1 # reject the change we made\n", + "\n", + " return current_state\n", + "\n", + "\n", + "Ts = [4, 5, 50]\n", + "\n", + "ncols = 1 + len(Ts)\n", + "f, axes = plt.subplots(ncols=ncols, figsize=(5 * ncols, 5))\n", + "\n", + "initial_state = np.ones(shape=(50, 50))\n", + "axes[0].set(title=\"Initial state\")\n", + "show_state(initial_state, ax=axes[0])\n", + "\n", + "for T, ax in zip(Ts, axes[1:]):\n", + " # initial_state = rng.choice([1,-1], size = (50,50))\n", + "\n", + " final_state = mcmc(initial_state, steps=100_000, T=T)\n", + " show_state(final_state, ax=ax)\n", + " ax.set(title=f\"T = {T}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5d1874d4-4585-49ed-bc6f-b11c22231669", + "metadata": {}, + "source": [ + "These images give a flavour of why physicists find this model useful, it gives window into how thermal noise and spontaneous order interact. At low temperatures the energy cost of being different from your neighbours is the most important thing, while at high temperatures, it doesn't matter and you really just do your own thing.\n", + "\n", + "There's a special point somewhere in the middle called the critical point $T_c$ where all sorts of cool things happen, but my favourite is that for large system sizes you get a kind of fractal behaviour which I will demonstrate more once we've sped this code up and can simulate larger systems in a reasonable time. You can kinda see it for 50x50 systesm at T = 5 but not really clearly." + ] + }, + { + "cell_type": "markdown", + "id": "5f728039-a975-4083-b68e-a13b4f2d1f87", + "metadata": {}, + "source": [ + "## Where do we go from here?\n", + "\n", + "The code we have so far is really just a sketch of a solution. So this is a good time to step back and think about what are aims are and how this software will fulfil them. I see three broad areas on which it needs improvement:\n", + "\n", + "**Functionality**\n", + "Right now we can't really do much except print nice pictures of states, but (within the fiction of this project) we really want to be able to do science! So we need to think about what measurements and observations we might want to make and how that might affect the structure of our code.\n", + "\n", + "**Testing**\n", + "I've already missed at least one devastating bug in this code, and there are almost certainly more! Before we start adding too much new code we should think about how to increase our confidence that the individual components are working correctly. It's very easy to build a huge project out of hundreds of functions, realise there's a bug and then struggle to find the source of that bug. If we test our components individually and thoroughly, we can avoid some of that pain.\n", + "\n", + "**Performance**\n", + "Performance only matters in so far as it limits what we can do. And there is a real danger that trying to optimise for performance too early or in the wrong places will just lead to complexity that makes the code harder to read, harder to write and more likely to contain bugs. However I do want to show you the fractal states at the critical point, and I can't currently generate those images in a reasonable time, so some optimisation will happen!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:recode]", + "language": "python", + "name": "conda-env-recode-py" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learning/04 Testing.ipynb b/learning/04 Testing.ipynb index d1ed6de..919f6a2 100644 --- a/learning/04 Testing.ipynb +++ b/learning/04 Testing.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "id": "d4082e07-c51f-46ba-9a5e-bf45c2c319ba", "metadata": {}, "outputs": [ @@ -159,6 +159,7 @@ "metadata": {}, "source": [ "## Autoformaters\n", + "Resources: [](https://the-turing-way.netlify.app/reproducible-research/code-quality/code-quality-style.html)\n", "\n", "While we're doing things that will help keep our code clean and tidy in the future, I would recommend installing a code formatter like `black`. This is a program that enforces a particular formatting style on your code by simply doing it for you. At first this sounds a bit weird, but it has a few benefits:\n", "\n", @@ -208,6 +209,14 @@ " return \" \".join([a, b, c / 2.0 + 3])" ] }, + { + "cell_type": "markdown", + "id": "68cccdcc-b82e-4dec-bfc1-54072db8d762", + "metadata": {}, + "source": [ + "Finally, be aware that if you try to commit code with incorrect syntax then black will just error and prevent it, this is probably a good thing but there may be the occasional time where that's a problem." + ] + }, { "cell_type": "markdown", "id": "0ba4802e-40e9-4cd5-8877-7a51ad2224b1", @@ -217,10 +226,46 @@ "\n" ] }, + { + "cell_type": "markdown", + "id": "e255b929-3ae7-4584-a2d4-5386d443a4af", + "metadata": { + "tags": [] + }, + "source": [ + "...\n", + "\n", + "We can use a t-test to check a sample from the MCMC sampler matches our expectations. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "64cd4fd1-2a22-41ec-820f-5f5cac4a68b3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# observations = average_color_data.mean(axis = -1)\n", + "\n", + "# from scipy import stats\n", + "# stats.ttest_1samp(observations[0], 0).pvalue < 1 / 50" + ] + }, + { + "cell_type": "markdown", + "id": "0a38999f-e4c9-4b59-913c-35eb7fbffb4c", + "metadata": {}, + "source": [ + "## Test Driven Development\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": null, - "id": "38ce37fc-fd99-478b-9d34-6726af280bf0", + "id": "1b729c67-246d-4620-8e00-f355432c28a7", "metadata": {}, "outputs": [], "source": [] diff --git a/learning/05 Adding functionality.ipynb b/learning/05 Adding functionality.ipynb new file mode 100644 index 0000000..9588234 --- /dev/null +++ b/learning/05 Adding functionality.ipynb @@ -0,0 +1,243 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ac56056-ca33-4f13-8e36-564b94144c1e", + "metadata": { + "tags": [] + }, + "source": [ + "

Markov Chain Monte Carlo for fun and profit

\n", + "

🎲 ⛓️ 👉 🧪

" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "eb5d773e-4cc0-48ae-bb71-7ece7ab5f936", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numba import jit\n", + "\n", + "# This loads some custom styles for matplotlib\n", + "import json, matplotlib\n", + "\n", + "with open(\"assets/matplotlibrc.json\") as f:\n", + " matplotlib.rcParams.update(json.load(f))\n", + "\n", + "np.random.seed(\n", + " 42\n", + ") # This makes our random numbers reproducable when the notebook is rerun in order" + ] + }, + { + "cell_type": "markdown", + "id": "486f066c-f027-44e8-8937-8636a52f32fb", + "metadata": {}, + "source": [ + "## Functionality\n", + "\n", + "The main thing we want to be able to do is to take measurements, the code as I have writting it doesn't really allow that because it only returns the final state in the chain. Let's say we have a measurement called `average_color(state)` that we want to average over the whole chain. We could just stick that inside our definition of `mcmc` but we know that we will likely make other measurements too and we don't want to keep writing new versions of our core functionality!\n", + "\n", + "## Exercise 1\n", + "Have a think about how you would implement this and what options you have." + ] + }, + { + "cell_type": "markdown", + "id": "c28b0a86-28f8-426f-9013-70e962f02256", + "metadata": {}, + "source": [ + "## Solution 1\n", + "So I chatted with my mentors on this project on how to best do this and we came up with a few ideas:\n", + "\n", + "### Option 1: Just save all the states and return them\n", + "\n", + "The problem with this is the states are very big and we don't want to waste all that memory. For an NxN state that uses 8 bit integers (the smallest we can use in numpy) 1000 samples would already use 2.5Gb of memory! We will see later that we'd really like to be able to go a bit bigger than 50x50 and 1000 samples!\n", + "\n", + "### Option 2: Pass in a function to make measurements\n", + "```python\n", + "\n", + "def mcmc(initial_state, steps, T, measurement, energy=energy):\n", + " ...\n", + "\n", + " current_state = initial_state.copy()\n", + " E = N**2 * energy(current_state)\n", + " for i in range(steps):\n", + " measurements[i] = measurement(state)\n", + " ...\n", + "\n", + " return measurements\n", + "```\n", + "\n", + "This could work but it limits how we can store measurements and what shape and type they can be. What if we want to store our measurements in a numpy array? Or what if your measurement itself is a vector or and object that can't easily be stored in a numpy array? We would have to think carefully about what functionality we want." + ] + }, + { + "cell_type": "markdown", + "id": "c7c9575f-2450-4298-a507-90f0c1b9b284", + "metadata": { + "tags": [] + }, + "source": [ + "### Option 3: Use Inheritance\n", + "```python\n", + "# This class would define the basic functionality of performing MCMC\n", + "class MCMCSampler(object):\n", + " def run(self, initial_state, steps, T):\n", + " ...\n", + " for i in range(steps):\n", + " self.measurement(state)\n", + "\n", + " \n", + "# This class would inherit from it and just implement the measurement\n", + "class AverageColorSampler(MCMCSampler):\n", + " measurements = np.zeros(10)\n", + " index = 0\n", + " \n", + " def measurement(self, state):\n", + " self.measurements[self.index] = some_function(state)\n", + " self.index += 1\n", + " \n", + "color_sampler = AverageColorSampler(...)\n", + "measurements = color_sampler.run(...)\n", + "```\n", + "\n", + "This would definitely work but I personally am not a huge fan of object oriented programming so I'm gonna skip this option!" + ] + }, + { + "cell_type": "markdown", + "id": "7d05d25d-c9ba-406d-9977-0ca4aeb430a7", + "metadata": {}, + "source": [ + "## Option 4: Use a generator\n", + "This is the approach I ended up settling on, we will use [python generator function](https://peps.python.org/pep-0255/). While you may not have come across generator functions before, you almost certainly will have come across generators, `range(n)` is a generator, `(i for i in [1,2,3])` is a generator. Generator functions are a way to build your own generators, by way of example here is range implemented as a generator function:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "5b17c054-230f-4188-98a6-51fd8fe5b437", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def my_range(n):\n", + " \"Behaves like the builtin range function of one argument\"\n", + " i = 0\n", + " while i < n:\n", + " yield i # sends i out to whatever function called us\n", + " i += 1\n", + " return # let's python know that we have nothing else to give\n", + "\n", + "\n", + "my_range(10), list(my_range(10))" + ] + }, + { + "cell_type": "markdown", + "id": "b74fadbe-80c2-4a20-b651-0e47188b005a", + "metadata": {}, + "source": [ + "This requires only a very small change to our mcmc function and suddenly we can do whatever we like with the states! While we're at it I'm going to add an aditional argument `stepsize` that allows us to only sample the state every `stepsize` MCMC steps. You'll see why we would want to set this to value greater than 1 in a moment." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f73d6335-6514-45b1-9128-d72122d8b0b7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19.3 ms ± 156 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "10.8 ms ± 869 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "0x slowdown!\n" + ] + } + ], + "source": [ + "from MCFF.ising_model import energy, all_up_state\n", + "from MCFF.mcmc import mcmc\n", + "\n", + "\n", + "@jit(nopython=True, nogil=True)\n", + "def mcmc_generator(initial_state, steps, T, stepsize=1000, energy=energy):\n", + " N, M = initial_state.shape\n", + " assert N == M\n", + "\n", + " current_state = initial_state.copy()\n", + " E = N**2 * energy(current_state)\n", + " for _ in range(steps):\n", + " for _ in range(stepsize):\n", + " i, j = np.random.randint(N), np.random.randint(N)\n", + "\n", + " # modify the state a little, here we just flip a random pixel\n", + " current_state[i, j] *= -1\n", + " new_E = N**2 * energy(current_state)\n", + "\n", + " if (new_E < E) or np.exp(-(new_E - E) / T) > np.random.random():\n", + " E = new_E\n", + " else:\n", + " current_state[i, j] *= -1 # reject the change we made\n", + " yield current_state.copy()\n", + " return\n", + "\n", + "\n", + "N_steps = 1000\n", + "stepsize = 1\n", + "initial_state = all_up_state(20)\n", + "without_yield = %timeit -o mcmc(initial_state, steps = N_steps, T = 5)\n", + "with_yield = %timeit -o [np.mean(s) for s in mcmc_generator(initial_state, T = 5, steps = N_steps, stepsize = 1)]\n", + "print(f\"{with_yield.best / without_yield.best:.0f}x slowdown!\")" + ] + }, + { + "cell_type": "markdown", + "id": "132bf8d1-d341-494a-9881-689605a104b7", + "metadata": {}, + "source": [ + "Fun fact: if you replace `yield current_state.copy()` with `yield current_state` your python kernel will crash when you run the code. I believe this is a bug in Numba that related to how pointers to numpy arrays work but let's not worry too much about it. \n", + "\n", + "We take a factor of two slowdown but that doesn't seem so much to pay for the fact we can now sample the state at every single step rather than just the last." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:recode]", + "language": "python", + "name": "conda-env-recode-py" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learning/06 Speeding it up.ipynb b/learning/06 Speeding it up.ipynb new file mode 100644 index 0000000..99da3aa --- /dev/null +++ b/learning/06 Speeding it up.ipynb @@ -0,0 +1,473 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ac56056-ca33-4f13-8e36-564b94144c1e", + "metadata": { + "tags": [] + }, + "source": [ + "

Markov Chain Monte Carlo for fun and profit

\n", + "

🎲 ⛓️ 👉 🧪

" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "eb5d773e-4cc0-48ae-bb71-7ece7ab5f936", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numba import jit\n", + "\n", + "# This loads some custom styles for matplotlib\n", + "import json, matplotlib\n", + "\n", + "with open(\"assets/matplotlibrc.json\") as f:\n", + " matplotlib.rcParams.update(json.load(f))\n", + "\n", + "np.random.seed(\n", + " 42\n", + ") # This makes our random numbers reproducable but only when the notebook is run once in order\n", + "\n", + "\n", + "def show_state(state, ax=None):\n", + " if ax is None:\n", + " f, ax = plt.subplots()\n", + " ax.matshow(state, cmap=\"Greys\", vmin=-1, vmax=1)\n", + " ax.set(xticks=[], yticks=[])" + ] + }, + { + "cell_type": "markdown", + "id": "3882f3c7-854e-4394-a982-0e71696cfcc9", + "metadata": {}, + "source": [ + "## Making it faster and the dangers of premature optimisation\n", + "\n", + "In order to show you a really big system will still need to make the code a bit faster. Right now we calculate the energy of each state, flip a pixel and then calculate the energy again. It turns out that you can actually directly calculate the energy change instead of doing this subtraction. Let's do this is a sort of test driven decelopment fashion: we want to write a function that when given a state and a pixel to flip, returns how much the energy goes up by (negative if down) upon performing the flip.\n", + "\n", + "I'll first write a slow version of this using the code we already have, and then use that to validate our faster version:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6c7a2bd3-acc1-45b5-b127-3691ecbe98f0", + "metadata": {}, + "outputs": [], + "source": [ + "from MCFF.ising_model import energy\n", + "\n", + "\n", + "def energy_difference_reference_implementation(state, site):\n", + " state = state.copy()\n", + " i, j = site\n", + " energy_before_flip = energy(state)\n", + " state[i, j] *= -1\n", + " energy_after_flip = energy(state)\n", + " return energy_after_flip - energy_before_flip" + ] + }, + { + "cell_type": "markdown", + "id": "7b16f42a-0178-4753-9e9d-2f78aed40509", + "metadata": {}, + "source": [ + "Now if you stare at the definition of energy long enough, you can convince yourself that the energy change when you flip one pixel only depends on the four surounding pixels in a simple way:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9627abbd-16ef-4f66-bf36-01adad101fac", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ref: 16.0, Ours: 16.0\n", + "Ref: 12.0, Ours: 12.0\n", + "Ref: 8.0, Ours: 8.0\n" + ] + } + ], + "source": [ + "@jit(nopython=True, nogil=True)\n", + "def energy_difference(state, site):\n", + " # loop over the four neighbours of the site, skipping if the site is near an edge\n", + " N, M = state.shape\n", + " i, j = site\n", + " h = 0\n", + " for di, dj in [[-1, 0], [1, 0], [0, -1], [0, 1]]: # loop over N,E,S,W neighbours\n", + " if (0 <= (i + di) < N) and (\n", + " 0 <= (j + dj) < M\n", + " ): # ignore neighbours not in the NxN grid\n", + " h += state[i + di, j + dj]\n", + " return 4 * state[i, j] * h / (N * M)\n", + "\n", + "\n", + "# do some simple test cases that I can calculate by hand\n", + "state = np.ones(\n", + " shape=(3, 3)\n", + ") # a simple 3x3 grid is the smallest one where the center has 4 neighbours\n", + "sites = [\n", + " (1, 1),\n", + " (0, 1),\n", + " (0, 0),\n", + "] # Let's try the center, one on an edge and one on a corner\n", + "\n", + "for site in sites:\n", + " reference = 9 * energy_difference_reference_implementation(state, site)\n", + " ours = 9 * energy_difference(state, site)\n", + " print(f\"Ref: {reference}, Ours: {ours}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d2f55f08-2932-4752-9a2e-ea566187a473", + "metadata": {}, + "source": [ + "Ok these simple tests looks good! I was struggling both with the correct factors of two and the sign, so seeing the outputs compared helped a lot. Now let's test against some random data:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a4b71b4d-e69d-497b-bb6b-4375b16159a4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tests Passed!\n" + ] + } + ], + "source": [ + "N = 50\n", + "values = np.array([1, -1], dtype=np.int8)\n", + "\n", + "for _ in range(100):\n", + " random_state = np.random.choice(values, size=(N, N))\n", + " random_site = np.random.randint(N, size=2)\n", + " assert np.allclose(\n", + " energy_difference_reference_implementation(random_state, random_site),\n", + " energy_difference(random_state, random_site),\n", + " )\n", + "print(\"Tests Passed!\")" + ] + }, + { + "cell_type": "markdown", + "id": "e6ecbc7c-530f-494b-aa31-0a118a104328", + "metadata": {}, + "source": [ + "Ok great! And this function is much much faster because it only has to look at four pixels rather than all $N^2$ of them!" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "41627f33-6672-4241-aea7-b0210bc4aba1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "64.3 µs ± 3.62 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n", + "1.2 µs ± 156 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n", + "56x Speedup!\n" + ] + } + ], + "source": [ + "N = 100\n", + "random_state = np.random.choice(values, size=(N, N))\n", + "random_site = np.random.randint(N, size=2)\n", + "\n", + "reference = %timeit -n 1000 -o energy_difference_reference_implementation(random_state, random_site)\n", + "ours = %timeit -n 1000 -o energy_difference(random_state, random_site)\n", + "print(f\"{reference.best / ours.best:.0f}x Speedup!\")" + ] + }, + { + "cell_type": "markdown", + "id": "0311b4d9-43b7-42ab-ad19-973094020c03", + "metadata": {}, + "source": [ + "We get a good speedup that increases with N and should be about $N^2$ for very large values of N. Ok so how do we use this? Well we need to rewrite mcmc yet again:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "942ce715-0f55-43b5-a1e0-91057fd4ecc1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.58 s ± 33.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "69.5 ms ± 2.64 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n", + "37x speedup!\n" + ] + } + ], + "source": [ + "@jit(nopython=True, nogil=True)\n", + "def old_mcmc_generator(initial_state, steps, T, stepsize=1000, energy=energy):\n", + " N, M = initial_state.shape\n", + " assert N == M\n", + "\n", + " current_state = initial_state.copy()\n", + " E = N**2 * energy(current_state)\n", + " for _ in range(steps):\n", + " for _ in range(stepsize):\n", + " i, j = np.random.randint(N), np.random.randint(N)\n", + "\n", + " # modify the state a little, here we just flip a random pixel\n", + " current_state[i, j] *= -1\n", + " new_E = N**2 * energy(current_state)\n", + "\n", + " if (new_E < E) or np.exp(-(new_E - E) / T) > np.random.random():\n", + " E = new_E\n", + " else:\n", + " current_state[i, j] *= -1 # reject the change we made\n", + " yield current_state.copy()\n", + " return\n", + "\n", + "\n", + "@jit(nopython=True, nogil=True)\n", + "def mcmc_generator(\n", + " initial_state, steps, T, stepsize=1000, energy_difference=energy_difference\n", + "):\n", + " N, M = initial_state.shape\n", + " assert N == M\n", + "\n", + " current_state = initial_state.copy()\n", + " for _ in range(steps):\n", + " for _ in range(stepsize):\n", + " i, j = np.random.randint(N), np.random.randint(N)\n", + "\n", + " # calculate the energy change if we were to flip this pixel but don't actually do it\n", + " change_in_E = N**2 * energy_difference(current_state, (i, j))\n", + "\n", + " if change_in_E < 0 or np.exp(-change_in_E / T) > np.random.random():\n", + " current_state[i, j] *= -1 # accept the change!\n", + "\n", + " yield current_state.copy()\n", + " return\n", + "\n", + "\n", + "N_steps = 1000\n", + "stepsize = 100\n", + "N = 100\n", + "initial_state = np.ones(shape=(N, N))\n", + "old = %timeit -o [_ for s in old_mcmc_generator(initial_state, T = 5, steps = N_steps, stepsize = stepsize)]\n", + "new = %timeit -o [_ for s in mcmc_generator(initial_state, T = 5, steps = N_steps, stepsize = stepsize)]\n", + "print(f\"{old.best / new.best:.0f}x speedup!\")" + ] + }, + { + "cell_type": "markdown", + "id": "bd67385b-c8b3-4c1b-bb96-6856eaa6aa7e", + "metadata": {}, + "source": [ + "We can now comfortably look at much larger systems!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ca619dc7-9b3f-45f7-ad0d-751b60b37cdb", + "metadata": {}, + "outputs": [], + "source": [ + "### Simulation Inputs ###\n", + "N = 500 # Use an NxN system\n", + "steps = 5 # How many times to sample the state\n", + "stepsize = (\n", + " 5 * N**2\n", + ") # How many individual monte carlo flips to do in between each sample\n", + "initial_state = np.random.choice(\n", + " np.array([-1, 1], dtype=np.int8), size=(N, N)\n", + ") # the intial state to use\n", + "T = 3.5\n", + "\n", + "### Simulation Code ###\n", + "critical_states = [\n", + " s for s in mcmc_generator(initial_state, steps=steps, stepsize=stepsize, T=T)\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "4c7b0ef0-b630-49c7-9ea5-f60325309751", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(\n", + " ncols=len(critical_states), figsize=(5 * len(critical_states), 5)\n", + ")\n", + "\n", + "for s, ax in zip(critical_states, axes):\n", + " show_state(s, ax=ax)" + ] + }, + { + "cell_type": "markdown", + "id": "aeb46049-4e33-44df-a523-aaee231e2a0d", + "metadata": {}, + "source": [ + "## Average Color and 'Susceptability'\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e7595584-4d1c-4734-912f-a6692308dc7d", + "metadata": {}, + "outputs": [], + "source": [ + "### The measurement we will make ###\n", + "def average_color(state):\n", + " return np.mean(state)\n", + "\n", + "\n", + "### Simulation Inputs ###\n", + "Ns = np.array(\n", + " [\n", + " 30,\n", + " ]\n", + ") # Use an NxN system\n", + "Ts = np.linspace(4, 5.5, 20) # What temperatures to use\n", + "steps = 1000 # How many times to sample the state\n", + "stepsize = (\n", + " lambda N: N**2\n", + ") # How many individual monte carlo flips to do in between each sample\n", + "N_repeats = 2 # How many times to repeat each run at fixed temperature\n", + "\n", + "### Simulation Code ###\n", + "average_color_data = np.array(\n", + " [\n", + " [\n", + " [\n", + " [\n", + " average_color(s)\n", + " for s in mcmc_generator(\n", + " np.ones(shape=(N, N)), steps=steps, stepsize=stepsize(N), T=T\n", + " )\n", + " ]\n", + " for _ in range(N_repeats)\n", + " ]\n", + " for T in Ts\n", + " ]\n", + " for N in Ns\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "5d9d37a1-2ceb-4f63-8e40-9362880bd469", + "metadata": {}, + "outputs": [], + "source": [ + "mean_color = np.mean(average_color_data, axis=(-2, -1))\n", + "color_susceptability = np.std(average_color_data, axis=-1).mean(axis=-1)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "22aaa06b-6580-4b16-a15b-2fe35b8af8d3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(nrows=2, sharex=\"col\")\n", + "\n", + "for i, N in enumerate(Ns):\n", + " axes[0].plot(Ts, mean_color[i], label=f\"N = {N}\")\n", + " axes[1].plot(Ts, color_susceptability[i])\n", + "\n", + "axes[0].legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "47d24c1d-9854-46a4-9da2-e1d4a382b09e", + "metadata": {}, + "outputs": [], + "source": [ + "### try combining mpiere, itertools.product and xarray" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:recode]", + "language": "python", + "name": "conda-env-recode-py" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learning/07 Producing research outputs.ipynb b/learning/07 Producing research outputs.ipynb new file mode 100644 index 0000000..40d5aa1 --- /dev/null +++ b/learning/07 Producing research outputs.ipynb @@ -0,0 +1,168 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5ac56056-ca33-4f13-8e36-564b94144c1e", + "metadata": { + "tags": [] + }, + "source": [ + "

Markov Chain Monte Carlo for fun and profit

\n", + "

🎲 ⛓️ 👉 🧪

" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "eb5d773e-4cc0-48ae-bb71-7ece7ab5f936", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from numba import jit\n", + "\n", + "# This loads some custom styles for matplotlib\n", + "import json, matplotlib\n", + "\n", + "with open(\"assets/matplotlibrc.json\") as f:\n", + " matplotlib.rcParams.update(json.load(f))\n", + "\n", + "np.random.seed(\n", + " 42\n", + ") # This makes our random numbers reproducable when the notebook is rerun in order" + ] + }, + { + "cell_type": "markdown", + "id": "fd49fb0b-71b6-492f-9f46-082ad3bc3905", + "metadata": {}, + "source": [ + "## Making some measurments \n", + "\n", + "So now that we have the ability to simulate our system lets do a little exploration. First let's take three temperatures at each we'll do 10 runs and see how the systems evolve. I'll also tack on a little histogram at the right hand side of where the systens spent their time." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e26963ee-dd2b-47d3-b088-4e1068fac6b0", + "metadata": {}, + "outputs": [], + "source": [ + "from MCFF.mcmc import mcmc_generator\n", + "\n", + "### The measurement we will make ###\n", + "def average_color(state):\n", + " return np.mean(state)\n", + "\n", + "\n", + "### Simulation Inputs ###\n", + "N = 20 # Use an NxN system\n", + "Ts = [10, 4.5, 3] # What temperatures to use\n", + "steps = 200 # How many times to sample the state\n", + "stepsize = N**2 # How many individual monte carlo flips to do in between each sample\n", + "N_repeats = 10 # How many times to repeat each run at fixed temperature\n", + "initial_state = np.ones(shape=(N, N)) # the intial state to use\n", + "flips = (\n", + " np.arange(steps) * stepsize\n", + ") # Use this to plot the data in terms of individual flip attemps\n", + "\n", + "### Simulation Code ###\n", + "average_color_data = np.array(\n", + " [\n", + " [\n", + " [\n", + " average_color(s)\n", + " for s in mcmc_generator(\n", + " initial_state, steps=steps, stepsize=stepsize, T=T\n", + " )\n", + " ]\n", + " for _ in range(N_repeats)\n", + " ]\n", + " for T in Ts\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ce10544d-85fe-49ee-8b4a-63ffd4982ed2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# It's always good to separate you plotting from your data generation\n", + "from itertools import count\n", + "\n", + "fig, axes = plt.subplots(\n", + " figsize=(15, 7),\n", + " nrows=3,\n", + " ncols=2,\n", + " sharey=\"all\",\n", + " sharex=\"col\",\n", + " gridspec_kw=dict(hspace=0, wspace=0, width_ratios=(4, 1)),\n", + ")\n", + "\n", + "for i, ax, hist_ax in zip(count(), axes[:, 0], axes[:, 1]):\n", + " c = average_color_data[i]\n", + " indiv_line, *_ = ax.plot(flips, c.T, alpha=0.4, color=\"k\", linewidth=0.9)\n", + " (mean_line,) = ax.plot(flips, np.mean(c, axis=0))\n", + " hist_ax.hist(c.flatten(), orientation=\"horizontal\", label=f\"T = {Ts[i]}\")\n", + "\n", + "axes[-1, 0].set(xlabel=f\"Monte Carlo Flip Attempts\")\n", + "axes[-1, 1].set(xlabel=\"Probability Density\")\n", + "axes[1, 0].set(ylabel=r\"Average Color $\\langle c \\rangle$\")\n", + "axes[-1, 0].legend([mean_line, indiv_line], [\"Mean\", \"Individual walker\"])\n", + "for ax in axes[:, 1]:\n", + " ax.legend(loc=4)" + ] + }, + { + "cell_type": "markdown", + "id": "bf1877e6-28c5-46a2-8927-9a90886a0498", + "metadata": {}, + "source": [ + "There are a few key takeaways about MCMC in this plot:\n", + "\n", + "- It takes a while for MCMC to 'settle in', you can see that for T = 10 the natural state is somewhere around c = 0, which takes about 2000 steps to reach from the initial state with c = 1. In general when doing MCMC we want to throw away some of the values at the beginging because they're too affected by the initial state.\n", + "- At High and Low temperatures the we basically just get small fluctuations about an average value\n", + "- At intermediate temperature the fluctuations occur on much longer time scales! Because the systems can only move a little bit each timestep, it means that the measurements we are making are *correlated* with themselves at previous times. The result of this is that if we use MCMC to draw N samples, we don't get as much information as if we had drawn samples from an uncorrelated variable (like a die roll for instance)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:recode]", + "language": "python", + "name": "conda-env-recode-py" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/learning/08 Doing reproducible science.ipynb b/learning/08 Doing reproducible science.ipynb new file mode 100644 index 0000000..81bb767 --- /dev/null +++ b/learning/08 Doing reproducible science.ipynb @@ -0,0 +1,33 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "94c1cebd-8bb4-4f19-bdb3-c503cd620d22", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:recode]", + "language": "python", + "name": "conda-env-recode-py" + }, + "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.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}