├── Smiley.png
├── Week3
    ├── Smiley.png
    ├── Week3_ImageReproduce.py
    ├── Week3_SimpleKeras.py
    └── Week3_MNIST_TF.py
├── Week9
    ├── dcgan.gif
    └── Week9_KDE.py
├── README.md
├── requirements.txt
├── Week5
    ├── .ipynb_checkpoints
    │   └── Week5_tSNE-checkpoint.ipynb
    ├── Week5_PCA.py
    └── Week5_tSNE.py
├── Week8
    ├── Week8_Ising.py
    └── Week8_BoltzmannMachine.py
├── Week4
    ├── Week4_MNIST_TF_Live.py
    ├── Week4_ConvolutionalNeuralNetwork.py
    └── Week4_Autoencoder.py
├── Week6
    ├── Week6_pandas.py
    ├── Week6_TF_IMDB.py
    ├── Week6_Prediction.py
    └── Week6_LSTM.py
├── Week7
    ├── Week7_MazePolicy.py
    ├── Week7_PolicyGradient.py
    └── Week7_RL.py
├── Week2
    ├── Week2_ChatGPT_NN.py
    └── Week2_BackPropagation.py
└── Week1
    └── Week1_CurveFitting.py


/Smiley.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nichol77/mlForPhysicists/HEAD/Smiley.png


--------------------------------------------------------------------------------
/Week3/Smiley.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nichol77/mlForPhysicists/HEAD/Week3/Smiley.png


--------------------------------------------------------------------------------
/Week9/dcgan.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/nichol77/mlForPhysicists/HEAD/Week9/dcgan.gif


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # mlForPhysicists
 2 | Machine Learning For Physicists
 3 | 
 4 | These notebooks have been put together as part of a "Machine Learning for Physicists" course for UCL Physics and Astronomy students that will run for the first time in the Autumn term 2020.
 5 | 
 6 | Some of the examples in this course were heavily inspired by the https://machine-learning-for-physicists.org course that has been run a few times by Florian Marquardt.
 7 | 
 8 | All of the notebooks are hereby provided under the terms of the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license:
 9 | 
10 | https://creativecommons.org/licenses/by-sa/4.0/


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | appnope==0.1.0
 2 | astroid==2.2.5
 3 | backcall==0.2.0
 4 | decorator==4.4.2
 5 | ipykernel==5.3.0
 6 | ipython==7.15.0
 7 | ipython-genutils==0.2.0
 8 | isort==4.3.17
 9 | jedi==0.17.1
10 | jupyter-client==6.1.3
11 | jupyter-core==4.6.3
12 | lazy-object-proxy==1.3.1
13 | matplotlib==3.1.3
14 | mccabe==0.6.1
15 | numpy==1.17.4
16 | parso==0.7.0
17 | pexpect==4.8.0
18 | pickleshare==0.7.5
19 | prompt-toolkit==3.0.5
20 | ptyprocess==0.6.0
21 | Pygments==2.6.1
22 | pylint==2.3.1
23 | python-dateutil==2.8.1
24 | pyzmq==19.0.1
25 | six==1.12.0
26 | tornado==6.0.4
27 | traitlets==4.3.3
28 | typed-ast==1.3.1
29 | wcwidth==0.2.4
30 | wrapt==1.11.1
31 | 


--------------------------------------------------------------------------------
/Week5/.ipynb_checkpoints/Week5_tSNE-checkpoint.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |  "cells": [
 3 |   {
 4 |    "cell_type": "code",
 5 |    "execution_count": null,
 6 |    "metadata": {},
 7 |    "outputs": [],
 8 |    "source": []
 9 |   }
10 |  ],
11 |  "metadata": {
12 |   "kernelspec": {
13 |    "display_name": "Python 3",
14 |    "language": "python",
15 |    "name": "python3"
16 |   },
17 |   "language_info": {
18 |    "codemirror_mode": {
19 |     "name": "ipython",
20 |     "version": 3
21 |    },
22 |    "file_extension": ".py",
23 |    "mimetype": "text/x-python",
24 |    "name": "python",
25 |    "nbconvert_exporter": "python",
26 |    "pygments_lexer": "ipython3",
27 |    "version": "3.7.6"
28 |   }
29 |  },
30 |  "nbformat": 4,
31 |  "nbformat_minor": 4
32 | }
33 | 


--------------------------------------------------------------------------------
/Week9/Week9_KDE.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.7.1
  9 | #   kernelspec:
 10 | #     display_name: Python 3
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Practical Machine Learning for Physicists
 16 | 
 17 | # ## Kernel Density Estimation
 18 | #
 19 | # This notebook is just a brief aside to demonstrate the method of kernel density estimation
 20 | #
 21 | # ### The algorithm
 22 | # Let $(x_1, x_2, \cdots x_n)$ be independent samples from some dsitribution with unkown density $f$ at any given point $x$. We want to estimate $f$, the kernel density estimator is:
 23 | # $$\hat{f}(x) = \frac{1}{n} \sum_{i=1}^n K_{h}(x-x_i) = \frac{1}{nh}  \sum_{i=1}^n K \left(\frac{x-x_i}{h} \right)$$
 24 | # where $K$ is the kernel and $h>0$ is known as the bandwidth. In principle, $K$ can be anyone of a number of different functions. In practice, $K$ is often taken as the standard normal distribution (mean of 0, sigma of 1)
 25 | 
 26 | # +
 27 | import matplotlib.pyplot as plt
 28 | import numpy as np
 29 | 
 30 | import matplotlib.style #Some style nonsense
 31 | import matplotlib as mpl #Some more style nonsense
 32 | 
 33 | import scipy.stats as stats
 34 | from scipy.stats import gaussian_kde
 35 | 
 36 | #Set default figure size
 37 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 38 | mpl.rcParams["legend.frameon"] = False
 39 | mpl.rcParams['figure.dpi']=200 # dots per inch
 40 | 
 41 | # +
 42 | xVals=np.random.normal(size=(100))
 43 | 
 44 | def kde_scipy(x, x_grid, bandwidth=0.2, **kwargs):
 45 |     """Kernel Density Estimation with Scipy"""
 46 |     # Note that scipy weights its bandwidth by the covariance of the
 47 |     # input data.  To make the results comparable to the other methods,
 48 |     # we divide the bandwidth by the sample standard deviation here.
 49 |     kde = gaussian_kde(x, bw_method=bandwidth / x.std(ddof=1), **kwargs)
 50 |     return kde.evaluate(x_grid)
 51 | 
 52 | 
 53 | # -
 54 | 
 55 | fig,ax=plt.subplots()
 56 | bins=np.linspace(-3,3,100)
 57 | bins2=np.linspace(-3,3,10000)
 58 | _= ax.hist(xVals,bins=bins,alpha=.7,label="Data Points",weights=[0.01]*100)
 59 | ax.plot(bins,stats.norm.pdf(bins),label="True PDF")
 60 | kde=gaussian_kde(xVals)
 61 | ax.plot(bins2,kde.evaluate(bins2),label="KDE Optimal")
 62 | for bw in [0.05,0.5,2]:
 63 |     ax.plot(bins2,kde_scipy(xVals,bins2,bw),label='KDE BW='+str(bw))
 64 | ax.legend()
 65 | ax.set_xlim([-3,3])
 66 | ax.set_ylim([0,0.65])
 67 | ax.set_xlabel("$x$")
 68 | ax.set_ylabel("$\hat{f}(x)$")
 69 | 
 70 | xVals=np.random.normal(size=(100))
 71 | yVals=np.random.normal(size=(100))
 72 | kde=gaussian_kde([xVals,yVals])
 73 | fig,ax=plt.subplots()
 74 | ax.plot(xVals,yVals,".",c="r",alpha=0.5)
 75 | ax.set_aspect("equal")
 76 | ax.set_xlim((-3,3))
 77 | ax.set_ylim((-3,3))
 78 | ax.set_xlabel("$x$")
 79 | ax.set_ylabel("$y$")
 80 | 
 81 | 
 82 | def fofz(z):
 83 |     # f(z)=z/10 + z/ ||z||
 84 |     # There must be a more elegant way of doing this, but the following messy line does work
 85 |     # actually I quite like the tiling of the n-element long array into a 2xn array
 86 |     return z/10+z/(np.tile(np.linalg.norm(z,axis=0),(2,1)))
 87 | 
 88 | 
 89 | z=np.vstack([xVals,yVals])
 90 | fig,ax=plt.subplots()
 91 | f=fofz(z)
 92 | ax.plot(f[0,:],f[1,:],".",c="r",alpha=0.5)
 93 | ax.set_aspect("equal")
 94 | ax.set_xlim((-1.5,1.5))
 95 | ax.set_ylim((-1.5,1.5))
 96 | ax.set_xlabel("$x$")
 97 | ax.set_ylabel("$y$")
 98 | 
 99 | # ## Plot KDE as heatmap
100 | #
101 | 
102 | # +
103 | nbins=200
104 | xi, yi = np.mgrid[-3:+3:nbins*1j, -3:+3:nbins*1j]
105 | array=np.vstack([xi.flatten(), yi.flatten()])
106 |                 
107 | zi = kde(array)
108 | # Make the plot
109 | fig,ax=plt.subplots()
110 | ax.pcolormesh(xi, yi, zi.reshape(xi.shape),shading='auto',cmap='viridis')
111 | ax.plot(xVals,yVals,".",c="r",alpha=0.5)
112 | ax.set_aspect("equal")
113 | ax.set_xlim((-3,3))
114 | ax.set_ylim((-3,3))
115 | ax.set_xlabel("$x$")
116 | ax.set_ylabel("$y$")
117 | 
118 | # -
119 | 
120 | 
121 | 


--------------------------------------------------------------------------------
/Week8/Week8_Ising.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # ---
  3 | # jupyter:
  4 | #   jupytext:
  5 | #     text_representation:
  6 | #       extension: .py
  7 | #       format_name: light
  8 | #       format_version: '1.5'
  9 | #       jupytext_version: 1.13.2
 10 | #   kernelspec:
 11 | #     display_name: Python 3
 12 | #     language: python
 13 | #     name: python3
 14 | # ---
 15 | 
 16 | # # Practical Machine Learning for Physicists
 17 | #
 18 | # In this notebook we will illustrate the Markov Chain Monte Carlo technique using an example from physics, a lattice of spin states.
 19 | #
 20 | # ## Spin and the Ising Model
 21 | #
 22 | # In the slides we saw that the energy in a spin model when $s_i \in \{-1,+1\}$ was given by:
 23 | # $$ E(s) = - \sum_i a_i s_i - \sum_{i,j} J s_i s_j $$
 24 | # where the $a_i$ describes the interactions with an external field and the $J$ terms are the self interaction.
 25 | #
 26 | # If we ignore the external field contribution and limit the spin-interaction to the nearest neighbours (up-down-left-right on a 2D lattice) then the energy function becomes:
 27 | # $$ E(s) = - \sum_{ij,nn} J s_i s_j $$
 28 | #
 29 | # To mimic a large areas we can use periodic bundary conditions (so the right-hand side of the right edge is the left edge).
 30 | #
 31 | # ## Magnetisation
 32 | #
 33 | # The degree of magnetisation can be characterised as
 34 | # $$ M = \frac{1}{N} \sum_{i=1}^N s_i $$
 35 | #
 36 | 
 37 | import numpy as np
 38 | import matplotlib.pyplot as plt
 39 | import matplotlib
 40 | matplotlib.rcParams['figure.dpi']=300 # highres display
 41 | from tqdm import tqdm
 42 | 
 43 | Nx=Ny=30
 44 | def init_spins():  #Get initial random spin state
 45 |     spins=np.random.random((Nx,Ny))  # Get random spins
 46 |     spins=spins>0.5  
 47 |     spins=2*(spins-0.5)  #Convert 0-1. to -1 or 1
 48 |     return spins
 49 | 
 50 | 
 51 | # ## Plot the spins
 52 | # Here we define a function to plot the spins (does it look familiar from Week 7?)
 53 | 
 54 | #Plot the array of -1,+1 spin values as unicode up down arrows.
 55 | def plotSpins(spinVals,title=None):
 56 |     fig, ax = plt.subplots(figsize=(2,2))
 57 |     ax.axis('tight')
 58 |     ax.axis('off')
 59 |     nRow=spinVals.shape[0]
 60 |     nCol=spinVals.shape[1]
 61 |     arrows='⇩⇧'
 62 |     spinArrow=[[ arrows[int(val>0)] for val in row ] for row in spinVals ]
 63 |     
 64 |     the_table = ax.table(spinArrow,loc='center',cellLoc='center')
 65 |     for pos, cell in the_table._cells.items():     
 66 |         cell._height = cell._width = 1./nRow
 67 |     if title:
 68 |         ax.set_title(title)
 69 | 
 70 | 
 71 | spins=init_spins()
 72 | plotSpins(spins[0:10,0:10],title="Initial Condition")  #Only plot a 10x10 square as it gets too crowded otherwise
 73 | fig,ax=plt.subplots()
 74 | ax.imshow(spins,cmap='binary')
 75 | 
 76 | 
 77 | # +
 78 | # Calculate the total energy in the spin array using
 79 | # E = sum ( - J s_i s_j)
 80 | # where the sum is only over the nearest neighbours (up, down and left, right)
 81 | # using periodic boundary conditions on the 2-D grid.
 82 | # Inputs: spinarray, 2-D array of spins (-1 or +1)
 83 | #  J is energy of each spin interaction 
 84 | # Return: Total energy
 85 | def get_energy(spinarray,J):
 86 |     middle = spinarray
 87 |     up   = np.roll(spinarray,+1,axis=0)  # array shift along axis=0
 88 |     right= np.roll(spinarray,+1,axis=1)  # array shift along axis=1
 89 |     total = np.sum((up + right)*middle) 
 90 |     return -J*total #total energy
 91 | 
 92 | print("Energy: ",get_energy(spins,1))
 93 | 
 94 | 
 95 | # -
 96 | 
 97 | # ## The ~~Metropolis~~ Rosenbluth-Hastings Algorithm
 98 | #
 99 | # The ~~Metropolis~~ Rosenbluth-Hastings algorithm is:
100 | # 1. Pick a random point in the grid
101 | # 2. Compute the energy difference in the spin in that location is flipped, $dE$
102 | # 3. If $dE<0$ flip the spin, otherwise randomly flip the spin with probability $p(dE) = e^{- \beta dE}$ where $\beta=\frac{1}{k_{B}T}$
103 | 
104 | def mcmh_step(spins,E1,T,J):
105 |     ij=np.random.randint(Nx,size=(2))
106 |     i=ij[0]
107 |     j=ij[1]
108 |     sij=spins[i][j]
109 |     spins[i][j]=-1*sij
110 |     E2=get_energy(spins,J)
111 |     dE=E2-E1
112 |     if dE < 0:
113 |         return spins,E2
114 |     if np.random.random(1)<np.exp(-dE/T):
115 |         return spins,E2
116 |     spins[i][j]=sij
117 |     return spins,E1
118 |     
119 | 
120 | 
121 | spins=init_spins()
122 | T=0.5
123 | J=1
124 | steps=100000
125 | energy=get_energy(spins,J)
126 | energies=np.zeros(steps)
127 | mags=np.zeros(steps)
128 | for step in range(steps):
129 |     spins,energy=mcmh_step(spins,energy,T, J)
130 |     energies[step]=energy
131 |     mags[step]=np.average(spins)
132 | 
133 | # +
134 | fig,ax=plt.subplots()
135 | ax.plot(np.arange(steps),energies)
136 | ax.set_xlabel("Steps")
137 | ax.set_ylabel("Energy")
138 | ax.set_title("Energy at T="+str(T))
139 | 
140 | fig,ax=plt.subplots()
141 | ax.plot(np.arange(steps),mags)
142 | ax.set_xlabel("Steps")
143 | ax.set_ylabel("Magnetisation")
144 | ax.set_title("Magnetisation at T="+str(T))
145 | # -
146 | 
147 | fig,ax=plt.subplots()
148 | ax.imshow(spins,cmap='binary')
149 | 
150 | # +
151 | nTemps=10
152 | tempArray=np.logspace(-0.5,1.5,nTemps)
153 | energyArray=np.zeros(nTemps)
154 | magArray=np.zeros(nTemps)
155 | 
156 | for ti in tqdm(range(len(tempArray))):
157 |     spins=init_spins()
158 |     T=tempArray[ti]
159 |     J=1
160 |     steps=100000
161 |     energy=get_energy(spins,J)
162 |     energies=np.zeros(steps)
163 |     mags=np.zeros(steps)
164 |     for step in range(steps):
165 |         spins,energy=mcmh_step(spins,energy,T, J)
166 |         energies[step]=energy
167 |         mags[step]=np.average(spins)
168 |     energyArray[ti]=energies[-1]
169 |     magArray[ti]=mags[-1]
170 |     fig,ax=plt.subplots()
171 |     ax.imshow(spins,cmap='binary')
172 |     # Turn off tick labels
173 |     ax.set_yticklabels([])
174 |     ax.set_xticklabels([])
175 | 
176 | # +
177 | fig,ax=plt.subplots()
178 | ax.plot(tempArray,energyArray)
179 | ax.set_xlabel("Temperature")
180 | ax.set_ylabel("Energy")
181 | ax.set_title("Energy vs T")
182 | ax.set_xscale("log")
183 | 
184 | fig,ax=plt.subplots()
185 | ax.plot(tempArray,np.abs(magArray))
186 | ax.set_xlabel("Temperature")
187 | ax.set_ylabel("Magnetisation")
188 | ax.set_title("Magnetisation vs T")
189 | ax.set_xscale("log")
190 | print(tempArray)
191 | # -
192 | 
193 | fig,ax=plt.subplots()
194 | ax.imshow(spins,cmap='binary')
195 | 
196 | 
197 | 


--------------------------------------------------------------------------------
/Week3/Week3_ImageReproduce.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Introduction to TensorFlow and Keras
 16 | #
 17 | # In this notebook we will go through the bare bones of creating a new neural network using Keras and TensorFlow. then we will recreate some of the 2 input, 1 output neural networks that we have been using before. The main purpose of this is to illustrate how much easier it is to do this in Keras than in our homebrew neural networks.
 18 | 
 19 | # +
 20 | import matplotlib.pyplot as plt
 21 | import numpy as np
 22 | 
 23 | import tensorflow as tf   #Import the TensorFlow library as tf
 24 | from tensorflow import keras  #and import Keras from TensorFlow
 25 | 
 26 | 
 27 | import matplotlib.style #Some style nonsense
 28 | import matplotlib as mpl #Some more style nonsense
 29 | 
 30 | #Added for a progress bar
 31 | from tqdm.notebook import tqdm
 32 | import imageio #For image download
 33 | 
 34 | 
 35 | #Set default figure size
 36 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 37 | mpl.rcParams["legend.frameon"] = False
 38 | mpl.rcParams['figure.dpi']=200 # dots per inch
 39 | # -
 40 | 
 41 | # ## Define our neural network
 42 | 
 43 | model=keras.Sequential()  #Sequential is a standard layered neural network
 44 | model.add(keras.layers.Input(shape=(2,)))
 45 | model.add(keras.layers.Dense(60,activation='relu')) #Add a fully-connected (Dense) layer  of 60 nodes with 2 input nodes
 46 | model.add(keras.layers.Dense(100,activation='relu')) #Add a 2nd fully-connected (Dense) layer with 100 nodes
 47 | model.add(keras.layers.Dense(60,activation='relu')) #Add a 3rd fully-connected (Dense) layer with 60 nodes
 48 | model.add(keras.layers.Dense(1,activation='relu'))  #A single node in the output layer
 49 | 
 50 | 
 51 | # ## Compile the network
 52 | 
 53 | # +
 54 | model.compile(loss="mean_squared_error",optimizer=keras.optimizers.SGD(learning_rate=0.1),metrics=['accuracy']) 
 55 | #Compile the network with mean squared error loss function
 56 | # and stochastic gradient descent optimiser with learning rate of 0.1
 57 | 
 58 | #Alternative better optimiser
 59 | #model.compile(loss="mean_squared_error",optimizer='adam',metrics=['accuracy']) #adam is more sophisticated optimiser
 60 | 
 61 | 
 62 | # -
 63 | 
 64 | # ## Read in our image
 65 | # Now we need to read in our image and flip it around so that the bottom left corner can be indexed as 0,0
 66 | 
 67 | input_img = imageio.v2.imread('http://www.hep.ucl.ac.uk/undergrad/0056/other/313px-William_Henry_Bragg_Nobel_bw.jpg')
 68 | pixel_image=np.transpose(input_img) # have to transpose...
 69 | pixel_image=pixel_image[:,::-1] # and flip... to get the right view!
 70 | pixel_image-=pixel_image.min()
 71 | pixel_image=(pixel_image.astype(dtype='float'))/pixel_image.max() # normalize between 0 and 1!
 72 | Npixels=np.shape(pixel_image) 
 73 | print(Npixels[0])
 74 | print(Npixels[1])
 75 | print("The image is "+str(np.shape(pixel_image)[0])+" X "+str(np.shape(pixel_image)[1])+" pixels")
 76 | 
 77 | 
 78 | # ## Sample the image
 79 | # The following two functions are used to randomly select pixel values from the image
 80 | 
 81 | #Now need to wrap the image in a function for easy calling
 82 | def imgFunction(x,y):
 83 |     global pixel_image,Npixels
 84 |     # convert to integer coordinates (assuming input is 0..1)
 85 |     xint=(x*Npixels[0]*0.9999).astype(dtype='int')
 86 |     yint=(y*Npixels[1]*0.9999).astype(dtype='int')
 87 |     return(pixel_image[xint,yint]) # extract color values at these pixels
 88 | 
 89 | 
 90 | #This function picks batchsize random x,y pairs and then evaluates myFunc for these x,y pairs
 91 | # returns both the x,y pairs and the values
 92 | def make_batch(batchsize):
 93 |     inputs=np.random.uniform(low=0,high=1,size=[batchsize,2])
 94 |     targets=np.zeros([batchsize,1]) # must have right dimensions
 95 |     targets[:,0]=imgFunction(inputs[:,0],inputs[:,1])
 96 |     return(inputs,targets)
 97 | 
 98 | 
 99 | # ## Train the network
100 | # Now we need to train the network. The configurable parameters here are the batchsize (number of random samples per step) and number of batches (number of steps).
101 | 
102 | batchsize=2000
103 | batches=2000
104 | costs=np.zeros(batches)
105 | for k in tqdm(range(batches)): #tqdm provides a handy progress bar
106 |     y_in,y_target=make_batch(batchsize) 
107 |     costs[k]=model.train_on_batch(y_in,y_target)[0]
108 |  
109 | 
110 | #Plot the cost
111 | fig, ax = plt.subplots()
112 | stepArray=np.arange(batches) 
113 | ax.plot(stepArray,costs,linewidth=3) 
114 | ax.set_xlabel("Step Number")
115 | ax.set_ylabel("Cost")
116 | 
117 | # ## Test the network
118 | # Now, I'll be honest the following cell took me a long time to get correct. It is conceptually simple we have an image that is 313 X 480 pixels and we need to reshape the 313 x values and 480 y values, into an array that is 150,240 x 2 to feed into the neural network (note this is not the ideal way to train a neural network on an image).
119 | #
120 | # Then we can plot our image and try and guess what it is.
121 | 
122 | # +
123 | xrange=np.linspace(0,1,Npixels[0]) #e.g. 50 steps from 0,1
124 | yrange=np.linspace(0,1,Npixels[1]) #e.g. 50 steps from 0,1
125 | X0,X1=np.meshgrid(xrange,yrange) #get the 2D grid points
126 | numpixels=np.shape(X0)[0]*np.shape(X0)[1]
127 | y_in=np.reshape(np.transpose([X0,X1]),(numpixels,2))
128 | print(np.shape(y_in))
129 | #y_fake=y_in[:,0]*y_in[:,1]  #I used this to test I was doing the reshaping
130 | #print(np.shape(y_fake))
131 | 
132 | y_out=model.predict_on_batch(y_in)
133 | pixels=np.transpose(np.reshape(y_out,(np.shape(X0)[1],np.shape(X0)[0])))
134 | print(np.shape(pixels))
135 | # -
136 | 
137 | fig, ax = plt.subplots()  #I like to make plots using this silly fig,ax method but plot how you like
138 | im=ax.imshow(pixels,interpolation='nearest',origin='lower',cmap='plasma')
139 | cb = fig.colorbar(im) #Get the colorbar for the range of z values
140 | ax.axis('off')
141 | 
142 | # ## The input image
143 | # So what did the input image look like?
144 | 
145 | # Check that we can actually plot the image
146 | xrange=np.linspace(0,1,Npixels[0]) #e.g. 50 steps from 0,1
147 | yrange=np.linspace(0,1,Npixels[1]) #e.g. 50 steps from 0,1
148 | X0,X1=np.meshgrid(xrange,yrange) #get the 2D grid points
149 | fig, ax = plt.subplots()  #I like to make plots using this silly fig,ax method but plot how you like
150 | im=ax.imshow(imgFunction(X0,X1),interpolation='nearest',origin='lower',cmap='plasma')
151 | cb = fig.colorbar(im) #Get the colorbar for the range of z values
152 | ax.axis('off')
153 | 
154 | # ## Suggested tasks
155 | # Can you make a better image reproduction?
156 | 
157 | 
158 | 


--------------------------------------------------------------------------------
/Week4/Week4_MNIST_TF_Live.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Exploring convolutional layers
 16 | #
 17 | 
 18 | # +
 19 | import matplotlib.pyplot as plt
 20 | import numpy as np
 21 | import math
 22 | 
 23 | # TensorFlow and tf.keras
 24 | import tensorflow as tf
 25 | from tensorflow import keras
 26 | 
 27 | import matplotlib.style #Some style nonsense
 28 | import matplotlib as mpl #Some more style nonsense
 29 | 
 30 | 
 31 | #Set default figure size
 32 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 33 | mpl.rcParams["legend.frameon"] = False
 34 | mpl.rcParams['figure.dpi']=200 # dots per inch
 35 | 
 36 | #Useful for debugging problems
 37 | print(tf.__version__)
 38 | # -
 39 | 
 40 | # ## Load the MNIST dataset
 41 | #
 42 | # The Keras library comes with a number of builtin datasets. One of which is the MNIST library of handwritten digits
 43 | 
 44 | mnist = keras.datasets.mnist   #The original handwritten digit MNIST
 45 | #mnist = keras.datasets.fashion_mnist   #A tricky version that uses images of fashion items
 46 | (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
 47 | 
 48 | # ### Play with the data
 49 | # The training library consists of 60,000 images and each image is 28x28 pixels. There are 60,000 labels to go with the images. Each label is one of the digits (0:9).
 50 | 
 51 | print("Shape of training images:",train_images.shape)
 52 | print("Length of training set labels:",len(train_labels))
 53 | print("First label:",train_labels[0])
 54 | print("Shape of testing images:",test_images.shape)
 55 | print("Length of testing set labels:",len(test_labels))
 56 | 
 57 | # +
 58 | 
 59 | #Normalise and reshape images so that they have 1 feature
 60 | train_images=train_images/255.0
 61 | test_images=test_images/255.0
 62 | train_images=np.reshape(train_images,(60000,28,28,1))
 63 | test_images=np.reshape(test_images,(10000,28,28,1))
 64 | # -
 65 | 
 66 | # ## Building our neural network
 67 | #
 68 | # Now we will use Keras to build our neural network. 
 69 | #
 70 | # ### Set up the layers
 71 | #
 72 | # A neural network is made up of layers and in the simple case these layers are applied sequentially.
 73 | 
 74 | # +
 75 | 
 76 | 
 77 | ## Altenratively we can use the functional API where one has to code the dependence between layers explictly
 78 | # In most situations in this course the Sequential API is easier to use, but the functional API offers much more freedom
 79 | input_layer =  keras.layers.Input(shape=(28,28,1))
 80 | conv1=keras.layers.Conv2D(32, (3, 3), activation='relu')(input_layer)
 81 | drop1=keras.layers.MaxPooling2D((2, 2))(conv1)
 82 | conv2=keras.layers.Conv2D(32, (3, 3), activation='relu')(drop1)
 83 | drop2=keras.layers.MaxPooling2D((2, 2))(conv2)
 84 | flatten_layer = keras.layers.Flatten()(drop2)
 85 | Layer_2 = keras.layers.Dense(20, activation="sigmoid")(flatten_layer)
 86 | output_layer= keras.layers.Dense(10, activation="linear")(Layer_2)
 87 | ##Defining the model by specifying the input and output layers
 88 | model = keras.models.Model(inputs=input_layer, outputs=output_layer)
 89 | 
 90 | model.summary()
 91 | # -
 92 | 
 93 | # ## From layers to a compiled model
 94 | #
 95 | # Before we can train the model we need to determine the:
 96 | # - *Loss function* - This is used to tell us how well our model is doing in
 97 | # - *Optimiser* - This is how the model gets updated based on the data and the loss function
 98 | # - *Metrics* - Used to monitor the training and testing steps. The following example uses *accuracy*, the fraction of the images that are correctly classified.
 99 | 
100 | model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer='adam',
101 |               metrics=['accuracy'])
102 | 
103 | # ## Train the model
104 | # To train the model we need to show the training data to the model. In our case the training data is the `train_images` and `train_labels` arrays. The model will hopefully *learn* how to associate the images and the labels.
105 | #
106 | # ### Fitting the model to the data
107 | # The training process is also called fitting the model to the data (for obvious reasons). The Keras syntax for fitting the model uses `model.fit`
108 | 
109 | history=model.fit(train_images, train_labels,batch_size=256, epochs=20)
110 | 
111 | # In the above output you can see that the model improves the loss (this number gets smaller) and accuracy (this number gets bigger) with each epoch. But doing well on the training data set is a bit like marking your own homework. A fairer test is to evaluate the performance on the testing data set (which the model has not seen).
112 | 
113 | # ### Testing the performance
114 | 
115 | # +
116 | print(np.shape(test_images))
117 | test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
118 | 
119 | #print('\nTest accuracy:', test_acc)
120 | # -
121 | 
122 | # So when I ran this I found a accuracy on the training dataset of 99.50% but the accuracy on the testing datset was 98.80%. Perfroming better on the training than testing datset is an indication of overfitting (which will be dicussed in more detail later in the course).
123 | 
124 | # The output of the test_range function is the list of predicted and true labels for the range. For each prediction the associated probability array is also printed.
125 | 
126 | # ## Interrograting the training
127 | # `keras.fit` returns a hitsory object that contains the evolution of the loss an accuracry metrics as a function of epoch. This allows us to see how quickly the fitting process is converging.
128 | 
129 | fig,ax=plt.subplots()
130 | ax.plot(history.history['loss'], linewidth=3)
131 | ax.set_xlabel("Epoch")
132 | ax.set_ylabel("Loss")
133 | 
134 | fig,ax=plt.subplots()
135 | ax.plot(history.history['accuracy'], linewidth=3)
136 | ax.set_xlabel("Epoch")
137 | ax.set_ylabel("Accuracy")
138 | 
139 | # ## Looking at those convoltional layers
140 | 
141 | # +
142 | 
143 | modelFirstConv = keras.models.Model(inputs=input_layer, outputs=conv1)
144 | modelFirstConv.summary()
145 | # -
146 | 
147 | plt.imshow(test_images[100])
148 | 
149 | testout=modelFirstConv(test_images)  #What craziness is this?
150 | print(testout.shape)
151 | 
152 | plt.imshow(testout[2,:,:,0])
153 | 
154 | for img in range(3):
155 | 
156 |     # Define grid size (e.g., 4 rows, 8 columns)
157 |     rows, cols = 4, 8
158 |     
159 |     fig, axes = plt.subplots(rows, cols, figsize=(12, 6))
160 |     
161 |     for i, ax in enumerate(axes.flat):
162 |         ax.imshow(testout[img,:,:,i], cmap="gray")
163 |         ax.axis("off")  # Hide axis
164 |     
165 |     plt.tight_layout()
166 |     plt.show()
167 | 
168 | 
169 | 


