Matthias Bartolo Machine Learning Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f362b55b",
   "metadata": {},
   "source": [
    "## Author:  Matthias Bartolo               Id: 0436103L"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7e07182",
   "metadata": {},
   "source": [
    "# Course Project\n",
    "# ICS2207 - Machine Learning: Classification, Search and Optimisation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f4336e8",
   "metadata": {},
   "source": [
    "### Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "77df94d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "^C\n"
     ]
    }
   ],
   "source": [
    "!pip install pillow \n",
    "import random\n",
    "import re\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from PIL import Image\n",
    "from PIL import ImageDraw\n",
    "from PIL import ImageFont"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea778606",
   "metadata": {},
   "source": [
    "### Function which Loads Dataset (text corpus) , given a filename\n",
    "\n",
    "#### The text corpus used was the following: Ben-Hur: A tale of the Christ by Lew Wallace\n",
    "obtained from: https://www.gutenberg.org/ebooks/2145"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "36e760c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def LoadingAndFilteringDataset(filename):\n",
    "    #Opening dataset file\n",
    "    dataset= open(filename, mode='r',encoding=\"utf8\")\n",
    "    #Reading from file\n",
    "    unfilteredtext=dataset.read()\n",
    "    #Filtering the characters in the dataset, with the characters present in the keyboard\n",
    "    filteredtext=re.sub('[^A-Za-z.,;\\\" ]',\"\",unfilteredtext)\n",
    "    #Transforming all text to lower case\n",
    "    filteredtext=filteredtext.lower()\n",
    "    #Closing dataset file\n",
    "    dataset.close()\n",
    "    #Returning filteredText\n",
    "    return filteredtext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8a71bc79",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading and Filtering Dataset (Variable will be used continously)\n",
    "dataset=LoadingAndFilteringDataset(\"dataset.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3fd6ad0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "17f654c9",
   "metadata": {},
   "source": [
    "### Function which Loads a Keyboard Image, and prints the keys on the keyboard\n",
    "\n",
    "#### The following resources were used, for the facilitation of creation of such function:\n",
    "Keyboard Image retrieved from: https://timvandevall.com/free-blank-keyboard-template-printable/\n",
    "\n",
    "Utilising font from: https://fonts.google.com/specimen/Roboto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bd6f224b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ShowKeyboard(keys):\n",
    "    #Opening keyboard image\n",
    "    img = Image.open('KeyboardImage.png')\n",
    "    \n",
    "    #Calling draw Method to add 2D graphics to the image\n",
    "    textOnImage = ImageDraw.Draw(img)\n",
    "    #Setting font\n",
    "    keyboardFont = ImageFont.truetype('Roboto-Black.ttf', 135)\n",
    " \n",
    "    #Adding text to keyboard Image\n",
    "    #Drawing text with offsets, offsets have been calculated through trial and error\n",
    "    startingx=400\n",
    "    startingy=1050\n",
    "    xOffset=220\n",
    "    yOffset=0\n",
    "    multiplyrate=0\n",
    "    #Looping through all the keys and adding the keys to the keyboard image, based on calculated offset\n",
    "    for i in range(0,len(keys)):\n",
    "        if(i%10==0 and i!=0):\n",
    "            yOffset+=230+i\n",
    "            startingx+=5*i\n",
    "            multiplyrate=0\n",
    "        textOnImage.text((startingx+xOffset*multiplyrate, startingy+yOffset), keys[i], font=keyboardFont)\n",
    "        multiplyrate+=1\n",
    "\n",
    "    #Returning image\n",
    "    return img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "85150265",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Variable to hold keys:\n",
    "#Qwerty keys\n",
    "keys=[ \"q\", \"w\", \"e\", \"r\", \"t\", \"y\", \"u\", \"i\", \"o\", \"p\", \"a\", \"s\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\",\"\\\"\", \"z\", \"x\", \"c\", \"v\", \"b\", \"n\", \"m\",\".\" ,\",\", \";\" ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6eceaea",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "799c2421",
   "metadata": {},
   "source": [
    "### Function which returns  a Dictionary of weight positions given a word index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9c19c396",
   "metadata": {},
   "outputs": [],
   "source": [
    "def AssignWeights(keys):\n",
    "    #Utilising same offsets as ShowKeyboard() method\n",
    "    weights=[]\n",
    "    startingx=400\n",
    "    startingy=1050\n",
    "    xOffset=220\n",
    "    yOffset=0\n",
    "    multiplyrate=0\n",
    "    #Looping through all keys, and appending to the weights list, the x and y calculated positions of the keys on the keyboard\n",
    "    for i in range(0,len(keys)):\n",
    "        if(i%10==0 and i!=0):\n",
    "            yOffset+=230+i\n",
    "            startingx+=5*i\n",
    "            multiplyrate=0\n",
    "        weights.append([startingx+xOffset*multiplyrate, startingy+yOffset])\n",
    "        multiplyrate+=1\n",
    "    \n",
    "    #Returning a dictionary, from the wieghts list, to ensure fast searches\n",
    "    return {i:weights[i] for i in range(0,len(weights))}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "535f4e5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Assigning weights (Variable will be used continously)\n",
    "weights=AssignWeights(keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f88d8aa4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c92cabf7",
   "metadata": {},
   "source": [
    "### Function which calculates, the distance, for a character entered, and given the current finger positions on the keyboard "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "305674cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function parameters include:\n",
    "#1. fingerpointer - to hold the position of the current finger on the keyboard\n",
    "#2. characterpointer - to hold the position of the next character to type on the keyboard\n",
    "#3. weights - the dictionary of weights for all the keys\n",
    "def KeyboardCharacterDistance(fingerpointer,characterpointer,weights):\n",
    "    distance=0\n",
    "    #If fingerpointer is characterpointer, i.e., current finger is on current character, then the distance returned is 0\n",
    "    if fingerpointer==characterpointer:\n",
    "        return distance\n",
    "    #The function will attempt to work out the euclidean distance, between the current position of the finger (fingerpointer)\n",
    "    #and, the position of the character entered (characterpointer).\n",
    "    #The function will the use the weight dictionary, to find the x and y positions of the two pointers, and\n",
    "    #calculate, the euclidean distance on said values\n",
    "    adjacent=abs(weights[fingerpointer][0]-weights[characterpointer][0])\n",
    "    opposite=abs(weights[fingerpointer][1]-weights[characterpointer][1])\n",
    "    hyphotenuse=math.sqrt(pow(adjacent,2)+pow(opposite,2))\n",
    "    #Returning rounded euclidean distance\n",
    "    return round(hyphotenuse/220,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e39626f7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "67643d08",
   "metadata": {},
   "source": [
    "### Function which calculates, the Fitness Function, of a given keyboard, and given text corpus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e3872666",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function parameters include:\n",
    "#1. keyboard - variable to hold keyboard\n",
    "#2. weights - the dictionary of weights for all the keys\n",
    "#3. text - the string text corpus\n",
    "def FitnessFunction(keyboard,weights, text):\n",
    "    #Initialising totalDistance and fingerpointers\n",
    "    totalDistance=0\n",
    "    distance=0\n",
    "    fingerpointers=[10,11,12,13,16,17,18,19]\n",
    "    \n",
    "    #Looping through all the characters in text \n",
    "    for currentChar in text:\n",
    "        #Only entering if statement if current character is not a space\n",
    "        if currentChar!=\" \":\n",
    "            #Retrieving index of current character in keyboard\n",
    "            charIndex=keyboard.index(currentChar)\n",
    "            #Calculating fingerpointer index based on current character index\n",
    "            fingerpointerIndex=charIndex%10\n",
    "            #Setting respective fingerpointers, since there is a partition in the middle of the keyboard, where there\n",
    "            #are no fingers\n",
    "            if fingerpointerIndex>=4 and fingerpointerIndex<6:\n",
    "                fingerpointerIndex-=1\n",
    "            elif fingerpointerIndex>=6:\n",
    "                fingerpointerIndex-=2\n",
    "            #Calculating distance via KeyboardCharacterDistance function, for current character\n",
    "            distance=KeyboardCharacterDistance(fingerpointers[fingerpointerIndex],charIndex,weights)\n",
    "            #Adding distance to totalDistance\n",
    "            totalDistance+=distance\n",
    "            #Resetting all fingerpointers, except the last move \n",
    "            fingerpointers=[10,11,12,13,16,17,18,19]\n",
    "            fingerpointers[fingerpointerIndex]=charIndex\n",
    "    \n",
    "    #Returning current keyboard and rounded total distance\n",
    "    return [keyboard,round(totalDistance,3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cb7db5b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "389c0530",
   "metadata": {},
   "source": [
    "### Function which performs Single Point Crossover, given 2 parents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4c9a65a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function parameters include:\n",
    "#1. parent1 - variable to hold keyboard parent1\n",
    "#2. parent2 - variable to hold keyboard parent2\n",
    "def SinglePointCrossover(parent1, parent2):\n",
    "    #Randomly selecting a splitting point between parents\n",
    "    splittingPoint=random.randint(1,(len(parent1)-1))\n",
    "    #Declaring children to be returned\n",
    "    child1=[]\n",
    "    child2=[]\n",
    "    \n",
    "    #Declaring and Initialising indexes to 0\n",
    "    index1=0\n",
    "    index2=0\n",
    "    \n",
    "    #While index1 is smaller than the splitting point, then add parent1 to child and incrementing index1\n",
    "    while(index1<splittingPoint):\n",
    "        if parent1[index1] not in child1:\n",
    "            child1.append(parent1[index1])\n",
    "            index1+=1\n",
    "    #While index2 is smaller than the splitting point, then add parent2 to child and incrementing index2\n",
    "    while(index2<splittingPoint):\n",
    "        if parent2[index2] not in child2:\n",
    "            child2.append(parent2[index2])\n",
    "            index2+=1\n",
    "    \n",
    "    #Resetting indexes\n",
    "    pos=index1\n",
    "    errorOffset=0\n",
    "    #While index1 is smaller than parent2, then continue to add keys from parent2, if keys are not already present in child\n",
    "    #If keys are already present in child, then proceed to find a key from the first half of parent2, which child does not have,\n",
    "    #and proceed to add said key\n",
    "    while(index1<len(parent2)):\n",
    "        if parent2[pos] not in child1:\n",
    "            child1.append(parent2[pos])\n",
    "            index1+=1\n",
    "            pos=index1\n",
    "        else:\n",
    "            errorOffset+=1\n",
    "            pos=index1-errorOffset\n",
    "    #Resetting indexes\n",
    "    pos=index2\n",
    "    errorOffset=0\n",
    "    #While index2 is smaller than parent1, then continue to add keys from parent1 if keys are not already present in child\n",
    "    #If keys are already present in child, then proceed to find a key from the first half of parent1, which child does not have,\n",
    "    #and proceed to add said key\n",
    "    while(index2<len(parent1)):\n",
    "        if parent1[pos] not in child2:\n",
    "            child2.append(parent1[pos])\n",
    "            index2+=1\n",
    "            pos=index2\n",
    "        else:\n",
    "            errorOffset+=1\n",
    "            pos=index2-errorOffset\n",
    "    \n",
    "    #Returning children\n",
    "    return child1, child2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49502fea",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "45099527",
   "metadata": {},
   "source": [
    "### Function which performs Double Point Crossover, given 2 parents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9d15d08d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function parameters include:\n",
    "#1. parent1 - variable to hold keyboard parent1\n",
    "#2. parent2 - variable to hold keyboard parent2\n",
    "def DoublePointCrossover(parent1, parent2):\n",
    "    #Randomly selecting first splitting point between parents\n",
    "    splittingPoint1=random.randint(1,round(len(parent1)/2))\n",
    "    #Randomly selecting second splitting point between parents\n",
    "    splittingPoint2=random.randint(splittingPoint1,(len(parent1)-1))\n",
    "    #Declaring children to be returned\n",
    "    child1=[]\n",
    "    child2=[]\n",
    "    \n",
    "    #Declaring and Initialising indexes to 0\n",
    "    index1=0\n",
    "    index2=0\n",
    "    #While index1 is smaller than first splitting point, then add parent1 to child and incrementing index1\n",
    "    while(index1<splittingPoint1):\n",
    "        if parent1[index1] not in child1:\n",
    "            child1.append(parent1[index1])\n",
    "            index1+=1\n",
    "    #While index2 is smaller than first splitting point, then add parent2 to child and incrementing index2\n",
    "    while(index2<splittingPoint1):\n",
    "        if parent2[index2] not in child2:\n",
    "            child2.append(parent2[index2])\n",
    "            index2+=1\n",
    "    \n",
    "    #Resetting indexes\n",
    "    pos=index1\n",
    "    errorOffset=0\n",
    "    #While index1 is smaller than second splitting point, then continue to add keys from parent2 if keys are not already present in child\n",
    "    #If keys are already present in child, then proceed to find a key from the first half of parent2, which child does not have,\n",
    "    #and proceed to add said key\n",
    "    while(index1<splittingPoint2):\n",
    "        if parent2[pos] not in child1:\n",
    "            child1.append(parent2[pos])\n",
    "            index1+=1\n",
    "            pos=index1\n",
    "        else:\n",
    "            errorOffset+=1\n",
    "            pos=index1-errorOffset\n",
    "    #Resetting indexes\n",
    "    pos=index2\n",
    "    errorOffset=0\n",
    "    #While index2 is smaller than second splitting point, then continue to add keys from parent1 if keys are not already present in child\n",
    "    #If keys are already present in child, then proceed to find a key from the first half of parent1, which child does not have,\n",
    "    #and proceed to add said key\n",
    "    while(index2<splittingPoint2):\n",
    "        if parent1[pos] not in child2:\n",
    "            child2.append(parent1[pos])\n",
    "            index2+=1\n",
    "            pos=index2\n",
    "        else:\n",
    "            errorOffset+=1\n",
    "            pos=index2-errorOffset\n",
    "    #Resetting indexes\n",
    "    pos=index1\n",
    "    errorOffset=0\n",
    "    #While index1 is smaller than parent1, then continue to add keys from parent1 if keys are not already present in child\n",
    "    #If keys are already present in child, then proceed to find a key from the first half of parent1, which child does not have,\n",
    "    #and proceed to add said key\n",
    "    while(index1<len(parent1)):\n",
    "        if parent1[pos] not in child1:\n",
    "            child1.append(parent1[pos])\n",
    "            index1+=1\n",
    "            pos=index1\n",
    "        else:\n",
    "            errorOffset+=1\n",
    "            pos=index1-errorOffset\n",
    "    #Resetting indexes\n",
    "    pos=index2\n",
    "    errorOffset=0\n",
    "    #While index2 is smaller than parent2, then continue to add keys from parent2 if keys are not already present in child\n",
    "    #If keys are already present in child, then proceed to find a key from the first half of parent2, which child does not have,\n",
    "    #and proceed to add said key\n",
    "    while(index2<len(parent2)):\n",
    "        if parent2[pos] not in child2:\n",
    "            child2.append(parent2[pos])\n",
    "            index2+=1\n",
    "            pos=index2\n",
    "        else:\n",
    "            errorOffset+=1\n",
    "            pos=index2-errorOffset\n",
    "    \n",
    "    #Returning children            \n",
    "    return child1, child2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac97a330",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2de69c36",
   "metadata": {},
   "source": [
    "### Mutation Functions:\n",
    "\n",
    "Different mutations inspired from: https://www.tutorialspoint.com/genetic_algorithms/genetic_algorithms_mutation.htm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffb55815",
   "metadata": {},
   "source": [
    "#### Function which performs Swap Mutation given a child"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1027682c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def SwapMutation(child):\n",
    "    #Generating 2 random indexes based on list length\n",
    "    randindex1=random.randint(0,len(child)-1)\n",
    "    randindex2=random.randint(0,len(child)-1)\n",
    "    #Making sure that indexes are not the same\n",
    "    while randindex1==randindex2:\n",
    "        randindex1=random.randint(0,len(child)-1)\n",
    "    #Swapping keys at both random indexes\n",
    "    child[randindex1],child[randindex2]=child[randindex2],child[randindex1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea6743b0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "df29a6e2",
   "metadata": {},
   "source": [
    "#### Function which performs Scramble Mutation given a child"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "75d56653",
   "metadata": {},
   "outputs": [],
   "source": [
    "def ScrambleMutation(child):\n",
    "    #Generating a random index\n",
    "    randindex1=random.randint(0,round(len(child)/2))\n",
    "    #Generating a secondary index, based on randindex1\n",
    "    randindex2=random.randint(randindex1+1,round(len(child)-1))\n",
    "    \n",
    "    #Setting reverseindex to randindex2 and index to randindex1\n",
    "    reverseindex=randindex2\n",
    "    index=randindex1\n",
    "    #Generating swapindex based on index and reverseindex\n",
    "    swapindex=random.randint(index,reverseindex)\n",
    "    #Looping until index is smaller than reverseindex\n",
    "    while(index<reverseindex):\n",
    "        #Generating swapindex based on index and reverseindex\n",
    "        swapindex=random.randint(index+1,reverseindex)\n",
    "        #Swapping keys of positions which have indexes: index and swapindex\n",
    "        child[index],child[swapindex]=child[swapindex],child[index]\n",
    "        #Incrementing index and decrementing reverseindex\n",
    "        index+=1\n",
    "        reverseindex-=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a87846",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fdbf3a0d",
   "metadata": {},
   "source": [
    "#### Function which performs Inversion Mutation given a child"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "30d6b265",
   "metadata": {},
   "outputs": [],
   "source": [
    "def InversionMutation(child):\n",
    "    #Generating a random index\n",
    "    randindex1=random.randint(0,round(len(child)/2))\n",
    "    #Generating a secondary index, based on randindex1\n",
    "    randindex2=random.randint(randindex1+1,round(len(child)-1))\n",
    "    \n",
    "    #Setting reverseindex to randindex2 and index to randindex1\n",
    "    reverseindex=randindex2\n",
    "    index=randindex1\n",
    "    #Looping until index is smaller than reverseindex\n",
    "    while(index<reverseindex):\n",
    "        #Swapping keys of positions which have indexes: index and reverseindex\n",
    "        child[index],child[reverseindex]=child[reverseindex],child[index]\n",
    "        #Incrementing index and decrementing reverseindex\n",
    "        index+=1\n",
    "        reverseindex-=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38be04a8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "39b5e949",
   "metadata": {},
   "source": [
    "### Evaluation Functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "548001e9",
   "metadata": {},
   "source": [
    "#### Function which given a population, outputs Evaluation Metrics:\n",
    "##### - Best Population Fitness\n",
    "##### - Worst Population Fitness\n",
    "##### - Average Population Fitness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5fea5bf9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def GetEvaluationMetrics(population):\n",
    "    #Declaring totalFitness and averagePopulationFitness\n",
    "    totalFitness=0\n",
    "    averagePopulationFitness=0\n",
    "    #Looping through all the population and appending the fitness of a keyboard to the totalfitness\n",
    "    for p in population:\n",
    "        totalFitness+=p[1]\n",
    "    #Acquiring averagePopulationFitness\n",
    "    averagePopulationFitness=totalFitness/len(population)\n",
    "    #Returning respective metrics\n",
    "    return population[0][1],population[len(population)-1][1],averagePopulationFitness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f88b370f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7d2aa6f7",
   "metadata": {},
   "source": [
    "#### Function which Draws a Line Graph, given Population values array, generation array and ylabel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9a8a0693",
   "metadata": {},
   "outputs": [],
   "source": [
    "def DrawGraph(worstFitnessArray,bestFitnessArray,avgFitnessArray,generation):\n",
    "    #Plotting the points with labels\n",
    "    plt.plot(generation, worstFitnessArray, label = \"Worst Population Fitness\")\n",
    "    plt.plot(generation, bestFitnessArray, label = \"Best Population Fitness\")\n",
    "    plt.plot(generation, avgFitnessArray, label = \"Avg Population Fitness\")\n",
    "\n",
    "    #Naming the x-axis\n",
    "    plt.xlabel(\"Generation\")\n",
    "    #Naming the y-axis\n",
    "    plt.ylabel(\"Fitness\")\n",
    "\n",
    "    #Giving a title to the graph\n",
    "    plt.title(\"Fitness vs Generation\")\n",
    "    #Displaying legend\n",
    "    plt.legend(loc='upper right')\n",
    "    #Displaying plot\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8bc66f1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "57846ca2",
   "metadata": {},
   "source": [
    "### The following function will be used by the Main Genetic Algorithm Function:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40224030",
   "metadata": {},
   "source": [
    "#### Function which creates the initial generation, given a population size, population array, dataset and keyboard keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0cbe932c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def CreateFirstGeneration(populationSize,population,dataset,keys,weights):\n",
    "    #Looping according to the populationsize\n",
    "    for num in range(populationSize):\n",
    "\n",
    "        #Randomly shuffling the keys\n",
    "        random.shuffle(keys)\n",
    "\n",
    "        #Creating a keyboard from the shuffled keys\n",
    "        keyboard=keys.copy()\n",
    "\n",
    "        #Appending keyboard to the population and calculating the keyboard's Fitness\n",
    "        population.append(FitnessFunction(keyboard,weights, dataset))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e57fa026",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "88ff6605",
   "metadata": {},
   "source": [
    "#### Functions which are used to sort the population array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2907670b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def SortPopulationByFitness(population):\n",
    "    #Sorting population\n",
    "    population.sort(key=GetSortKey)\n",
    "       \n",
    "def GetSortKey(population):\n",
    "    return population[1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ad4c782",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b807305b",
   "metadata": {},
   "source": [
    "### Main Genetic Algorithm Function"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "968bc299",
   "metadata": {},
   "source": [
    "#### Function outputs the best keyboard, after a number of generations\n",
    "\n",
    "#### Function takes the following parameters:\n",
    "##### 1. keys - variable to hold the keys which will be used to create keyboards\n",
    "##### 2. dataset - variable to hold the text corpus as a string\n",
    "##### 3. weights - variable to hold the dictionary of weights for all the keys\n",
    "##### 4. populationSize - variable to hold the size of the population\n",
    "##### 5. noOfGenerations - variable to hold the amount of generations\n",
    "##### 6. crossoverBit - variable which will be used to determine which crossover operation to perform\n",
    "##### 7. mutationBit - variable which will be used to determine which mutation operation to perform\n",
    "##### 8. mutationRate - variable which will be used to determine the rate of mutation operation\n",
    "##### 9. crossoverRate - variable which will be used to determine the rate of the crossover operation\n",
    "##### 10. elitismRate - variable which will be used to determine the rate of the elitism operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "1033f9f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate):\n",
    "    #Declaring lists, which will be used for evaluation and to hold best keyboard\n",
    "    bestvalue=[]\n",
    "    worstvalue=[]\n",
    "    averagevalue=[]\n",
    "    generationvalue=[]\n",
    "    bestkeyboard=[]\n",
    "    \n",
    "    #Declaring population array\n",
    "    population=[]\n",
    "    #Creation of first generation by invoking CreateFirstGeneration Method\n",
    "    CreateFirstGeneration(populationsize,population,dataset,keys,weights)\n",
    "    #Looping for a number of generations\n",
    "    for generation in range(noOfGenerations):\n",
    "        #Sorting the current population\n",
    "        SortPopulationByFitness(population)\n",
    "        #Declaring new population list to hold the new population\n",
    "        newpopulation=[]\n",
    "        \n",
    "        #Elitism:\n",
    "        #Calculating number of elites to append to the new population\n",
    "        sizeOfElitism=round(populationsize*elitismRate)\n",
    "        #Appending elites to the new population\n",
    "        newpopulation.extend(population[0:sizeOfElitism])\n",
    "        \n",
    "\n",
    "        #Variable to hold saved index of parent 1\n",
    "        pIndex=0\n",
    "        index=0\n",
    "        #Looping until newpopulation size is equal to population size\n",
    "        while len(population)>len(newpopulation):\n",
    "                #Setting Parent1Index to pIndex\n",
    "                Parent1Index= pIndex\n",
    "                #Setting Parent2Index to Parent1Index+a random offset between 0 and length of half of the population\n",
    "                Parent2Index= Parent1Index+random.randint(0,round(len(population)/2))\n",
    "                #Generating Crossover Chance from a range of 0 and 1, and rounding to 1 decimalpoint\n",
    "                CrossoverChance=round(random.uniform(0,1),1)\n",
    "               \n",
    "                #Crossover:\n",
    "                #If CrossoverChance is smaller than CrossoverRate, then attempt to perform Crossover\n",
    "                if CrossoverChance< crossoverRate:\n",
    "                    #Based on CrossoverBit, respective Crossover Method will be called\n",
    "                    if crossoverBit==2:\n",
    "                        children=DoublePointCrossover(population[Parent1Index][0],population[Parent2Index][0])\n",
    "                    else:\n",
    "                        children=SinglePointCrossover(population[Parent1Index][0],population[Parent2Index][0])\n",
    "                    #Incrementing pIndex\n",
    "                    pIndex+=1\n",
    "                #Else no crossover is performed, and the children taken would be the parents\n",
    "                else:\n",
    "                    children=[population[Parent1Index][0],population[Parent2Index][0]]\n",
    "                    \n",
    "                #Mutation:\n",
    "                #Generating Child1 Mutation Chance from a range of 0 and 1, and rounding to 1 decimalpoint\n",
    "                Child1MutationChance=round(random.uniform(0,1),1)\n",
    "                #Generating Child2 Mutation Chance from a range of 0 and 1, and rounding to 1 decimalpoint\n",
    "                Child2MutationChance=round(random.uniform(0,1),1)\n",
    "                #Based on mutationBit, respective Mutation Method will be called\n",
    "                #For every child, if the mutation Chance, is smaller than, the mutation rate, then attempt\n",
    "                #to perform mutation, else no mutation is performed\n",
    "                if mutationBit==1:\n",
    "                    if Child1MutationChance < mutationRate:\n",
    "                        SwapMutation(children[0])\n",
    "                    if Child2MutationChance < mutationRate:\n",
    "                        SwapMutation(children[1])\n",
    "                elif mutationBit==2:\n",
    "                    if Child1MutationChance < mutationRate:\n",
    "                        ScrambleMutation(children[0])\n",
    "                    if Child2MutationChance < mutationRate:\n",
    "                        ScrambleMutation(children[1])\n",
    "                elif mutationBit==3: \n",
    "                    if Child1MutationChance < mutationRate:\n",
    "                        InversionMutation(children[0])\n",
    "                    if Child2MutationChance < mutationRate:\n",
    "                        InversionMutation(children[1])\n",
    "                \n",
    "                #Calculating Fitness of new children, and appending entities to the new population\n",
    "                newpopulation.append(FitnessFunction(children[0],weights, dataset))\n",
    "                if len(population)>len(newpopulation):\n",
    "                    newpopulation.append(FitnessFunction(children[1],weights, dataset))\n",
    "                \n",
    "        #Setting the population to the new population        \n",
    "        population=newpopulation.copy()\n",
    "        \n",
    "        #Sorting the population\n",
    "        SortPopulationByFitness(population)\n",
    "        #Printing generation number and Best Population Fitness\n",
    "        print(\"Generation: \",(generation+1),\" Best Population Fitness\",population[0])\n",
    "        print()\n",
    "        #Retrieving Evaluation metrics of population and appending them to relevant lists\n",
    "        best,worst,average=GetEvaluationMetrics(population)\n",
    "        bestvalue.append(best)\n",
    "        worstvalue.append(worst)\n",
    "        averagevalue.append(average)\n",
    "        generationvalue.append(generation)\n",
    "        #Setting best keyboard variable\n",
    "        bestkeyboard=population[0]\n",
    "    \n",
    "    #Drawing appropriate Graphs\n",
    "    DrawGraph(worstvalue,bestvalue,averagevalue,generationvalue)\n",
    "    #Returning best keyboard\n",
    "    return bestkeyboard\n",
    "       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad805fa9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c61558de",
   "metadata": {},
   "source": [
    "### QWERTY and AZERTY Keyboard Layouts Fitness results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ccb643d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pillow in c:\\users\\user\\anaconda3\\lib\\site-packages (8.2.0)\n",
      "The qwerty keyboard has the following fitness:  815030.085\n",
      "The keyboard has a Fitness/Character of: 0.7537460117672518\n"
     ]
    }
   ],
   "source": [
    "#Variable which holds qwerty Keyboard\n",
    "qwertyKeyboard=[ \"q\", \"w\", \"e\", \"r\", \"t\", \"y\", \"u\", \"i\", \"o\", \"p\", \"a\", \"s\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\",\";\", \"z\", \"x\", \"c\", \"v\", \"b\", \"n\", \"m\",\",\" ,\".\", \"\\\"\" ]\n",
    "#Calculating and printing Fitness\n",
    "fitness1=FitnessFunction(qwertyKeyboard,weights, dataset)\n",
    "print(\"The qwerty keyboard has the following fitness: \",fitness1[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(fitness1[1]/len(dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "40f70f76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The azerty keyboard has the following fitness:  871862.803\n",
      "The keyboard has a Fitness/Character of: 0.8063053409488156\n"
     ]
    }
   ],
   "source": [
    "#Variable which holds azerty Keyboard\n",
    "azertyKeyboard=[ \"a\", \"z\", \"e\", \"r\", \"t\", \"y\", \"u\", \"i\", \"o\", \"p\", \"q\", \"s\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\",\"m\", \"w\", \"x\", \"c\", \"v\", \"b\", \"n\", \";\",\",\" ,\".\", \"\\\"\" ]\n",
    "#Calculating and printing Fitness\n",
    "fitness2=FitnessFunction(azertyKeyboard,weights, dataset)\n",
    "print(\"The azerty keyboard has the following fitness: \",fitness2[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(fitness2[1]/len(dataset)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca9a3ad9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8d0efcf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6379d5a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4cdf6172",
   "metadata": {},
   "source": [
    "### Test Cases:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41691cb5",
   "metadata": {},
   "source": [
    "#### Test Case 1: Testing with a population of 10, for 100 generations, Single Point Crossover, and a crossover rate of 0.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ec27db0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "populationsize=10\n",
    "noOfGenerations=100\n",
    "crossoverBit=1\n",
    "mutationBit=0\n",
    "mutationRate=0\n",
    "crossoverRate=0.9\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard1=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "788d7070",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard1[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard1[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard1[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b87e9df9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "866da634",
   "metadata": {},
   "source": [
    "#### Test Case 2: Testing with a population of 100, for 100 generations, Single Point Crossover, and a crossover rate of 0.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1787aed9",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=1\n",
    "mutationBit=0\n",
    "mutationRate=0\n",
    "crossoverRate=0.9\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard2=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ced8f61d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard2[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard2[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard2[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4df9a14a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f5cb8aa1",
   "metadata": {},
   "source": [
    "#### Test Case 3: Testing with a population of 100, for 100 generations, Single Point Crossover, and a crossover rate of 0.4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "843033dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=1\n",
    "mutationBit=0\n",
    "mutationRate=0\n",
    "crossoverRate=0.4\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard3=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8944f14",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard3[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard3[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard3[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2dba1a2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "54aede2d",
   "metadata": {},
   "source": [
    "#### Test Case 4: Testing with a population of 100, for 100 generations, Double Point Crossover, and a crossover rate of 0.9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d080ccbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=2\n",
    "mutationBit=0\n",
    "mutationRate=0\n",
    "crossoverRate=0.9\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard4=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fdbc21e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard4[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard4[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard4[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9605a4cf",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "96d6bab4",
   "metadata": {},
   "source": [
    "#### Test Case 5: Testing with a population of 100, for 100 generations, Double Point Crossover, and a crossover rate of 0.9, Swap Mutation with mutation rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "951a8c05",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=2\n",
    "mutationBit=1\n",
    "mutationRate=0.1\n",
    "crossoverRate=0.9\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard5=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "775bc799",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard5[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard5[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard5[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e95556f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "75a42474",
   "metadata": {},
   "source": [
    "#### Test Case 6: Testing with a population of 100, for 100 generations, Double Point Crossover, and a crossover rate of 0.9, Scramble Mutation with mutation rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d34c1131",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=2\n",
    "mutationBit=2\n",
    "mutationRate=0.1\n",
    "crossoverRate=0.9\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard6=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "111ed14b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard6[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard6[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard6[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69a691a7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ed1c2008",
   "metadata": {},
   "source": [
    "#### Test Case 7: Testing with a population of 100, for 100 generations, Double Point Crossover, and a crossover rate of 0.9, Inversion Mutation with mutation rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "865a3500",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=2\n",
    "mutationBit=3\n",
    "mutationRate=0.1\n",
    "crossoverRate=0.9\n",
    "elitismRate=0\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard7=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cad44f14",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard7[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard7[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard7[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c2f44ce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "02b78dca",
   "metadata": {},
   "source": [
    "#### Test Case 8: Testing with a population of 100, for 100 generations, Double Point Crossover, and a crossover rate of 0.9, Scramble Mutation with mutation rate of 0.1, and elitism rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b632a399",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=2\n",
    "mutationBit=2\n",
    "mutationRate=0.1\n",
    "crossoverRate=0.9\n",
    "elitismRate=0.1\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard8=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24240411",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard8[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard8[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard8[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b921fa59",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fe042990",
   "metadata": {},
   "source": [
    "#### Test Case 9: Testing with a population of 100, for 100 generations, Double Point Crossover, and a crossover rate of 0.9, Inversion Mutation with mutation rate of 0.1, and elitism rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45919f77",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=100\n",
    "noOfGenerations=100\n",
    "crossoverBit=2\n",
    "mutationBit=3\n",
    "mutationRate=0.1\n",
    "crossoverRate=0.9\n",
    "elitismRate=0.1\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard9=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbd4d56b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard9[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard9[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard9[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eab7d6fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7ec6eb7b",
   "metadata": {},
   "source": [
    "#### Test Case 10: Testing with a population of 15, for 70 generations, Double Point Crossover, and a crossover rate of 0.9, Scramble Mutation with mutation rate of 0.2, and elitism rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f697b68",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=15\n",
    "noOfGenerations=70\n",
    "crossoverBit=2\n",
    "mutationBit=2\n",
    "mutationRate=0.2\n",
    "crossoverRate=0.9\n",
    "elitismRate=0.1\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard10=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf8a890d",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard10[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard10[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard10[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da30061a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e15a6c69",
   "metadata": {},
   "source": [
    "#### Test Case 11: Testing with a population of 15, for 70 generations, Double Point Crossover, and a crossover rate of 0.9, Inversion Mutation with mutation rate of 0.2, and elitism rate of 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc6cd484",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=15\n",
    "noOfGenerations=70\n",
    "crossoverBit=2\n",
    "mutationBit=3\n",
    "mutationRate=0.2\n",
    "crossoverRate=0.9\n",
    "elitismRate=0.1\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard11=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ace30d5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard11[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard11[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard11[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a88c01be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f64a7223",
   "metadata": {},
   "source": [
    "#### Test Case 12: Testing with a population of 15, for 70 generations, Double Point Crossover, and a crossover rate of 0.9, Inversion Mutation with mutation rate of 0.2, and elitism rate of 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74457da5",
   "metadata": {},
   "outputs": [],
   "source": [
    "populationsize=15\n",
    "noOfGenerations=70\n",
    "crossoverBit=2\n",
    "mutationBit=3\n",
    "mutationRate=0.2\n",
    "crossoverRate=0.9\n",
    "elitismRate=0.3\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard12=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d3e6cfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard12[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard12[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard12[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e475cb5a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6855b63a",
   "metadata": {},
   "source": [
    "#### Test Case 13: Testing with a population of 15, for 70 generations, Double Point Crossover, and a crossover rate of 0.9, Swap Mutation with mutation rate of 0.2, and elitism rate of 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40b96e71",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "populationsize=15\n",
    "noOfGenerations=70\n",
    "crossoverBit=2\n",
    "mutationBit=1\n",
    "mutationRate=0.2\n",
    "crossoverRate=0.9\n",
    "elitismRate=0.3\n",
    "\n",
    "start = time.time()\n",
    "bestkeyboard13=GeneticAlgorithmMain(keys,dataset,weights,populationsize,noOfGenerations,crossoverBit,mutationBit,mutationRate,crossoverRate,elitismRate)\n",
    "end = time.time()\n",
    "print(\"Time taken to execute: \",round((end-start),2),\" s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97d19cc6",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"The keyboard has the following Fitness: \",bestkeyboard13[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(bestkeyboard13[1]/len(dataset)))\n",
    "ShowKeyboard(bestkeyboard13[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f44a453",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "20525574",
   "metadata": {},
   "source": [
    "### Testing Most Optimal Keyboard with other dataset\n",
    "### The text corpus used was the following: The Story of Malta by Maturin M. Ballou\n",
    "obtained from: https://www.gutenberg.org/ebooks/34036"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b61d7a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading and Filtering Dataset (Variable will be used continously)\n",
    "dataset2=LoadingAndFilteringDataset(\"dataset2.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e5fa0eb",
   "metadata": {},
   "source": [
    "### QWERTY and AZERTY Keyboard Layouts Fitness results for new dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4782771",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Variable which holds qwerty Keyboard\n",
    "qwertyKeyboard=[ \"q\", \"w\", \"e\", \"r\", \"t\", \"y\", \"u\", \"i\", \"o\", \"p\", \"a\", \"s\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\",\";\", \"z\", \"x\", \"c\", \"v\", \"b\", \"n\", \"m\",\",\" ,\".\", \"\\\"\" ]\n",
    "#Calculating and printing Fitness\n",
    "fitness1=FitnessFunction(qwertyKeyboard,weights, dataset2)\n",
    "print(\"The qwerty keyboard has the following fitness: \",fitness1[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(fitness1[1]/len(dataset2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e555ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Variable which holds azerty Keyboard\n",
    "azertyKeyboard=[ \"a\", \"z\", \"e\", \"r\", \"t\", \"y\", \"u\", \"i\", \"o\", \"p\", \"q\", \"s\", \"d\", \"f\", \"g\", \"h\", \"j\", \"k\", \"l\",\"m\", \"w\", \"x\", \"c\", \"v\", \"b\", \"n\", \";\",\",\" ,\".\", \"\\\"\" ]\n",
    "#Calculating and printing Fitness\n",
    "fitness2=FitnessFunction(azertyKeyboard,weights, dataset2)\n",
    "print(\"The azerty keyboard has the following fitness: \",fitness2[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(fitness2[1]/len(dataset2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a9dec4d",
   "metadata": {},
   "source": [
    "### Testing Most Optimal Keyboard with new dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efb82d07",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Variable which holds optimal Keyboard\n",
    "optimalKeyboard=[ \"d\", \"f\", \"y\", \"g\", \"p\", \"x\", \"l\", \"b\", \"u\", \"w\", \"o\", \"e\", \"i\", \"n\", \"c\", \"s\", \"r\", \"h\", \"a\",\"t\", \"v\", \",\", \"j\", \"k\", \";\", \".\", \"q\", \"m\", \"\\\"\", \"z\" ]\n",
    "#Calculating and printing Fitness\n",
    "fitness3=FitnessFunction(optimalKeyboard,weights, dataset2)\n",
    "print(\"The most optimal keyboard has the following fitness: \",fitness3[1])\n",
    "print(\"The keyboard has a Fitness/Character of:\",(fitness3[1]/len(dataset2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25a39128",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64ab8b69",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}