{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# CS341 Project 4: Genetic Algorithms\n",
"\n",
"Your first goal is to analyze the performance of several genetic algorithms in the context of parameter-estimation. Your second goal is to analyze the results, i.e. what do we learn about the model? In this project, we are revisiting Goldbeter's 5-state fly clock model, whose parameters were originally chosen \"by hand.\" You will use a cost function which ensures the oscillations in constant darkness have a period of 23.6 hours.\n",
"\n",
"There are many, many variants of genetic algorithms. We will be using the following algorithm.\n",
"\n",
"
\n",
"
Create an initial population of $\\lambda$ individuals $G^0$ and generate their costs.\n",
"
Sort the individuals in $G^0$ by cost (in preparation for selection)\n",
"
For each generation $g$\n",
"
\n",
"
Take the $eliteCount$ best children from the previous generation $G^{g-1}$ and put them into this generation $G^g$\n",
"
Select the breeding pool $P$ of $\\mu$ individuals from the previous generation.\n",
"
For i in range($eliteCount$,$\\lambda$)\n",
"
\n",
"
Randomly choose two parents from $P$.\n",
"
Use cross-over to generate a child $G^g_i$.\n",
"
Mutate the values in $G^g_i$.\n",
"
Compute the child's cost.\n",
"
\n",
"
Sort the individuals in $G^g$ by cost (in preparation for selection)\n",
"
\n",
"
\n",
"\n",
"The key operators and parameters can be varied:\n",
"
\n",
"
Selection can favor fit (low-cost) parents more or less, and always has an aspect of randomness. If we favor low-cost parents more, then the algorithm converges quickly, but it doesn't explore parameter space very well, and could miss a more fit individual. If we favor them less, the algorithm might not find children of increasingly good fitness. Explanations of several selection operators may be found in: Blickle, T. and Thiele, L. 1995. A comparison of selection schemes used in genetic algorithms. Tech. Rep. TIK-Report 11, Swiss Federal Institute of Technology (ETH), Zurich, Switzerland, May.\n",
"
Crossover is typically \"uniform\" (each element of the child is randomly taken from one of its two parents) or \"single\" (a cross-over point is selected and all elements up to the cross-over point are taken from one parent and the remaining elements are taken from the second parent).\n",
"
Mutation is typically implemented by choosing a value from a Gaussian distribution centered on each element. One straightforward way to vary the mutation is to vary the width of the distribution. We control the size of the mutation by scaling the width of the Gaussian distribution (it should be $mutationScale\\cdot parameterValue$).\n",
"
The number of parents $\\mu$ and children $\\lambda$ affects how widely we can sample space. Large numbers of children allow for a broader sampling. The number of parents (the size of the breeding pool) should be a fraction of the number of children (typically, it is a number like 1/5). It works with the selection operator to control how broadly the space is searched and how quickly the algorithm progresses towards a solution. The number of children that you need to use depends upon the problem. It can range from in the tens (e.g. our simple island cost function from class) to thousands.\n",
"
The number of elite individuals should be small (e.g. 1 to 3). Including elites guarantees that the best-fit individual in generation $g$ will be at least as fit as the best-fit individual in generation $g-1$.\n",
"
The number of generations should be as big as it needs to be for the best (or average) cost to stop improving. For some problems, thousands of generations are used. Here, we are able to use many fewer (e.g. I used 5 for the simple island cost function in class)\n",
"
Run each algorithm on the fly model at least 5 times for each ``flavor'' for at least 5 generations, i.e. analyze performance for \n",
"\t\n",
"
a GA with truncation selection, an elite count of 1, 10 parents, 50 children, and a mutation scale of 0.05\n",
"\t
a GA with tournament selection (tournament size = 2), an elite count of 1, 10 parents, 50 children, and a mutation scale of 0.05\n",
"\t
a GA with linear ranking selection, an elite count of 1, 10 parents, 50 children, and a mutation fraction of 0.05\n",
"
\n",
"
Report your results in a concise, but informative manner. You will want to identify trends. To do this, quantify the performance of the algorithm. For example, determine the mean population cost for each generation and plot how that changes across generations.\n",
"
\n",
"\n",
"## Implication for Model\n",
"Using some of your output from above, analyze the effects of different parameters on the model's performance. Below are suggestions to guide your analysis. Follow at least one of them.\n",
"\n",
"\n",
"
How different are the optimization results? i.e. how different are the sets of model parameters (e.g. rate constants and activation thresholds) that are found by different runs of the GA? \n",
"
You may see different relationships between amplitudes of clock components. Do you see any patterns in this behavior? (e.g. is the peak mRNA concentration always bigger (or always smaller) than the peak P1 concentration?) If so, maybe you can conclude that the relative amplitude is not a property of the model's parameters, but that it is a property of its structure. Make a detailed case for your conclusion.\n",
"
Choose several optimization results and determine whether or not the non-intuitive behavior mentioned in Goldbeter's paper occurs. In his paper, he showed that increasing the rate of Per protein degradation ($v_d$) increases the total PER in the system. Is this true for multiple optimization results (i.e. model parameter sets)?\n",
"
\n",
"\n",
"## Extensions\n",
"\n",
"
\n",
"
Implement proportional selection and include analysis of the GA with proportional selection it in your write-up.\n",
"
Include additional analysis with different values of the algorithm's parameters. What happens if the number of children per generation is different? What about increasing or decreasing the mutation fraction?\n",
"
Include simulated annealing in your set of optimization algorithms.\n",
"
Implement a simulated annealing optimization algorithm.\n",
"
Make a hybrid algorithm that uses both a GA (or simulated annealing) and a deterministic method (e.g. a hill-descending method). The idea is that the stochastic algorithms helps you find the right region of parameter space, and that in that region, the cost function will be smooth (and maybe even monotonic). Once we are in a region that is smooth and monotonic, we can use a deterministic optimization method to refine our parameter set to find the local optimum.\n",
"
Include amplitude in the cost function for Goldbeter's model: add a penalty for each state variable whose peak-to-trough amplitude is less than 0.1.\n",
"
Also find parameters for the Gonze/Goodwin oscillator.\n",
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Steps to get you started\n",
"### 1. Cost function for fly clock model\n",
"\n",
"To write the cost function for the fly clock model, you will need gol95_model and get_period from project 2. \n",
"\n",
"Your cost function should have the signature:\n",
"\n",
"def gol95_cost( params ): \n",
"\n",
"\n",
"where params is the ndarray of parameters used to simulate the model.\n",
"\n",
"It should\n",
"
\n",
"
Run the simulation with params as the parameters for at least 10 days, so that it is likely to have reached the limit cycle.\n",
"
Re-run the simulation, beginning with the values from the final time step of the previous simulation.\n",
"
Compute the period $per$ and the cycle-to-cycle standard deviation of the period $sdper$ by calling get_period.\n",
"
Compute the cost according to\n",
" $\\sqrt{ \\left(\\frac{per-23.6}{23.6}\\right)^2 + \\frac{sdper}{23.6}}$\n",
"
\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"# Write your code here (copy-paste the model and get_period, write gol95_cost)\n",
"\n",
"# Test your cost function here.\n",
"# When Stephanie tests hers with the parameters from Project 2, her cost is < 0.05"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 2. Selection operator\n",
"\n",
"Write your selection operators in this cell, so that you can test them with artificial data. I have included a barebones operator along with test code below. The uniform operator is a useless one, because it applies no selection pressure. The test code has costs ranging from 0.1 to 500 and the uniform operator samples from them all, so the histogram of costs from the breeding pool should indicate a uniform distribution from 0.1 to 500. "
]
},
{
"cell_type": "code",
"execution_count": 164,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Text(0, 0.5, 'Frequency')"
]
},
"execution_count": 164,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"\n",
"class GASettings:\n",
" def __init__( self, numParents = 10, numChildren = 50 ):\n",
" self.numParents = numParents;\n",
" self.numChildren = numChildren;\n",
" self.numGenerations = 5;\n",
" self.selection = 'truncation'; \n",
" self.slope = 15; # for linear ranking selection\n",
" self.tournamentSize = 2;\n",
" self.crossover = 'uniform';\n",
" self.mutation = 0.05; # std of normal distribution computed as mutation*value\n",
" self.eliteCount = 1;\n",
"\n",
"def select_pool( G, Gcost, settings ):\n",
" \"\"\" Select a breding pool from the previous generation.\n",
" G is numChildren x numParameters\n",
" Gcost is numChildren long and is sorted in ascending order.\n",
" Returns (P,Pcost)\n",
" where \n",
" P is numParents x numParameters\n",
" Pcost is numParents long.\n",
" \"\"\"\n",
" if Gcost.size != settings.numChildren:\n",
" print(\"problem\")\n",
" return\n",
" P = np.zeros( (settings.numParents,G.shape[1]) )\n",
" Pcost = np.zeros( (settings.numParents,) )\n",
"\n",
" if settings.selection == 'uniform':\n",
" for i in range(settings.numParents):\n",
" idx = np.random.choice(G.shape[0])\n",
" P[i,:] = G[idx,:]\n",
" Pcost[i] = Gcost[idx]\n",
" else:\n",
" print( \"Unknown selection operator: \", settings.selection )\n",
" return (P, Pcost)\n",
"\n",
"# Test the selection operators\n",
"# Make fake parameters, using the index as the values (so we can differentiate them)\n",
"lam = 10000 # number of individuals in generation\n",
"mu = 1000 # number of individuals in breeding pool\n",
"NP = 5 # num of parameters per individual\n",
"G = np.zeros( (lam,NP) )\n",
"for i in range(lam):\n",
" G[i,:] = i\n",
"Gcost = np.linspace(0.1,500,lam)\n",
"settings = GASettings(numParents=mu, numChildren=lam)\n",
"\n",
"settings.selection = 'uniform'\n",
"(P, Pcost) = select_pool(G, Gcost, settings)\n",
"plt.figure( figsize=(8,4) )\n",
"plt.hist( Pcost );\n",
"plt.title( \"Breeding Pool Chosen Uniformly\")\n",
"plt.xlabel( 'Cost')\n",
"plt.ylabel('Frequency')\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 3. Test cross-over and mutation\n",
"\n",
"Stephanie puts cross-over and mutation in a function named generateChild. The input to generateChild is the cost function, the breeding pool, the lower bounds, the upper bounds, and the settings. You can test it by generating an artificial breednig pool, such as one in which the first individual is an array of all 1's, the second is all 2's etc. Then, if you print out the results, which two individuals were chosen, how the cross-over was done and how the mutation worked should be clear."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Write your code for testing cross-over and mutation here."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 4. Write your Genetic Algorithm\n",
"\n",
"Write it according to the algorithm above and what we have done in class.\n",
"\n",
"Test it with the simple island cost function from class."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Your GA code goes here! Copy-paste the simple island cost function from the Jupyter notebook from class."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 5. Run your Genetic Algorithm on the Fly Clock Model\n",
"\n",
"Below, I supply code that generates the upper and lower bounds for the parameters. The rest is up to you."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Code with lower and upper bounds the parameters in Goldbeter's fly clock model.\n",
"# I put the published values in comments.\n",
"\n",
"lb = np.zeros((18,));\n",
"ub = np.zeros((18,));\n",
"lb[0] = 0; ub[0] = 1;# vs = 0.76;\n",
"lb[1] = 0; ub[1] = 1;# vm = 0.65;\n",
"lb[2] = .1; ub[2] = 1;# Km = 0.5;\n",
"lb[3] = 0; ub[3] = 1;# ks = 0.38;\n",
"lb[4] = 0; ub[4] = 1;# vd = 0.95;\n",
"lb[5] = 0; ub[5] = 2;# k1 = 1.9;\n",
"lb[6] = 0; ub[6] = 2;# k2 = 1.3;\n",
"lb[7] = 1; ub[7] = 1;# KI = 1;\n",
"lb[8] = 0.1; ub[8] = 1;# Kd = 0.2;\n",
"lb[9] = 4; ub[9] = 4;# n = 4;\n",
"lb[10] = 0.5; ub[10] = 2.5;# K1 = 2;\n",
"lb[11] = 0.5; ub[11] = 2.5;# K2 = 2;\n",
"lb[12] = 0.5; ub[12] = 2.5;# K3 = 2;\n",
"lb[13] = 0.5; ub[13] = 2.5;# K4 = 2;\n",
"lb[14] = 0; ub[14] = 5;# V1 = 3.2;\n",
"lb[15] = 0; ub[15] = 5;# V2 = 1.58;\n",
"lb[16] = 0; ub[16] = 5;# V3 = 5;\n",
"lb[17] = 0; ub[17] = 5;# V4 = 2.5;\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ## Begin your project here\n",
" \n",
" Complete the project (analyzing the algorithm's performance and the parameters output) here. You can add your new selection operators to the code in cells above. Just concentrate main code for the report here.\n"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"# Start code here and write-up here. :)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
"\n",
"Acknowledgements\n",
"\n",
"*Replace this text with links to external resources and thanks to people you worked with.*"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}