--------------------------------------------------------------------------------
/Week6/Week6_pandas.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # pandas - Python data analysis tutorial  -- Optional content
 16 | #
 17 | # The pandas package is an analysis package for working with tabular data i.e. the types of data that could be represented in a spreadsheet. Some nomenclature 
 18 | # - DataFrame -- the table which can have some number of rows and columns
 19 | # - Series -- each column in a DataFrame is a Series
 20 | #
 21 | #
 22 | 
 23 | # +
 24 | #Our seemingly ever growing list of standard includes
 25 | import numpy as np
 26 | import matplotlib.pyplot as plt 
 27 | 
 28 | import matplotlib.style #Some style nonsense
 29 | import matplotlib as mpl #Some more style nonsense
 30 | 
 31 | #Import tqdm for progress bar
 32 | from tqdm import tqdm
 33 | 
 34 | #Set default figure size
 35 | mpl.rcParams["legend.frameon"] = False
 36 | mpl.rcParams['figure.dpi']=200 # dots per inch
 37 | 
 38 | # TensorFlow and tf.keras
 39 | import tensorflow as tf
 40 | from tensorflow import keras
 41 | # -
 42 | 
 43 | # ## How many sunspots?
 44 | # Here is an example of getting a dataset of the tabulated mean number of sunsports from 1749 to now. The data comes from the [Sunspot Index and Long-term Solar Observations webpae.](http://sidc.be/silso/home) The `snmtotcsv.php` script returns a csv of the monthly mean number of sunspots (actually instead of a comma separated file the use the semi-colon to separate items). The file does not have a header row so we will have to manually label the columns.
 45 | #
 46 | 
 47 | # +
 48 | #You might need to install pandas if so uncomment and run the following line.
 49 | # #!pip install pandas
 50 | # -
 51 | 
 52 | import pandas as pd
 53 | url='http://www.sidc.be/silso/INFO/snmtotcsv.php'
 54 | df = pd.read_csv(url,header=None,delimiter=';',names=["Year","Month","Frac. Date","Mean","StdDev","NumObs","Flag"],)
 55 | 
 56 | #Top of the table
 57 | df.head()
 58 | 
 59 | #Bottom of the table
 60 | df.tail()
 61 | 
 62 | # ### Accesing individual series
 63 | # One of the nice features of pandas (although you can do this with other python data structures so it isn't unique) is that you can address individual series in the DataFrame. The syntax for getting a Series is just to address it using the name of the column.
 64 | 
 65 | meanSeries=df["Mean"]
 66 | print(meanSeries)
 67 | 
 68 | # ### Plotting the data
 69 | 
 70 | fig,ax=plt.subplots()
 71 | ax.plot(df["Frac. Date"],df.Mean)  #Either get columns via 
 72 | ax.set_xlabel("Fractional Date")
 73 | ax.set_ylabel("Mean # Sunspots")
 74 | 
 75 | 
 76 | # ## Preparing the data
 77 | # To prepare the data for training the network we need to change it into a format where the data has some sequence (to use as the input) and some data value (to use as the target). We will do this by creating sequences of $n_{ts}$ consecutive values, with the target $offset$ values later.
 78 | 
 79 | #Function to convert a series with data values into a dataframe of n_ts values 
 80 | # with a target offset samples later
 81 | def make_timeseqs(series,n_ts,offset):
 82 |     nn_df = pd.DataFrame()
 83 |     for i in range(n_ts):
 84 |         nn_df[i] = series.shift(n_ts-i) #Shift the data by n_ts-i samples
 85 |     nn_df['label'] = series.shift(-offset)
 86 |     return nn_df
 87 | 
 88 | 
 89 | df.Mean=df.Mean/df.Mean.max()
 90 | offset=0
 91 | n_ts=6 #Number of values in a time sequence
 92 | nn_df=make_timeseqs(df.Mean,n_ts,offset) #6 samples per row for training, offset of 0 (so next sample)
 93 | nn_df.head(8)
 94 | 
 95 | # ### Cleaning the data
 96 | # Clearly the shifted data results in a number of NaN (Not a Number) values populating the DataFrame. We need to throw away these values and just keep those rows which have all valid data
 97 | 
 98 | nn_df.dropna(axis=0, inplace=True)
 99 | nn_df.head()
100 | 
101 | # ### Creating, train, validation and testing data samples
102 | # We want to create training, validation and testing data samples from these rows. The input data needs to have the shape `(num_rows, num_time_seqs, num_features)`. For the sunspot data the `num_features` is just 1 and `num_time_seqs` is 6 in this example
103 | #
104 | #
105 | # #### scikit-learn
106 | # Another useful library is the scikit-learn library which you can install via pip
107 | 
108 | 
109 | 
110 | # +
111 | #If necessary you can install scikit-learn with
112 | # #!pip install scikit-learn
113 | # -
114 | 
115 | train_label=nn_df.label.values
116 | train_data=nn_df.drop('label',axis=1).values
117 | print(train_data.shape)
118 | train_data=train_data.reshape(-1,n_ts,1)
119 | print(train_data.shape)
120 | print(train_label.shape)
121 | 
122 | # +
123 | test_data=train_data[-100:]
124 | test_label=train_label[-100:]
125 | train_data=train_data[:-100]
126 | train_label=train_label[:-100]
127 | 
128 | from sklearn.model_selection import train_test_split
129 | train_data, val_data, train_label, val_label = train_test_split(train_data, train_label, random_state = 0)
130 | print(train_data.shape)
131 | # -
132 | 
133 | # ## Define our model
134 | 
135 | model=keras.models.Sequential()
136 | model.add(keras.layers.Input(shape=(n_ts,1)))
137 | model.add(keras.layers.LSTM(64,return_sequences=True)) # LSTM layer with 50 neurons
138 | model.add(keras.layers.LSTM(32,activation='relu'))
139 | model.add(keras.layers.Dense(32,activation='relu'))
140 | model.add(keras.layers.Dense(1,activation="linear"))
141 | model.compile(loss='mean_squared_error',optimizer='adam')
142 | model.summary()
143 | 
144 | history=model.fit(train_data,train_label,epochs=10,batch_size=16,verbose=1,validation_data=(val_data,val_label))
145 | 
146 | # ### Plot some things
147 | #
148 | 
149 | fig,ax=plt.subplots()
150 | ax.plot(history.history['loss'], label='train_loss')
151 | ax.plot(history.history['val_loss'], label='val_loss')
152 | ax.set_title = 'Loss of the model'
153 | ax.xlabel = 'Time (Epochs)'
154 | ax.ylabel = 'Loss'
155 | ax.legend()
156 | 
157 | # ### Predict the future
158 | 
159 | test_predict=model.predict(test_data)
160 | fig,ax=plt.subplots()
161 | ax.plot(test_predict[offset:],label="Predicted Data")
162 | ax.plot(test_label,label="True Test Data")
163 | ax.set_title("Prediction vs Reality")
164 | ax.set_xlabel("Sample #")
165 | ax.set_ylabel("Mean Sunspot #")
166 | ax.legend()
167 | 
168 | 
169 | # Clearly the model does a reasonable job of predicting the underlying trends (if the high variability in the true data is just statictical noise (we expect the number of sunspots each month to have standard Poissonian counting statistics) the arguable we should want our model not to try and follow those noise wiggles).
170 | #
171 | # ## Suggested tasks
172 | # 1. Change the network architechture (reduce or remove LSTM layers)
173 | # 2. Try and predict over longer time periods (increase the offset)
174 | # 3. Investigate the stability of your predictions vs some of the hyper parameters (sequence length, offset, learning rate, etc.)
175 | 
176 | 
177 | 


--------------------------------------------------------------------------------
/Week8/Week8_BoltzmannMachine.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.13.2
  9 | #   kernelspec:
 10 | #     display_name: Python 3
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Tutorial: Boltzmann Machines
 16 | #
 17 | # This shows how to train a Boltzmann machine, to sample from an observed probability distribution.
 18 | 
 19 | # This notebook was taken almost in its entirity from the lecture series "Machine Learning for Physicists" by Florian Marquardt. See https://machine-learning-for-physicists.org.
 20 | #
 21 | # This notebook is distributed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license:
 22 | #
 23 | # https://creativecommons.org/licenses/by-sa/4.0/
 24 | 
 25 | # This notebook shows how to:
 26 | # - use a Boltzmann machine to sample from an observed high-dimensional probability distribution (e.g. produce images that look similar to observed training images)
 27 | #
 28 | 
 29 | # +
 30 | import numpy as np
 31 | import matplotlib.pyplot as plt
 32 | import matplotlib
 33 | matplotlib.rcParams['figure.dpi']=300 # highres display
 34 | 
 35 | from IPython.display import clear_output
 36 | from time import sleep
 37 | 
 38 | 
 39 | # +
 40 | def BoltzmannStep(v,b,w):
 41 |     """
 42 |     Perform a single step of the Markov chain,
 43 |     going from visible units v to hidden units h,
 44 |     according to biases b and weights w.
 45 |     
 46 |     z_j = b_j + sum_i v_i w_ij
 47 |     
 48 |     and P(h_j=1|v) = 1/(exp(-z_j)+1)
 49 |     
 50 |     Note: you can go from h to v, by inserting
 51 |     instead of v the h, instead of b the a, and
 52 |     instead of w the transpose of w
 53 |     """
 54 |     batchsize=np.shape(v)[0]
 55 |     hidden_dim=np.shape(w)[1]
 56 |     z=b+np.dot(v,w)
 57 |     P=1/(np.exp(-z)+1)
 58 |     # now, the usual trick to obtain 0 or 1 according
 59 |     # to a given probability distribution:
 60 |     # just produce uniform (in [0,1]) random numbers and
 61 |     # check whether they are below the cutoff given by P
 62 |     p=np.random.uniform(size=[batchsize,hidden_dim])
 63 |     return(np.array(p<=P,dtype='int'))
 64 |     
 65 | def BoltzmannSequence(v,a,b,w,drop_h_prime=False):
 66 |     """
 67 |     Perform one sequence of steps v -> h -> v' -> h'
 68 |     of a Boltzmann machine, with the given
 69 |     weights w and biases a and b!
 70 |     
 71 |     All the arrays have a shape [batchsize,num_neurons]
 72 |     (where num_neurons is num_visible for v and
 73 |     num_hidden for h)
 74 |     
 75 |     You can set drop_h_prime to True if you want to
 76 |     use this routine to generate arbitrarily long sequences
 77 |     by calling it repeatedly (then don't use h')
 78 |     Returns: v,h,v',h'
 79 |     """
 80 |     h=BoltzmannStep(v,b,w)
 81 |     v_prime=BoltzmannStep(h,a,np.transpose(w))
 82 |     if not drop_h_prime:
 83 |         h_prime=BoltzmannStep(v_prime,b,w)
 84 |     else:
 85 |         h_prime=np.zeros(np.shape(h))
 86 |     return(v,h,v_prime,h_prime)
 87 | 
 88 | def trainStep(v,a,b,w):
 89 |     """
 90 |     Given a set of randomly selected training samples
 91 |     v (of shape [batchsize,num_neurons_visible]), 
 92 |     and given biases a,b and weights w: update
 93 |     those biases and weights according to the
 94 |     contrastive-divergence update rules:
 95 |     
 96 |     delta w_ij = eta ( <v_i h_j> - <v'_i h'_j> )
 97 |     delta a_i  = eta ( <v_i> - <v'_i>)
 98 |     delta b_j  = eta ( <h_j> - <h'_j>)
 99 |     
100 |     Returns delta_a, delta_b, delta_w, but without the eta factor!
101 |     It is up to you to update a,b,w!
102 |     """
103 |     v,h,v_prime,h_prime=BoltzmannSequence(v,a,b,w)
104 |     return( np.average(v,axis=0)-np.average(v_prime,axis=0) ,
105 |             np.average(h,axis=0)-np.average(h_prime,axis=0) ,
106 |             np.average(v[:,:,None]*h[:,None,:],axis=0)-
107 |                np.average(v_prime[:,:,None]*h_prime[:,None,:],axis=0) )
108 | 
109 | 
110 | 
111 | # -
112 | 
113 | def produce_samples_random_segment(batchsize,num_visible,max_distance=3):
114 |     """
115 |     Produce 'batchsize' samples, of length num_visible.
116 |     Returns array v of shape [batchsize,num_visible]
117 |     
118 |     This here: produces randomly placed segments of
119 |     size 2*max_distance.
120 |     """
121 |     random_pos=num_visible*np.random.uniform(size=batchsize)
122 |     j=np.arange(0,num_visible)
123 |     
124 |     return( np.array( np.abs(j[None,:]-random_pos[:,None])<=max_distance, dtype='int' ) )
125 | 
126 | 
127 | # +
128 | # Now: the training
129 | 
130 | num_visible=20
131 | num_hidden=10
132 | batchsize=50
133 | eta=0.1
134 | nsteps=500
135 | skipsteps=10
136 | 
137 | a=np.random.randn(num_visible)  #Biases on visible
138 | b=np.random.randn(num_hidden)  #Biases on hidden
139 | w=np.random.randn(num_visible,num_hidden)  # Weights between hidden and visible
140 | 
141 | test_samples=np.zeros([num_visible,nsteps])
142 | 
143 | for j in range(nsteps):
144 |     v=produce_samples_random_segment(batchsize,num_visible)
145 |     da,db,dw=trainStep(v,a,b,w)
146 |     a+=eta*da
147 |     b+=eta*db
148 |     w+=eta*dw
149 |     test_samples[:,j]=v[0,:]
150 |     if j%skipsteps==0 or j==nsteps-1:
151 |         clear_output(wait=True)
152 |         plt.figure(figsize=(10,3))
153 |         plt.imshow(test_samples,origin='lower',aspect='auto',interpolation='none')
154 |         plt.axis('off')
155 |         plt.show()
156 | 
157 | # +
158 | # Now: visualize the typical samples generated (from some starting point)
159 | # run several times to continue this. It basically is a random walk
160 | # through the space of all possible configurations, hopefully according
161 | # to the probability distribution that has been trained!
162 | 
163 | nsteps=100
164 | test_samples=np.zeros([num_visible,nsteps])
165 | 
166 | v_prime=np.zeros(num_visible)
167 | h=np.zeros(num_hidden)
168 | h_prime=np.zeros(num_hidden)
169 | 
170 | for j in range(nsteps):
171 |     v,h,v_prime,h_prime=BoltzmannSequence(v,a,b,w,drop_h_prime=True) # step from v via h to v_prime!
172 |     test_samples[:,j]=v[0,:]
173 |     v=np.copy(v_prime) # use the new v as a starting point for next step!
174 |     if j%skipsteps==0 or j==nsteps-1:
175 |         clear_output(wait=True)
176 |         plt.imshow(test_samples,origin='lower',interpolation='none')
177 |         plt.show()
178 | 
179 | # +
180 | # Now show the weight matrix
181 | 
182 | plt.figure(figsize=(0.2*num_visible,0.2*num_hidden))
183 | plt.imshow(w,origin='lower',aspect='auto')
184 | plt.show()
185 | # -
186 | 
187 | # # Suggested task 1: train on differently shaped samples (e.g. a bar with both random position and random width)
188 | #
189 | # ...or two bars, located always at the same distance!
190 | 
191 | # # Suggested task 2 
192 | # ## Train on MNIST images!
193 | #
194 | # Here the visible units must be a flattened version of the images, something like
195 | #
196 | # v=np.reshape(image,[batchsize,widh*height])
197 | #
198 | # ...if image is of shape [batchsize,width,height], meaning an array holding the pixel values for all images in a batch!
199 | #
200 | # ...to plot the results, you would use 
201 | #
202 | # np.reshape(v,[batchsize,width,height])
203 | #
204 | # to get back to the image format!
205 | 
206 | 
207 | 


--------------------------------------------------------------------------------
/Week6/Week6_TF_IMDB.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Natural Language Processing
 16 | #
 17 | # In this notebook we introudce some of the ideas of natural language processing. To speed things up ww will be using a couple of optional Tensorflow libraries. Tensorflow Hub and Tensoflow Datasets and also a library called tf_keras which is basically the same as the keras already in tensorflow.
 18 | #
 19 | # The content of this notebook is extremely heavily inspired by one of the [Tensorflow tutorials](https://www.tensorflow.org/tutorials/keras/text_classification_with_hub)
 20 | #
 21 | # # Pre-trained models
 22 | #
 23 | # This notebook is the first time in the course that we will be using a pre-trained model (in this case for a text embedding layer). Using these pre-trained models can dranatically speed up certain tasks.
 24 | #
 25 | # ## Installing the libraries
 26 | # In the first cell we use pip to install these libraries.
 27 | 
 28 | # !pip install tensorflow_hub
 29 | # !pip install tensorflow_datasets
 30 | # !pip install tf_keras
 31 | 
 32 | # ## Import libraries, check versions and GPU availability
 33 | # Next up we import the libraries and check some of the Tensorflow settings and see if you are running on a GPUs or not.
 34 | 
 35 | # +
 36 | import tensorflow as tf
 37 | import tensorflow_hub as hub
 38 | import tensorflow_datasets as tfds
 39 | import tf_keras as keras
 40 | 
 41 | 
 42 | print("Version: ", tf.__version__)
 43 | print("Eager mode: ", tf.executing_eagerly())
 44 | print("Hub version: ", hub.__version__)
 45 | print("GPU is", "available" if tf.config.list_physical_devices("GPU") else "NOT AVAILABLE")
 46 | 
 47 | 
 48 | 
 49 | # -
 50 | 
 51 | # ## Load Internet Movie Database Review Dataset
 52 | # Now we are going to load a text dataset from the [Internet Movie Database](https://www.imdb.com). This dataset consists of reviews of various lengths of text that have been labelled as either positive or negative.
 53 | 
 54 | # Split the training set into 60% and 40% to end up with 15,000 examples
 55 | # for training, 10,000 examples for validation and 25,000 examples for testing.
 56 | train_data, validation_data, test_data = tfds.load(
 57 |     name="imdb_reviews", 
 58 |     split=('train[:60%]', 'train[60%:]', 'test'),
 59 |     as_supervised=True)
 60 | 
 61 | # ## Printing some example reviews
 62 | # The Tensorflow dataset is an interesting object, in the code below we create a batch of 10 reviews (and labels) and then turn it into a Tensorflow Iterator with `iter` and actually get the values with `next`. At first it might seem a little clunky using tensorflow datasets but they are useful resource to try and understand.
 63 | 
 64 | train_examples_batch, train_labels_batch = next(iter(train_data.batch(10)))
 65 | print(train_examples_batch)
 66 | 
 67 | #Also print the labels
 68 | print(train_labels_batch)
 69 | 
 70 | # ## Text Embedding
 71 | # Obvioulsy as we've stated repeatedly in the course neural networks take input vectors (of various sizes) and then apply some combination of matrix multiplications, additions, non-linear activation functions and other mathematical operations. Normally English sentences are not immediately well-suited to these operations so the first stage in any natural language processing is to convert the input into some kind of numerical vector via a process of embedding. Fortunately lots of people have done this before us so in true [Blue Peter](https://www.bbc.co.uk/cbbc/watch/bp-heres-one-i-made-earlier-video-challenge) style we can use one that is already been pre-trained.
 72 | #
 73 | # In the code below we use Tensorflow Hub to get a pre-trained text embedding layer. The embedding we use is the catchily named [google/nnlm-en-dim50/2](https://tfhub.dev/google/nnlm-en-dim50/2) which as it's name suggest is Neural Network Langauge Model in English which encodes sequences into vectors of dimension 50. We create a layer called hub_layer which is trainable but starts off from the already pre-trained weights.
 74 | #
 75 | # #### From TensorFlow's Tutorial
 76 | # There are many other pre-trained text embeddings from TFHub that can be used in this tutorial:
 77 | #
 78 | # * [google/nnlm-en-dim128/2](https://tfhub.dev/google/nnlm-en-dim128/2) - trained with the same NNLM architecture on the same data as [google/nnlm-en-dim50/2](https://tfhub.dev/google/nnlm-en-dim50/2), but with a larger embedding dimension. Larger dimensional embeddings can improve on your task but it may take longer to train your model.
 79 | # * [google/nnlm-en-dim128-with-normalization/2](https://tfhub.dev/google/nnlm-en-dim128-with-normalization/2) - the same as [google/nnlm-en-dim128/2](https://tfhub.dev/google/nnlm-en-dim128/2), but with additional text normalization such as removing punctuation. This can help if the text in your task contains additional characters or punctuation.
 80 | # * [google/universal-sentence-encoder/4](https://tfhub.dev/google/universal-sentence-encoder/4) - a much larger model yielding 512 dimensional embeddings trained with a deep averaging network (DAN) encoder.
 81 | #
 82 | # And many more! Find more [text embedding models](https://tfhub.dev/s?module-type=text-embedding) on TFHub.
 83 | #
 84 | #
 85 | 
 86 | embedding = "https://tfhub.dev/google/nnlm-en-dim50/2"
 87 | hub_layer = hub.KerasLayer(embedding, input_shape=[], 
 88 |                            dtype=tf.string, trainable=True)
 89 | hub_layer(train_examples_batch[:3])
 90 | 
 91 | # ## Building a full model
 92 | # To build the full model we need to take our embedding layer and then add a simple fully connected network that ends with a single neuron in the output layer (which we will use to compare to the labels). 
 93 | 
 94 | # +
 95 | model = keras.Sequential()
 96 | model.add(hub_layer)
 97 | model.add(keras.layers.Dense(16, activation='relu'))
 98 | model.add(keras.layers.Dense(1))
 99 | 
100 | model.summary()
101 | # -
102 | 
103 | # ## Model comments
104 | #
105 | # So our full model contains 48,191,433 parameters. But the vast majority of these are in the form of the embedding layer and those parameters are already pre-trained. The fully connected classification part of the network is just 816 + 17 parameters.
106 | #
107 | # # Model Compilation
108 | #
109 | # We are going to use the `adam` optimizer and since we are doing a binary classification taks we will use BinaryCrossentropy as our loss function.
110 | #
111 | # # Model training
112 | #
113 | # Then we will train our model for 10 epochs. To speed things up we will only train on a subset of the data.
114 | 
115 | # +
116 | model.compile(optimizer='adam',
117 |               loss=keras.losses.BinaryCrossentropy(from_logits=True),
118 |               metrics=['accuracy'])
119 | 
120 | history = model.fit(train_data.shuffle(10000).batch(512),
121 |                     epochs=10,
122 |                     validation_data=validation_data.batch(512),
123 |                     verbose=1)
124 | # -
125 | 
126 | # ## Model performance
127 | #
128 | # The last step is to use our test dataset (which we haven't touched yet) to evaluate the performance of the model.
129 | #
130 | # When I first ran this the accuracy was 85.3% which is not bad considering all we have done is add a single hidden layer of 16 neurons after our pre-trained embedding layer.
131 | 
132 | # +
133 | results = model.evaluate(test_data.batch(512), verbose=2)
134 | 
135 | for name, value in zip(model.metrics_names, results):
136 |   print("%s: %.3f" % (name, value))
137 | # -
138 | 
139 | # # Suggested tasks
140 | # 1. Can you improve on the model performance?
141 | # 2. How does the speed of model training change if you try some of the other pre-trained text embeddings layers?
142 | 
143 | 
144 | 


--------------------------------------------------------------------------------
/Week6/Week6_Prediction.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Using LSTM's to predict the future
 16 | #
 17 | #
 18 | 
 19 | # +
 20 | import numpy as np
 21 | import matplotlib.pyplot as plt 
 22 | from scipy.integrate import solve_ivp
 23 | 
 24 | import matplotlib.style #Some style nonsense
 25 | import matplotlib as mpl #Some more style nonsense
 26 | 
 27 | #Import tqdm for progress bar
 28 | from tqdm import tqdm
 29 | 
 30 | #Set default figure size
 31 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 32 | mpl.rcParams["legend.frameon"] = False
 33 | mpl.rcParams['figure.dpi']=200 # dots per inch
 34 | 
 35 | # TensorFlow and tf.keras
 36 | import tensorflow as tf
 37 | from tensorflow import keras
 38 | # -
 39 | 
 40 | # ## Define an LSTM based model
 41 | # Below we define a simple network using one LSTM layer with 50 neurons and then a Dense layer to map to a single output. This network will be able to handle a sequence input and give back a single value sequence output (since there is one neuron in the Dense layer) 
 42 | 
 43 | #Define
 44 | model=keras.models.Sequential()
 45 | model.add(keras.layers.Input(shape=(None,1)))
 46 | model.add(keras.layers.LSTM(20,return_sequences=False)) # LSTM layer with 50 neurons
 47 | model.add(keras.layers.Dense(1,activation="linear"))
 48 | model.compile(loss='mean_squared_error',optimizer='adam')
 49 | model.summary()
 50 | 
 51 | 
 52 | # ## Define a function to model
 53 | # Here we will pick a simple combination of sine function and an exponential. Then we will generate a sequence of x and y values.
 54 | 
 55 | # +
 56 | def sinexp(x):
 57 |     return np.sin(x)*np.exp(-x/10)
 58 | 
 59 | numPoints=100
 60 | x=np.linspace(0,10*np.pi,numPoints)
 61 | y=sinexp(x)
 62 | fig,ax=plt.subplots()
 63 | ax.plot(x,y,label=r"$y=\sin(x) \times \exp(-x/10)$")
 64 | ax.set_xlabel("x")
 65 | ax.set_xlabel("y")
 66 | ax.set_title("Target Function")
 67 | ax.legend()
 68 | # -
 69 | 
 70 | # ## How to predict the future?
 71 | # There are a number of ways we could try and train our LSTM to predict the future. Currently we have an array of $y$ data values. But how do we feed this into a model and use it to predict something. We need to define a few dimensions. How many steps do we want to include in the training data (window size) and how far into the future do we want to predict (offset)?
 72 | #
 73 | 
 74 | # +
 75 | windowsize=10 #Number of samples we will use to train our network
 76 | offset=10 #How many samples into the future to predict
 77 | 
 78 | 
 79 | 
 80 | #This function splits up a 1-d array x into a series of overlapping windows
 81 | #The return is a tuple of the array of input windows and target (label) windows
 82 | def shapeArray(x,windowsize,offset):
 83 |     xInput= np.array([x[i : i + windowsize] for i in range(len(x)-(windowsize+offset)+1)])
 84 |     xLabel= np.array([x[i +windowsize : i+ windowsize+offset] for i in range(len(x)-(windowsize+offset)+1)])
 85 |     return (xInput,xLabel)
 86 |   
 87 | samp=np.arange(numPoints)  #Number of samples
 88 | sampInput,sampLabel=shapeArray(samp,windowsize,offset)
 89 | for i in range(5):
 90 |     print(i,sampInput[i],sampLabel[i])
 91 |     
 92 | 
 93 |     
 94 | #Get our xInput and xLabel arrays    
 95 | xInput,xLabel=shapeArray(x,windowsize,offset)
 96 | #for i in range(5):
 97 | #    print(i,xInput[i],xLabel[i])
 98 | 
 99 | #Get our yInput and yLabel arrays
100 | yInput=sinexp(xInput)
101 | yLabel=sinexp(xLabel)
102 | 
103 | #Print show the shape of the arrays
104 | print(yInput.shape)
105 | print(yLabel.shape)
106 | # -
107 | 
108 | # So if we were to use the `samp` array we could train a network to predict `19` given the input `[0 1 2 3 4 5 6 7 8 9]` and `23` given `[ 4  5  6  7  8  9 10 11 12 13]`
109 | #
110 | # ## Training the network
111 | # Now we need to train our model. Again there are many ways we could choose to do this. Here we will pick a random starting $x_0$ and then generate 100 points from that starting position. So that each step of the training will use (slightly) different input and target values.
112 | 
113 | # +
114 | steps=200  #Number of training steps
115 | costs=np.zeros(steps)  #Array for plotting cost
116 | for i in tqdm(range(steps)):
117 |     x0=0#np.random.uniform(low=0,high=5)  #Pick random start point between 0 and 5
118 |     x=np.linspace(x0,x0+10*np.pi,numPoints) #generate numPoints points from that  posiiton
119 |     xInput,xLabel=shapeArray(x,windowsize,offset)  #Split that into the input and label arrays
120 | 
121 |     yInput=sinexp(xInput)  # Apply the sinexp function to xInput
122 |     yLabel=sinexp(xLabel)  # Apply the sinexp function to xLabel
123 |     # Now we need to reshape the array into batchsize * window size * features (1)
124 |     y_in=yInput.reshape(yInput.shape[0],yInput.shape[1],1)  # Reshape the input array to have the dimensions (batchsize,time samples, features)
125 |     # We only want a single number for the target (since we set return_sequences=False above). We will take the last sample of the yLabel
126 |     y_target=yLabel[:,-1].reshape(yLabel.shape[0],1) # Reshape the output array to have the dimensions (batchsize, time samples)
127 |     costs[i]=model.train_on_batch(y_in,y_target) #Train the network
128 | 
129 | #Plot costs vs steps
130 | fig,ax=plt.subplots()
131 | ax.plot(np.arange(steps),costs,label=r"Costs")
132 | ax.set_xlabel("Steps")
133 | ax.set_ylabel("Cost")
134 | ax.set_title("Network Training Cost")
135 | ax.legend()
136 | # -
137 | 
138 | # ## Network performance
139 | # So our network training gets a low cost but does this correspond to good predictive performance? Let's start by plotting the input and expected target.
140 | 
141 | x_test=np.linspace(0,10*np.pi,numPoints)
142 | y_test=sinexp(x_test)
143 | y_testoff=sinexp(x_test[offset:])
144 | fig,ax=plt.subplots()
145 | samps=np.arange(0,numPoints-offset)
146 | ax.plot(x_test,y_test,label=r"$y_{input}$")
147 | ax.plot(x_test[offset:],y_testoff,label=r"$y_{target}$")
148 | ax.set_xlabel("x")
149 | ax.set_ylabel("y")
150 | ax.set_title("Training data")
151 | ax.legend()
152 | 
153 | # ## Looking at a single window of data
154 | # We feed in a window of `windowsize` samples and try to predict the value that comes `offset` values after this.
155 | 
156 | # +
157 | #Note that our network has been trained on a particular dx between samples if we don't use this it will not work well!
158 | #Predict over a larger phase space from 0 ->15pi instead of 0->10pi
159 | numTestPoints=150
160 | x_test=np.linspace(0,15*np.pi,numTestPoints)
161 | y_test=sinexp(x_test)
162 | y_testoff=sinexp(x_test[offset:])
163 | test_samps=np.arange(0,numTestPoints-offset)
164 | xTest_in,xTest_label=shapeArray(x_test,windowsize,offset)
165 | yTest_in=sinexp(xTest_in)
166 | yTestLabel=sinexp(xTest_label)
167 | 
168 | 
169 | fig,ax=plt.subplots()
170 | ax.plot(xTest_in[0],yTest_in[0],label="Input")
171 | ax.plot(xTest_label[0],yTestLabel[0],label="Target")
172 | ax.plot(xTest_label[0][-1],yTestLabel[0][-1],"*",label="Target")
173 | ax.set_xlabel("x")
174 | ax.set_ylabel("y")
175 | ax.set_title("Single Window")
176 | ax.legend()
177 | #np.shape(yTest_in)
178 | 
179 | 
180 | # -
181 | 
182 | # ## The actual network prediction
183 | # Below we plot the actual prediction vs the expected function. As ever most of the challenege is wrestling the arrays into the correct format and organisation.
184 | 
185 | # +
186 | 
187 | yTest_in2=yTest_in.reshape(yTest_in.shape[0],yTest_in.shape[1],1)
188 | y_hat=model.predict_on_batch(yTest_in2.reshape(yTest_in2.shape[0],windowsize,1))
189 | print(y_hat.shape)
190 | fig,ax=plt.subplots()
191 | ax.plot(x_test,y_test,label=r"$y=\sin(x) \times \exp(-x/10)$")
192 | #ax.plot(x_test[offset:],y_testoff,label=r"$y_{target}$")
193 | ax.plot(x_test[windowsize+offset-1:],y_hat.reshape(y_hat.shape[0]),label=r"$y_{prediction}$")
194 | ax.set_xlabel("x")
195 | ax.set_ylabel("y")
196 | ax.set_title("Network Prediction")
197 | ax.legend()
198 | # -
199 | 
200 | 
201 | 


--------------------------------------------------------------------------------
/Week5/Week5_PCA.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Unsupervised Dimensionality Reduction
 16 | # ## Principal Component Analysis
 17 | #
 18 | # In this notebook we will explore principal component analysis (PCA) which you could argue is just linear algebra rather than machine learning, at least in its most simple incarnation.
 19 | #
 20 | # ### PCA algorithm
 21 | # Let's consider $N$ data points $\{ x_1,\cdots,x_N \}$ that live in a $p$-dimensional space $\mathbb{R}^p$. First we will zero-mean the data such that $\mu=\frac{1}{N}\sum_i x_i =0$, then we will construct a matrix $X$ whose rows are the data points and columns the dimensions
 22 | # $$X=\left[x_1,x_2,\cdots, x_N \right]^T$$
 23 | #
 24 | # Then we can form the covariance matrix $\Sigma(X)$ which is a $p \times p$ symmetric matrix
 25 | # $$\Sigma(X)=\frac{1}{N-1}X^TX$$
 26 | # The diagonal elements of this matrix are the variances along each of the $p$-dimensions.
 27 | #
 28 | # #### Eigenvector decomposition
 29 | # Now we are going to decompose this matrix into its component eigenvectors. Remeber the eigenvectors $v$ and eigenvalues $\lambda$ of a sqaure matrix $A$ satsify the eigenvalue equation
 30 | # $$A v = \lambda v$$
 31 | #
 32 | # Let $V$ denote the matrix whose columns are $v$, and $\Lambda$ the diagonal matrix whose elements are the eigenvalues. Then the full family of eigenvalue equations can be written as
 33 | # $$A V =  V \Lambda $$
 34 | # where the ordering on the right is to make sure that the columnwise eigenvectors are multiplied by there corresponding eigenvalues. Now assumming our eigenvevctors are linearly independent (which we know is true for eigenvectors from quantum mechanics) then $V^{-1}$ exists and we can write
 35 | # $$ A = V \Lambda V^{-1} $$
 36 | #
 37 | # #### Singular Value Decomposition
 38 | # For rectangular matrices the equivalent of eigenvalue decomposition is singular value decompoisiton. Where our matrix $X$ is rewritten such that $X=USV^T$ where $S$ is a diagonal matrix of the singular values and $U$ & $V$ are unitary matrices whose columns are the left and right singular vectors $X$. 
 39 | #
 40 | # Writing $X$ this way allows us to write the covariance matrix as:
 41 | # $$\Sigma(X)=\frac{1}{N-1}VSU^TUSV^T$$
 42 | # but since $U$ is unitary $U^TU=I$
 43 | # $$\Sigma(X)=V\left(\frac{S^2}{N-1}\right)V^T$$
 44 | # $$\Sigma(X) \equiv V \Lambda V^T$$
 45 | # where $\Lambda$ is a diagonal matrix with eigenvalues $\lambda_i$ 
 46 | 
 47 | # +
 48 | import matplotlib.pyplot as plt
 49 | import numpy as np
 50 | import math
 51 | 
 52 | # TensorFlow and tf.keras
 53 | import tensorflow as tf
 54 | from tensorflow import keras
 55 | 
 56 | import matplotlib.style #Some style nonsense
 57 | import matplotlib as mpl #Some more style nonsense
 58 | 
 59 | from scipy import linalg
 60 | 
 61 | #Set default figure size
 62 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 63 | mpl.rcParams["legend.frameon"] = False
 64 | mpl.rcParams['figure.dpi']=200 # dots per inch
 65 | 
 66 | #Useful for debugging problems
 67 | print(tf.__version__)
 68 | 
 69 | # +
 70 | mnist = keras.datasets.mnist   #The original handwritten digit MNIST
 71 | #mnist = keras.datasets.fashion_mnist   #A tricky version that uses images of fashion items
 72 | (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
 73 | train_images=train_images/255.0
 74 | 
 75 | print("train_images.shape: ",np.shape(train_images))
 76 | X=np.reshape(train_images,(60000,784))
 77 | print("X.shape:",np.shape(X))
 78 | 
 79 | mu=np.mean(X,axis=0)
 80 | x=X-mu
 81 | #rho=np.dot(np.transpose(x),x)  #Make the covaraince matrix by hand
 82 | rho=np.cov(x,rowvar=False) # Make the covaraince matrix by np.cov
 83 | print("rho.shape:",np.shape(rho))
 84 | 
 85 | #Get the eigenvalues and vectors
 86 | vals,vecs=linalg.eigh(rho)
 87 | #vals is a 1-D array of the eigenvalues in ascending order, vecs is a columnwise array of the normalised
 88 | # eigenvectors such that vecs[:,i] is the eigenvector correspondong to vals[i]
 89 | print("vecs.shape:",np.shape(vecs))
 90 | print("vals.shape:",np.shape(vals))
 91 | vecs=np.flip(vecs)
 92 | vals=np.flip(vals)
 93 | 
 94 | # -
 95 | 
 96 | fig,ax=plt.subplots()
 97 | ax.imshow(np.reshape(vecs[:,0],[28,28]), origin='lower',cmap='binary',interpolation='nearest')
 98 | 
 99 | fig,ax=plt.subplots(2,3)
100 | for i in range(2):
101 |     for j in range(3):
102 |         ax[i,j].imshow(np.reshape(vecs[:,(i+j*3)],[28,28]), origin='lower',cmap='binary',interpolation='nearest')
103 | plt.subplots_adjust(left=0.05,
104 |                     bottom=0.2, 
105 |                     right=0.9, 
106 |                     top=0.9, 
107 |                     wspace=0.1, 
108 |                     hspace=0.2)  #Adjust the space between the subplots so there isn't acres of whitespace
109 | 
110 | print(np.shape(vals))
111 | fig,ax=plt.subplots()
112 | index=np.arange((np.shape(vals)[0]))
113 | ax.plot(index,vals.real,".")
114 | ax.set_xlabel("PCA Index")
115 | ax.set_ylabel("Variance")
116 | ax.grid()
117 | 
118 | fig,ax=plt.subplots()
119 | cumsum=np.cumsum(vals.real)
120 | cdf=cumsum/cumsum[-1]
121 | index=np.arange((np.shape(vals)[0]))
122 | ax.plot(index,cdf,".")
123 | ax.set_xlabel("PCA Index")
124 | ax.set_ylabel("Fraction of explained variance")
125 | ax.grid()
126 | 
127 | # ### Using the first $N$ components
128 | # Having determined all of the eigenvectors we can now try to reconstruct our image using only a subset of the eigenvectors. Essenitally we will be constructing a projection operator to do something close to
129 | # $$y = V^T V x$$
130 | # and then vary the number of eigenvectors including in the projection.
131 | #
132 | # Doing this below for all 60,000 of the training images the order of the matrices in the dot products can look a little confusing.
133 | # $$ P = x v $$
134 | # $$ y = P v^T $$
135 | # and in this last line we can either compute the matrix multiplication over the full matrix (to recover x) or over the first $N$ columns of $P$ and rows of $v^T$.
136 | 
137 | P=np.dot(x,vecs)
138 | print("x.shape:",x.shape)
139 | print("P.shape:",P.shape)
140 | newImage2=(np.dot(P[:,0:2],vecs.T[0:2,:]))+mu
141 | newImage10=(np.dot(P[:,0:10],vecs.T[0:10,:]))+mu
142 | newImage50=(np.dot(P[:,0:50],vecs.T[0:50,:]))+mu
143 | newImage100=(np.dot(P[:,0:100],vecs.T[0:100,:]))+mu
144 | newImage200=(np.dot(P[:,0:200],vecs.T[0:200,:]))+mu
145 | newImage500=(np.dot(P[:,0:500],vecs.T[0:500,:]))+mu
146 | newImage784=(np.dot(P[:,:],vecs.T[:,:]))+mu
147 | 
148 | fig,ax=plt.subplots(2,4)
149 | whichImage=7
150 | ax[0,0].imshow(np.flipud(np.reshape(X[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
151 | ax[0,0].set_title("Original")
152 | ax[0,1].imshow(np.flipud(np.reshape(newImage2[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
153 | ax[0,1].set_title("2 PCs")
154 | ax[0,2].imshow(np.flipud(np.reshape(newImage10[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
155 | ax[0,2].set_title("10 PCs")
156 | ax[0,3].imshow(np.flipud(np.reshape(newImage50[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
157 | ax[0,3].set_title("50 PCs")
158 | ax[1,0].imshow(np.flipud(np.reshape(newImage100[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
159 | ax[1,0].set_title("100 PCs")
160 | ax[1,1].imshow(np.flipud(np.reshape(newImage200[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
161 | ax[1,1].set_title("200 PCs")
162 | ax[1,2].imshow(np.flipud(np.reshape(newImage500[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
163 | ax[1,2].set_title("500 PCs")
164 | ax[1,3].imshow(np.flipud(np.reshape(newImage784[whichImage,:],[28,28])), origin='lower',cmap='binary',interpolation='nearest')
165 | ax[1,3].set_title("All PCs")
166 | plt.subplots_adjust(left=0.05,
167 |                     bottom=0.2, 
168 |                     right=0.9, 
169 |                     top=0.9, 
170 |                     wspace=0.3, 
171 |                     hspace=0.3)  #Ad
172 | 
173 | 
174 | 
175 | 


--------------------------------------------------------------------------------
/Week7/Week7_MazePolicy.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.7.1
  9 | #   kernelspec:
 10 | #     display_name: Python 3
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # ## Reinforcement Learning
 16 | 
 17 | # +
 18 | import numpy as np
 19 | import matplotlib.pyplot as plt
 20 | 
 21 | import matplotlib
 22 | matplotlib.rcParams['figure.dpi']=300 # highres display
 23 | 
 24 | # for subplots within subplots:
 25 | from matplotlib import gridspec
 26 | 
 27 | #For silly animations
 28 | from IPython.display import clear_output
 29 | from time import sleep
 30 | 
 31 | # +
 32 | # Maze generation algorithm from wikipedia
 33 | # the code was removed in January 2020, but you can still
 34 | # access it under this link:
 35 | # https://en.wikipedia.org/w/index.php?title=Maze_generation_algorithm&oldid=930153705
 36 | 
 37 | 
 38 | def generate_maze(width=81, height=51, complexity=.75, density=.75):
 39 |     """Generate a maze using a maze generation algorithm."""
 40 |     # Only odd shapes
 41 |     shape = ((height // 2) * 2 + 1, (width // 2) * 2 + 1)
 42 |     # Adjust complexity and density relative to maze size
 43 |     complexity = int(complexity * (5 * (shape[0] + shape[1])))  # Number of components
 44 |     density    = int(density * ((shape[0] // 2) * (shape[1] // 2)))  # Size of components
 45 |     # Build actual maze
 46 |     Z = np.zeros(shape, dtype=bool)
 47 |     # Fill borders
 48 |     Z[0, :] = Z[-1, :] = 1
 49 |     Z[:, 0] = Z[:, -1] = 1
 50 |     # Make aisles
 51 |     for i in range(density):
 52 |         x, y = np.random.randint(0, shape[1] // 2) * 2, np.random.randint(0, shape[0] // 2) * 2  # Pick a random position
 53 |         Z[y,x] = 1
 54 |         for j in range(complexity):
 55 |             neighbours = []
 56 |             if x > 1:             neighbours.append((y, x - 2))
 57 |             if x < shape[1] - 2:  neighbours.append((y, x + 2))
 58 |             if y > 1:             neighbours.append((y - 2, x))
 59 |             if y < shape[0] - 2:  neighbours.append((y + 2, x))
 60 |             if len(neighbours):
 61 |                 y_, x_ = neighbours[np.random.randint(0, len(neighbours) - 1)]
 62 |                 if Z[y_, x_] == 0:
 63 |                     Z[y_, x_] = 1
 64 |                     Z[y_ + (y - y_) // 2, x_ + (x - x_) // 2] = 1
 65 |                     x, y = x_, y_
 66 |     return Z
 67 | generate_maze(6,6)
 68 | # -
 69 | 
 70 | fix,ax=plt.subplots()
 71 | ax.imshow(generate_maze(60, 40), cmap=plt.cm.binary, interpolation='nearest')
 72 | ax.set_xticks([]) 
 73 | ax.set_yticks([])
 74 | 
 75 | # +
 76 | # make a maze, convert array from True/False to integer:
 77 | world=np.array(generate_maze(width=11,height=11),dtype='int')
 78 | 
 79 | # the four directions of motion [delta_jx,delta_jy]:
 80 | directions=np.array([[0,1],[0,-1],[1,0],[-1,0]])
 81 | 
 82 | # initial position
 83 | jx,jy=1,1
 84 | 
 85 | # take a random walk through the maze and animate this!
 86 | nsteps=40
 87 | for j in range(nsteps):
 88 |     # make a random step
 89 |     pick=np.random.randint(4)
 90 |     jx_new,jy_new=np.array([jx,jy])+directions[pick]
 91 |     if world[jx_new,jy_new]==0: # is empty, can move!
 92 |         jx,jy=jx_new,jy_new
 93 |         # show what's happening
 94 |         picture=np.copy(world) # copy the array (!)
 95 |         picture[jx,jy]=2
 96 |         plt.imshow(picture,origin='lower',cmap=plt.cm.plasma )
 97 |         plt.show()
 98 |         sleep(0.01)
 99 |         clear_output(wait=True)
100 | 
101 | # +
102 | # full policy gradient RL for picking up 'treasure chests'
103 | # in an automatically generated maze; 2020 by F.M.
104 | 
105 | M=11 # the size of the world: M x M
106 | eta=0.01 # the learning rate
107 | num_chests=10 # maximum number of treasure chests
108 | 
109 | # make a maze, convert array from True/False to integer:
110 | world=np.array(generate_maze(width=M,height=M),dtype='int')
111 | 
112 | # the four directions of motion [delta_jx,delta_jy]:
113 | directions=np.array([[0,1],[0,-1],[1,0],[-1,0]])
114 | 
115 | # the policy probabilities as an array policy[state,action]
116 | # here the state is represented by two coordinates jx,jy
117 | policy=np.full([M,M,4],0.25)
118 | # and also the underlying 'z'-values for the
119 | # softmax parametrization:
120 | policy_z=np.full([M,M,4],0.0)
121 | 
122 | # steps inside one trajectory
123 | nsteps=80
124 | 
125 | # total number of trials, i.e. trajectories
126 | ntrials=200
127 | skipsteps=5 # don't plot every trial
128 | 
129 | # storing all the state/action pairs of the current trajectory
130 | states=np.zeros([nsteps,2], dtype='int')
131 | actions=np.zeros(nsteps, dtype='int')
132 | 
133 | # a map of rewards (the 'boxes' are here!)
134 | reward=np.zeros([M,M])
135 | 
136 | # storing all the returns, for all trials:
137 | Returns=np.zeros(ntrials)
138 | 
139 | # try random selection of reward sites (treasure chests)
140 | for n in range(10): 
141 |     jx_target,jy_target=np.random.randint(M,size=2)
142 |     if jx_target>4 or jy_target>4: # stay away from starting point!
143 |         if world[jx_target,jy_target]==0: # empty, keep it!
144 |             reward[jx_target,jy_target]+=1
145 |         
146 | # try many trajectories:
147 | for trial in range(ntrials):
148 | 
149 |     # set return to zero for this trajectory:
150 |     R=0
151 |     # initial position:
152 |     jx,jy=1,1
153 |     
154 |     # go through all time steps
155 |     for t in range(nsteps):
156 |         # make a random step, according to the policy distribution
157 |         p=np.random.uniform()
158 |         cumulative_distribution=np.cumsum(policy[jx,jy,:])
159 |         for pick in range(4):
160 |             if p<cumulative_distribution[pick]:
161 |                 break
162 | 
163 |         # record the move
164 |         states[t,0]=jx
165 |         states[t,1]=jy
166 |         actions[t]=pick
167 | 
168 |         # now make the move
169 |         jx_new,jy_new=np.array([jx,jy])+directions[pick]
170 | 
171 |         # really make it if there is no wall:
172 |         if world[jx_new,jy_new]==0: # is empty, can move!
173 |             jx,jy=jx_new,jy_new
174 |         
175 |         # get a reward if on a treasure chest!
176 |         r=reward[jx,jy]
177 |         R+=r
178 |    
179 |     # store the return
180 |     Returns[trial]=R
181 |     
182 |     # use policy gradient update rule to adjust
183 |     # probabilities!
184 |     for t in range(nsteps): # go through the trajectory again
185 |         a=actions[t] # remember the action taken at step t
186 |         sx=states[t,0] # state/x-position at step
187 |         sy=states[t,1] # state/y-position
188 |         kronecker=np.zeros(4); kronecker[a]=1.0
189 |         policy_z[sx,sy,:]+=eta*R*(kronecker-policy[sx,sy,:])
190 | 
191 |     # now calculate (again) the policy probab. from the z-values
192 |     policy=np.exp(policy_z)
193 |     policy/=np.sum(policy,axis=2)[:,:,None] # normalize
194 |     # these two steps together implement softmax on every
195 |     # site! efficient array syntax!
196 |     
197 |     # visualize!
198 |     if trial%skipsteps==0 or trial==ntrials-1:
199 |         # show what's happened in this trajectory
200 |         clear_output(wait=True)
201 |         fig,ax=plt.subplots(ncols=2,nrows=2,figsize=(7,7))
202 |         ax[0,0].plot(Returns) # all the returns, in all trials
203 |         ax[0,0].set_title("Return vs. trial")
204 |         
205 |         picture=np.zeros([M,M,3]) # last index: red/green/blue
206 |         picture[:,:,0]=world # walls are red
207 |         for j in range(nsteps): # highlight trajectory
208 |             picture[states[j,0],states[j,1],1]=0.5*(1.0+(1.0*j)/nsteps)
209 |         # put a bright pixel at the positions visited
210 |         picture[:,:,2]+=0.5*reward # highlight the target sites!
211 |         picture[:,:,0]+=0.5*reward
212 | 
213 |         # show picture (transpose is needed because
214 |         # otherwise the first coordinate jx is plotted upwards,
215 |         # not to the right)
216 |         ax[0,1].imshow(np.transpose(picture,[1,0,2]),origin='lower')
217 |         ax[0,1].axis('off')
218 |         
219 |         ax[1,0].imshow(np.transpose(policy[:,:,0]),origin='lower')
220 |         ax[1,0].axis('off')
221 |         ax[1,0].set_title("prob(move up)")
222 |         ax[1,1].imshow(np.transpose(policy[:,:,2]),origin='lower')
223 |         ax[1,1].set_title("prob(move right)")
224 |         ax[1,1].axis('off')
225 |         plt.show()
226 | # -
227 | 
228 | 
229 | 


--------------------------------------------------------------------------------
/Week3/Week3_SimpleKeras.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Introduction to TensorFlow and Keras
 16 | #
 17 | # In this notebook we define a simple network architechture for taking in 1D input. Here we are going to train a network to mimic the behaviour of an arbitrary function.
 18 | #
 19 | # Once more this notebook is heavily inspired by https://machine-learning-for-physicists.org and is relased under the same Creative Commons License.
 20 | #
 21 | 
 22 | # +
 23 | import matplotlib.pyplot as plt
 24 | import numpy as np
 25 | 
 26 | import tensorflow as tf
 27 | from tensorflow import keras
 28 | 
 29 | 
 30 | import matplotlib.style #Some style nonsense
 31 | import matplotlib as mpl #Some more style nonsense
 32 | 
 33 | 
 34 | #Set default figure size
 35 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 36 | mpl.rcParams["legend.frameon"] = False
 37 | mpl.rcParams['figure.dpi']=200 # dots per inch
 38 | 
 39 | print("tf.__version__",tf.__version__)
 40 | 
 41 | # -
 42 | 
 43 | # ### Define our first two networks
 44 | # Below we show two example neural network, the first is defined using the Keras Sequential API (easy) and the second uses the Functional API (more flexibile)
 45 | #
 46 | # The sequential network will have one input neuron and one output neuron and two hidden layers.
 47 | # - First hidden layer has 1 input and 20 neurons with sigmoid activation functions
 48 | # - Second hidden layer takes 20 inputs (from the first hidden layer) and has 10 neurons with sigmoid activation functions.
 49 | # - Output layer is a single neuron with linear activation function.
 50 | #
 51 | #
 52 | # The functional network will have one input neuron and one output neuron and two hidden layers.
 53 | # - First hidden layer has 1 input and 20 neurons with ReLU activation functions
 54 | # - Second hidden layer takes 20 inputs (from the first hidden layer) and has 10 neurons with ReLU activation functions.
 55 | # - Output layer is a single neuron with linear activation function.
 56 | 
 57 | # +
 58 | #This first example creates a model using the Sequential API where each layer is defined sequentially
 59 | model1 = keras.Sequential([
 60 |     keras.layers.Input(shape=(1,)),
 61 |     keras.layers.Dense(20,activation="sigmoid"),
 62 |     keras.layers.Dense(10,activation='sigmoid'),
 63 |     keras.layers.Dense(1,activation='linear')
 64 | ])
 65 | 
 66 | ## Altenratively we can use the functional API where one has to code the dependence between layers explictly
 67 | # In most situations in this course the Sequential API is easier to use, but the functional API offers much more freedom
 68 | input_layer =  keras.layers.Input(shape=(1,))
 69 | Layer_1 = keras.layers.Dense(20, activation="relu")(input_layer)
 70 | Layer_2 = keras.layers.Dense(10, activation="relu")(Layer_1)
 71 | output_layer= keras.layers.Dense(1, activation="linear")(Layer_2)
 72 | ##Defining the model by specifying the input and output layers
 73 | model2 = keras.models.Model(inputs=input_layer, outputs=output_layer)
 74 | 
 75 | # -
 76 | 
 77 | # Having defined our network the next step is to compile it, specifing which loss function and which optimiser we want to use. Here we will use the 'adam' optimiser which is adaptive and much more perfromant than the standard gradient descent algorithm.
 78 | 
 79 | model1.compile(loss='mean_squared_error',optimizer='adam')
 80 | model2.compile(loss='mean_squared_error',optimizer='adam')
 81 | 
 82 | # ### Now let's look at our network
 83 | # There are lots of built in functions to understand the network structure here we will look at a couple.
 84 | # ` model.summary()` - This prints a string summary of the network.
 85 | #
 86 | 
 87 | model1.summary()
 88 | model2.summary()
 89 | 
 90 | 
 91 | # There are a few things to note here:
 92 | # * Each layer has it's own name that is autogenerated (dense_1, dense_2, etc.)
 93 | # * The first dimension of the output of each layer is `None` this is because that dimension is variable and corresponds to the batchsize
 94 | # * Can you work out why each layer has the number of parameters that it does?
 95 | #
 96 | # If you have some extra packages installed (pydot + graphviz) you can also get a pretty plot of the network using the `kera.util.plot_model` function
 97 | 
 98 | # +
 99 | #keras.utils.plot_model(model1,show_shapes=True)
100 | # -
101 | 
102 | # Now lets define our target function
103 | 
104 | #A wave packet target function
105 | def target_func(y):
106 |     return( np.sin(y)/(1+y**2) ) # a wave packet...
107 | 
108 | 
109 | # Rather than using `model.fit` we will use `model.train_on_batch` to illustrate the steps in running the training. Repeatedly running the cell below will have the same effect as increasing the number of batches used in the training.
110 | 
111 | # +
112 | 
113 | nbatch = 2000  #Number of batches
114 | batchsize = 100 #Samples per batch
115 | costs=np.zeros(nbatch) #Output array for the costs
116 | costs2=np.zeros(nbatch) #Output array for the costs
117 | 
118 | #Loop over the batches, get batchsize samples and train the network
119 | for i in range(nbatch):
120 |     x=np.random.uniform(low=-10.0,high=+10.0,size=[batchsize,1]) #Generate batchsize random numbers between -10 and +10
121 |     y=target_func(x) #Evaluate the function for each random number
122 |     costs[i]=model1.train_on_batch(x,y)  #Train the model on this batch of data
123 |     costs2[i]=model2.train_on_batch(x,y)  #Train the model on this batch of data
124 |                         
125 | # -
126 | 
127 | #Here we plot the cost vs batch number 
128 | fig, ax = plt.subplots()  #I like to make plots using this silly fig,ax method but plot how you like
129 | step=np.arange(nbatch)  # This function gets a range of numbers from 0 up to nbatch-1
130 | ax.plot(step,costs,linewidth=3,label='Model 1',alpha=0.5)
131 | ax.plot(step,costs2,linewidth=3,label='Model 2',alpha=0.5)
132 | ax.set_xlabel("Batch Number")
133 | ax.set_ylabel("Cost")
134 | ax.legend()
135 | ax.set_yscale('log')
136 | 
137 | # +
138 | # get the output on a 1D grid of points:
139 | N=400 # number of points
140 | y_in=np.zeros([N,1]) # prepare correct shape for network, here N becomes the batch size
141 | y_in[:,0]=np.linspace(-20.0,20.0,N) # fill with interval
142 | y_out=model1.predict_on_batch(y_in) # apply the network to this set of points!
143 | y_out2=model2.predict_on_batch(y_in) # apply the network to this set of points!
144 | 
145 | # plot it!
146 | fig, ax = plt.subplots() 
147 | ax.plot(y_in,y_out,label="Model 1")
148 | ax.plot(y_in,y_out2,label="Model 2")
149 | ax.plot(y_in,target_func(y_in),label="Target")
150 | ax.set_xlabel("x")
151 | ax.set_ylabel("y")
152 | ax.set_xlim([-20,20])
153 | ax.axvspan(-20,-10,facecolor='lightgrey', alpha=0.5)
154 | ax.axvspan(+10,+20,facecolor='lightgrey', alpha=0.5)
155 | ax.legend()
156 | 
157 | 
158 | fig, ax = plt.subplots() 
159 | ax.plot(y_in,y_out-target_func(y_in),label="Model 1")
160 | ax.plot(y_in,y_out2-target_func(y_in),label="Model 2")
161 | ax.set_xlabel("x")
162 | ax.set_ylabel("Network - Target")
163 | ax.set_title("Residual")
164 | ax.set_xlim([-20,20])
165 | ax.axvspan(-20,-10,facecolor='lightgrey', alpha=0.5)
166 | ax.axvspan(+10,+20,facecolor='lightgrey', alpha=0.5)
167 | ax.legend()
168 | # -
169 | 
170 | # ## Discussion
171 | #
172 | # The main difference between these two models is the actuvation function. Model 1 uses sigmoid and has a smooth curve. Model 2 uses ReLU and has some sharp features in the network output. For low numbers of training batches it isn't obvious that the performance of the network outside of the region it was trained on (-10,10) is worse, but if you increase the number of batches this will become apparent.
173 | #
174 | # ## Further work
175 | #
176 | # ### Exercise 1: Make a better network?
177 | # Can you improve the network model and make a better fit to the inpout function? You could try changing the number of neurons per layer, the number of layers, or the activation functions for each layer. What metric would you use for determining if the network was better?
178 | #
179 | # ### Exercise 2: Try other functions
180 | # Are some functions easier to model than others? What types of functions are the most difficult to model?
181 | 
182 | # +
183 | 
184 | modelBack = keras.models.Model(inputs=input_layer, outputs=Layer_2)
185 | modelBack.summary()
186 | backOut=modelBack.predict_on_batch(y_in)
187 | print("Input shape",np.shape(y_in))
188 | print("backOut shape",np.shape(backOut))
189 | 
190 | # +
191 | 
192 | colorList=plt.rcParams['axes.prop_cycle'].by_key()['color']
193 | fig, ax = plt.subplots(4,3,sharex=True) 
194 | # Remove vertical space between Axes
195 | fig.subplots_adjust(hspace=0)
196 | # Remove horizontal space between Axes
197 | fig.subplots_adjust(wspace=0)
198 | for i in range(len(backOut[0])):
199 |     j=i%3
200 |     k=i//3
201 |     ax[k,j].plot(y_in,backOut[:,i],label="Neuron "+str(i),color=colorList[i])
202 |     #ax[k,j].legend()
203 | ax[3,1].plot(y_in,y_out2,label="Model 2",color=colorList[0])
204 | ax[3,1].legend()
205 | ax[3,2].plot(y_in,target_func(y_in),label="Target",color=colorList[1])
206 | ax[3,2].legend()
207 | #ax.set_xlabel("x")
208 | #ax.set_ylabel("y")
209 | #ax.set_xlim([-20,20])
210 | #ax.axvspan(-20,-10,facecolor='lightgrey', alpha=0.5)
211 | #ax.axvspan(+10,+20,facecolor='lightgrey', alpha=0.5)
212 | #ax.legend()
213 | # -
214 | 
215 | 
216 | 


--------------------------------------------------------------------------------
/Week7/Week7_PolicyGradient.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # ---
  3 | # jupyter:
  4 | #   jupytext:
  5 | #     text_representation:
  6 | #       extension: .py
  7 | #       format_name: light
  8 | #       format_version: '1.5'
  9 | #       jupytext_version: 1.7.1
 10 | #   kernelspec:
 11 | #     display_name: Python 3
 12 | #     language: python
 13 | #     name: python3
 14 | # ---
 15 | 
 16 | # # Practical Machine Learning for Physicists
 17 | # ## Policy Gradient
 18 | #
 19 | # In this notebook we will introduce the policy gradient algorithm for learning the best policies to follow. So here we directly parameterise our policy in terms of some parameters $\theta$.
 20 | # $$ \pi_{\theta}(s,a) = \mathbb{P}\left[a | s, \theta\right] $$
 21 | #
 22 | #
 23 | # ### Policy Objective Function
 24 | # Then we define some policy objective function $J(\theta)$ which is a scalar measure of the policy performance. This could be either the *start value* (for step-wise problems) or the *average value* or the *average return*, these are (resepectively):
 25 | # $$J(\theta)=J_1(\theta) = V_{\pi_\theta}(s_1)=\mathbb{E}[v_1]$$
 26 | # $$J_{\text{avV}}(\theta) = \sum_s d_{\pi_\theta}(s) V_{\pi_\theta}(s)$$
 27 | # $$J_{\text{avR}}(\theta) = \sum_s d_{\pi_\theta}(s) \sum_a \pi_{\theta}(s,a) \mathcal{R}_{s,a}$$
 28 | # where $d_{\pi_\theta}(s)$ is the stationary distribution of Markov chains (i.e. it is the distribution of paths that can be followed).
 29 | #
 30 | # ### Policy Update
 31 | # We will use gradient descent to update our $theta$
 32 | # $$\theta_{t+1}=\theta_t + \alpha \nabla_\theta J(\theta_t)$$
 33 | #
 34 | # ### Score Function
 35 | # Let’s assume our policy $\pi_\theta (s,a)$ is differentiable and we know the gradient $\nabla_\theta \pi_\theta(s,a)$. Then we can write
 36 | # $$\nabla_\theta \pi_\theta(s,a) = \pi_\theta(s,a) \frac{\nabla_\theta \pi_\theta(s,a)}{\pi_\theta(s,a)}$$
 37 | # $$\nabla_\theta \pi_\theta(s,a)= \pi_\theta(s,a) \nabla_\theta \log \pi_\theta(s,a)$$
 38 | #
 39 | # The *score function* is defined as $\nabla_\theta \log \pi_\theta(s,a)$
 40 | #
 41 | # ## Policy Gradient Theorem
 42 | # For any differentiable policy $\pi_\theta (s,a)$ the policy gradient is given by
 43 | # $$\nabla_\theta J(\theta) = \mathbb{E}_{\pi_\theta} \left[ \nabla_\theta \log \pi_\theta (s,a) Q_{\pi_\theta}(s,a)\right]$$
 44 | #
 45 | # ## Reward Baseline
 46 | # Let's rewrite that last but instead subtract off a baseline value $B(s)$ from the reward in the policy gradient.
 47 | # $$\mathbb{E}_{\pi_\theta} \left[ \nabla_\theta \log \pi_\theta (s,a) B(s) \right] =  \sum_s d_{\pi_\theta}(s) \sum_a \nabla_\theta \pi_{\theta}(s,a) B(s)$$
 48 | # $$ = \sum_s d_{\pi_\theta}(s) B(s) \nabla_\theta \sum_a \pi_{\theta}(s,a)$$
 49 | # But $\sum_a \pi_{\theta}(s,a)=1$ and $\nabla_\theta (1)=0$ so
 50 | # $$\mathbb{E}_{\pi_\theta} \left[ \nabla_\theta \log \pi_\theta (s,a) B(s) \right] = 0$$
 51 | #
 52 | # Okay so we can subtract off a baseline, but why would we want. Because we can reduce the variance!
 53 | # Let's define
 54 | # $$X_k = (R -b_k) G_k$$
 55 | # where $R=Q_{\pi_\theta}(s,a)$, $b_k=B(s)$ and $G_k=\nabla_\theta \log \pi_\theta (s,a)$.
 56 | #
 57 | # Now the variance of $X_k$ is
 58 | # $$\textrm{Var}[X_k]=\mathbb{E}[X^2_k] - \mathbb{E}[X]^2$$
 59 | # we want to find the baseline that makes this a minimum so we want to set
 60 | # $$\frac{\partial \textrm{Var}[X_k]}{\partial b_k}=0$$
 61 | #
 62 | # The baseline that will achieve this is
 63 | # $$ b_k = \frac{\mathbb{E}[G^2_k R]}{\mathbb{E}[G^2_k]}$$
 64 | 
 65 | # ## Example 1: Up is good
 66 | # Let's define a simple environment where up is good. The return is given by the final position (e.g. the height) and obviously the optimal strategy would be to go up always.
 67 | #
 68 | # Now we can define a policy
 69 | # $$\pi_\theta(\text{up})= \frac{1}{1+e^{-\theta}}$$
 70 | # and obviously
 71 | # $$\pi_\theta(\text{down})= 1 - \pi_\theta(\text{up}) $$
 72 | #
 73 | # Let $x$ denote vertical position and define the return to simply be $\mathcal{R}(t)=x(t)$
 74 | #
 75 | # Now we can calculate $\nabla_\theta J(\theta)$:
 76 | # $$\nabla_\theta J(\theta) = \sum_t \left[ \nabla_\theta \log \pi_\theta (a_t) R(t)\right]$$
 77 | #
 78 | # Now 
 79 | # $$ \nabla_\theta \log \pi_\theta (a_t) = \frac{\partial \log \pi_\theta (a_t)}{\partial \theta} $$
 80 | # $$  \frac{\partial \log \pi_\theta (\text{up})}{\partial \theta} =  \frac{\partial \log \left( \frac{1}{1+e^{-\theta}}\right)}{\partial \theta}$$
 81 | # $$  \frac{\partial \log \pi_\theta (\text{up})}{\partial \theta} = \frac{e^{-\theta}}{1+e^{-\theta}} = e^{-\theta}  \pi_\theta (\text{up}) = 1 -\pi_\theta (\text{up}) $$
 82 | # $$  \frac{\partial \log \pi_\theta (\text{down})}{\partial \theta} =  -e^{-\theta}  \pi_\theta (\text{down}) = -(1-\pi_\theta (\text{down})) =   -\pi_\theta (\text{up})$$
 83 | # which gives
 84 | # $$ \sum_t \nabla_\theta \log \pi_\theta (a_t)  = N_{\text{up}} - N \pi_\theta (\text{up}) = N_{\text{up}} - \bar{N}_{\text{up}} $$
 85 | #
 86 | # The return is given by how many net up-steps we have taken
 87 | # $$ R=x(T)=N_{\text{up}}  - N_{\text{down}}  = 2 N_{\text{up}} -N $$
 88 | #
 89 | # Putting the two together gives:
 90 | # $$\nabla_\theta J(\theta) = 2 \mathbb{E} \left[( N_{\text{up}} - \frac{N}{2})( N_{\text{up}}-\bar{ N}_{\text{up}}) \right]$$
 91 | #
 92 | # We can simplify this a little
 93 | # $$\nabla_\theta J(\theta) = 2 \mathbb{E} \left[ \left( (N_{\text{up}} - \bar{ N}_{\text{up}}) + (\bar{ N}_{\text{up}} - \frac{N}{2}) \right) (N_{\text{up}} - \bar{ N}_{\text{up}}) \right] $$
 94 | #
 95 | # $$ =2 \mathrm{Var} \left[N_{\text{up}} \right] + 2(\bar{ N}_{\text{up}} - \frac{N}{2}) \mathbb{E}\left[N_{\text{up}} - \bar{ N}_{\text{up}}\right]$$
 96 | # Now the last term vanishes as
 97 | # $$\mathbb{E}\left[N_{\text{up}} - \bar{ N}_{\text{up}}\right] = \mathbb{E}\left[N_{\text{up}} \right] - \mathbb{E}\left[\bar{ N}_{\text{up}}\right] $$
 98 | # So
 99 | # $$= 2 \mathrm{Var} \left[N_{\text{up}} \right] = 2N \pi_\theta (\text{up}) (1 - \pi_\theta (\text{up})) $$
100 | #
101 | #
102 | 
103 | # +
104 | import numpy as np
105 | import matplotlib.pyplot as plt
106 | 
107 | import matplotlib
108 | matplotlib.rcParams['figure.dpi']=300 # highres display
109 | 
110 | 
111 | # +
112 | #Define probability for going up
113 | def probUp(theta):
114 |     return(1./(1+np.exp(-theta)))
115 | 
116 | 
117 | thetaArr=np.linspace(-5,5,100)
118 | fig,ax=plt.subplots()
119 | ax.plot(thetaArr,probUp(thetaArr))
120 | ax.set_xlabel(r"$\theta$")
121 | ax.set_ylabel("$P(up)$")
122 | # -
123 | 
124 | # #### Random Walk
125 | #
126 | 
127 | # +
128 | theta=0  #Starting theta
129 | steps=100  #Number of steps in random walk
130 | x=0 # Starting height
131 | randArr=np.random.rand(steps)  #Generate random numbers between 0-1
132 | boolArr=randArr>probUp(theta)  #Compare to the probUp probability
133 | stepArr=2*(boolArr-0.5) #Convert the boolArray into and array of -1 and +1
134 | xArr=np.append([0],np.cumsum(stepArr)) #Find the cumulative sum (and add a zero for the start)
135 | 
136 | fig,ax=plt.subplots()
137 | ax.plot(np.arange(steps+1),xArr)  # Plot steps vs cumulative sum
138 | ax.set_xlabel("Step")
139 | ax.set_ylabel("Reward or Height")
140 | ax.set_title(r"$\theta=$"+str(theta)+" Reward")
141 | 
142 | # -
143 | 
144 | # ## Training for a better $\theta$  -- No Baseline
145 | #
146 | 
147 | # +
148 | theta0=0  #Initial theta
149 | N=100  #Num points per step
150 | eta=0.001  #Learning rate
151 | steps=400  #Num steps in pot
152 | 
153 | fg,ax=plt.subplots()  #Get plot
154 | stepArr=np.arange(steps) #The numbers 0, steps-1
155 | 
156 | for loop in range(3):  #Do three separate loops
157 |     probArr=np.zeros(steps) # Get probArray filled with zeros
158 |     theta=theta0  # Set initial theta at the start of teh step
159 |     for i in range(steps):  #Loop over the steps
160 |         pup=probUp(theta)   #Get probability for up step
161 |         nup=np.random.binomial(N,pup) #Random number of up steps
162 |         nbar=N*pup  #Get expected number of up steps
163 |         update=2*(nup-N/2)*(nup-nbar)  #The update amount
164 |         theta=theta+eta*update # Do the update
165 |         probArr[i]=pup #Save for plotting
166 |     ax.plot(stepArr,probArr,label="Loop "+str(loop+1))
167 |         
168 | ax.set_xlabel("Step")
169 | ax.set_ylabel("$P(\text{up})$")
170 | ax.legend()
171 | # -
172 | 
173 | # As you can see from above there are large variations in the convergence rate. 
174 | #
175 | # Now each setp our update is (ignoring the learning rate and the factor of 2):
176 | # $$X = \left(N_{\text{up}} -\frac{N}{2}\right) \left(N_{\text{up}} - \bar{N}_{\text{up}} \right)$$
177 | #
178 | # So let's introudce a new variable $Y = N_{\text{up}} - \bar{N}_{\text{up}}$ and a constant $c=\bar{N}_{\text{up}} -\frac{N}{2}$
179 | # which let's us write
180 | # $$ X = \left(Y+c\right)Y$$
181 | # The advantage of $Y$ is that it is zero-meaned and we can use the higher central moments of binomial distribution to determine the mean and variance:
182 | # - Mean: 0
183 | # - Variance (2nd moment) $\mu_2 = N p (1 -p)$ 
184 | # - 3rd moment $\mu_3 = N p (1 -p) (1 - 2p) $
185 | # - Variance of variance (4th moment) $\mu_4 = N p (1 -p) \left[3 p^2(2-N) + 3p(N-2) +1 \right]$
186 | #
187 | # Expectation value of $X$,
188 | # $$\mathbb{E}[X] = \mathbb{E}[Y^2] + c \mathbb{E}[Y]= \mathbb{E}[Y^2]$$
189 | #
190 | # Variance of $X$
191 | # $$\mathrm{Var}[X] = \mathbb{E}[X^2] - \mathbb{E}[X]^2$$
192 | # $$\mathrm{Var}[X] = \mathbb{E}[Y^4] + 2 c \mathbb{E}[Y^3] + c^2 \mathbb{E}[Y^2] - \mathbb{E}[Y^2]^2$$
193 | #
194 | 
195 | N=100
196 | p=np.linspace(0,1,100)
197 | c=p*N-0.5*N
198 | mu2Arr=N*p*(1-p)
199 | mu3Arr=N*p*(1-p)*(1-2*p)
200 | mu4Arr=N*p*(1-p)*(1+(3*N-6)*p*(1-p))
201 | ExArr=mu2Arr
202 | VarArr=mu4Arr+2*c*mu3Arr+c*c*mu2Arr -mu2Arr*mu2Arr
203 | fig,ax=plt.subplots()
204 | ax.plot(p,2*ExArr,label="$E[X]$")
205 | ax.plot(p,2*np.sqrt(VarArr),label="$\sqrt{{Var}[X]}$")
206 | ax.legend()
207 | 
208 | # +
209 | #Let's verfiy that is what we see the brute force way
210 | N=100
211 | steps=1000
212 | tsteps=20
213 | pupArr=np.zeros(tsteps)
214 | meanArr=np.zeros(tsteps)
215 | stdArr=np.zeros(tsteps)
216 | thetaArr=np.linspace(-3,3,tsteps)
217 | 
218 | 
219 | ti=0
220 | for pup in np.linspace(0,1,tsteps):
221 |     nbar=N*pup
222 |     pupArr[ti]=pup
223 |     updates=np.zeros(steps)
224 |     for i in range(steps):    
225 |         nup=np.random.binomial(N,pup)
226 |         updates[i]=2*(nup-N/2)*(nup-nbar)
227 |     meanArr[ti]=(np.mean(updates))
228 |     stdArr[ti]=np.std(updates)
229 |     ti+=1
230 |     
231 | fig,ax=plt.subplots()
232 | ax.plot(pupArr,meanArr)
233 | ax.plot(pupArr,stdArr)
234 | 
235 | # -
236 | 
237 | # ## Optimal reward baseline subtraction
238 | # Let's form a new update statistic $X^\prime$ where we subtract off the optimal baseline
239 | # $$X^\prime = \left(Y+c-b\right)Y$$
240 | # where
241 | # $$ b = \frac{\mathbb{E}\left[Y^2 (Y+c) \right]}{\mathbb{E}\left[Y^2 \right]}$$
242 | 
243 | N=100
244 | p=np.linspace(1e-5,1-1e-5,100)
245 | c=p*N-0.5*N
246 | mu2Arr=N*p*(1-p)
247 | mu3Arr=N*p*(1-p)*(1-2*p)
248 | mu4Arr=N*p*(1-p)*(1+(3*N-6)*p*(1-p))
249 | b=(mu3Arr+c*mu2Arr)/mu2Arr
250 | ExArr=mu2Arr
251 | VarArr=mu4Arr+2*c*mu3Arr+c*c*mu2Arr -mu2Arr*mu2Arr
252 | VarPrimeArr=mu4Arr+2*(c-b)*mu3Arr+(c-b)*(c-b)*mu2Arr -mu2Arr*mu2Arr
253 | fig,ax=plt.subplots()
254 | ax.plot(p,ExArr,label="$E[X]$")
255 | ax.plot(p,np.sqrt(VarArr),label="$\sqrt{{Var}[X]}$")
256 | ax.plot(p,np.sqrt(VarPrimeArr),label="$\sqrt{{Var}[X^\prime]}$")
257 | ax.legend()
258 | 
259 | # # Suggested tasks
260 | # 1. Implement the optimal baseline improvement, does the algorithm with the optimal baseline converge quicker than the no-baseline results shown above
261 | 
262 | 
263 | 


--------------------------------------------------------------------------------
/Week4/Week4_ConvolutionalNeuralNetwork.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3
 11 | #     name: python3
 12 | # ---
 13 | 
 14 | # + [markdown] id="view-in-github" colab_type="text"
 15 | # <a href="https://colab.research.google.com/github/nichol77/mlForPhysicists/blob/master/Week4/Week4_ConvolutionalNeuralNetwork.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
 16 | 
 17 | # + [markdown] id="H95srAmCvbMJ"
 18 | # # Convolutional Neural Networks
 19 | #
 20 | # Convolutional neural networks have become some of the most widely used networks in the field of image recognition. In this notebook we will briefly illustrate the main features of convolutional neural networks.
 21 | #
 22 | # ## What is a convolutional neural network?
 23 | #
 24 | # Simply put a convolutional neural network is any neural network that contains at least convolutional layer.
 25 | #
 26 | # ## Okay, so what is a convolutional layer?
 27 | #
 28 | # A convolutional layer is a layer in which a convolutional filter passes along an input matrix.
 29 | #
 30 | # ### Okay, so what is a convolutional filter?
 31 | #
 32 | # A convolutional filter is a matrix which is smaller than the input matrix matrix. This matrix is convolved with the input matrix as part of the convolutional layer. Perhaps this is best illustrated by an example, imagine we have a $5\times5$ input matrix:
 33 | #
 34 | # $$\begin{bmatrix} 1 & 2 & 1 & 4 & 3\\ 3 & 0 & 1 & 2 & 5 \\ 0 & 2 & 4 & 0 & 0 \\ 0 & 1 & 2 & 1 & 0 \\ 1 & 3 &4 & 6 & 2 \end{bmatrix}$$
 35 | #
 36 | # Now we can create our convoluitonal filter (which must be smaller than $5\times5$), so lets pick a $2\times2$ matrix
 37 | # $$\begin{bmatrix} 0 & 1 \\ -1 & 0 \end{bmatrix}$$
 38 | #
 39 | # This filter is convolved with the input matrix which involves:
 40 | # 1. Slicing the input matrix into $2\times2$ (to match the filter size) sub matrices
 41 | # 2. For each sub-matrix calculating the convolution with the filter by
 42 | #     1. Element-wise multiplication
 43 | #     2. Summation of the results
 44 | #
 45 | # So let's take the first $2\times2$ sub matrix of the input matrix as the top-left corner of the $5\times5$ matrix.
 46 | # $$\begin{bmatrix} 1 & 2 \\ 3 & 0 \end{bmatrix}$$
 47 | # we now need to do the element-wise multiplication and summing of this sub matrix with the filter:
 48 | # $$\begin{bmatrix} 1 & 2 \\ 3 & 0 \end{bmatrix} \times \begin{bmatrix} 0 & 1 \\ -1 & 0 \end{bmatrix} \rightarrow \begin{bmatrix} 0 & 2 \\ -3 & 0 \end{bmatrix} = 0 + 2 -3 + 0 = -1$$
 49 | #
 50 | # Then we can slide this filter across the input matrix to create an output matrix (at this point one has to decide how we are going to handle the edge cases, here we will let our $5\times5$ matrix reduce to a $4\times4$ matrix).
 51 | # $$\begin{bmatrix} -1 & 1 & 3 & 1 \\ 0 & -1 & -2 & 5 \\ 2 & 3 & -2 & -1 \\ 0 & -1 & -3 & -6 \end{bmatrix}$$
 52 | #
 53 | # ## What is so great about convolutional networks?
 54 | #
 55 | # Convolutional networks are very simple, they are just a different kind of layer in neural network where each neuron in the layer effectively is effectively one of the output pixels in our output matrix. Each one of those neurons is only connected to the number of input pixels corresponding to the filter size (in our example above $2\times2=4$ input values).
 56 | #
 57 | # It is just a neural network with fewer connections than a fully connected network! So why are people using this in almost all image recognition tasks?
 58 | #
 59 | # It turns out that convolutional neural networks have one very important feature for image processing tasks. Becasue the convolutional filter (also called a kernel) slides across the image it means that if the filter encounters a particular sub-matrix pattern it gives the same result. That is the convolutional layer is inherently translation invariant. So no matter where in your image the straight line or circle lies an appropriate convolutional filter will pick out these features.
 60 | #
 61 | # The other very important feature is that a convolutional network only has weights for each pixel in its kernel (so for a $4\times4$ kernel that would be 16 weights) and the number of weights is independent on the image size.
 62 | #
 63 | #
 64 | #
 65 | 
 66 | # + [markdown] id="vtakip7xvbMO"
 67 | # ## Our first convolutional neural network
 68 | 
 69 | # + id="E8pDBc0EvbMO" outputId="3afbdd14-09ba-4205-d68d-76fd74a82e4a" colab={"base_uri": "https://localhost:8080/"}
 70 | import matplotlib.pyplot as plt
 71 | import numpy as np
 72 | import math
 73 | 
 74 | # TensorFlow and tf.keras
 75 | import tensorflow as tf
 76 | from tensorflow import keras
 77 | 
 78 | import matplotlib.style #Some style nonsense
 79 | import matplotlib as mpl #Some more style nonsense
 80 | 
 81 | 
 82 | #Set default figure size
 83 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 84 | mpl.rcParams["legend.frameon"] = False
 85 | mpl.rcParams['figure.dpi']=200 # dots per inch
 86 | 
 87 | #Useful for debugging problems
 88 | print(tf.__version__)
 89 | 
 90 | # + [markdown] id="QLb0iMeJvbMQ"
 91 | # ### For this example we are going to download the CIFAR10 dataset (which has hooks built in to Keras)
 92 | # Much of this code was heavily inspired by the Tensorflow convolutional neural network tutorial.
 93 | # https://www.tensorflow.org/tutorials/images/cnn
 94 | 
 95 | # + id="BpZaY_jyvbMQ" outputId="1faa971a-cb4c-49b1-bdbe-641082fdf164" colab={"base_uri": "https://localhost:8080/"}
 96 | (train_images, train_labels), (test_images, test_labels) = keras.datasets.cifar10.load_data()
 97 | 
 98 | # Normalize pixel values to be between 0 and 1
 99 | train_images, test_images = train_images / 255.0, test_images / 255.0
100 | 
101 | # + [markdown] id="mJ5MRB7uvbMQ"
102 | # ### Does the data look correct?
103 | # The training dataset comprises of 60,000 images of things like airplanes, trucks, frogs. Here we will plot the first 25 images in the training dataset to see what kind of images we are going to be training our network on.
104 | 
105 | # + id="DUNquThkvbMQ" outputId="b69dd3ea-8694-4334-f5e0-b1d6032bcd11" colab={"base_uri": "https://localhost:8080/", "height": 1000}
106 | class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
107 |                'dog', 'frog', 'horse', 'ship', 'truck']
108 | 
109 | plt.figure(figsize=(10,10))
110 | for i in range(25):
111 |     plt.subplot(5,5,i+1)
112 |     plt.xticks([])
113 |     plt.yticks([])
114 |     plt.grid(False)
115 |     plt.imshow(train_images[i], cmap=plt.cm.binary)
116 |     # The CIFAR labels happen to be arrays,
117 |     # which is why you need the extra index
118 |     plt.xlabel(class_names[train_labels[i][0]])
119 | plt.show()
120 | 
121 | # + [markdown] id="aWamMwN2vbMQ"
122 | # ## Let's make a convolutional neural network
123 | #
124 | # In the six lines of code below we define our convolutional neural network. The network is just a stack of `Conv2D` and `MaxPooling2D` layers. The `Conv2D` layer does the convolution (as you might expect) whilst the `MaxPooling2D` layer just downsamples the image by taking the maximum from a group of pixels (in this case the maximum of each $2\times 2$ pixel subset).
125 | #
126 | # If you look at the first layer we define the input shape to be $(32, 32, 3)$ which corresponds to $32 \times 32$ pixels in each image and three colours in each image (red, green and blue).
127 | #
128 | 
129 | # + id="sFq2UtqavbMR"
130 | model = keras.models.Sequential()
131 | model.add(keras.layers.Input(shape=(32, 32, 3)))
132 | model.add(keras.layers.Conv2D(32, (3, 3), activation='relu'))
133 | model.add(keras.layers.MaxPooling2D((2, 2)))
134 | model.add(keras.layers.Conv2D(64, (3, 3), activation='relu'))
135 | model.add(keras.layers.MaxPooling2D((2, 2)))
136 | model.add(keras.layers.Conv2D(64, (3, 3), activation='relu'))
137 | 
138 | # + [markdown] id="3PlDe31YvbMR"
139 | # Let's display our network architechture so far
140 | 
141 | # + id="GZDLNj_ivbMR" outputId="ff9aba5f-109a-4be2-d881-b7c91e827d31" colab={"base_uri": "https://localhost:8080/", "height": 309}
142 | model.summary()
143 | 
144 | 
145 | # + [markdown] id="Woy2XmGBvbMR"
146 | # You'll notice as the model progresses we move from having $32 \times 32 \times 3$ numbers representing each image in the input to having fewer pixels in each subsequent layer $30 \times 30$ (2 pixels lost in each dimension due to using a $3 \times 3$ convolution filter) then $15 \times 15$ then $13 \times 13$ then $6 \times 6$ then $4 \times 4$. But as we go through the image we increase the number of channels from $3$ in the input image to $32$ and finally $64$. These two go hand in hand with smaller pixel maps we can computationally afford to have more of them.
147 | 
148 | # + [markdown] id="Mle5NrP9vbMR"
149 | # ### Generating an output layer
150 | # Finally we need to add some layers to our networks to allow us to do some image classification. So we will need to end up with a network that can produce something which can be compared to the 10 labels.
151 | #
152 | # So we will add a layer that will flatten the three-dimensional $(4,4,64)$ output layer of the last convolution to make a one-dimensional layer of length 1024. Then we will add two fully connected (Dense) layers and end up with a layer of output size 10 that can be compared with our 10 image labels.
153 | 
154 | # + id="sD52vj7lvbMR"
155 | model.add(keras.layers.Flatten())
156 | model.add(keras.layers.Dense(64, activation='relu'))
157 | model.add(keras.layers.Dense(10))
158 | 
159 | # + [markdown] id="Clqijm40vbMS"
160 | # So our full network looks like this.
161 | 
162 | # + id="q-MMlWzSvbMT" outputId="1c67e586-221c-4b77-f3a4-8c7fc39ff2ba" colab={"base_uri": "https://localhost:8080/", "height": 405}
163 | model.summary()
164 | 
165 | 
166 | # + [markdown] id="j4suS7WSvbMT"
167 | # ### Time to train
168 | # The two steps remaining in the training are compiling our model and then fitting it to the training data
169 | #
170 | # ## Tips
171 | # * Make sure you understand what the `from_logits=True` part of the loss function means.
172 | # * What does the `accuracy` metric calculate?
173 | #
174 | 
175 | # + id="9FxpYanvvbMU" outputId="6fa211a9-9831-4aee-9464-0ae4f3dee765" colab={"base_uri": "https://localhost:8080/"}
176 | model.compile(optimizer='adam',
177 |               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
178 |               metrics=['accuracy'])
179 | 
180 | history = model.fit(train_images, train_labels, epochs=10,
181 |                     validation_data=(test_images, test_labels))
182 | 
183 | # + [markdown] id="pdEJpEy3vbMU"
184 | # ### Evaluate model performance
185 | 
186 | # + id="PE52vAM4vbMU" outputId="40a4b457-969c-40d0-8916-0f0425819970" colab={"base_uri": "https://localhost:8080/", "height": 893}
187 | 
188 | 
189 | plt.plot(history.history['accuracy'], label='accuracy')
190 | plt.plot(history.history['val_accuracy'], label = 'val_accuracy')
191 | plt.xlabel('Epoch')
192 | plt.ylabel('Accuracy')
193 | plt.ylim([0.5, 1])
194 | plt.legend(loc='lower right')
195 | 
196 | test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
197 | 
198 | # + [markdown] jp-MarkdownHeadingCollapsed=true id="arT2RrtLvbMV"
199 | # ### Summary
200 | # So our model got to achieve an accuracy of 77.9% on the training dataset, but only 70.6% on the validation (test) data set. As the training and testing accuracies diverge a little you can see we have clearly overfitted our model to the training data set. We will come back to this topic again in the course.
201 | #
202 | # ### Suggested tasks
203 | # * How much better can you do in terms of validation accuracy?
204 | # * How would you quantify the performance of the model?
205 | # * Is the performance of the model the same for every label?
206 | # * Can you produce a confusion matrix for the model?
207 | 
208 | # + id="opQD3DHIvbMV"
209 | 
210 | 


--------------------------------------------------------------------------------
/Week2/Week2_ChatGPT_NN.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # ChatGPT
 16 | #
 17 | # You might have seen the news reports in December about this new machine learning tool from a company called OpenAI, the tool is [ChatGPT](https://openai.com/blog/chatgpt/).
 18 | #
 19 | # ## Here is what I got when I asked ChatGPT to make me a neural network without usingh Keras, TensorFlow or PyTorch 
 20 | #
 21 | # I asked:
 22 | # > Can you write code for neural network without using keras or PyTorch or tensorflow or any other prepackaged code?
 23 | #
 24 | # ChatGPT replied:
 25 | # >Certainly! Here is an example of how you can build a simple neural network from scratch in Python using only NumPy, a popular numerical computing library. This network will have a single hidden layer with three units, and an output layer with a single unit. We will use the sigmoid activation function for the hidden layer and the unit step function for the output layer.
 26 | #
 27 | #
 28 | #
 29 | 
 30 | # +
 31 | import numpy as np
 32 | 
 33 | class NeuralNetwork:
 34 |     def __init__(self, input_size, hidden_size, output_size):
 35 |         # initialize weights randomly with mean 0
 36 |         self.W1 = np.random.randn(input_size, hidden_size)
 37 |         self.W2 = np.random.randn(hidden_size, output_size)
 38 | 
 39 |     def sigmoid(self, x):
 40 |         return 1 / (1 + np.exp(-x))
 41 | 
 42 |     def forward(self, X):
 43 |         # forward propagation through our network
 44 |         self.z = np.dot(X, self.W1)
 45 |         self.a = self.sigmoid(self.z)
 46 |         self.z2 = np.dot(self.a, self.W2)
 47 |         y_hat = self.sigmoid(self.z2)
 48 |         return y_hat
 49 | 
 50 | # create a neural network
 51 | network = NeuralNetwork(2, 3, 1)
 52 | 
 53 | # input data
 54 | X = np.array([[1, 2], [3, 4], [5, 6]])
 55 | 
 56 | # make predictions
 57 | predictions = network.forward(X)
 58 | print(predictions)
 59 | 
 60 | # -
 61 | 
 62 | # ChatGPT describes the code like this (but with better formatting):
 63 | # > This code defines a NeuralNetwork class with three methods: __init__, sigmoid, and forward. The __init__ method is the constructor of the class and is called when you create a new instance of the class. It initializes the weights W1 and W2 of the network randomly with mean 0. The sigmoid method defines the sigmoid activation function, which takes a matrix of activations x and returns the sigmoid of x. The forward method implements the forward propagation of the network, which involves performing a dot product of the input data X with the weights W1, applying the sigmoid activation function to the result, performing a dot product of the activations with the weights W2, and applying the sigmoid activation function to the final result.
 64 | #
 65 | # > I hope this helps! Let me know if you have any questions.
 66 | 
 67 | # +
 68 | # Now lets plot our network
 69 | print("X.shape",X.shape)
 70 | print("predictions.shape",predictions.shape)
 71 | x1=np.linspace(0,10,50)
 72 | x2=np.linspace(0,10,50)
 73 | x1v, x2v = np.meshgrid(x1, x2)
 74 | 
 75 | #x1v and x2v are 2-D arrays where each columnin x1v haveing the same value and each row in x2v having the same value
 76 | x1flat=x1v.flatten()  #Flatten the 50x50 2-D array into a 2500 element 1d array
 77 | x2flat=x2v.flatten()
 78 | Nparallel=np.shape(x1flat)[0]  #This is a numpy way of getting the length of the first dimension of an array
 79 | print(np.shape(x1flat))  #Just calling np.shape returns a tuple
 80 | print("Nparallel:",Nparallel) #But the first element of that tuple is the length
 81 | xTest=np.zeros((Nparallel,2)) # Now need to create the input, which will need to have a shape which is (2500,2)
 82 | xTest[:,0]=x1flat # fill first component (index 0)
 83 | xTest[:,1]=x2flat # fill second component
 84 | print("np.shape(xTest):",np.shape(xTest))
 85 | 
 86 | 
 87 | # +
 88 | #Now we can evaluate our network on all 2500 pairs of x1 and x2 in parallel
 89 | z=network.forward(xTest)
 90 | print("z.shape:",np.shape(z))
 91 | 
 92 | 
 93 | #Now to plot it
 94 | #So now we will have our first bit of code
 95 | import numpy as np  #import the numpy library as np
 96 | import matplotlib.pyplot as plt #import the pyplot library as plt
 97 | import matplotlib.style #Some style nonsense
 98 | import matplotlib as mpl #Some more style nonsense
 99 | 
100 | #Set default figure size
101 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
102 | mpl.rcParams["legend.frameon"] = False
103 | mpl.rcParams['figure.dpi']=150 # dots per inch
104 | 
105 | z2d=z.reshape((len(x1),len(x2)))  #Reshape the 2500,1 array into one which is 50x50
106 | #Now plot the results
107 | fig, ax = plt.subplots() #Get the fig and ax objects for the plot 
108 | im=ax.matshow(z2d,origin='lower',extent=(0,10,0,10)) #Plot the output z as a colormap with the origin in the bottom left
109 | cb = fig.colorbar(im) #Get the colorbar for the range of z values
110 | ax.xaxis.set_ticks_position('bottom') #Move the x-axis to the bottom (personal preference)
111 | ax.set_title('Network Output') #Give our plot some title
112 | ax.set_xlabel("x_1") #Slightly uninteresting labels
113 | ax.set_ylabel("x_2")
114 | # -
115 | 
116 | # # Network training
117 | # Next I asked ChatGPT about how to train a network and got the following code and description.
118 | #
119 | # > To train a neural network, you need to minimize the error between the predicted outputs and the true labels. One way to do this is through backpropagation, which is an algorithm that adjusts the weights of the network in order to reduce the error.
120 | #
121 | # > Here is an example of how you can modify the NeuralNetwork class to include a method for backpropagation:
122 | 
123 | # +
124 | import numpy as np
125 | 
126 | class NeuralNetwork:
127 |     def __init__(self, input_size, hidden_size, output_size):
128 |         # initialize weights randomly with mean 0
129 |         self.W1 = np.random.randn(input_size, hidden_size)
130 |         self.W2 = np.random.randn(hidden_size, output_size)
131 | 
132 |     def sigmoid(self, x):
133 |         return 1 / (1 + np.exp(-x))
134 | 
135 |     def forward(self, X):
136 |         # forward propagation through our network
137 |         self.z = np.dot(X, self.W1)
138 |         self.a = self.sigmoid(self.z)
139 |         self.z2 = np.dot(self.a, self.W2)
140 |         y_hat = self.sigmoid(self.z2)
141 |         return y_hat
142 | 
143 |     def sigmoid_derivative(self, x):
144 |         # derivative of sigmoid function
145 |         return x * (1 - x)
146 | 
147 |     def train(self, X, y, epochs):
148 |         for epoch in range(epochs):
149 |             # forward propagation
150 |             y_hat = self.forward(X)
151 | 
152 |             # compute loss
153 |             loss = y - y_hat
154 | 
155 |             # backpropagation
156 |             d_W2 = np.dot(self.a.T, loss * self.sigmoid_derivative(y_hat))
157 |             d_W1 = np.dot(X.T, np.dot(loss * self.sigmoid_derivative(y_hat), self.W2.T) * self.sigmoid_derivative(self.a))
158 | 
159 |             # update weights
160 |             self.W1 += d_W1
161 |             self.W2 += d_W2
162 | 
163 | 
164 | 
165 | # -
166 | 
167 | # > The train method takes as input the training data X, the labels y, and the number of epochs to train for. An epoch is a complete pass through the training data. During each epoch, the method performs forward propagation to make predictions, computes the loss between the predictions and the labels, and performs backpropagation to adjust the weights of the network. The weights are updated using the gradient descent algorithm, which adjusts the weights in the direction that minimizes the loss.
168 | #
169 | # > To train the network, you can call the train method and pass in your training data and labels:
170 | #
171 | #
172 | 
173 | # +
174 | # input data
175 | X = np.array([[1, 2], [3, 4], [5, 6]])
176 | y = np.array([[0], [1], [1]])
177 | 
178 | # create a neural network
179 | network = NeuralNetwork(2, 3, 1)
180 | 
181 | # train the network
182 | network.train(X, y, epochs=10000)
183 | 
184 | 
185 | # +
186 | #Now we can evaluate our network on all 2500 pairs of x1 and x2 in parallel
187 | z=network.forward(xTest)
188 | print("z.shape:",np.shape(z))
189 | 
190 | 
191 | #Now to plot it
192 | #So now we will have our first bit of code
193 | import numpy as np  #import the numpy library as np
194 | import matplotlib.pyplot as plt #import the pyplot library as plt
195 | import matplotlib.style #Some style nonsense
196 | import matplotlib as mpl #Some more style nonsense
197 | 
198 | #Set default figure size
199 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
200 | mpl.rcParams["legend.frameon"] = False
201 | mpl.rcParams['figure.dpi']=150 # dots per inch
202 | 
203 | z2d=z.reshape((len(x1),len(x2)))  #Reshape the 2500,1 array into one which is 50x50
204 | #Now plot the results
205 | fig, ax = plt.subplots() #Get the fig and ax objects for the plot 
206 | im=ax.matshow(z2d,origin='lower',extent=(0,10,0,10)) #Plot the output z as a colormap with the origin in the bottom left
207 | cb = fig.colorbar(im) #Get the colorbar for the range of z values
208 | ax.xaxis.set_ticks_position('bottom') #Move the x-axis to the bottom (personal preference)
209 | ax.set_title('Network Output') #Give our plot some title
210 | ax.set_xlabel("x_1") #Slightly uninteresting labels
211 | ax.set_ylabel("x_2")
212 | # -
213 | 
214 | # ## What were you expecting this to look like?
215 | #
216 | # Why do we end up with this rather dull looking thing once we have 'trained' our network? It is because we have only trained the network with 3 pieces of information. The input point we gave earlier was:
217 | # ```
218 | # # input data
219 | # X = np.array([[1, 2], [3, 4], [5, 6]])
220 | # y = np.array([[0], [1], [1]])
221 | # ```
222 | #
223 | # So in terms of $x_1$ and $x_2$ we have only defined the output at 3 points:
224 | # ```
225 | # (1,2) == 0
226 | # (3,4) == 1
227 | # (5,6) == 1
228 | # ```
229 | #
230 | # This means at least two things:
231 | #    1. We are not giving our network very much information about the shape we wantin the $x_1$,$x_2$ 2D-plane.
232 | #    2. Each loop we are giving it the same information... so this is not going to be a very quick or productive training.
233 | 
234 | # +
235 | # What is the training doing?
236 | # Let's start with a new blank network
237 | network2 = NeuralNetwork(2, 3, 1)
238 | 
239 | #Now we can evaluate how close this network comes to our desired output [0,1,1]
240 | # Each time we run the above line we create a new network2 object with different random numbers
241 | y_hat = network2.forward(X)
242 | print(y_hat)
243 | 
244 | 
245 | # +
246 | # But to train we want to run over the same network many times
247 | Nepoch=10000
248 | # Let's create a temporary array for storing the values of the 'loss' which is how far away our network is from what we want it to be
249 | losses=np.zeros([Nepoch+1,3])
250 | 
251 | #Calculate the initial loss
252 | loss=y-network2.forward(X)
253 | print(loss)
254 | # Put it at the start of the loss array
255 | losses[0]=loss.reshape(3)
256 | 
257 | #We've moved the loop over epochs outside the train function so we can easily capture the loss values
258 | for epoch in range(Nepoch):
259 |     network2.train(X, y, epochs=1) #One training epoch at a time
260 |     loss=y-network2.forward(X) #The loss is always got the same way but after each step in training the network will give different outputs
261 |     losses[epoch+1]=loss.reshape(3) #Need to reshape from 3x1 to just 3 to fill the array
262 |     
263 | 
264 | # -
265 | 
266 | #Now let's plot the 3 componets of the losses
267 | fig, ax = plt.subplots() #Get the fig and ax objects for the plot 
268 | ax.plot(range(Nepoch+1),losses)
269 | ax.set_xlabel("Epoch Number")
270 | ax.set_ylabel("Loss (Target - Network Output)")
271 | 
272 | 
273 | 


--------------------------------------------------------------------------------
/Week3/Week3_MNIST_TF.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Introduction to TensorFlow and Keras
 16 | # ## The MNIST dataset
 17 | # In this notebook we will introduce you to TensorFlow and Keras and we will demonstrate classification of one of the 'classic' datasets the MNIST handwritten digits.
 18 | #
 19 | 
 20 | # +
 21 | import matplotlib.pyplot as plt
 22 | import numpy as np
 23 | import math
 24 | 
 25 | # TensorFlow and tf.keras
 26 | import tensorflow as tf
 27 | from tensorflow import keras
 28 | 
 29 | import matplotlib.style #Some style nonsense
 30 | import matplotlib as mpl #Some more style nonsense
 31 | 
 32 | 
 33 | #Set default figure size
 34 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 35 | mpl.rcParams["legend.frameon"] = False
 36 | mpl.rcParams['figure.dpi']=200 # dots per inch
 37 | 
 38 | #Useful for debugging problems
 39 | print(tf.__version__)
 40 | # -
 41 | 
 42 | # ## Load the MNIST dataset
 43 | #
 44 | # The Keras library comes with a number of builtin datasets. One of which is the MNIST library of handwritten digits
 45 | 
 46 | mnist = keras.datasets.mnist   #The original handwritten digit MNIST
 47 | #mnist = keras.datasets.fashion_mnist   #A tricky version that uses images of fashion items
 48 | (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
 49 | 
 50 | # ### Play with the data
 51 | # The training library consists of 60,000 images and each image is 28x28 pixels. There are 60,000 labels to go with the images. Each label is one of the digits (0:9).
 52 | 
 53 | print("Shape of training images:",train_images.shape)
 54 | print("Length of training set labels:",len(train_labels))
 55 | print("First label:",train_labels[0])
 56 | print("Shape of testing images:",test_images.shape)
 57 | print("Length of testing set labels:",len(test_labels))
 58 | 
 59 | # ### Plot an image
 60 | #
 61 | # Each image pixel has a value ranging from 0-255. When we come to do the processing we will rescale these inputs to the range 0-1.
 62 | 
 63 | plt.imshow(train_images[0])
 64 | plt.colorbar()
 65 | 
 66 | train_images=train_images/255.0
 67 | test_images=test_images/255.0
 68 | 
 69 | 
 70 | def display_image_array(whichImg):    
 71 |     numcols=int(math.sqrt(len(whichImg)))
 72 |     if numcols*numcols < len(whichImg):
 73 |         numcols=numcols+1
 74 |     BigImage=np.zeros([28*numcols,28*numcols])
 75 |     for j in range(len(whichImg)):
 76 |         x=(j%numcols)*28
 77 |         y=int(j/numcols)*28
 78 |         BigImage[x:x+28,y:y+28]=train_images[whichImg[j]]
 79 |     plt.imshow(BigImage,interpolation='nearest', cmap='binary')
 80 |     plt.axis('off')
 81 |     plt.show()
 82 | 
 83 | 
 84 | # +
 85 | whichImg=range(64)
 86 | display_image_array(whichImg)
 87 | 
 88 | #If you decide to use the fashion MNIST data set at some stage you will want to know the
 89 | # mapping from 0-9 to item of fashion
 90 | #class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
 91 | #               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
 92 | # -
 93 | 
 94 | # ## Building our neural network
 95 | #
 96 | # Now we will use Keras to build our neural network. 
 97 | #
 98 | # ### Set up the layers
 99 | #
100 | # A neural network is made up of layers and in the simple case these layers are applied sequentially.
101 | 
102 | model = keras.Sequential([
103 |     keras.layers.Input(shape=(28,28)),
104 |     keras.layers.Flatten(),
105 |     keras.layers.Dense(128,activation='relu'),
106 |     keras.layers.Dense(10)
107 | ])
108 | 
109 | # This model has three layers:
110 | # 1. The first layer simply 'flattens' our 28x28 pixel image into a 1-dimensional array of length 784 (=28x28). (Despite all the fancy features most neural networks are at heart one-dimensional in temrs of input*** of course higher dimensionality can always be squesihed down to a larger single dimension). This layer has no paramters.
111 | # 2. The second layer is fully connected (or *dense*) layer with 128 nodes. This layer has parameters.
112 | # 3. The third layer is the output layer and has 10 nodes which correspond to the digits 0:9. This layer has parameters.
113 | 
114 | # ## From layers to a compiled model
115 | #
116 | # Before we can train the model we need to determine the:
117 | # - *Loss function* - This is used to tell us how well our model is doing in
118 | # - *Optimiser* - This is how the model gets updated based on the data and the loss function
119 | # - *Metrics* - Used to monitor the training and testing steps. The following example uses *accuracy*, the fraction of the images that are correctly classified.
120 | 
121 | model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer=tf.keras.optimizers.SGD(learning_rate=1.0),
122 |               metrics=['accuracy'])
123 | 
124 | # ## Train the model
125 | # To train the model we need to show the training data to the model. In our case the training data is the `train_images` and `train_labels` arrays. The model will hopefully *learn* how to associate the images and the labels.
126 | #
127 | # ### Fitting the model to the data
128 | # The training process is also called fitting the model to the data (for obvious reasons). The Keras syntax for fitting the model uses `model.fit`
129 | 
130 | history=model.fit(train_images, train_labels,batch_size=100, epochs=30)
131 | 
132 | # In the above output you can see that the model improves the loss (this number gets smaller) and accuracy (this number gets bigger) with each epoch. But doing well on the training data set is a bit like marking your own homework. A fairer test is to evaluate the performance on the testing data set (which the model has not seen).
133 | 
134 | # ### Testing the performance
135 | 
136 | # +
137 | print(np.shape(test_images))
138 | test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
139 | 
140 | #print('\nTest accuracy:', test_acc)
141 | # -
142 | 
143 | # So when I ran this I found a accuracy on the training dataset of 98.11% but the accuracy on the testing datset was 97.10%. Perfroming better on the training than testing datset is an indication of overfitting (which will be dicussed in more detail later in the course).
144 | 
145 | # ## Predictions with probabilities
146 | # With our trained model we can now start trying to interogate the output probabilistically. We will make a new model with a *softmax* later to convert the linear outputs, [logits](https://developers.google.com/machine-learning/glossary#logits), to probabilities. N.B, We could have obtained the same by adding *softmax* activiation to the output layer in the original model definition. The *softmax* function is effectively taking an exponentiated unit function. So if the $i$th element of the *softmax* function $\sigma(x)$ is $$ \sigma(x)_i = \frac{e^{x_i}}{\sum_i e^{x_i}} $$
147 | #
148 | 
149 | prob_model=tf.keras.Sequential([model,tf.keras.layers.Softmax()])
150 | 
151 | 
152 | #This function tests a range of the test images and returns an array of the predicted values
153 | #and the associate probabilities for those predictions
154 | def test_range(start,stop,dontprint=False):
155 |     global test_images, test_labels
156 |     global prob_model
157 |     #Get an array of the predicted probabilities for each image in the range start-stop (not inclusive)
158 |     predictions_probs=prob_model.predict(test_images[start:stop,:]) 
159 |     #Find the biggest probability for each image (the index of the array matches the numbers for the MNIST)
160 |     #axis =1 tells np.argmax which axis to loop over
161 |     predictions=np.argmax(predictions_probs,axis=1)
162 |     #Optional printing
163 |     if dontprint==False:
164 |         print("Predictions: ", predictions)
165 |     true_labels=test_labels[start:stop]
166 |     if dontprint==False:
167 |         print("True labels: ", true_labels)
168 |     if dontprint==False:
169 |         print("Prediction Probabilities: ", predictions_probs)
170 |     #
171 |     return (predictions,predictions_probs)
172 | 
173 | 
174 | #Demonstrate the test_range function
175 | _ = test_range(0,2)
176 | 
177 | 
178 | # The output of the test_range function is the list of predicted and true labels for the range. For each prediction the associated probability array is also printed.
179 | 
180 | #This function shows the first maxnum mistakes in the testing dataset
181 | def display_mistakes(maxnum):
182 |     global test_images, test_labels
183 |     (predictions, predictions_probs)=test_range(0,len(test_labels),dontprint=True)
184 |     diff=test_labels-predictions
185 |     count=0
186 |     for j in range(len(test_labels)):
187 |         if diff[j]!=0:
188 |             if count<maxnum:
189 |                 count=count+1
190 |                 plt.imshow(test_images[j],interpolation='nearest', cmap='binary')
191 |                 plt.show()
192 |                 print("True ", test_labels[j], " - Predicted ", predictions[j], " with prob. ", predictions_probs[j,predictions[j]])
193 |         
194 | 
195 | 
196 | display_mistakes(10)
197 | 
198 | # ## Interrograting the training
199 | # `keras.fit` returns a hitsory object that contains the evolution of the loss an accuracry metrics as a function of epoch. This allows us to see how quickly the fitting process is converging.
200 | 
201 | # fig,ax=plt.subplots()
202 | # ax.plot(history.history['loss'], linewidth=3)
203 | # ax.set_xlabel("Epoch")
204 | # ax.set_ylabel("Loss")
205 | 
206 | fig,ax=plt.subplots()
207 | ax.plot(history.history['accuracy'], linewidth=3)
208 | ax.set_xlabel("Epoch")
209 | ax.set_ylabel("Accuracy")
210 | 
211 | # ## Training, Validation and Testing
212 | # Now we are going to break up the training data into a training and validation sub-sample to provide epoch-by-epoch performance monitoring
213 | 
214 | mnist = keras.datasets.mnist   #The original handwritten digit MNIST
215 | #mnist = keras.datasets.fashion_mnist   #A tricky version that uses images of fashion items
216 | (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
217 | train_images=train_images/255.0  #See how big an effect the normalisation has by commenting out
218 | test_images=test_images/255.0
219 | (valid_images,valid_labels)=(train_images[50000:],train_labels[50000:])
220 | (train_images,train_labels)=(train_images[:50000],train_labels[:50000])
221 | print(np.shape(valid_images))
222 | print(np.shape(train_images))
223 | print(np.shape(train_labels))
224 | print(np.shape(test_images))
225 | 
226 | # +
227 | model = keras.Sequential([
228 |     keras.layers.Flatten(input_shape=(28,28)),
229 |     keras.layers.Dense(32,activation='relu'),
230 | #    keras.layers.Dropout(0.2),
231 |     keras.layers.Dense(10)
232 | ])
233 | 
234 | model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), optimizer=tf.keras.optimizers.SGD(learning_rate=1.0),
235 |               metrics=['accuracy'])
236 | # -
237 | 
238 | history=model.fit(train_images, train_labels,batch_size=100, epochs=200, validation_data=(valid_images, valid_labels))
239 | 
240 | # +
241 | fig,ax=plt.subplots()
242 | ax.plot(history.history['accuracy'], label='Train Acc.')
243 | ax.plot(history.history['val_accuracy'], label = 'Validate Acc.')
244 | ax.set_xlabel('Epoch')
245 | ax.set_ylabel('Accuracy')
246 | #ax.set_ylim([0.5, 1])
247 | plt.legend(loc='lower right')
248 | 
249 | test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
250 | # -
251 | 
252 | # # Further work
253 | # Now you can try and do different things with the keras network. Try and see if you can find a model that performs better on the training sample. Some possible optimisations include:
254 | # - Switching from the standard MNIST dataset to the fashion MNIST dataset to see if it is harder to try and indentify shoes and t-shirts rather than numbers
255 | # - Switching to a different optimisation routine (or changing the learning rate)
256 | # - Changing the network architechture (number of layers or size of each layer)
257 | # - Splitting the dataset into training and validation datasets to test the training is we progress
258 | #
259 | 
260 | 
261 | 


--------------------------------------------------------------------------------
/Week6/Week6_LSTM.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Simple LSTM examples
 16 | 
 17 | # This notebook was heavily inspired (read we took the whole thing) by the notebooks in the lecture series "Machine Learning for Physicists" by Florian Marquardt. See https://machine-learning-for-physicists.org. As with the original work this notebook is also released under the Sharealike License https://creativecommons.org/licenses/by-sa/4.0/
 18 | 
 19 | # In this notebook we will do the following
 20 | # - train a recurrent (LSTM) network to recall a number when asked
 21 | # - train a recurrent (LSTM) netowrk to countdown
 22 | #
 23 | 
 24 | # +
 25 | import matplotlib.pyplot as plt
 26 | import numpy as np
 27 | import math
 28 | 
 29 | # TensorFlow and tf.keras
 30 | import tensorflow as tf
 31 | from tensorflow import keras
 32 | 
 33 | import matplotlib.style #Some style nonsense
 34 | import matplotlib as mpl #Some more style nonsense
 35 | 
 36 | from scipy import linalg
 37 | 
 38 | #Set default figure size
 39 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 40 | mpl.rcParams["legend.frameon"] = False
 41 | mpl.rcParams['figure.dpi']=200 # dots per inch
 42 | 
 43 | #Useful for debugging problems
 44 | print(tf.__version__)
 45 | 
 46 | 
 47 | # -
 48 | 
 49 | # # Example 1: Recall-Net
 50 | 
 51 | # A network that can recall a number (that it has been told before), when asked to do so!
 52 | 
 53 | def init_recall_net(timesteps):
 54 |     #Make our new sequential network
 55 |     rnn = keras.models.Sequential()
 56 | 
 57 |     #Add input layer
 58 |     rnn.add(keras.layers.InputLayer(batch_input_shape=(None, timesteps, 3)))
 59 |     
 60 |     #Add two LSTM layers
 61 |     # note: batch_input_shape is (batchsize,timesteps,data_dim)
 62 |     rnn.add(keras.layers.LSTM(5, return_sequences=True))
 63 |     rnn.add(keras.layers.LSTM(2, return_sequences=True))
 64 |     
 65 |     #Compile the network
 66 |     rnn.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
 67 |     return rnn
 68 | 
 69 | 
 70 | def produce_batch(batchsize,timesteps):
 71 |     
 72 |     observations=np.zeros([batchsize,timesteps,3])
 73 |     desired_output=np.zeros([batchsize,timesteps,2])
 74 |     
 75 |     tell_position=np.random.randint(int(timesteps/2),size=batchsize)
 76 |     ask_position=int(timesteps/2)+1+np.random.randint(int(timesteps/2)-1,size=batchsize)
 77 |     
 78 |     # mark input-slot 0 with 1 at the tell_position:
 79 |     observations[range(batchsize),tell_position,0]=1
 80 |     # write the value to be memorized into input-slot 1
 81 |     memorize_numbers=np.random.random(batchsize)
 82 |     observations[range(batchsize),tell_position,1]=memorize_numbers
 83 |     # mark input-slot 2 with 1 at the ask_position
 84 |     observations[range(batchsize),ask_position,2]=1
 85 |     
 86 |     desired_output[range(batchsize),ask_position,0]=memorize_numbers
 87 |     return(observations,desired_output)
 88 | 
 89 | 
 90 | # +
 91 | #Test the bacth production function
 92 | timesteps=5
 93 | batchsize=1
 94 | test_observations,test_target=produce_batch(batchsize,timesteps)
 95 | print("Observations\n",test_observations)
 96 | print("Target\n",test_target)
 97 | 
 98 | 
 99 | # -
100 | 
101 | # So the network needs to read the first column to find out which number in the second column to remember, then it needs to read the third column to find out which row it needs to recall that number in.
102 | 
103 | # +
104 | timesteps=20
105 | rnn=init_recall_net(timesteps)
106 | 
107 | batchsize=1
108 | test_observations,test_target=produce_batch(batchsize,timesteps)
109 | 
110 | batchsize=20
111 | epochs=300
112 | 
113 | test_output=np.zeros([timesteps,epochs])
114 | 
115 | for k in range(epochs):
116 |     input_observations,output_targets=produce_batch(batchsize,timesteps)
117 |     rnn.train_on_batch(input_observations,output_targets)
118 |     test_output[:,k]=rnn.predict_on_batch(test_observations)[0,:,0]
119 |     print("epoch: ", k, " deviation: ", "{:1.3f}".format(sum((test_output[:,k]-test_target[0,:,0])**2)), end="      \r")
120 | 
121 | 
122 | # -
123 | 
124 | fig,ax=plt.subplots(figsize=(7,5))
125 | im=ax.imshow(test_output,origin='lower',interpolation='nearest',aspect='auto')
126 | ax.set_xlabel("Epoch")
127 | ax.set_ylabel("Time step")
128 | ax.set_yticks(np.arange(timesteps))
129 | cb = fig.colorbar(im)
130 | 
131 | # So here time (in the 20 step sequence) runs up the screen, whilst our time (measured in number fo training epochs) runs across the screen. The LSTM network gets better at only returning a value in the desired location but there is some tail bleeding into higher timesteps.
132 | 
133 | # +
134 | batchsize=30
135 | test_observations,test_target=produce_batch(batchsize,timesteps)
136 | test_output=np.zeros([batchsize,timesteps])
137 | 
138 | test_output[:,:]=rnn.predict_on_batch(test_observations)[:,:,0]
139 | 
140 | fig,ax=plt.subplots(figsize=(3,2))
141 | im=ax.imshow(test_target[:,:,0],vmax=1.0,vmin=0.0,origin='lower',interpolation='nearest',aspect='auto')
142 | cb=fig.colorbar(im)
143 | ax.set_title("Target")
144 | ax.set_xlabel("Time step")
145 | ax.set_ylabel("Batch")
146 | 
147 | fig,ax=plt.subplots(figsize=(3,2))
148 | im=ax.imshow(test_output,vmax=1.0,vmin=0.0,origin='lower',interpolation='nearest',aspect='auto')
149 | cb=fig.colorbar(im)
150 | ax.set_title("Network Output")
151 | ax.set_xlabel("Time step")
152 | ax.set_ylabel("Batch")
153 | 
154 | print("Deviation: ", sum((test_output-test_target[:,:,0])**2))
155 | 
156 | 
157 | # -
158 | 
159 | # Here time within the sequence runs across the page and the (arbitrary) batch index runs up the page. You see the network gets hits in the right places but they bleed into the higher timesteps.
160 | 
161 | def produce_batch_tell_ask_twice(batchsize, timesteps):
162 |     
163 |     observations=np.zeros([batchsize,timesteps,3])
164 |     desired_output=np.zeros([batchsize,timesteps,2])
165 |     
166 |     tell_position=np.random.randint(int(timesteps/2),size=batchsize)
167 |     ask_position=int(timesteps/2)+1+np.random.randint(int(timesteps/4)-2,size=batchsize)
168 |     ask_position2=ask_position+1+np.random.randint(int(timesteps/4)-2,size=batchsize)
169 |     
170 |     # mark input-slot 0 with 1 at the tell_position:
171 |     observations[range(batchsize),tell_position,0]=1
172 |     # write the value to be memorized into input-slot 1
173 |     memorize_numbers=np.random.random(batchsize)
174 |     observations[range(batchsize),tell_position,1]=memorize_numbers
175 |     # mark input-slot 2 with 1 at the ask_position
176 |     observations[range(batchsize),ask_position,2]=1
177 |     observations[range(batchsize),ask_position2,2]=1
178 |     
179 |     desired_output[range(batchsize),ask_position,0]=memorize_numbers
180 |     desired_output[range(batchsize),ask_position2,0]=memorize_numbers
181 |     return(observations,desired_output)
182 | 
183 | 
184 | # +
185 | batchsize=30
186 | test_observations,test_target=produce_batch_tell_ask_twice(batchsize,timesteps)
187 | test_output=np.zeros([batchsize,timesteps])
188 | 
189 | test_output[:,:]=rnn.predict_on_batch(test_observations)[:,:,0]
190 | 
191 | fig,ax=plt.subplots(figsize=(4,3))
192 | im=ax.imshow(test_target[:,:,0],vmax=1.0,vmin=0.0,origin='lower',interpolation='nearest',aspect='auto')
193 | cb=fig.colorbar(im)
194 | ax.set_title("Target")
195 | ax.set_xlabel("Time step")
196 | ax.set_ylabel("Batch")
197 | 
198 | fig,ax=plt.subplots(figsize=(4,3))
199 | im=ax.imshow(test_output,vmax=1.0,vmin=0.0,origin='lower',interpolation='nearest',aspect='auto')
200 | cb=fig.colorbar(im)
201 | ax.set_title("Network Output")
202 | ax.set_xlabel("Time step")
203 | ax.set_ylabel("Batch")
204 | 
205 | print("Deviation: ", sum((test_output-test_target[:,:,0])**2))
206 | 
207 | 
208 | # -
209 | 
210 | # ## We need more memory
211 | # So we will use a deeper pool of LSTMs
212 | 
213 | def init_recall_net_powerful(timesteps):
214 |     rnn = keras.models.Sequential()
215 |     # note: batch_input_shape is (batchsize,timesteps,data_dim)
216 |     rnn.add(keras.layers.InputLayer(batch_input_shape=(None, timesteps, 3)))
217 | 
218 |     #Only difference is the number of LSTMs in the first layer
219 |     rnn.add(keras.layers.LSTM(20, return_sequences=True))
220 |     rnn.add(keras.layers.LSTM(2, return_sequences=True))
221 |     rnn.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
222 |     return rnn
223 | 
224 | 
225 | # +
226 | timesteps=20
227 | rnn=init_recall_net_powerful(timesteps)
228 | 
229 | batchsize=1
230 | test_observations,test_target=produce_batch(batchsize,timesteps)
231 | 
232 | batchsize=20
233 | epochs=300
234 | 
235 | test_output=np.zeros([timesteps,epochs])
236 | 
237 | for k in range(epochs):
238 |     input_observations,output_targets=produce_batch(batchsize,timesteps)
239 |     rnn.train_on_batch(input_observations,output_targets)
240 |     test_output[:,k]=rnn.predict_on_batch(test_observations)[0,:,0]
241 |     print("\r epoch: ", k, " deviation: ", sum((test_output[:,k]-test_target[0,:,0])**2), end="")
242 | 
243 | # -
244 | 
245 | fig,ax=plt.subplots(figsize=(7,5))
246 | im=ax.imshow(test_output,origin='lower',interpolation='nearest',aspect='auto')
247 | ax.set_xlabel("Epoch")
248 | ax.set_ylabel("Time step")
249 | ax.set_yticks(np.arange(timesteps))
250 | cb = fig.colorbar(im)
251 | 
252 | # +
253 | batchsize=30
254 | test_observations,test_target=produce_batch(batchsize,timesteps)
255 | test_output=np.zeros([batchsize,timesteps])
256 | 
257 | test_output[:,:]=rnn.predict_on_batch(test_observations)[:,:,0]
258 | 
259 | fig,ax=plt.subplots(figsize=(5,4))
260 | im=ax.imshow(test_target[:,:,0],vmax=1.0,vmin=0.0,origin='lower',interpolation='nearest',aspect='auto')
261 | cb=fig.colorbar(im)
262 | ax.set_title("Target")
263 | ax.set_xlabel("Time step")
264 | ax.set_ylabel("Batch")
265 | 
266 | fig,ax=plt.subplots(figsize=(5,4))
267 | im=ax.imshow(test_output,vmax=1.0,vmin=0.0,origin='lower',interpolation='nearest',aspect='auto')
268 | cb=fig.colorbar(im)
269 | ax.set_title("Network Output")
270 | ax.set_xlabel("Time step")
271 | ax.set_ylabel("Batch")
272 | 
273 | 
274 | print("Deviation: ", sum((test_output-test_target[:,:,0])**2))
275 | 
276 | 
277 | # -
278 | 
279 | # With the deeper memoery there is muuch less of the bleeding (shadowing) to higher timesteps.
280 | 
281 | # # Example 2: Countdown-Net
282 | 
283 | # A net that counts down: At some random time, it is told a number, and then it outputs a 'one' after this number of steps!
284 | 
285 | def init_count_net(timesteps):
286 |     global firstLSTMlayer
287 |     rnn = keras.models.Sequential()
288 |     # note: batch_input_shape is (batchsize,timesteps,data_dim)
289 |     rnn.add(keras.layers.InputLayer(batch_input_shape=(None, timesteps, 2)))
290 |     firstLSTMlayer=keras.layers.LSTM(2, return_sequences=True)
291 |     rnn.add(firstLSTMlayer)
292 |     rnn.add(keras.layers.LSTM(2, return_sequences=True))
293 |     rnn.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
294 |     return rnn
295 | 
296 | 
297 | def produce_batch_counting(batchsize, timesteps):
298 |     observations=np.zeros([batchsize,timesteps,2])
299 |     desired_output=np.zeros([batchsize,timesteps,2])
300 |     
301 |     tell_position=np.random.randint(int(timesteps/2),size=batchsize)
302 |     count_position=np.random.randint(int(timesteps/2)-1,size=batchsize)
303 |     expect_position=tell_position+count_position
304 |     
305 |     # mark input-slot 0 with 1 at the tell_position:
306 |     observations[range(batchsize),tell_position,0]=1
307 |     # write the counter value
308 |     observations[range(batchsize),tell_position,1]=count_position
309 |     
310 |     desired_output[range(batchsize),expect_position,0]=1
311 |     return(observations,desired_output)
312 | 
313 | 
314 | # +
315 | timesteps=20
316 | 
317 | 
318 | rnn=init_count_net(timesteps)
319 | 
320 | 
321 | batchsize=1
322 | test_observations,test_target=produce_batch_counting(batchsize, timesteps)
323 | 
324 | batchsize=20
325 | epochs=300
326 | 
327 | test_output=np.zeros([timesteps,epochs])
328 | 
329 | for k in range(epochs):
330 |     input_observations,output_targets=produce_batch_counting(batchsize, timesteps)
331 |     rnn.train_on_batch(input_observations,output_targets)
332 |     test_output[:,k]=rnn.predict_on_batch(test_observations)[0,:,0]
333 |     print("epoch: ", k, " deviation: ", "{:1.3f}".format(sum((test_output[:,k]-test_target[0,:,0])**2)), end="    \r")
334 | 
335 | # -
336 | 
337 | fig,ax=plt.subplots(figsize=(7,5))
338 | im=ax.imshow(test_output,origin='lower',interpolation='nearest',aspect='auto')
339 | ax.set_title("Countdown Network")
340 | ax.set_xlabel("Epoch")
341 | ax.set_ylabel("Time step")
342 | ax.set_yticks(np.arange(timesteps))
343 | cb = fig.colorbar(im)
344 | 
345 | # Now: try to inspect output of LSTM neurons at intermediate times. This is also a nice example of how to use some smart keras functionality.
346 | 
347 | from tensorflow.keras import Model
348 | # get a function that represents the mapping from the 
349 | # network inputs to the neuron output values of the first LSTM layer:
350 | neuron_values = Model([rnn.inputs], [firstLSTMlayer.output])
351 | 
352 | batchsize=1
353 | test_observations,test_target=produce_batch_counting(batchsize, timesteps)
354 | 
355 | print(test_observations)
356 | 
357 | the_values=neuron_values.predict_on_batch([test_observations])
358 | 
359 | np.shape(the_values)
360 | 
361 | fig,ax=plt.subplots(figsize=(7,5))
362 | im=ax.imshow(the_values[0,:,:],origin='lower',interpolation='nearest',aspect='auto')
363 | ax.set_title("Neuron Value")
364 | ax.set_xlabel("1st LSTM Index")
365 | ax.set_ylabel("Time step")
366 | ax.set_xticks([0,1])
367 | ax.set_yticks(np.arange(timesteps))
368 | cb = fig.colorbar(im)
369 | 
370 | 
371 | 


--------------------------------------------------------------------------------
/Week5/Week5_tSNE.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Unsupervised Dimensionality Reduction
 16 | # ## t-Distributed Stochastic Neighbor Embedding (t-SNE)
 17 | #
 18 | # In this notebook we will explore t-SNE to reduce the dimensionality of some high dimensional data to a lower order representation.
 19 | 
 20 | # +
 21 | import matplotlib.pyplot as plt
 22 | import numpy as np
 23 | import math
 24 | 
 25 | # TensorFlow and tf.keras
 26 | import tensorflow as tf
 27 | from tensorflow import keras
 28 | 
 29 | import matplotlib.style #Some style nonsense
 30 | import matplotlib as mpl #Some more style nonsense
 31 | 
 32 | 
 33 | #Set default figure size
 34 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 35 | mpl.rcParams["legend.frameon"] = False
 36 | mpl.rcParams['figure.dpi']=200 # dots per inch
 37 | 
 38 | #Useful for debugging problems
 39 | print(tf.__version__)
 40 | # -
 41 | 
 42 | # ## t-SNE Code
 43 | # The code below was taken from [Laurens van der Maaten website](https://lvdmaaten.github.io/tsne/).
 44 | 
 45 | # +
 46 | #
 47 | #  tsne.py
 48 | #
 49 | # Implementation of t-SNE in Python. The implementation was tested on Python
 50 | # 2.7.10, and it requires a working installation of NumPy. The implementation
 51 | # comes with an example on the MNIST dataset. In order to plot the
 52 | # results of this example, a working installation of matplotlib is required.
 53 | #
 54 | # The example can be run by executing: `ipython tsne.py`
 55 | #
 56 | #
 57 | #  Created by Laurens van der Maaten on 20-12-08.
 58 | #  Copyright (c) 2008 Tilburg University. All rights reserved.
 59 | 
 60 | import numpy as np
 61 | import pylab
 62 | 
 63 | 
 64 | def Hbeta(D=np.array([]), beta=1.0):
 65 |     """
 66 |         Compute the perplexity and the P-row for a specific value of the
 67 |         precision of a Gaussian distribution.
 68 |     """
 69 | 
 70 |     # Compute P-row and corresponding perplexity
 71 |     P = np.exp(-D.copy() * beta)
 72 |     sumP = sum(P)
 73 |     H = np.log(sumP) + beta * np.sum(D * P) / sumP
 74 |     P = P / sumP
 75 |     return H, P
 76 | 
 77 | 
 78 | def x2p(X=np.array([]), tol=1e-5, perplexity=30.0):
 79 |     """
 80 |         Performs a binary search to get P-values in such a way that each
 81 |         conditional Gaussian has the same perplexity.
 82 |     """
 83 | 
 84 |     # Initialize some variables
 85 |     print("Computing pairwise distances...")
 86 |     (n, d) = X.shape
 87 |     sum_X = np.sum(np.square(X), 1)
 88 |     D = np.add(np.add(-2 * np.dot(X, X.T), sum_X).T, sum_X)
 89 |     P = np.zeros((n, n))
 90 |     beta = np.ones((n, 1))
 91 |     logU = np.log(perplexity)
 92 | 
 93 |     # Loop over all datapoints
 94 |     for i in range(n):
 95 | 
 96 |         # Print progress
 97 |         if i % 500 == 0:
 98 |             print(("Computing P-values for point %d of %d..." % (i, n)))
 99 | 
100 |         # Compute the Gaussian kernel and entropy for the current precision
101 |         betamin = -np.inf
102 |         betamax = np.inf
103 |         Di = D[i, np.concatenate((np.r_[0:i], np.r_[i+1:n]))]
104 |         (H, thisP) = Hbeta(Di, beta[i])
105 | 
106 |         # Evaluate whether the perplexity is within tolerance
107 |         Hdiff = H - logU
108 |         tries = 0
109 |         while np.abs(Hdiff) > tol and tries < 50:
110 | 
111 |             # If not, increase or decrease precision
112 |             if Hdiff > 0:
113 |                 betamin = beta[i].copy()
114 |                 if betamax == np.inf or betamax == -np.inf:
115 |                     beta[i] = beta[i] * 2.
116 |                 else:
117 |                     beta[i] = (beta[i] + betamax) / 2.
118 |             else:
119 |                 betamax = beta[i].copy()
120 |                 if betamin == np.inf or betamin == -np.inf:
121 |                     beta[i] = beta[i] / 2.
122 |                 else:
123 |                     beta[i] = (beta[i] + betamin) / 2.
124 | 
125 |             # Recompute the values
126 |             (H, thisP) = Hbeta(Di, beta[i])
127 |             Hdiff = H - logU
128 |             tries += 1
129 | 
130 |         # Set the final row of P
131 |         P[i, np.concatenate((np.r_[0:i], np.r_[i+1:n]))] = thisP
132 | 
133 |     # Return final P-matrix
134 |     print(("Mean value of sigma: %f" % np.mean(np.sqrt(1 / beta))))
135 |     return P
136 | 
137 | 
138 | def pca(X=np.array([]), no_dims=50):
139 |     """
140 |         Runs PCA on the NxD array X in order to reduce its dimensionality to
141 |         no_dims dimensions.
142 |     """
143 | 
144 |     print("Preprocessing the data using PCA...")
145 |     (n, d) = X.shape
146 |     X = X - np.tile(np.mean(X, 0), (n, 1))
147 |     (l, M) = np.linalg.eig(np.dot(X.T, X))
148 |     Y = np.dot(X, M[:, 0:no_dims])
149 |     return Y
150 | 
151 | 
152 | def tsne(X=np.array([]), no_dims=2, initial_dims=50, perplexity=30.0, max_iter=1000):
153 |     """
154 |         Runs t-SNE on the dataset in the NxD array X to reduce its
155 |         dimensionality to no_dims dimensions. The syntaxis of the function is
156 |         `Y = tsne.tsne(X, no_dims, perplexity), where X is an NxD NumPy array.
157 |     """
158 | 
159 |     # Check inputs
160 |     if isinstance(no_dims, float):
161 |         print("Error: array X should have type float.")
162 |         return -1
163 |     if round(no_dims) != no_dims:
164 |         print("Error: number of dimensions should be an integer.")
165 |         return -1
166 | 
167 |     # Initialize variables
168 |     X = pca(X, initial_dims).real
169 |     (n, d) = X.shape
170 |     initial_momentum = 0.5
171 |     final_momentum = 0.8
172 |     eta = 500
173 |     min_gain = 0.01
174 |     Y = np.random.randn(n, no_dims)
175 |     dY = np.zeros((n, no_dims))
176 |     iY = np.zeros((n, no_dims))
177 |     gains = np.ones((n, no_dims))
178 | 
179 |     # Compute P-values
180 |     P = x2p(X, 1e-5, perplexity)
181 |     P = P + np.transpose(P)
182 |     P = P / np.sum(P)
183 |     P = P * 4.									# early exaggeration
184 |     P = np.maximum(P, 1e-12)
185 | 
186 |     # Run iterations
187 |     for iter in range(max_iter):
188 | 
189 |         # Compute pairwise affinities
190 |         sum_Y = np.sum(np.square(Y), 1)
191 |         num = -2. * np.dot(Y, Y.T)
192 |         num = 1. / (1. + np.add(np.add(num, sum_Y).T, sum_Y))
193 |         num[list(range(n)), list(range(n))] = 0.
194 |         Q = num / np.sum(num)
195 |         Q = np.maximum(Q, 1e-12)
196 | 
197 |         # Compute gradient
198 |         PQ = P - Q
199 |         for i in range(n):
200 |             dY[i, :] = np.sum(np.tile(PQ[:, i] * num[:, i], (no_dims, 1)).T * (Y[i, :] - Y), 0)
201 | 
202 |         # Perform the update
203 |         if iter < 20:
204 |             momentum = initial_momentum
205 |         else:
206 |             momentum = final_momentum
207 |         gains = (gains + 0.2) * ((dY > 0.) != (iY > 0.)) + \
208 |                 (gains * 0.8) * ((dY > 0.) == (iY > 0.))
209 |         gains[gains < min_gain] = min_gain
210 |         iY = momentum * iY - eta * (gains * dY)
211 |         Y = Y + iY
212 |         Y = Y - np.tile(np.mean(Y, 0), (n, 1))
213 | 
214 |         # Compute current value of cost function
215 |         if (iter + 1) % 10 == 0:
216 |             C = np.sum(P * np.log(P / Q))
217 |             print(("Iteration %d: error is %f" % (iter + 1, C)))
218 | 
219 |         # Stop lying about P-values
220 |         if iter == 100:
221 |             P = P / 4.
222 | 
223 |     # Return solution
224 |     return Y
225 | 
226 | 
227 | 
228 | # -
229 | 
230 | # ## Example 1: The MNIST Dataset
231 | #
232 | # In this example we will look at a subset of the MNIST dataset
233 | 
234 | # +
235 | mnist = keras.datasets.mnist   #The original handwritten digit MNIST
236 | #mnist = keras.datasets.fashion_mnist   #A tricky version that uses images of fashion items
237 | (train_images, train_labels), (test_images, test_labels) = mnist.load_data()
238 | train_images=train_images/255.0
239 | 
240 | print(np.shape(train_images))
241 | X=np.reshape(train_images[:2500],(2500,784))
242 | labels=train_labels[:2500]
243 | print(np.shape(X))
244 | # -
245 | 
246 | print("Run Y = tsne.tsne(X, no_dims, perplexity) to perform t-SNE on your dataset.")
247 | Y=tsne(X,2,50,20.0,max_iter=500)
248 | 
249 | print(np.shape(Y))
250 | fig,ax=plt.subplots(figsize=(8,8))
251 | im=ax.scatter(Y[:,0],Y[:,1],20,labels,cmap="tab10")
252 | cb = fig.colorbar(im) #Get the colorbar for the range of z values
253 | 
254 | # ## Example 2: Gaussian clouds
255 | # This example was taken from the https://machine-learning-for-physicists.org course. There is lots of excellent background material on that site and like the original notebooks these notebooks are released under the creative commons license.
256 | 
257 | # +
258 | # produce a high-dimensional data set, composed of a few Gaussian point clouds in high-dimensional space
259 | 
260 | n_dim=100 # a really high-dimensional space
261 | 
262 | n_clusters=5 # number of clusters, i.e. clouds
263 | N_cluster_points=30 # number of points inside each cluster
264 | N=n_clusters*N_cluster_points # total number of points
265 | 
266 | Gauss_spread=1.0 # size of each cluster (cloud)
267 | 
268 | X=np.zeros([N,n_dim])
269 | 
270 | for j in range(n_clusters):
271 |     Xmean=np.random.randn(n_dim) # the center position of the cluster
272 |     X[j*N_cluster_points:(j+1)*N_cluster_points,:]=Xmean[None,:]+Gauss_spread*np.random.randn(N_cluster_points,n_dim)
273 | 
274 | # plot these points in a projection into 2D space
275 | # color them according to the cluster they belong to!
276 | 
277 | fig,ax=plt.subplots(figsize=(8,8))
278 | for j in range(n_clusters):
279 |     X0=X[j*N_cluster_points:(j+1)*N_cluster_points,0]
280 |     X1=X[j*N_cluster_points:(j+1)*N_cluster_points,1]    
281 |     ax.scatter(X0,X1)
282 | 
283 | 
284 | # +
285 | # now apply t-SNE to reduce to two dimensions in a smart way!
286 | 
287 | Y=tsne(X, no_dims=2, initial_dims=50, perplexity=20.0,max_iter=300)
288 | 
289 | # plot the points according to the t-SNE projection into 2D space
290 | # color them according to the cluster they belong to!
291 | fig,ax=plt.subplots(figsize=(8,8))
292 | for j in range(n_clusters):
293 |     Y0=Y[j*N_cluster_points:(j+1)*N_cluster_points,0]
294 |     Y1=Y[j*N_cluster_points:(j+1)*N_cluster_points,1]    
295 |     ax.scatter(Y0,Y1)
296 | 
297 | # -
298 | 
299 | # ## Example 3: Multiple Gaussians, finding the true number
300 | 
301 | # +
302 | # Plot a tSNE-scatterplot, but with some randomly marked points,
303 | # together with the corresponding high-dimensional data points plotted
304 | # as curves!
305 | 
306 | def plot_tsne_with_curves(y0,y1,x,xlabel,n_picks=10,vmin=-0.1,vmax=2):
307 |     random_picks=np.random.randint(np.shape(y0)[0],size=n_picks) # pick some random points
308 |     
309 |     fig=plt.figure(constrained_layout=True,figsize=(8,4))
310 |     gs=fig.add_gridspec(ncols=8,nrows=4)
311 |     scatter_plot=fig.add_subplot(gs[0:4,0:4])
312 |     
313 |     myplot={}
314 |     j=0
315 |     for n0 in range(4):
316 |         for n1 in range(4):
317 |             myplot[j]=fig.add_subplot(gs[n0,4+n1])
318 |             myplot[j].axis('off')
319 |             j+=1
320 |     
321 |     scatter_plot.scatter(y0,y1,c=xlabel)
322 |     scatter_plot.scatter(y0[random_picks],y1[random_picks],color="black",alpha=0.7,s=80)
323 |     
324 |     for idx in range(len(random_picks)):
325 |         scatter_plot.text(y0[random_picks[idx]], y1[random_picks[idx]], 
326 |                       str(idx), fontsize=8, color="orange", 
327 |                      alpha=0.8, horizontalalignment='center',
328 |                 verticalalignment='center')
329 |     
330 |     for idx,m in enumerate(random_picks):
331 |         if idx<j:
332 |             myplot[idx].plot(x[m,:])
333 |             myplot[idx].text(0.1, 0.75, str(idx), fontsize=12, color="orange", 
334 |                              alpha=0.5, horizontalalignment='center',
335 |                         verticalalignment='center', transform=myplot[idx].transAxes)
336 |             myplot[idx].set_ylim([vmin,vmax])
337 |         
338 |     plt.show()
339 | 
340 | 
341 | # +
342 | def my_generator1D(batchsize,x): # produce a batch of curves, a random number of Gaussian
343 |     maxNum=2 # the maximum number of Gaussians
344 |     NumGaussians=np.random.randint(maxNum+1,size=batchsize) # select the number, for each sample
345 |     Curves=np.zeros([batchsize,len(x)])
346 |     for j in range(maxNum):  #Loop over number of Gaussians
347 |         R=np.random.uniform(low=0.1,high=0.11,size=batchsize) # width
348 |         A=np.random.uniform(low=0.9,high=1.0,size=batchsize) # amplitude
349 |         x0=np.random.uniform(size=batchsize,low=-0.8,high=0.8) # position
350 |         Curves+=(j<=NumGaussians[:,None]-1)*A[:,None]*np.exp(-((x[None,:]-x0[:,None])/R[:,None])**2)
351 |     Curves+=0.1*np.random.randn(batchsize,len(x)) # add a bit of background noise on top
352 |     return( Curves, NumGaussians )
353 | 
354 | n_dim=100
355 | x=np.linspace(-1,1,n_dim)
356 | N=2000 # how many curves
357 | 
358 | X,Xlabel=my_generator1D(N,x) 
359 | # small x is the coordinate, capital X are the high-dim. "data points", meaning samples of curves!
360 | print(np.shape(x))
361 | print(np.shape(X))
362 | print(np.shape(Xlabel))
363 | 
364 | 
365 | 
366 | 
367 | 
368 | # -
369 | 
370 | fig,ax=plt.subplots(ncols=10,nrows=1,figsize=(10,1))
371 | for n in range(10):
372 |     ax[n].plot(X[n,:])
373 |     ax[n].set_ylim([-0.1,2])
374 |     ax[n].axis('off')
375 | plt.show()
376 | 
377 | # +
378 | # plot these points in a projection into 2D space
379 | 
380 | # pick two arbitrary coordinates
381 | j0=17
382 | j1=35
383 | 
384 | plt.figure(figsize=(8,8))
385 | X0=X[:,j0]
386 | X1=X[:,j1]    
387 | plt.scatter(X0,X1,c=Xlabel)
388 | plt.show()
389 | 
390 | # +
391 | # now apply t-SNE to reduce to two dimensions in a smart way!
392 | 
393 | Y=tsne(X, 2, 20, 30.0, max_iter=300)
394 | # -
395 | 
396 | plot_tsne_with_curves(Y[:,0],Y[:,1],X,Xlabel,n_picks=16)
397 | 
398 | # ## Suggested Tasks
399 | # 1. Change the perplexity variable in one (or more) of the examples above. What effect does perplexity have on the result tSNE distribution?
400 | # 2. Modify Example 3 to use different to use different sample curves
401 | 
402 | 
403 | 


--------------------------------------------------------------------------------
/Week2/Week2_BackPropagation.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Practical Machine Learning for Physicists
 16 | # ## Introduction to backpropagation
 17 | #
 18 | # Backpropagation sounds very confusing but it is actually just the chain rule in action. In this notebook we will implement our own version of backpropagation to train our simple neural network model from last week.
 19 | #
 20 | # A reminder in a single layer (labelled by $l$) of our network the output of a given neuron (labelled with $i$) is called $y^{l}_i$ and depends on some weights ($w$) and bias ($b$) and the output of the previous layer $l-1$:
 21 | # $$y^{l}_i = f( \sum_j w^l_{ij} y^{l-1}_j + b^{l}_i) = f( z^l_i)$$ 
 22 | # where $f$ is our non-linear activation function and we have introduced 
 23 | # $$ z^l_i = \sum_j w^l_{ij} y^{l-1}_j + b^{l}_i$$
 24 | #
 25 | 
 26 | # Now lets assume there are $N$ layers in our network so one of the outputs of the final layer will be $y^N_i$. Using these outputs we will calculate some (as yet to be defined) cost function that could be the mean square error or the chi-squared or some other suitable cost function ($L$).
 27 | #
 28 | # We will now introduce $\Delta^l_i$ which is called the error of neuron $i$ in layer $l$ and shows how the cost function changes with this neuron.
 29 | # $$\Delta^l_i \equiv \frac{\partial L}{\partial z^l_i} = \frac{\partial L}{\partial y^l_i} f^\prime(z^l_i)$$
 30 | # As we did in the simple curve fitting case we want to differentiate our cost function ($L$) with respect to our parameters, the weights ($w$) and biases ($b$). So we want to find:
 31 | # $$  \frac{\partial L}{\partial b^l_i} = \frac{\partial L}{\partial z^l_i} \frac{\partial z^l_i}{\partial b^l_i} =\frac{\partial L}{\partial z^l_i} $$
 32 | # since $\frac{\partial z^l_i}{\partial b^l_i}=1$.
 33 | #
 34 | #
 35 | #
 36 | #
 37 | 
 38 | # Now we know that the cost function only depends on the neurons in layer $l$ through their influence on layer $l+1$. So we can use the chain rule again.
 39 | # $$  \Delta^l_i  =\frac{\partial L}{\partial z^l_i} = \sum_j \frac{\partial L}{\partial z^{l+1}_j} \frac{\partial z^{l+1}_j}{\partial z^l_i} $$
 40 | # but from above
 41 | # $$ \frac{\partial L}{\partial z^{l+1}_j} = \Delta^{l+1}_j$$ 
 42 | # and
 43 | # $$ \frac{\partial z^{l+1}_j}{\partial z^l_i} = \frac{\partial z^{l+1}_j}{\partial y^l_i}\frac{\partial y^l_i}{\partial z^l_i} = w^{l+1}_{ij} f^\prime(z^l_i)$$
 44 | # where $f^\prime$ is the derivative of the activation function $f$.
 45 | # Giving the backpropagation equation:
 46 | # $$ \Delta^l_i  = \left( \sum_j  \Delta^{l+1}_j w^{l+1}_{ij} \right) f^\prime(z^l_i) $$
 47 | #
 48 | # We will also need to know how the cost function ($L$) depends on the weights, so we will need
 49 | # $$ \frac{\partial L}{\partial w^{l}_{ij}} = \frac{\partial L}{\partial z^l_i}\frac{\partial z^l_i}{\partial w^{l}_{ij}} = \Delta^{l}_i y^{l-1}_j $$
 50 | 
 51 | # ### Backpropagation algorithm
 52 | # 1. For a given input $x$ evaluate the network, this will involve calculating all $y^l_i$ and $z^l_i$
 53 | # 2. Calculate the cost function $L$ using the outputs of the final layer $y^N_i$
 54 | # 3. Calculate the error in the cost function relative to the final layer $z^N_i$, this step will require the derivative of the cost function and activation function.
 55 | # 4. Backpropagate the error using the backpropagation equation above.
 56 | # 5. Then using the above equations evaluate the gradients $\frac{\partial L}{\partial w^{l}_{ij}}$ and $\frac{\partial L}{\partial b^{l}_j}$
 57 | 
 58 | # ## Backpropagation in action
 59 | # We are going to implement a fully connected neural network of the form
 60 | # $$y^{l}_i = f( \sum_j w^l_{ij} y^{l-1}_j + b^{l}_i)$$
 61 | #
 62 | # Initially we will use the sigmoid as our activation function:
 63 | # $$f_{sigmoid}(x) = \frac{1}{ 1 + e^{-x}}$$
 64 | # so
 65 | # $$ \frac{df}{dx} = \frac{e^{-x}}{\left(1+e^{-x}\right)^2} = e^{-x} f^2$$
 66 | #
 67 | 
 68 | # +
 69 | #So now we will have our first bit of code
 70 | import numpy as np  #import the numpy library as np
 71 | import matplotlib.pyplot as plt #import the pyplot library as plt
 72 | import matplotlib.style #Some style nonsense
 73 | import matplotlib as mpl #Some more style nonsense
 74 | 
 75 | #Set default figure size
 76 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 77 | mpl.rcParams["legend.frameon"] = False
 78 | mpl.rcParams['figure.dpi']=150 # dots per inch
 79 | 
 80 | 
 81 | # +
 82 | 
 83 | class SimpleNN:
 84 |     """A simple neural network class"""
 85 |     #Define and initialise our class variables  
 86 |     def __init__(self,nLayers,nBatch,layerSize,useRELU=False,wMax=1,bMax=1):
 87 |         self.nlayers=nLayers
 88 |         self.batchsize=nBatch
 89 |         self.layersize=layerSize
 90 |         self.useRELU=useRELU
 91 |         
 92 |         #Initialise the weights and biases with random numbers
 93 |         self.w=[np.random.uniform(low=-1*wMax,high=+1*wMax,size=[ self.layersize[j],self.layersize[j+1] ]) for j in range(self.nlayers)]
 94 |         self.b=[np.random.uniform(low=-1*bMax,high=+1*bMax,size=[ self.layersize[j+1] ]) for j in range(self.nlayers)]
 95 |         
 96 |         #Define the arrays for various outputs needed for backpropagation
 97 |         self.yArray=[np.zeros([self.batchsize,self.layersize[j]]) for j in range(self.nlayers+1)]
 98 |         self.dfArray=[np.zeros([self.batchsize,self.layersize[j+1]]) for j in range(self.nlayers)]
 99 |         self.dwArray=[np.zeros([self.layersize[j],self.layersize[j+1]]) for j in range(self.nlayers)]
100 |         self.dbArray=[np.zeros(self.layersize[j+1]) for j in range(self.nlayers)]
101 |     
102 |     
103 |     #This function evaluates both the neuron output funciton f(x), but also gets df/dx(x)
104 |     def get_f_df(self,x):  
105 |         emx=np.exp(-x) 
106 |         f=1./(1+emx) #Sigmoid
107 |         df=emx*f*f #df/dx
108 |         return (f,df) #Return both
109 |     
110 |     # For a change: Set up rectified linear units (relu) 
111 |     # instead of sigmoid
112 |     def get_f_df_relu(self,z): # calculate f(z) and f'(z)
113 |         val=z*(z>0)
114 |         return(val,z>0) # return both f and f'
115 | 
116 |     #Evaluate one layer step of the network 
117 |     def forward_step(self,y,w,b):
118 |         z=np.dot(y,w)+b  #Calculate z from the inputs, weights and biases
119 |         #Remember y has shape (Nbatch x Layer Size N)
120 |         # w has shape (Layer Size N x Layer Size N+1)
121 |         # b has shape (Layer Size N+1)
122 |         # z has shape (Nbatch x Layer Size N+1) 
123 |         if(self.useRELU):
124 |             return self.get_f_df_relu(z) #Get f(z) and df/dz(z)
125 |         return self.get_f_df(z) #Get f(z) and df/dz(z)
126 | 
127 |     def network_forward(self,yin):
128 |         y=yin # start with input values which have shape (batch size x input layer size)
129 |         self.yArray[0]=y 
130 |         for i in range(self.nlayers):  #Loop over the self.nlayers of the network
131 |             y,df=self.forward_step(y,self.w[i],self.b[i]) #Take one step forward in the network
132 |             self.yArray[i+1]=y   #Store y for backpropagation
133 |             self.dfArray[i]=df #Stor df for backpropagation
134 |         return y
135 |     
136 |     def backward_step(self,delta,w,df):
137 |         #delta is the error at layer N of shape (Nbatch x layer N output size)
138 |         #w is the weights at layer N of shape (layer N-1 output size x layer N output size)
139 |         #df has shape (Nbatch x layer N-1 output size)
140 |         return (np.dot(delta,np.transpose(w))*df)
141 | 
142 |     def backpropagate(self,yTarget):
143 |         #This function fills the dwArray and dbArray arrays with the gradients at each layer
144 |     
145 |         #Evaluate error at last layer
146 |         delta=(self.yArray[-1]-yTarget)*self.dfArray[-1]
147 |         self.dwArray[-1]=np.dot(np.transpose(self.yArray[-2]),delta)/self.batchsize
148 |         self.dbArray[-1]=delta.sum(0)/self.batchsize
149 |         for i in range(self.nlayers-1):
150 |             delta=self.backward_step(delta,self.w[-1-i],self.dfArray[-2-i])
151 |             self.dwArray[-2-i]=np.dot(np.transpose(self.yArray[-3-i]),delta)/self.batchsize
152 |             self.dbArray[-2-i]=delta.sum(0)/self.batchsize
153 |             
154 |     #Update the weights and biases using the gradients and learning rate (eta)
155 |     def update_with_gradients(self,eta):
156 |         for i in range(self.nlayers):
157 |             self.w[i]-=eta*self.dwArray[i]
158 |             self.b[i]-=eta*self.dbArray[i]
159 |    
160 |     #Function that evaluates one pass through the network using input yIn
161 |     #Then backpropagates the errors through the network to update the weights and biases
162 |     def train_network(self,yIn,yTarget,eta):
163 |         yOut=self.network_forward(yIn)
164 |         self.backpropagate(yTarget)
165 |         self.update_with_gradients(eta)
166 |         cost=((yTarget-yOut)**2).sum()/self.batchsize
167 |         return(cost)
168 |     
169 |    
170 | # -
171 | 
172 | # ### Set up a network and run it
173 | 
174 | #Need to define the network
175 | myNN = SimpleNN(nLayers=3,nBatch=100,layerSize=[2,20,30,1])
176 | 
177 | # ## Train the network on one batch repeatedly (this isn't a good idea)
178 | 
179 | yIn=np.random.uniform(low=-1,high=+1,size=[myNN.batchsize,myNN.layersize[0]])
180 | yTarget=np.random.uniform(low=-1,high=+1,size=[myNN.batchsize,myNN.layersize[-1]])
181 | 
182 | eta=0.001
183 | numSteps=2000
184 | cost=np.zeros(numSteps)
185 | for step in range(numSteps):
186 |     cost[step]=myNN.train_network(yIn,yTarget,eta)
187 | 
188 | #Actually plot something
189 | fig, ax = plt.subplots()  #I like to make plots using this silly fig,ax method but plot how you like
190 | stepArray=np.arange(numSteps) #Get numbers 0-199
191 | ax.plot(stepArray,cost,linewidth=3) 
192 | ax.set_xlabel("Step Number")
193 | ax.set_ylabel("Cost")
194 | 
195 | # ## Use random batches
196 | 
197 | #Define a new fresh network
198 | myNN = SimpleNN(nLayers=2,nBatch=100,layerSize=[2,200,1],useRELU=True,wMax=0.1,bMax=0)
199 | 
200 | 
201 | # +
202 | #Define a 2D function with some abritrary shape
203 | def myFunc(x0,x1):
204 |     r2=x0**2+x1**2
205 |     return(np.exp(-5*r2)*np.abs(x1+x0))
206 | 
207 | xrange=np.linspace(-0.5,0.5,40)
208 | X0,X1=np.meshgrid(xrange,xrange)
209 | fig, ax = plt.subplots()
210 | ax.imshow(myFunc(X0,X1),extent=(-0.5,0.5,-0.5,0.5),interpolation='nearest',origin='lower')
211 | ax.set_title("Input Image")
212 | 
213 | 
214 | # -
215 | 
216 | #This function picks batchsize random x,y pairs and then evaluates myFunc for these x,y pairs
217 | # returns both the x,y pairs and the values
218 | def make_batch(batchsize):
219 |     inputs=np.random.uniform(low=-0.5,high=+0.5,size=[batchsize,2])
220 |     targets=np.zeros([batchsize,1]) # must have right dimensions
221 |     targets[:,0]=myFunc(inputs[:,0],inputs[:,1])
222 |     return(inputs,targets)
223 | 
224 | 
225 | # +
226 | # try to evaluate the (randomly initialized) network
227 | # on some area in the 2D plane
228 | test_batchsize=np.shape(X0)[0]*np.shape(X0)[1]
229 | testsample=np.zeros([test_batchsize,2])
230 | testsample[:,0]=X0.flatten()
231 | testsample[:,1]=X1.flatten()
232 | 
233 | testoutput=myNN.network_forward(testsample)
234 | fig, ax = plt.subplots()
235 | myim=ax.imshow(np.reshape(testoutput,np.shape(X0)),extent=(-0.5,0.5,-0.5,0.5),origin='lower',interpolation='none')
236 | ax.set_title("Start Image")
237 | 
238 | # +
239 | #Define our learning rate and number of learning steps and make an array for the cost function per step
240 | eta=.01
241 | steps=2000
242 | cost=np.zeros(steps)
243 | 
244 | #Loop through the steps, get a random batch of samples, train the network, repeat
245 | for k in range(steps):
246 |     y_in,y_target=make_batch(myNN.batchsize)
247 |     cost[k]=myNN.train_network(y_in,y_target,eta)
248 | 
249 | #Plot the output image
250 | fig, ax = plt.subplots()
251 | stepArray=np.arange(steps) 
252 | ax.plot(stepArray,cost,linewidth=3) 
253 | ax.set_xlabel("Step Number")
254 | ax.set_ylabel("Cost")
255 | ax.set_title("Cost function during training")
256 | 
257 | # -
258 | 
259 | #Now plot the final result... does it look somewhat like the input image?
260 | testoutput=myNN.network_forward(testsample)
261 | fig, ax = plt.subplots()
262 | myim=ax.imshow(np.reshape(testoutput,np.shape(X0)),extent=(-0.5,0.5,-0.5,0.5),origin='lower',interpolation='none')
263 | ax.set_title("Current Network Image")
264 | 
265 | 
266 | # start fresh by making a new neural network object
267 | myNN = SimpleNN(nLayers=2,nBatch=100,layerSize=[2,100,1],useRELU=True,wMax=0.1,bMax=0)
268 | 
269 | # +
270 | # import functions for updating display 
271 | # (simple animation)
272 | from IPython.display import clear_output
273 | from time import sleep
274 | 
275 | eta=0.01 # learning rate
276 | nsteps=2000  #Number of steps in the training
277 | updateEvery=100  #Only update the plot every 100 steps (just to speed things up)
278 | costs=np.zeros(nsteps)
279 | for j in range(nsteps):
280 |     
281 |      # the crucial lines:
282 |     y_in,y_target=make_batch(myNN.batchsize) # random samples (points in 2D)
283 |     costs[j]=myNN.train_network(y_in,y_target,eta) # train network (one step, on this batch)
284 |     
285 |     if j%updateEvery ==0:
286 |         clear_output(wait=True)
287 |         fig,ax=plt.subplots(ncols=2,nrows=1,figsize=(8,4)) # prepare figure
288 |         ax[1].axis('off') # no axes
289 |     
290 |    
291 |         testoutput=myNN.network_forward(testsample) # check the new network output in the plane
292 |         img=ax[1].imshow(np.reshape(testoutput,np.shape(X0)),interpolation='nearest',origin='lower') # plot image
293 |         ax[0].plot(costs)
294 |     
295 |         ax[0].set_title("Cost during training")
296 |         ax[0].set_xlabel("number of batches")
297 |         ax[1].set_title("Current network prediction")
298 |         plt.show()
299 |         #sleep(0.1)
300 | # -
301 | 
302 | # # Suggested Tasks:
303 | # 1. Can you improve the quality of the functional represenation above? Potential things to change are the number of training epochs, the learning rate, the number of neurons in the hidden layer and the number of hidden layers.
304 | # 2. How does the cost function compare to the eye test?
305 | # 3. What other functions could you try and replicate using a neural network?
306 | 
307 | 
308 | 


--------------------------------------------------------------------------------
/Week7/Week7_RL.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | # ---
  3 | # jupyter:
  4 | #   jupytext:
  5 | #     text_representation:
  6 | #       extension: .py
  7 | #       format_name: light
  8 | #       format_version: '1.5'
  9 | #       jupytext_version: 1.7.1
 10 | #   kernelspec:
 11 | #     display_name: Python 3
 12 | #     language: python
 13 | #     name: python3
 14 | # ---
 15 | 
 16 | # # Practical Machine Learning for Physicists
 17 | #
 18 | #
 19 | # ## Markov Processes
 20 | # In the optional video we introduced three types of Markov Process which all made use of the Markov Property:
 21 | #
 22 | # A state $S_t$ is *Markov* if and only if 
 23 | # $$ P\left[S_{t+1} | S_{t} \right] = P\left[S_{t+1} | S_1, \cdots, S_{t} \right] $$
 24 | #
 25 | # That is the state captures all of the relevant information from the history. We do not need to store the history of the states only the current state.
 26 | #
 27 | # > "The future is independent of the past given the present"
 28 | #
 29 | # ### Markov Chain
 30 | # A *Markov Chain* is a tuple $<\mathcal{S},\mathcal{P}>$ where
 31 | # - $\mathcal{S}$ is the finite set of states
 32 | # - $\mathcal{P}$ is the state transition probability matrix
 33 | # $$\mathcal{P}_{ss^\prime} = \mathbb{P}\left[S_{t+1}=s^\prime | S_t = s\right]$$
 34 | #
 35 | # ### Markov Reward Process
 36 | # A *Markov Reward Process* (MRP) is a Markov chain with values $<\mathcal{S},\mathcal{P}, \mathcal{R}, \gamma>$
 37 | # - $\mathcal{R}$ is the reward function, $\mathcal{R}_s=\mathbb{E}\left[R_{t+1} | S_t=s\right]$
 38 | # - $\gamma$ is the discount factor $0 \leq \gamma \leq 1$
 39 | #
 40 | # ### Return
 41 | # The return $G_t$ is the total discounted reward from the future
 42 | # $$G_t = R_{t+1} + \gamma R_{t+2} + \gamma^2 R_{t+3} + \cdots = \sum_{i=0}^\infty \gamma^i R_{t+i+1}$$
 43 | #
 44 | # ### Value Function
 45 | # The value function $v(s)$ is the expected return value startong from state $s$
 46 | # $$ v(s) = \mathbb{E}\left[ G_t | S_t=s\right] $$
 47 | #
 48 | #
 49 | 
 50 | # ### Bellman Equation for Markov Reward Processes
 51 | # We can decompose the value function into two parts:
 52 | # - immediate reward $R_{t+1}$
 53 | # - discounted value of next state $\gamma v\left(S_{t+1}\right)$
 54 | # $$v(s) = \mathbb{E} \left[R_{t+1} + \gamma v\left(S_{t+1}\right) | S_t=s\right] $$
 55 | #
 56 | # Or in matrix form using $v_{t+1}=\mathcal{P} v_t$ and dropping the indices for cleanliness
 57 | # $$ v = \mathcal{R} + \gamma \mathcal{P} v $$
 58 | #
 59 | # #### Solving the Bellman Equation for MRPs
 60 | # The Bellman equation is a soluble linear equation with solution
 61 | # $$ v = \left(I - \gamma \mathcal{P}\right)^{-1} \mathcal{R}$$
 62 | #
 63 | # The computational complexity is $O(n^3)$ for $n$ states, so the direct solution is only possible for small MRPs. For large MRPs we need to use iterative methods to get the solution.
 64 | #
 65 | # ### Markov Decision Process
 66 | # A *Markov Decision Process* (MDP) is a Markov reward process with decisions. The tuple is $<\mathcal{S},\mathcal{A}, \mathcal{P}, 
 67 | # \mathcal{R}, \gamma>$
 68 | # - $\mathcal{S}$ is the finite set of states
 69 | # - $\mathcal{A}$ is the finite set of actions
 70 | # - $\mathcal{P}$ is the state transition probability matrix
 71 | # $$\mathcal{P^a}_{ss^\prime} = \mathbb{P}\left[S_{t+1}=s^\prime | S_t = s, A_t=a\right]$$
 72 | # - $\mathcal{R}$ is the reward function, $\mathcal{R}^a_s=\mathbb{E}\left[R_{t+1} | S_t=s, A_t=a\right]$
 73 | # - $\gamma$ is the discount factor $0 \leq \gamma \leq 1$
 74 | #
 75 | # ### Policies
 76 | # A *policy* $\pi$ is a distribution over actions given states
 77 | # $$ \pi(a|s) = \mathbb{P} \left[ A_t=a | S_t=s \right]$$
 78 | #
 79 | # The policy fully defines the behaviour of the agent. The policies (like all things Markov) depend on the state and not on the history.
 80 | #
 81 | # A policy can reduce a Markov Decision Process to a Markov Reward Process  $<\mathcal{S}, \mathcal{P}^\pi, 
 82 | # \mathcal{R}^\pi, \gamma>$ where
 83 | # $$P^{\pi}_{ss^\prime}=\sum_{a \in A} \pi \left(a|s\right)P^a_{ss^\prime}$$
 84 | # $$R^{\pi}_{ss^\prime}=\sum_{a \in A} \pi \left(a|s\right)R^a_{ss^\prime}$$
 85 | #
 86 | # ### Value Functions
 87 | # The *state-value function* is the expected reutrn from state $s$ if policy $\pi$ is followed
 88 | # $$v_\pi(s) = \mathbb{E}_\pi \left[ G_t | S_t=s \right]$$
 89 | #
 90 | # The *action-value function* is the expected return from state $s$, taking action $a$, if policy $\pi$ is followed
 91 | # $$q_\pi(s,a) = \mathbb{E}_\pi \left[ G_t | S_t=s,A_t=a \right]$$
 92 | #
 93 | # ### Optimal Value functions
 94 | # The optimal state-value function $v_*(s)$
 95 | # $$v_*(s) = \max_\pi v_\pi (s)$$
 96 | #
 97 | # The optimal action-value function $q_* (s,a)$
 98 | # $$q_*(s,a) = \max_\pi q_\pi (s,a)$$
 99 | #
100 | 
101 | # ### Bellman Optimality Equations
102 | # There are optimality equations for both the state-value and action-value functions. They both involve selecting the action that gives the maximum reward and summing over the states
103 | # $$v_*(s) = \max_a \mathcal{R}^a_s + \gamma \sum_{s^\prime \in S} \mathcal{P}^{a}_{s s^\prime} v_* (s^\prime)$$
104 | # $$q_*(s,a) = \mathcal{R}^a_s + \gamma \sum_{s^\prime \in S} \mathcal{P}^{a}_{s s^\prime} \max_{a^\prime} q_* (s^\prime, a^\prime)$$
105 | 
106 | # ### Dynamic Programming
107 | #
108 | # #### Iterative Policy Evaluation
109 | # How do we evaluate a given policy $\pi$? Evaluating the policy is  the same as determining the value function $v_\pi$.
110 | #
111 | # In psuedo-code what we want to do is
112 | # - Loop over iteration $i$
113 | #     - Loop over all the states in $s \in S$
114 | #     - Update the value function $v_{k+1}(s)$ from $v_k(s^\prime)$
115 | # $$ v_{k+1}(s) = \sum_{a \in \mathcal{A} } \pi(a | s) \left( \mathcal{R}^a_s + \gamma \sum_{s^\prime \in \mathcal{S}} \mathcal{P}^a_{ss^\prime} v_k(s^\prime) \right) $$
116 | # Or in matrix notation
117 | # $$\mathbf{v}^{k+1} = \mathbf{\mathcal{R}}^\pi + \gamma \mathbf{\mathcal{P}}^\pi \mathbf{v}^k $$
118 | #
119 | #
120 | #
121 | 
122 | # +
123 | import numpy as np
124 | import matplotlib.pyplot as plt
125 | 
126 | import matplotlib
127 | matplotlib.rcParams['figure.dpi']=300 # highres display
128 | 
129 | # for subplots within subplots:
130 | from matplotlib import gridspec
131 | 
132 | #For silly animations
133 | from IPython.display import clear_output
134 | from time import sleep
135 | 
136 | # +
137 | from enum import IntEnum
138 | class Dir(IntEnum):
139 |     Up=0
140 |     Down=1
141 |     Left=2
142 |     Right=3
143 | 
144 | 
145 | class GridWorld():
146 |     def __init__(self,nCol,nRow):
147 |         self.nCol=nCol
148 |         self.nRow=nRow
149 |         
150 |     def getZeroGrid(self):
151 |         return np.zeros((self.nRow,self.nCol))
152 |     
153 |     def getNumberGrid(self):
154 |         return np.arange(self.nRow*self.nCol).reshape(self.nRow,self.nCol)
155 |     
156 |     def getRandomPolicyGrid(self):
157 |         policy=np.ones((self.nRow,self.nCol,4))
158 |         return policy*0.25
159 |     
160 |     def go(self,row,col,way):
161 |         if way==Dir.Up:
162 |             row2=max(0,row-1)
163 |             col2=col
164 |         elif way==Dir.Down:
165 |             row2=min(self.nRow-1,row+1)
166 |             col2=col
167 |         elif way==Dir.Left:
168 |             row2=row
169 |             col2=max(0,col-1)
170 |         elif way==Dir.Right:
171 |             row2=row
172 |             col2=min(self.nCol-1,col+1)
173 |         return (row2,col2)
174 |     
175 |     def get(self,vk,row,col,way):
176 |         row2,col2=self.go(row,col,way)
177 |         return vk[row2,col2]
178 |             
179 | def plotGridWorld(cellText,showCorners, title=None, applyFormat=False):
180 |     fig, ax = plt.subplots(figsize=(2,2))
181 |     ax.axis('tight')
182 |     ax.axis('off')
183 |     nRow=cellText.shape[0]
184 |     nCol=cellText.shape[1]
185 |     cellColor=np.zeros((nRow,nCol))
186 | 
187 |     
188 |     if applyFormat:
189 |         # Format table numbers as string
190 |         cellText = [['%.2f' % j for j in i] for i in cellText]
191 | 
192 |     the_table = ax.table(cellText,loc='center',cellLoc='center')
193 |     for pos, cell in the_table._cells.items():
194 |         if not showCorners:
195 |             if (pos == (0,0) or pos == (nRow-1,nCol-1)):
196 |                 cell.set_text_props(color='grey')
197 |                 cell.set_color('grey') 
198 |                 cell.set_edgecolor('black')        
199 |         cell._height = cell._width = 1./nRow
200 |     if title:
201 |         ax.set_title(title)
202 | # -
203 | 
204 | # ### Small Gridworld
205 | #
206 | # The small gridworld consists of a $4 \times 4$ grid array with terminal goal states in the top-left and bottom-right corners. The rules of gridworld are:
207 | # - $-1$ reward each step
208 | # - stop when you reach the terminal goal state (hence the terminal)
209 | # - actions leading out of the grid leave the state unchanged (but still cost $-1$)
210 | #
211 | 
212 | gw=GridWorld(5,5)
213 | cellText=gw.getNumberGrid()
214 | plotGridWorld(cellText,title="The Small Gridworld",showCorners=False)
215 | 
216 | # ### Random policy
217 | # Following a random policy we had have equal odds of moving in any given direction. This means that a policy of any action in any states is $\pi(a|s)=0.25$ since there are four directions we can move in and we have equal odds of each direction.
218 | #
219 | # $$ v_{k+1}(s) = \sum_{a \in \mathcal{A} }0.25  \left( \mathcal{R}^a_s + \gamma v_k(s^\prime) \right) $$
220 | # where $s^\prime$ is the state thate we end up in following action $a$ from state $s$. So if we start in state 10 and following action up we end up in state 6.
221 | #
222 | # So let's start by initialising our grid world to have zero values everywhere.
223 | 
224 | vk=gw.getZeroGrid()
225 | plotGridWorld(vk,showCorners=True,title="Initial Value")
226 | 
227 | 
228 | # #### Updating our values
229 | #
230 | # Now we can use the update equation above to get a new estimate of the value. This new estimate will have two parts (for the non-terminal squares)
231 | # - -1 from moving
232 | # - the value of the square we move to
233 | #
234 | # We will use our random policy $\pi(a|s)=0.25$ to average over the available directions to move.
235 | 
236 | # +
237 | 
238 | #Unneccesarily verbose and loopy for clarity
239 | #Unneccesarily verbose and loopy for clarity
240 | def updateVk(vk,policy):
241 |     global gw
242 |     nRow=vk.shape[0]
243 |     nCol=vk.shape[1]
244 |     vl=gw.getZeroGrid()
245 |     for row in range(nRow):
246 |         for col in range(nCol):
247 |             #Check if we are in terminal state
248 |             if (row==0 and col==0) or (row==nRow-1 and col==nCol-1):
249 |                 continue
250 |             
251 |             #Update our value based on the Bellman equation
252 |             vl[row][col]=-1
253 |             for way in Dir:
254 |                 vl[row][col]+=policy[row][col][way]*gw.get(vk,row,col,way)
255 |     return vl
256 | 
257 | #Reset the value to all zeros
258 | vk=gw.getZeroGrid()
259 | rp=gw.getRandomPolicyGrid()
260 | vk=updateVk(vk,rp) #Do first updat
261 | plotGridWorld(vk,showCorners=True,title="Random-$\pi$ 1 step")
262 | 
263 | plotHere=[2,3,4,5,10,20,40,80,120,160,2000]
264 | for i in range(2,2001):
265 |     vk=updateVk(vk,rp)
266 |     if i in plotHere:
267 |         plotGridWorld(vk,showCorners=True,title="Random-$\pi$ "+str(i)+" steps",applyFormat=True)
268 | 
269 | # -
270 | 
271 | # After ~160 steps the random walk policy has determined the optimal values of the squares. These values are essentially (-1 times) the average number of steps from that starting location to one of the goal states.
272 | #
273 | # ### Determining a better policy
274 | # We can also use our policy $\pi$ to determine a better policy by using the greedy algorithm. The greedy algorithm will favour the directions of most value (e.g. it will always move to the neighbouring square with highest value, if two or more squares have equal value they will have equal probability).
275 | 
276 | # +
277 | # Takes in a value array vk of size nRow*nCol
278 | # Returns a policy array of size nRow*nCol*4 (for up,down,left,right)
279 | # The policy return contains the probability that a particular action
280 | # will be followed
281 | def defineGreedyPolicy(vk):
282 |     arrows='⇧⇩⇦⇨'
283 |     nRow=vk.shape[0]
284 |     nCol=vk.shape[1]
285 |     pol=np.zeros((nRow,nCol,4))
286 |     for row in range(nRow):
287 |         for col in range(nCol):
288 |             #Check if we are in terminal state
289 |             if (row==0 and col==0) or (row==nRow-1 and col==nCol-1):
290 |                 continue
291 |             #Update our policy based on the current value of the cells nearby
292 |             dirs=np.zeros(4)
293 |             for way in Dir:
294 |                 dirs[way]=gw.get(vk,row,col,way)
295 |                 
296 |             maxVal=np.max(dirs)
297 |             #print(row,col,dirs)
298 |             val=0
299 |             for i in Dir:
300 |                 if dirs[i] >= maxVal-1e-9: #The 1e-9 is just for precision in larger grids
301 |                     pol[row][col][i]=1
302 |     
303 |     #Normalise our probabilities
304 |     for row in range(nRow):
305 |         for col in range(nCol):
306 |             norm=np.sum(pol[row][col])
307 |             pol[row][col]=np.divide(pol[row][col],norm,out=np.zeros_like(pol[row][col]),where=norm!=0)
308 |     
309 |     
310 |     return pol
311 | 
312 | def convertPolicyToString(pol):
313 |     arrows='⇧⇩⇦⇨'
314 |     nRow=pol.shape[0]
315 |     nCol=pol.shape[1]
316 |     arStr=[arrows]*(nRow*nCol)
317 |     arStr=np.reshape(arStr,(nRow,nCol))
318 |     for row in range(nRow):
319 |         for col in range(nCol):
320 |             val=''
321 |             for way in Dir:
322 |                 if(pol[row][col][way]>0):
323 |                     val+=arrows[way]
324 |             arStr[row][col]=val
325 |     return arStr
326 | 
327 | 
328 | vk=gw.getZeroGrid()
329 | policy=defineGreedyPolicy(vk)
330 | plotGridWorld(convertPolicyToString(policy),showCorners=False,title="Initial Policy")
331 | 
332 | plotHere=[1,2,3,4,5,10,20,40,80,120,160,200]
333 | for i in range(1,201):
334 |     vk=updateVk(vk,rp)
335 |     policy=defineGreedyPolicy(vk)
336 |     if i in plotHere:
337 |         if i == 1:
338 |             title="Greedy -- 1 step"
339 |         else:
340 |             title="Greedy -- "+str(i)+" steps"
341 |         plotGridWorld(convertPolicyToString(policy),showCorners=False,title=title)
342 | 
343 | 
344 | # -
345 | 
346 | # ### How do we do even better?
347 | # We start with any policy, $\pi$, then:
348 | # 1. Use $\pi$ to evaluate the value, $V$
349 | # 2. Use the greedy algorithm to determine a better policy, $\hat{\pi}_{*}$, based on moving to the highest value $V$
350 | # 3. Rinse, repeat using $\pi=\hat{\pi}_{*}$,
351 | # 4. Stop when we reach some convergence (e.g. when the values or policy don't change)
352 | #
353 | # At this point we should have reached the optimal policy $\pi_*$
354 | 
355 | # +
356 | vk=gw.getZeroGrid()
357 | policy=defineGreedyPolicy(vk)
358 | plotGridWorld(convertPolicyToString(policy),showCorners=False,title="Initial Policy")
359 | 
360 | plotHere=[1,2,3,4,5,10,20,40,80,120,160,200]
361 | for i in range(1,6):
362 |     vk=updateVk(vk,policy)
363 |     policy=defineGreedyPolicy(vk)
364 |     if i in plotHere:
365 |         if i == 1:
366 |             title="$\hat{\pi}_*$ -- 1 step"
367 |         else:
368 |             title="$\hat{\pi}_*$ -- "+str(i)+" steps"
369 |         plotGridWorld(convertPolicyToString(policy),showCorners=False,title=title)
370 | 
371 | 
372 | # -
373 | 
374 | # ### Have we reached the optimal policy??
375 | #
376 | # To check we have reached the optimal policy we can try and use the policy to evaluate the optimal value function. 
377 | 
378 | vk=gw.getZeroGrid()
379 | pistar=policy
380 | for i in range(5):
381 |     vk=updateVk(vk,pistar)
382 |     plotGridWorld(vk,showCorners=True,title=r"$v_\pi$ -- "+str(i)+" steps",applyFormat=True)
383 | 
384 | # ### Summary
385 | # The optimal policy achieves the optimal value after $N-1$ steps, where $N$ is the size of grid (well $N \times N$).
386 | 
387 | 
388 | 


--------------------------------------------------------------------------------
/Week4/Week4_Autoencoder.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Autoencoders
 16 | #
 17 | # In this section we are going to introduce how you can use convolution neural models (CNN) as autoencoders. Autoencoders are an interesting category of neural model which at first appear to do something trivial, which is to copy its input to its output.
 18 | #
 19 | # ## What is the point of a model that just gives you back what you give it?
 20 | #
 21 | # So what is the point of a model that just gives you back exactly what you gave it? There are a number of possible uses of   autoencoders:
 22 | # 1. Image compression -- if one layer of the model uses a smaller representation than the input image then the first half of the autoencoder (up to the bottleneck) is an effective image compression algorithm.
 23 | # 2. Noise removal -- similarly if the autoencoder is trained to generate clean images from images that have add noise added to them it can be a very useful and efficient form of noise removal. Unfortunately, most of the time we don't have clean versions of all the images we only have noisy versions (think images from a telescope ... it is not possible to make clean images... if it was we would have built a better telescope!). But as 2. Noise removal -- similarly if the autoencoder is trained to generate clean images from images that have add noise added to them it can be a very useful and efficient form of noise removal. Unfortunately, most of the time we don't have clean versions of all the images we only have noisy versions (think images from a telescope ... it is not possible to make clean images... if it was we would have built a better telescope!). But as [NVIDIA's 2018 Noise2Noise paper](https://research.nvidia.com/publication/2018-07_Noise2Noise%3A-Learning-Image) shows if you train a model to make noisy images from noisy images the nmost effective model will actually be producing clean images!
 24 | #
 25 | # ### Dimensionality of autoencoders
 26 | # Autoencoders can be broken down into two parts an encoder and a decoder. For example we could write
 27 | # $$ A(x) = p_\theta \left(q_\phi\left(x\right)\right)$$
 28 | # where $A(x)$ is the autoencoder which is mapping from dimension $X \rightarrow X$, $q_\phi\left(x\right)$ the encoder mapping from $X\rightarrow Z$ and $p_\theta(z)$ is the decoder mapping from $Z \rightarrow X$.
 29 | #
 30 | # A perfect autoencoder would have the same effect as the identity matrix, $I$ on $x$. But if the dimensionality is such that $dim(Z) \lt dim(X)$, then the encoder part is effectively compressing the input (normally image) down to a lower dimensional representation.
 31 | #
 32 | # ### Latent space
 33 | # In a lot of machine learning literature you will come across the term latent space to describe the reduced dimensionality in which we are able to describe the compressed input.
 34 | # ![Latent Space Illustration](https://hackernoon.com/hn-images/1*op0VO_QK4vMtCnXtmigDhA.png)
 35 | # *Depiction of convolutional neural model. Source: Source: Hackernoon Latent Space Visualization.*
 36 | #
 37 | 
 38 | # ### Let's make an autoencoder
 39 | #
 40 | # This code is heavily inspired by a tutorial from https://machine-learning-for-physicists.org and is released under the same Creative Commons License.
 41 | 
 42 | # +
 43 | import matplotlib.pyplot as plt
 44 | import numpy as np
 45 | import math
 46 | 
 47 | # TensorFlow and tf.keras
 48 | import tensorflow as tf
 49 | from tensorflow import keras
 50 | 
 51 | import matplotlib.style #Some style nonsense
 52 | import matplotlib as mpl #Some more style nonsense
 53 | 
 54 | 
 55 | #Set default figure size
 56 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
 57 | mpl.rcParams["legend.frameon"] = False
 58 | mpl.rcParams['figure.dpi']=200 # dots per inch
 59 | 
 60 | #Useful for debugging problems
 61 | print(tf.__version__)
 62 | 
 63 | 
 64 | # +
 65 | #A big messy function to do the training
 66 | # model -- our keras neural model autoencoder
 67 | # image_generator -- a function to generate random images for the training (see below for examples)
 68 | # img_size -- the size of our image in pixels
 69 | # batchsize -- the number of images to include in each training batch
 70 | # steps -- the number of steps taken in the training
 71 | #
 72 | # returns an array of the costs
 73 | def generate_and_train(model,image_generator,img_size,batchsize,steps):
 74 |    
 75 |     #Generate an array of the numbers 1 to img_size and create a meshgrid from them    
 76 |     pixels=np.linspace(-1,1,img_size)
 77 |     x,y=np.meshgrid(pixels,pixels)
 78 |     
 79 |     #Now create a test image using 1 call to image_generator
 80 |     #y_test=np.zeros([1,pixels,pixels,1])
 81 |     #y_test[:,:,:,0]=image_generator(1,x,y)
 82 |     
 83 |     #Now create the empty arrays for the images and cost
 84 |     y_in=np.zeros([batchsize,img_size,img_size,1])
 85 |     y_target=np.zeros([batchsize,img_size,img_size,1])
 86 |     cost=np.zeros(steps)
 87 |     
 88 |     #Loop through the steps, get a random batch of samples, train the model, repeat
 89 |     for k in range(steps):
 90 |         # produce samples:
 91 |         y_in[:,:,:,0]=image_generator(batchsize,x,y)
 92 |         y_target=np.copy(y_in) # autoencoder wants to reproduce its input!
 93 |         
 94 |         # do one training step on this batch of samples:
 95 |         cost[k]=model.train_on_batch(y_in,y_target)
 96 |     
 97 |     return cost,y_target
 98 | 
 99 | def get_test_image(image_generator,img_size):
100 |     #Generate an array of the numbers 1 to img_size and create a meshgrid from them    
101 |     pixels=np.linspace(-1,1,img_size)
102 |     x,y=np.meshgrid(pixels,pixels)
103 |     
104 |     #Now create a test image using 1 call to image_generator
105 |     y_test=np.zeros([1,img_size,img_size,1])
106 |     y_test[:,:,:,0]=image_generator(1,x,y)
107 |     return y_test
108 | 
109 | # A function to generate and plot a single test image and the output of our model
110 | # only to be called after training the model
111 | def plot_test_image(model,image_generator,img_size):
112 |     #Get random test image
113 |     y_test=get_test_image(image_generator,img_size)
114 |     
115 |     #Create the output image
116 |     y_test_out=model.predict_on_batch(y_test)
117 |     fig, ax = plt.subplots(1,2)
118 |     ax[0].imshow(y_test[0,:,:,0],origin='lower')
119 |     ax[0].set_title("Input")
120 |     ax[1].imshow(y_test_out[0,:,:,0],origin='lower')
121 |     ax[1].set_title("Output")
122 |     
123 | def print_layers(network, y_in):
124 |     """
125 |     Call this on some test images y_in, to get a print-out of
126 |     the layer sizes. Shapes shown are (batchsize,pixels,pixels,channels).
127 |     After a call to the visualization routine, y_target will contain
128 |     the last set of training images, so you could feed those in here.
129 |     """
130 |     layer_features=get_layer_activations(network,y_in)
131 |     #print(layer_features)
132 |     for idx,feature in enumerate(layer_features):
133 |         s=np.shape(feature)
134 |         print("Layer "+str(idx)+": "+str(s[1]*s[2]*s[3])+" neurons / ", s)
135 | 
136 | def get_layer_activation_extractor(network):
137 |     #print(network.inputs)
138 |     #for layer in network.layers:
139 |     #    print(layer.output)
140 |     return(keras.Model(inputs=network.inputs,
141 |                             outputs=[layer.output for layer in network.layers]))
142 | 
143 | def get_layer_activations(network, y_in):
144 |     """
145 |     Call this on some test images y_in, to get the intermediate 
146 |     layer neuron values. These are returned in a list, with one
147 |     entry for each layer (the entries are arrays).
148 |     """
149 |     extractor=get_layer_activation_extractor(network)
150 |     #print(extractor)
151 |     layer_features = extractor(y_in)
152 |     return layer_features
153 |     
154 | 
155 | 
156 | # -
157 | 
158 | # ## Example 1: Circles, circles everywhere
159 | # This example isn't even a real autoencoder because it never shrinks the dimensionality of the representation. So it should in theory be possible to train it to perfection.
160 | 
161 | # +
162 | image_size=30
163 | 
164 | # A simple image generator that returns an array of batchsize images
165 | # each image has a size of x * y pixels
166 | # in this image each image has a randomly placed circle (and the circle is of random size)
167 | def my_generator(batchsize,x,y):
168 |     R=np.random.uniform(size=batchsize)
169 |     x0=np.random.uniform(size=batchsize,low=-1,high=1)
170 |     y0=np.random.uniform(size=batchsize,low=-1,high=1)
171 |     return( 1.0*((x[None,:,:]-x0[:,None,None])**2 + (y[None,:,:]-y0[:,None,None])**2 < R[:,None,None]**2) )
172 | 
173 | input_shape=(image_size,image_size,1)
174 | #Now let's define a model to try and learn how to make these images
175 | model=keras.Sequential()
176 | input_layer=keras.layers.Input(shape=input_shape)
177 | model.add(input_layer)
178 | # 3x3 kernel size, 10 channels in first hidden layer:
179 | model.add(keras.layers.Conv2D(10,3,activation="sigmoid",padding='same'))
180 | # 3x3 kernel size, only 1 channel in last hidden layer:
181 | model.add(keras.layers.Conv2D(1,3,activation="linear",padding='same'))
182 | model.compile(loss='mean_squared_error',
183 |               optimizer='adam')
184 | model.summary()
185 | 
186 | # -
187 | 
188 | #Just for fun let's plot what the image looks like before any training
189 | #Probably since our input image is just 1 or 0 the output even with random model weights and biases will
190 | #have a circle imprint
191 | plot_test_image(model,my_generator,image_size)
192 | 
193 | #Now we can do the actual model training
194 | steps=100
195 | cost,_=generate_and_train(model,my_generator,img_size=image_size,batchsize=100,steps=steps)
196 | #Plot the cost
197 | fig, ax = plt.subplots()
198 | stepArray=np.arange(steps) 
199 | ax.plot(stepArray,cost,linewidth=3) 
200 | ax.set_xlabel("Step Number") 
201 | ax.set_ylabel("Cost")
202 | 
203 | #And now when we look our model is probably doing a much better job of reproducing the image
204 | plot_test_image(model,my_generator,image_size)
205 | 
206 | # ## But what is our network doing?
207 | # We can extract information from the layers in out neural network
208 | 
209 | # +
210 | model.summary()
211 | layer_outputs = [layer.output for layer in model.layers[:1]] # Extracts the outputs of the hidden layer
212 | activation_model = keras.models.Model(inputs=model.inputs, outputs=layer_outputs) # Creates a model that will return these outputs, given the model input
213 | 
214 | 
215 | 
216 | # -
217 | 
218 | # ## Running the activation model in predict mode
219 | 
220 | #Get random test image
221 | y_test=get_test_image(my_generator,image_size)
222 | #Now use our activation_model on our test image
223 | activations = activation_model.predict(y_test) 
224 | print(activations.shape)
225 | 
226 | # The shape of the activations is a $30 \times 30$ with 10 channels. Now we can plot one of these channels.
227 | 
228 | plt.matshow(activations[0, :, :, 4], cmap='viridis')
229 | 
230 | #There are 10 channels in the hidden layer so we will plot the channels
231 | # in a 5x2 grid
232 | fig, ax = plt.subplots(nrows=2, ncols=5)  #Make the subplot array
233 | for i in range(10):  #Loop over the channels
234 |     row=int(i/5)
235 |     col=int(i%5)
236 |     ax[row,col].set_axis_off()
237 |     ax[row,col].matshow(activations[0, :, :, i], cmap='viridis')  #Plot the channel
238 | plt.subplots_adjust(left=0.05,
239 |                     bottom=0, 
240 |                     right=0.9, 
241 |                     top=0.9, 
242 |                     wspace=0.1, 
243 |                     hspace=-0.6)  #Adjust the space between the subplots so there isn't acres of whitespace
244 | 
245 | # # Example 2: Let's make a bottleneck -- our first real encoder
246 | 
247 | model2=keras.models.Sequential()
248 | # 3x3 kernel size, 10 channels in first hidden layer:
249 | model2.add(keras.layers.Input(shape=(None,None,1))) #Here we don't specify the image size
250 | model2.add(keras.layers.Conv2D(4,5,activation="sigmoid",padding='same'))
251 | model2.add(keras.layers.AveragePooling2D(pool_size=(3,3),padding='same')) # down
252 | model2.add(keras.layers.Conv2D(4,5,
253 |                activation="sigmoid",padding='same'))
254 | model2.add(keras.layers.AveragePooling2D(pool_size=(3,3),padding='same')) # down
255 | model2.add(keras.layers.Conv2D(1,3,
256 |                activation="sigmoid",padding='same'))
257 | model2.add(keras.layers.UpSampling2D(size=(3,3))) # up
258 | model2.add(keras.layers.Conv2D(4,5,
259 |                activation="sigmoid",padding='same'))
260 | model2.add(keras.layers.UpSampling2D(size=(3,3))) # up
261 | model2.add(keras.layers.Conv2D(4,5,
262 |                activation="sigmoid",padding='same'))
263 | model2.add(keras.layers.Conv2D(1,3,activation="linear",padding='same'))
264 | model2.compile(loss='mean_squared_error',
265 |               optimizer='adam')
266 | model2.summary()
267 | 
268 | #Now we can do the actual model training
269 | steps=500
270 | cost,y_target=generate_and_train(model2,my_generator,img_size=9*3,batchsize=100,steps=steps)
271 | #Plot the cost
272 | fig, ax = plt.subplots()
273 | stepArray=np.arange(steps) 
274 | ax.plot(stepArray,cost,linewidth=3) 
275 | ax.set_xlabel("Step Number") 
276 | ax.set_ylabel("Cost")
277 | 
278 | #And now when we look our model is probably doing a much better job of reproducing the image
279 | plot_test_image(model2,my_generator,30)
280 | 
281 | print_layers(model2,y_target)
282 | 
283 | model2.summary()
284 | 
285 | 
286 | # +
287 | #This function had its plotting routine take from https://towardsdatascience.com/visualizing-intermediate-activation-in-convolutional-neural-networks-with-keras-260b36d60d0
288 | #The function takes a trained neural network model and a test image and plots the activations at each layer for each channel in the network
289 | def plot_intermediate_layers(model,test_img,images_per_row=4):
290 |     layer_names = []
291 |     for layer in model.layers[:]:
292 |         layer_names.append(layer.name) # Names of the layers, so you can have them as part of your plot
293 |     print(layer_names)
294 | 
295 |     layer_outputs = [layer.output for layer in model.layers[:]] # Extracts the outputs of the hidden layer
296 |     activation_model = keras.models.Model(inputs=model.inputs, outputs=layer_outputs) # Creates a model that will return these outputs, given the model input
297 |     activations = activation_model.predict(test_img) 
298 |    
299 |     for layer_name, layer_activation in zip(layer_names, activations): # Displays the feature maps
300 |         n_features = layer_activation.shape[-1] # Number of features in the feature map
301 |         size = layer_activation.shape[1] #The feature map has shape (1, size, size, n_features).
302 |         n_rows = n_features // images_per_row # Tiles the activation channels in this matrix
303 |         if(n_rows==0):
304 |             n_rows=1
305 |     
306 |         display_grid = np.zeros((size * n_rows, min(images_per_row,n_features) * size))
307 |         #print(display_grid.shape)
308 |         #print(layer_name, "n_features",n_features,size,n_cols)
309 | 
310 |         for i in range(n_features):
311 |             row = i // images_per_row
312 |             col = i % images_per_row
313 |             channel_image = layer_activation[0,:, :,i]
314 |             channel_image -= channel_image.mean() # Post-processes the feature to make it visually palatable
315 |             channel_image /= channel_image.std()
316 |             channel_image *= 64
317 |             channel_image += 128
318 |             channel_image = np.clip(channel_image, 0, 255).astype('uint8')
319 |             display_grid[ row * size : (row + 1) * size,col * size : (col + 1) * size] = channel_image
320 |         scale = 1. / size
321 |         plt.figure(figsize=(scale * display_grid.shape[1],
322 |                         scale * display_grid.shape[0]))
323 |         plt.title(layer_name)
324 |         plt.grid(False)
325 |         plt.imshow(display_grid, aspect='auto', cmap='viridis')
326 |         
327 |         
328 | plot_intermediate_layers(model2,y_test)
329 | # -
330 | 
331 | # ## Summary 
332 | # So our autoencoder manages to have a bottleneck which is just 9 neurons wide but still manages to roughly reproduce our input images.
333 | #
334 | # ### Tutorials
335 | # 1. What happens if you change the acctivation function from `sigmoid` to `relu`?
336 | # 2. Change the generator for different kinds of images
337 | 
338 | 
339 | 


--------------------------------------------------------------------------------
/Week1/Week1_CurveFitting.py:
--------------------------------------------------------------------------------
  1 | # ---
  2 | # jupyter:
  3 | #   jupytext:
  4 | #     text_representation:
  5 | #       extension: .py
  6 | #       format_name: light
  7 | #       format_version: '1.5'
  8 | #       jupytext_version: 1.14.4
  9 | #   kernelspec:
 10 | #     display_name: Python 3 (ipykernel)
 11 | #     language: python
 12 | #     name: python3
 13 | # ---
 14 | 
 15 | # # Curve Fitting
 16 | 
 17 | # We have introduced the analogy of machine learning essentially just being curve fitting with a large number of parameters. So in this notebook we will look into some of the basics of curve fitting, including:
 18 | # - Brief reminder of terminology 
 19 | # - Maximum likelihood
 20 | # - $\chi^2$ test and Gaussian distribution
 21 | # - Mean squared error
 22 | # - Parameter estimation
 23 | #
 24 | 
 25 | # ## Gaussian distribution
 26 | # In many circumstances we are dealing with data that can be well described by the Gaussian (normal) distribution. The probability distribution function for a Gaussian with mean $\mu$ and standard deviation $\sigma$ is 
 27 | # $$P(x; \mu, \sigma) = \frac{1}{\sigma \sqrt{2 \pi}} e^{-\frac{1}{2}\left(\frac{x-\mu}{\sigma}\right)^2} $$
 28 | #
 29 | # Now one common example of curve fitting is the case when we have some number, $N$, of data points, $x_i$, and we are interested in determining which values of $\mu$ and $\sigma$ are the ones which 'fit' our data (assuming the data are described by a Gaussian distribution.
 30 | #
 31 | # ## Maximum likelihood
 32 | #
 33 | # To determine the likelihood of our data given a Gaussian hypothesis we can take the product of the individual probabilities
 34 | # $$ L(x; \mu, \sigma) = \prod_i \frac{1}{\sigma \sqrt{2 \pi}} e^{-\frac{1}{2}\left(\frac{x_{i}-\mu}{\sigma}\right)^2} = \left( \frac{1}{\sigma \sqrt{2 \pi}}\right)^N e^{-\frac{1}{2} \sum_i (\frac{x_{i}-\mu}{\sigma})^2} $$
 35 | #
 36 | # Whilst this seems like a bit of mess we can simplify things by taking the natural log of the likelihood (the log-likelihood).
 37 | # $$ \ln L(x; \mu, \sigma) = N \ln \left( \frac{1}{\sigma \sqrt{2 \pi}}\right) -\sum_i \frac{1}{2} \left(\frac{x_{i}-\mu}{\sigma}\right)^2$$
 38 | #
 39 | # Then if we want to find the value of $\mu$ that maximises the likelihood we can simply differentiate the log-likehood with respect to $\mu$.
 40 | # $$ 0 = \frac{\partial \ln L}{\partial \mu} = - \sum_i \frac{1}{\sigma} \left(x_{i}-\mu\right)$$
 41 | # which results in
 42 | # $$\sum_i x_i = \sum_i \mu = N \mu$$
 43 | # or $$ \mu = \frac{1}{N} \sum_i x_i$$
 44 | #
 45 | # This is actually an illustration of an important feature of maximum likelihood estimation... in that it produces unbiased estimates of parameters.
 46 | #
 47 | 
 48 | # ## $\chi^2$ test
 49 | #
 50 | # One interesting feature of our discussion of the log-likelihood of the Gaussian distributed data is that it naturally introduced the $\chi^2$ test statistic, which is effectively what we minimised above (when we maximised the likelihood)
 51 | # $$ -2 \ln L \propto \chi^2 = \sum_i \left(\frac{x_{i}-\mu}{\sigma}\right)^2$$
 52 | #
 53 | # The close connections between the $\chi^2$ test and the Gaussian log-likelihood unfortunately does tend to lead to a certain amount of sloppiness regarding language and often we will talk about likelihoods which aren't quite mathematically defined as such. Of course in the field of machine learning much of this confusion is washed away by the use of an entirely different set of jargon (e.g. cost functions).
 54 | #
 55 | # The $\chi^2$ test is very similar to the least squares minimisation but due to its connection with the Gaussian probability distribution it has a number of interesting properties that we don't have the time or inclination to dwell on here. They are covered in detail in the fourth year statistical data analysis course.
 56 | #
 57 | # ## Mean squared error
 58 | #
 59 | # One quantity that is closely related to the $\chi^2$ is the mean squared error. One advantage of the mean squared error is that it can be calculated even when the value $\sigma$ is unknown or when the data is not distributed according to the Gaussian dsitribution. The mean sqaured error, $\textrm{MSE}$ is defind as:
 60 | # $$ \textrm{MSE} = \frac{1}{N} \sum_i^N \left( f(x_i;\theta) - \tilde{f} \right)^2 $$
 61 | # where $\tilde{f}$ is the true distribution that we are trying to describe with $f(x_i;\theta)$.
 62 | #
 63 | # ## Total sqaured error
 64 | #
 65 | # Sometimes it wis more convenient to work with the total sqaured error, TSE:
 66 | # $$ \textrm{TSE} = \sum_i^N \left( f(x_i;\theta) - \tilde{f} \right)^2 $$
 67 | # which of course is just $N$ times the mean squared error.
 68 | #
 69 | #
 70 | #
 71 | 
 72 | # ## Gradient descent
 73 | # We have already seen an example of gradient descent above. When we differentiated the log-likelihood with respect to the parameter $\mu$ we were effectively determining the gradient of our 'cost' function with respect to the model parameters. 
 74 | #
 75 | # Now more genereally if we have a function of $x$ which depends on some number of parameters $\theta$ then we can define our $\chi^2$ as
 76 | # $$ \chi^2 = \sum_i^N \left( \frac{f(x_i;\theta) - \tilde{f}}{\sigma} \right)^2 $$
 77 | # where $\tilde{f}$ is the true distribution that we are trying to describe with $f(x_i;\theta)$. Ultimately we want to determine the parameters $\theta$ that minimise our $\chi^2$. So we want to find the gradient of $\chi^2$ with respect to $\theta$
 78 | # $$ \frac{\partial \chi^2}{\partial \theta}  = \frac{\partial \chi^2}{\partial f}  \frac{\partial f}{\partial \theta}$$
 79 | # $$ \frac{\partial \chi^2}{\partial \theta}  =  \sum_i^N 2 \left( \frac{f(x_i;\theta) - \tilde{f}}{\sigma} \right) \frac{\partial f}{\partial \theta} $$
 80 | #
 81 | 
 82 | # ## Stochastic gradient descent
 83 | # In the above example our sum is implictly a sum over the full data set. In stochastic gradient descent instead of using the full dataset we instead use a small batch of data, say of size $n$, that is randomly sampled from the full data set. So we can using a sample of data determine our estimate of the gradient
 84 | # $$ \left< \frac{\partial \chi^2}{\partial \theta} \right> = \sum_i^n \frac{2}{\sigma} \left(f(x_i;\theta) -\tilde{f}\right) \frac{\partial f}{\partial \theta}$$
 85 | # or 
 86 | # $$ \left< \frac{\partial \chi^2}{\partial \theta} \right> \propto \left< f(x_i;\theta) -\tilde{f}\right> \frac{\partial f}{\partial \theta} = \left< \Delta f\right> \frac{\partial f}{\partial \theta} $$
 87 | # where the $\left< \right>$ represents the average over the batch of $n$ samples.
 88 | #
 89 | # Using this gradient starting a some starting value of $\theta_i$ we can define an update rule to determine the next value of $\theta_{i+1}$ via
 90 | # $$ \theta_{i+1} = \theta_{i} - \eta_i  \left< \Delta f\right> \frac{\partial f}{\partial \theta} $$
 91 | # where $\eta_i$ is the *learning rate* which controls how big a step we take from one value of $\theta$ to the next. Now it is clear for sufficiently small values of the learning rate, $\eta_i$, this method will converge to a *local minimum* of our cost function (in the case the $\chi^2$). But if we choose too small a value of the learning rate we will obviously take too many steps and therefore waste a potential a huge amount of computational effort. As suggested by the subscript the optimum value of the learning rate typically changes depending on where we are in the *learning process*, e.g. how many steps we have taken in the minimisation. 
 92 | 
 93 | # ## Manual curve fitting example
 94 | # Now we are going to actual run some code to try and do some actual curve fitting using the stochastic gradient descent method. This code is inspired by https://machine-learning-for-physicists.org/ and is released under the same Creative Commons Sharealike License. 
 95 | # https://creativecommons.org/licenses/by-sa/4.0/
 96 | 
 97 | # +
 98 | import numpy as np  #import the numpy library as np
 99 | import matplotlib.pyplot as plt #import the pyplot library as plt
100 | import matplotlib.style #Some style nonsense
101 | import matplotlib as mpl #Some more style nonsense
102 | 
103 | #Set default figure size
104 | #mpl.rcParams['figure.figsize'] = [12.0, 8.0] #Inches... of course it is inches
105 | mpl.rcParams["legend.frameon"] = False
106 | mpl.rcParams['figure.dpi']=200 # dots per inch
107 | 
108 | # -
109 | 
110 | # Let's start by looking at a simple non linear function that depends on two parameters $\theta_1$ and $\theta_2$, $$f(x,\theta_1,\theta_2) = \frac {\theta_1}{\left(\theta_2-x\right)^2 +1}$$
111 | #
112 | # One advantage of this function is that we can differentiate it analytically with respect to the parameters theta
113 | # $$ \frac{\partial f}{\partial \theta_1} = \frac {1}{\left(\theta_2-x\right)^2 +1}$$
114 | # $$ \frac{\partial f}{\partial \theta_2} = \frac {2\left(x-\theta_2\right)\theta_1}{\left(\left(\theta_2-x\right)^2 +1\right)^2}$$
115 | 
116 | # +
117 | def f(x,theta):
118 |     """
119 |     This is a function which calculates
120 |         .. math::
121 |             f(x,\theta_1,\theta_2) = \frac {\theta_1}{\left(\theta_2-x\right)^2 +1} 
122 |     Args:
123 |         x: A numpy array of x values
124 |         theta: a list of [theta1,theta2]
125 | 
126 |     Returns:
127 |         A numpy array of f(x,theta)
128 |     """
129 |     return (theta[0])/(((theta[1]-x)**2)+1.0)
130 |     
131 | 
132 | def grad_f(x,theta):
133 |     """
134 |     This is a function which calculates
135 |         .. math::
136 |             \frac{\partial f}{\partial \theta_1} = \frac {1}{\left(\theta_2-x\right)^2 +1}
137 |             \frac{\partial f}{\partial \theta_2} = \frac {2\left(x-\theta_2\right)\theta_1}{\left(\left(\theta_2-x\right)^2 +1\right)^2}
138 |             
139 |     Args:
140 |         x: A numpy array of x values
141 |         theta: a list of [theta1,theta2]
142 | 
143 |     Returns:
144 |         A 2D numpy array of [df/dtheta1(x,theta),df/dtheta2]
145 |     """
146 |     return np.array([1/((theta[1]-x)**2 +1.0),  2*(x-theta[1])*theta[0]/((theta[1]-x)**2+1.0)**2])
147 |    
148 | 
149 | def true_f(x):
150 |     """
151 |     This is a function which calls f(x,theta) with theta=[2,0.5]
152 |     Args:
153 |         x: A numpy array of x values
154 | 
155 |     Returns:
156 |         A numpy array of f(x,[2,0.5])
157 |     """
158 |     return f(x,[2.0,0.5])
159 | 
160 | # Get randomly sampled x values
161 | def samples(nsamples,width=2.0):
162 |     """
163 |     Returns an array of random numbers from 
164 |     Args:
165 |         nsamples: The length of the random samples array
166 | 
167 |     Returns:
168 |         A numpy array of f(x,[2,0.5])
169 |     """
170 |     return(width*np.random.randn(nsamples))
171 | 
172 | def get_mean_squared_error(x, theta):
173 |     """
174 |     Returns the mean squared error
175 |         .. math::
176 |             MSE (x,\theta) = \frac{\sum_i=1^N \left(f(x,\theta) - f(2,0.5) \right)^2}{N}  
177 |     Args:
178 |         x: A numpy array of x values
179 |         theta: a list of [theta1,theta2]
180 | 
181 |     Returns:
182 |         A single number the mean squared error 
183 |     """
184 |     return np.average((f(x,theta)-true_f(x))**2)
185 | 
186 | def get_2d_mean_squared_error(theta0Vals,theta1Vals,numSamples):
187 |     """
188 |     Returns a 2D array of mean squared error values
189 |     Args:
190 |         theta0Vals: An array of the theta0 values
191 |         theta1Vals: An array of the theta1 values
192 |         numSamples: Number of random samples to take at each point
193 | 
194 |     Returns:
195 |         A 2d array of mean squared error values evaluated at each pair of theta values
196 |     """
197 |     N0=len(theta0Vals)  # Length of theta0Vals array
198 |     N1=len(theta1Vals)  # Length of theta1Vals array
199 |     output=np.zeros((N0,N1)) # 2D array for output values
200 |     for j0 in range(N0): # Loop over theta0 indices
201 |         for j1 in range(N1): # Loop over theta1 indices
202 |             theta=np.array([theta0Vals[j0],theta1Vals[j1]])  # Temp theta array
203 |             x=samples(numSamples) # Get numSamples random numbers
204 |             output[j0,j1]=get_mean_squared_error(x,theta) # Calculate the mean_squared_error
205 |     return(output)
206 | 
207 | 
208 | 
209 | # -
210 | 
211 | #Just to remind ourselves of what shape the numpy arrays are
212 | x=np.linspace(-10,10,100)  #Get 100 points from -10 to 10
213 | print("x.shape",x.shape)
214 | print("f.shape",f(x,[1,-3]).shape)
215 | print("grad_f.shape",grad_f(x,[1,-3]).shape)
216 | 
217 | #Here we will plot our true function with theta=[2,0.5] and one with theta=[1,-3]
218 | fig, ax = plt.subplots()  #I like to make plots using this silly fig,ax method but plot how you like
219 | ax.plot(x,true_f(x),linewidth=3,label=r"True $f(\theta=[2,0.5])$")
220 | ax.plot(x,f(x,[1,-3]),linewidth=3,label=r'$f(\theta=[1,-3])$')
221 | ax.set_xlabel("x")
222 | ax.set_ylabel("f(x)")
223 | ax.legend()
224 | 
225 | # ## Plot the likelihood (mean squared error) surface
226 | # In this section we will plot what the mean squared error surface in $\theta_0$ vs $\theta_1$ space. 
227 | #
228 | # Remember we are plotting the mean squared error because we it is simple to calculate and will be related to the likelihood. Sometimes we are lazy and we call it the likelihood surface or chi-squared surface, but strictly speaking that isn't true.
229 | 
230 | # Now we are going to get a 2D map of our mean squared error over a range of theta0,theta1 space  
231 | theta0Vals=np.linspace(-4,4,50) #Get 50 theta0 values from -4 to +4
232 | theta1Vals=np.linspace(-3,3,50) #Get 50 theta1 values from -3 to +3
233 | chi2=get_2d_mean_squared_error(theta0Vals,theta1Vals,10000) #Generate the mean squared error map with 10000 random samples per point
234 | X,Y=np.meshgrid(theta0Vals,theta1Vals,indexing='ij') # X,Y are both
235 | nlevels=20 # Number of levels (white lines on plots) we will use for the contour plot
236 | fig, ax = plt.subplots() #Get the fig and ax objects for the plot 
237 | ax.contourf(X,Y,chi2,nlevels) #Plot filled contours (colour map below)
238 | ax.contour(X,Y,chi2,nlevels,colors="white") #Plot line contours (white lines below)
239 | ax.set_xlabel(r"$\theta_0$") #Label the axis
240 | ax.set_ylabel(r"$\theta_1$") #Label the axis
241 | 
242 | 
243 | # ## Stochastic gradient descent
244 | # Now we will try and implement a stochastic gradient descent algorithm
245 | 
246 | # +
247 | numSteps=150 #Number of steps in our stochastic gradient descent algorithm
248 | theta=[-3,0.5] #Starting place, you can change this and see what happens
249 | eta=0.1 #'Learning' rate, how far do we step each time
250 | mseArray=np.zeros(numSteps)  #Array for plotting
251 | thetaArray=np.zeros((numSteps+1,2))  #Array for plotting 
252 | thetaArray[0]=theta #Starting step
253 | 
254 | 
255 | for i in range(numSteps): #Loop over i from 0 to numSteps-1
256 |     x=samples(10) # Generate 10 random samples... change this number to see what happens
257 |     mse=get_mean_squared_error(x,theta)  #Get the mean squared error for these samples
258 |     mseArray[i]=mse #For plotting
259 |     #Work out difference to true function
260 |     deviation=f(x,theta)-true_f(x)
261 |     #Now work out where do go next
262 |     theta-=eta*np.average(deviation[None,:]*grad_f(x,theta),axis=1)
263 |     thetaArray[i+1]=theta  #For plotting
264 |     
265 | # -
266 | 
267 | # First plot is going to be step number vs mean_squared_error
268 | fig, ax = plt.subplots()  #I like to make plots using this silly fig,ax method but plot how you like
269 | count=np.arange(numSteps+1)  #The integers from 0 up to num steps
270 | ax.plot(count[:-1],mseArray,linewidth=3)
271 | ax.set_xlabel("Step Number")
272 | ax.set_ylabel(r"Mean Squared Error")
273 | 
274 | # Now we are going to get a 2D map of our mean_squared_error over a range of theta0,theta1 space  
275 | # And overlay the steps taken by the stochastic gradient descent algorithm
276 | fig, ax = plt.subplots() #Get the fig and ax objects for the plot 
277 | ax.contourf(X,Y,chi2,nlevels)
278 | ax.contour(X,Y,chi2,nlevels,colors="white")
279 | ax.set_xlabel(r"$\theta_0$")
280 | ax.set_ylabel(r"$\theta_1$")
281 | ax.quiver(thetaArray[:-1,0], thetaArray[:-1,1], thetaArray[1:,0]-thetaArray[:-1,0], thetaArray[1:,1]-thetaArray[:-1,1], scale_units='xy',scale=1)
282 | 
283 | 
284 | # # Suggested Tasks
285 | # So we have successfully achieved our first ever optimisation. Things to try:
286 | # - Investigate the 'stability' of the fit: does it always converge to the correct place?
287 | #     - You could try changing the learning rate or the number of samples or the starting location or true location
288 | # - From the same starting place what is the optimal number of samples and learning rate to get close to the true answer. Here close means that the deviation from true $f$ is less than some (arbritrary but small) threshold.    
289 | # - Try to add 'noise' to the determination of the function (e.g. add some Gaussian noise to the result of the function f
290 | # - Try some different functions, why didn't we start with this function?  $$f(x,\theta_1,\theta_2) = \frac {\theta_1}{\left(\theta_2-x\right)^2}$$
291 | # - What about this function? $$\frac{\sin(\theta_1 (x-\theta_0))}{5+x^2}$$
292 | #
293 | #
294 | 
295 | 
296 | 
297 | 
298 | 
299 | 


--------------------------------------------------------------------------------