old.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01. Get the Fashion-MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tensorflow as tf\n",
    "\n",
    "# Load the Fashion-MNIST dataset, with the train and test inputs and outputs\n",
    "(train_inputs, train_outputs), (test_inputs, test_outputs) = tf.keras.datasets.fashion_mnist.load_data()\n",
    "\n",
    "# Translate the train and test outputs into labels\n",
    "class_labels = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "train_labels = [class_labels[i] for i in train_outputs]\n",
    "test_labels = [class_labels[i] for i in test_outputs]\n",
    "\n",
    "train_inputs = train_inputs/255.0\n",
    "test_inputs = test_inputs/255.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+gAAAB3CAYAAACQe2rvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABE6UlEQVR4nO2dd7hdVbX23wlGKdIDhJaETiCEECChSr1AItWGcGn6fQh6QQEviijKRZRyQcqHoA8qSgm9I0TAhE7Q0AKE0AkBAiF0URRhfX+stWd+a7Hnzj4np+x9zvt7njwZZ+9VZxlzrr3eMWbIskzGGGOMMcYYY4zpXRbo7QswxhhjjDHGGGOMH9CNMcYYY4wxxpiWwA/oxhhjjDHGGGNMC+AHdGOMMcYYY4wxpgXwA7oxxhhjjDHGGNMC+AHdGGOMMcYYY4xpAdriAT2E8EIIYYfEd1uFEJ7s6WsyptUIIRwYQrgbf2chhDV685qMMaY7aNa/hRCGFtt+qieuq92pjiN1vr85hHBAT16T6RiN5szGtAuNfHxn57fz8m+tRLc+oIcQ/oZ/H4cQ/oG//7MrzpFl2V1Zlq09j+uo66xCCHuHEMZ7AM/pifoyzVG02Vr5vxZC+H0I4bO9fV3mk6Cu3gshvB1CuDeEcEgIoS1+AO3rhBD2CSFMKfrSrOIBY8v5PObtIYT/21XX2JcIIWxZ9IF3QghvhhDuCSFs0tvXZcp0tp6yLBubZdkfGhy3bSbAPYH7Q3tTmYu9FUL4Ywhhld6+rnaiGC/fCiF8prevpbsIIWwTQnipK4/ZrRPILMs+W/sn6UVJu+Kzi7vz3JLUxAP35yXd1N3X0S40W1+t8ENGK1xDD7BrURejJG0s6Ue9fD0N6Sd1kmLXLMsWkzRE0kmSvi/pt/U2DCEs2JMX1p8JIRwp6QxJP5e0vKTBks6RtHsvXlafJYSwuKQbJf0/SUtLWknS/0j6Z29elynTXfXUz8eAT9DO/cF1WaI2F1tB0mvK69M0QQhhqKStJGWSduvdq2kvWuYNTwhhYAjhxuIN1JshhLsqb6BGhhCmFr9CXhZCWKjYr/SrRfFr1/dDCFMlvR9CuET5pOyG4hew7xXbLSDpPyRNkHRnsfvbxTabhRAWCCH8KIQwI4QwO4RwQQhhiWLf2hv3b4QQXineyvx395dS71Ar46JcX5V0fgjhMyGEM4r7f6WwP1Ns/4lf0APkKCGEcSGEacUbx5dZdiGEXUIID+NN5Ah8V63bfjGAZFn2sqSbJQ0PFaVHs2/yQghLFG349aJN/6ho458pyno4tl22+MV4ueJv10mTZFn2TpZl10vaS9IBIYThIVc/nBtCuCmE8L6kbUMIK4YQrirq4/kQwrdrxwghjA75G993Q66e+EXx+UIhhItCCG8UdfHXEMLyvXSrLU/hr4+X9F9Zll2dZdn7WZZ9mGXZDVmWHTUPH7ZUMR69HvJf/m8MIaxcfPcz5ROOs4vx4uzeu8uWYy1JyrLskizLPsqy7B9Zlt2SZdnUEMLqIYSJRfudE0K4OISwZG3Hwpf8d6gzzhffH1WMta+EEL7Ok4YQPh9CeKjoMzNDCMf11A23Kcl6qm0QQji1aPvPhxDG4vM45hRj/T0hhNNDCG9IukzSryRtVvSNt3v2tlqORv3hwBDC3Q3KeYkQwm+LNv9yCOGEUPy4O6++REIIw4pj71387fG8k2RZ9oGkKyWtK83b74QQ9g/5fOuNEMKxoX+GHuwvabKk30sqhcYUc6NfhlyV8F4I4f4Qwur1DhJyJcrMEMI2db77TNGPXizmTL8KISzc4JpCCOHsYpyZHkLYHl+sGEK4PuTPoc+EEA6qnOcTc4YQwqLK5+grhrmq4xU7UEZ1aZkHdEnflfSSpGWVv+k4RvkvLjW+ImlnSatKGiHpwAbH2lv52/ElsyzbW+W3wacU24yW9FyWZXMkfa74bMlim/uK4x8oaVtJq0n6rKTqRGxbSWtK2lHS9/t4xxuk/BfgIZK+IemHkjaVNFLSBsrLs9k3vL+VdHDxxnG4pImSFELYUNLvJB0saRlJv5Z0fSjLYli3/56/W2oPQi6nGifprfk4zP+TtITytry1cqf5tSzL/inpauXlWuMrku7Ismy266RzZFn2F+X+bKvio30k/UzSYpLulXSDpEeUv1HZXtLhIYSdim3PlHRmlmWLS1pd0uXF5wcor8NVlNfFIZL+0e03075sJmkhSdckvm/kwxaQdL5yfzdYeTmfLUlZlv1Q0l2SDi3Gi0O76frbkackfRRC+EMIYWwIYSl8FySdKGlFScOUt+PjKvvXHedDCDtL+m/lP6qvKak61r6v3KctqdwXfTOEsEcX3VNfpFE9SdIYSU9KGijpFEm/DSGExLHGSHpO+bxtX+V+6b6ibyzZLVffPsxPOf9e0r8lrSFpQ+XzzNqP8c30JYUQRkn6k6TDsiy7xOP5/BFCWET5j++Ti4+SfieEsK5ytdZ/Kn/zvoTy8b6/sb+ki4t/O4VPvlT4qnJVyVKSnlE+TypR+P9LJH0xy7Lb65zjJOU/ho1U3l9WkvTjBtc0RtKzyvvdTyRdHUJYuvjuUuVztxUlfUnSz0MI2xXf1Z0zZFn2vqSxkl6B6viVBudvjizLeuSfpBck7dDg++MlXSdpjcS+++LvUyT9qrC3kfRSZduvz+vckn4q6djCHqr8x4BP4fs/S/oW/l5b0oeSPoXt16lc0297qjx7sr6KMv6XpIXw/bOSxuHvnSS9UNgHSrq7crysVrfKfzA5WNLilW3OlfTTymdPSto6Vbd99V9xr3+T9LakGcod/bA67fR2Sf+3XrnXylzSgkX9rYvvDpZ0e2HvIOlZfHePpP1dJx2qq0/4NuWD+A+VT7QuwOdjJL1Y2fYHks4v7DuVD1gDK9t8XfnD/Yjevud2+Kd8YvRqg++TPqzOtiMlvYW/Y7/zv0+U1bCizb+k/AHjeknL19luD0kP4e8XlB7nfyfpJHy3FseUOsc+Q9LphT206jf9L11PxTjyDLZbpCi/QcXf1TGn6stK41B//9eZci6+/6ekhfH93pImJc5Rry/9T3HObfC5x/OO198LmjsX+1DSK5LWT2xLv/NjSZdU6vdfavAc1Nf+SdqyKLOBxd/TJR2B738v6Tf4e5yk6fg7Uz43miFpeOXYtfltUP5Dyer4bjNJzyeu6cCiDgM++4uk/ZT/0PWRpMXw3YmSfl/YjZ57thGeRbviX6+8QQ8hDIYM4G/Fx/+r/NeTW0IIz4UQjq7s9irsvyt/o51iZhOXMU6N489XVN4oasxQ/nDOX39mVr6fb0lDC/N6lst7atQrn2bv/4vKy39GCOGOEMJmxedDJH23kF69XcjjVqkct5m67SvskWXZklmWDcmy7Fvq/NvSgZIG6JP1Vfs1d5KkRUIIY0IeLzRSc986uk46z0qS3ixsltEQ5VIolukxmutb/o/yB5DpIZex71J8fqHytyGXFvKqU0IIA7r9LtqXNyQNbCDTTPqwEMIiIYRfF/LEd5X/aLJkcP6AeZJl2RNZlh2YZdnKyhVSK0o6I4SwfAjh0pDLdd+VdJFy30RS4/yK+uR4Gyl816SQhyS8o/wtbvXYBqTqqfj6VWz398JMzbns/xvQyXIeonzMnoUx4teSamFnzfSlQyTdm5XfOHo87xx7ZLkaZCFJh0q6I4QwaB5+p+Szivp9o4evu7c5QNItWa5UlqTxqsjcNe9nu8MlXZ5l2WOJcyyr/MePB9CmJxSfp3g5K56qC2pj/4qS3syy7L3Kd7W58vw893SYXnlAz7LsxayckExZlr2XZdl3syxbTXkigSMZF9DRUzT6O4QwSLnk5MHE9lL+C8sQ/D1Y+a+fr+GzVSrfz7+koXWpllG98qnd//vKO4ykWN5zD5Rlf82ybHflg821mivhnSnpZ8VDae3fIlmWXdLgOvoT7xf/L4LPBtXbsMIc5b9iVuvrZUnKsuwj5XWwd/HvRjgo10knCHmW3pUk1XIxsIxmKv91l2W6WJZl4yQpy7Knszw0ZzlJJ0u6MoSwaJbHT/9PlmXrStpc0i7K5WOmPvcpfwu1R+L7Rj7su8pVU2OyPNSgFgZVk5+6zTdBlmXTlb8lGa48UV+m/O3T4srl0CnZdJVZ+uR4S8YrfzO5SpZlSyiPg2722P2eSj11ePd5/G0KOlDOM5X7roEYIxbPsmy94vtm+tIhkgaHEE6vHNfjeSfJ8jwCVyt/y7qlGvudWZJWru1bxEQv07NX3HsU9/sVSVuHEF4Nef6qIyRtEELYoAOH+rKkPUII30l8P0f5y6v10KaXqD1bJlipErJTG/tfkbR0CGGxyncvF3ajOUOX95uWiUEPeeKKNYpCe0d5B/i4iw7/mvLY2xpjJU3ALyivF+fiNpdIOiKEsGrIl7f6uaTLsnJMzrHFm5b1JH1NeYKU/sIlkn4U8oRiA5XLeS4qvntE0nohhJEhT/JzXG2nEMKnQwj/GUJYIsuyDyW9q7n1fJ6kQ4pfJUMIYdGQJ+FgZ+m3ZFn2unJHsW8IYcGQJ0qqm1Cjsl/tAfxnIYTFQghDJB2pufUl5QPNXsplwePxueukA4QQFi/eeF8q6aIsyx6ts9lfJL0X8mQ8Cxd1Obx4qFcIYd8QwrJZln2sXFYnSR+HELYNIaxfvMV9V/mPLl3lI/scWZa9o9wv/TKEsEfhqweEPBb0FDX2YYspH/TfDnls2k8qh6+OKUZSCGGdEMJ3w9yEeqso/9FvsvIy/Zukd0IIK0k6qgOHvlzSgSGEdUMeB1qtj8WUv/n4IIQwWnnOB5NgHvU0v7wmaeUQwqe74FhtTWfLOcuyWZJukXRaMaYsEPLEcFsXmzTTl95Tns/hcyGEk4rPPJ7PB0WZ7a48XvoJNfY7V0raNYSwedEXjlP/+tFwD+XPcesqV2WOVB7ucZc69mLhFeV5er4TQvhm9ctinnSepNPD3MTGK4W5OX3qsZykbxfzgS8X13VTlmUzlYcRnhjypLwjlCsaa/OCRnOG1yQtE4pk4l1ByzygK0/8cptyp3OfpHOyLJvURcc+UXmhvh3yjOGl5dUK6cnPJN1TbLOp8pi3C5VLG5+X9IGkwyrHvUO5LP/Pkk7NsuyWLrreduAESVMkTZX0qHI1wgmSlGXZU8pzCtwm6WnNfYtYYz9JL4RcmnWI8odCZVk2RdJBypMxvaW8bA/s5vtoNw5SPhi/IWk95c6kGQ5T/gb+OeX1MV55G5ckZVl2f/H9isqzUdY+d500xw0hhPeUv6H4oaRfKP/R7hMUP5jsonzAel75L8C/UZ5ERsonVY+HPPznTElfzbLsH8rVElcqfzh/Qrn/ubCb7qdPkGXZacp/jPqR8h9iZyqXKF6rBj5MuQR1YeV1M1m5ZI6cKelLIc++fFa33kR78Z7yHAv3h3zFgsmSHlOuSPgf5UtGviPpj8qTUzZFlmU3K6+Ticp90MTKJt+SdHzRB3+suaosU59G9TS/TJT0uKRXQwhz5rVxH2d+ynl/SZ+WNE352HulcuWn1GRfyrLsbeWJFceGEH7q8bzT3FCMx+8qf1Y4IMuyx9XA7xTfH6b8x/pZyp9tZqsNltjrIg5QnlfnxSzLXq39U972/jN0YIWALMteVP6QfnSov2rR95W35cnFc8VtyhVwKe5X/sw5R3l9finLslr4wd7K85a8ojzU8ydZlt1WfNfouWe68gf454rnyPmWvoeyDL/vUzSKVyWtlmXZu508xlDlE+sBmbNcGmOMMcYYY+pQKHHflrRmlmXP9/LlmDagld6g9xRLK8/e3qmHc2OMMcYYY4xJEULYtQitWlTSqcrfur7Qu1dl2oV+94CeZdnsLMvO7e3rMMYYY4wxxvRJdtfc5GNrKg9X61+yZdNp+p3E3RhjjDHGGGOMaUX63Rt0Y4wxxhhjjDGmFfEDujHGGGOMMcYY0wI0neZekgYOHJgNHTq0my6lMR988EG0X3zxxWgvtdRS0V5kkUWiHbAGPW0e56233or2Zz7zmWgPGjQo2gsuuOD8XPY8eeGFFzRnzpwOr43Y03Xx/vvvR/uNN96I9qc+NbcJsaxY5v/+d/1E95/+9NxlUv/+97/X3f7DDz+M9tprN1o1oWt44IEH5mRZtmxH9+vp+mAZvfvu3HyHc+bMXdWG9bHQQgtFe4EF5v4ux+OwjhdddNFor7TSSnX37QlauT7++c+5q6X87W9/i/bbb78dbdbBMsssE236qpRPeu+996LNcl966aWjveyyHS6aTtNZXyX17tjx8cdzl4r/xz/+UddOjR30PwMGDIj2wgsv3OXX2VHaZezoL7Syr2Io47/+9a9osw/Q57Otd5TU8ZdYosuWB54n7eqr+ir2Va1FK/uq/kiqPjr0gD506FBNmTKlUxfAAYIToGZ54oknon3ooYdG+ytf+Uq0N9xww2jz4Y8PkY8//ni0r7nmmmivttpq0f7e974X7SWXXLLD19oRNt54407tNz910Rn++te/RvuCCy6INh86FltssWizzPnQyLofPHhwtB9++OFoz549O9qvv/56tCdNmtSZS+8QIYQZndmvo/Uxv/2BZTRx4twlgc8777xos+0OGzYs2vwxig+E9913X7Q33XTTaP/85z+PdrMPJvN7f9i3R+qjMzz//NyVUu64445oX3fdddHmw/R+++0X7VGjRkV7+vTp0b7qqquifdttt0Wbk+d999032t/4xjc6de2dobO+Suqe+uCDt5T+8Yg/ntD/0x4xYkS02T9mzZoV7eWXXz7aG2ywQd1zdVW7b4Z2GTv6C93pq9jW2c5Tn1fhQzNfcLAPjBkzJtp8SdFRZsyYWwzTpk2L9s477xztZvtGs/dXpdV8VX/Hvqq1aOV5VX8kVR8dekBvhtQEJeWQH3roodLfl112WbQ5WeWbKE64jjnmmGi/+eabHbrWtdZaK9qPPPJItE888cRoc6DaaaedSvt/97vfjfb666/foXO3G7fffnu0H3vssWizXvnAwjriAzoVD/xFnQ+TAwcOjPYLL7zQ6WtuNZqZvLOszjzzzNJ3fGDjW1c+vHEixh9Vrr766rrn45sSvim///77o7355ptHmw+cW2+9dbQPO+yw0nFZz+3MzTffHO3TTz+99B1/rGC5U63A9vvVr3412q+99lq0+Ys0f9haYYUVos2+cuWVV0b7jDPOiPYOO+wQ7bPOOuuTN9PHaDRhf/LJJ6NNJcJTTz0V7alTp0ab5cu2SzUE+xz78siRI6Pd3Q/lpn/CdtXMQ+vBBx9c+ptqH/4ART/E8SalIuFLEL4dp9/iQzl/tJ8wYUK02a9222230rV+8YtfjHZnfowwxpi+gL2cMcYYY4wxxhjTAvgB3RhjjDHGGGOMaQG6XOKekvgxkdX+++8fbUrLpbJ08LOf/Wy0KSelBJHSdya8euedd6LNBECpRGZk9OjR0aas8d577y1tR9n3lltuGe2LLrqo7nHbGSYQW3XVVaPNsIJVVlkl2pSjMbkbpXbchhJ3yqi5PeXCfSlRxbPPPhvtXXbZJdrVOECWEaXpbNOULzLuiyEHqe0p02bsP/sV6+PWW2+N9j333FO6Vkosv/CFL6idYH2MHz8+2tUwFko8U/JL9onFF1+87vnoh1g33J71TTnpZpttFu2XXnop2gy/kaTTTjut7rn7Eqw3lsWQIUOizZhytmXGl9O3pJL8UaLLmLz5iX3tz3DcT/Wl1HjNfUlnwg04xjO0hyETDI3rqZAG3mNK3v2DH/wg2swtIkkrrrhitOnn6Z84Z2I/YWjON7/5zWjT97D/8FwMV6NUnnOyyy+/vHStjJE/4ogjop2qZ2OM6Yv4DboxxhhjjDHGGNMC+AHdGGOMMcYYY4xpAbpc4p5izz33jDYlTJRGSWXJ2EcffRTt1Hrk3IYSKMoRuQ1pRjJFaT2zM1ev9a677oo2l4Tj8lbtDLMfU/5M6TRl8LSXW265aKfWOGemZdYLt7/zzjuj3Y4S95QcktJEZu6uZkJnWfBYlDyz7Fg3lLKnZO2ss5Skmn2AUlQeR5J++ctfRnvHHXeMNsNWWhXKwRutM877ZygMfRXLjqEhzBrOfVmvlGATHpN9iH2CKy1I0o033hhthlH0JSg757jC9r7yyitH+8ILL4w2l9wcN25ctJkZn76cx2foDcMeWmGt9HanGQl5R2XmDE2TpEcffTTaTz/9dLS5Qgz96i233BJttq3uJCX7f+6556LNPk/pulT2JSwvHoureHB7zteuuOKKaFOmTik7Q3M49+K5aFMSL5XrIzUHbGZuaPoGtb7XE+EkqZV2Up+n2ncz+3b0c1OfZsqLzxd33313tMeOHTvPY7KOOffqzPWRZurWb9CNMcYYY4wxxpgWwA/oxhhjjDHGGGNMC9CtEvcHHngg2pRJUQ5F2W4VygVffvnlup9T+kX5QUp6QijLpaR3scUWizYlkY3kDTzHb37zm2j3lezJc+bMiTblIpRFMwssM7GnwhC4b0ray/ZRzUzbzjBL7quvvhptygMpX5bK7e/vf/97tFmOKekfbbZVyqt5TG6TyhhPuXo1/IPXdP3110d7n332Uatz4IEHRvv000+PdlXuTpkz+wTLi3z605+ONsNECOufEtIUPCYl3vRbUt+RtdPfU94rlUM6Hn744WhT7ksZ7zPPPBNtliPHhVdeeSXazPDN8YzZ41nue++9d93P+xvNSBBTKxmkuOCCC6K96aabRpuhZmeddVa0KaOurhzDrOyjRo2K9hlnnBHtkSNHzvOaupPU3OPPf/5ztOmz6culsn9OzbnowxhqRV91ww03RJtlwr7H+VlqHGE/rkpAOe6xPrfZZpvkPqbvUs9nMAyC7YrtsDMrajTjn0gzvqqjx7SsvWPQl7A+OL7zmYyhZ4suumi06SO5klej577U6iP8PLV/KvSa+A26McYYY4wxxhjTAvgB3RhjjDHGGGOMaQG6VeI+adKkaFO2TFltVX5OmQAzpJ5yyinRpvyK8kXKEbkNj0k5DKWMlMY8+OCD0aZMripxpRSL93HVVVdFu69I3ClfZ9nyvqdNmxZtytGr8ucaKZkapb3chsdvd1g+lLhTolPN4k3ZIrdjO2Z9pOQ3lFCl5I6prKKU61D6yLCV6jXddttt0W4HiTvlTZtttlm0r7vuutJ2Y8aMiTbLkfXEUA/KqOlL2D+4L/0Ls77Pnj277nVTWnrSSSfV3abdoaydMnOp7DfWWGONaE+dOjXarNtBgwZFm5nYKavl9n/5y1+izXFnu+22izb75T333BNtyqglacMNN5SZN1wRhX2MmdinTJkS7TfffDPaBxxwQLS33nrraFPGXt2fNvsr5ZJsW70Nx8RU+JhUvheOBSQ1pnAexrCm1DapeRH9HOcTnA9K5bGHmekpce9MNmXTfnz88cdxTLz88svj5wybGzFiRLTZ3rjqz+DBg6PNUDBJevfdd6O95pprRpvzm9RqLjwW+wCvg1JmHnPJJZeMduq5pwr7BvsffSPnjTzf17/+9eRx25lUWOfEiROjfeutt0abYzfLinMvrtRx0EEHRbvRqmOpcAc+W7JdNBPC6DfoxhhjjDHGGGNMC+AHdGOMMcYYY4wxpgXoVp3QlVdeGW2+/k9lXpfKMgPKOikzoPyAmeIp4fj1r38d7fXWWy/alFNRGrHccstF+4gjjoj2OeecE+1qVm0ei9kAp0+fHu2nnnoq2lWZY6tD+QdlQCxPSuco96D0hxn4KfdIZaymXJqSEmY+b3cou6U8iXL3qhSRf1MuyAzFq6++erSHDh0abZZvKoslwz9Y98yYyiy+PE5VNsZ6rsot24lvf/vb0WZWZ0kaMmRItCmBY5my3NneCeufx+Hn9D08DqWiY8eOnee52h22M/rs6nf0RTvuuGO0WS5sy9yG4wLl6xyrWDeUVbPuWWdV30UpJWXDfZFmshJz3Ge2fIYhcD7AsZ4rLTBL/5FHHhlthoVUr2edddaJNsPbKIukv20liTtXEGD7rM5VGP7Ce+H4nQqPYlvnObgN53fchjbHFJ6L11Y9bmq1C9M/eOedd6Kf5socJ5xwQrQZkjRhwoRos51zxYHnn3++dA7Oe+67775ocx762muvRZsrGnF859jNZ4Blllmm7jacV3EuRel7Ve5O2f4bb7wRbd4f/RnnXk8//bT6IvRh5K9//Wu0GcLGeTRtzgEeeuihaH/ve9+LdnVlgPXXXz/aw4YNizbD4Xgdm2++ebQZPpnCb9CNMcYYY4wxxpgWwA/oxhhjjDHGGGNMC9CtEvdHHnkk2sycRwlhNVM1oXyT7LTTTtGmPJAZX0899dRo77nnntGmrJHSLWbVpcyNEi3K8KSyTIs275WSmXaTuFO6udhii0WbMh1K0JhVkmVFSSHlbFtssUW0WX6Uy1GmlMr63o589atfjfZWW20V7YsvvjjazGArScccc0y0KWNKwTpgudOmBCoVssHM6yeeeGK0N9lkk2hTmi+VpV/MvN0OpCSdzMotST/84Q/r7s97p3yO5U5JG/0ht6G8LZV5mZ/vuuuudbdpd1gm9DHV8Ci2We5DH8U2zhAF1jkzt1My/fjjj0eb9ZqSzPGY1fp76aWXot1MX25n2L7p5zkuMCSG7Z4+kJnbGcJGWSvnBqQaDkEof+eqCwzN+t3vfhdtjlvDhw9PHre7oHyd8x+GoVVln7wXzk84vqbaLmH/I5zHpbIZE/ZDzjOq19duY4fpWgYMGBBD+NiuuNoC5cQMg6FNaThXdJDKfeOCCy6I9s477xxtSqR5HXvttVe06Uc492L75ud8XqH0mZJ4hshK5dV/OP4xdIvjHeX/X/va19RX4LMAxxGGJbGNsHw452X50ubcliFNHKekcjjW1VdfHW3WDecT5513XrRT0nziN+jGGGOMMcYYY0wL4Ad0Y4wxxhhjjDGmBfADujHGGGOMMcYY0wJ0eQw6lw5grDLjNhiTRlsqxw4yHowwFpDxalzKhvGhjFdg7CA/Z6w4WWGFFaL9yiuvlL7jPTEOgvGljH054IAD6p6jVWG8S2o5FsbDcRvW67Rp06LNJcFefPHFaHNJMJYfY0dYd+0Ol25geW677bbRZl4EqRxjyLhVtmOWF2OZuHQHy5Htlsdh/gfGgTIeh/Hy1aWieO7qUiGtTjW2uQZ9gSStttpq0ebSLYzrZO4G1nMq9pPlyFgyXhO3Hzx4cOIu+g5c1ia11KBUjmvl2MH4WI4vXJbtN7/5Td19q7kVatDX0QeynjgeVePNuGxPX49BT8WdE/p8+qGJEydGe9999432r371qy67Pi5XRB+70UYbRZv1x/bEfXsKtivGtLKcq7GSjINde+21o81xmuWeyhvA/pcaOwjHGtYx8/wwd4RU7k/V5Tv7IqmyY/k2k8chlTslBeuSx2yWlN9rZlnFZvnggw/05JNPSirHis+cOTPazAPBZQcZN85lbTnHkso+nvMb9m2Oy6kxlz6CeRQ4/+U9VJcXrMGlhZkzq/od7/uZZ56JNpf1eu+99+Z5vlamo3mnjj322GinlmWmz+QzHOepd999d7QZy15t26NGjYo2l07lcc8+++xoM6fGVVddlbiLufgNujHGGGOMMcYY0wL4Ad0YY4wxxhhjjGkBulzifvLJJ0ebkgrKmBotXUbZIuVRlBlQekLpFiU3lBDyODw+lwyhlOqyyy6LNmXelGhV9+F3vI4HHnhA7Upq2S3Ce6WsbuDAgdGmLIRSa9YF5UiUR7OtpJZ4aUe4HNCf//znaFP2csstt5T2YYjEOeecE23K0Sl1Yn2kpHCpEAVK3igtpWT7pJNOinZVxr7UUktFm8tPcFmKVAhLu0D5FcuaZUc5LMuObZn9ILX0RmrpokbLR/UV6IdoU74nlX1LSvrLdsrl8K677rpob7PNNtFm6A37WWoJNY55lNiNHDmydK0p6XxfpBnJK/vG5z73ubo2YTmz/6TOlVqWRyrXE/0Ww4XGjh1bd/sZM2bUPV93Qnl4akyszqtS8mf6/9Sysc3UH7dJ+Sp+zmuoytgHDRoUbc4FOEdgv2x3minfRu23RjOyds4bTjjhhGhXwzeboSdCDj/1qU/FeQKXMWMboaydvriZ7SXp2muvjfbGG28cbcroN9hgg2gz7Iahbeuvv360KTPnEmpcKpLjFft0KhxYKvcBhsDRH/K4bDfs6+1CR8Ml6L/pp/l8xjlZ6vmFYwrLtno9lMJzbsty57Mol+5rBr9BN8YYY4wxxhhjWgA/oBtjjDHGGGOMMS1Al0vcKefgq31KbykVrEqxmAmPMqsxY8ZEmxKQlCyLUhfKGCg9oCSIUhJK29Zaa61ov//++6Vr5Tl4XGYq32OPPdSupDLTE5bBEkssEW1mriSUoDAzJuud2d0paaUMst05+uijo812yLYzbNiw0j7XX399tI8//vi6x6XsjHLe1IoDPHdK+s52T/kU+yQlZFI5Uyozo7abrL1RptuVVlop2swSy31YB9yf7Tr1OfscJVfMar7yyivXvW7WpdSc/LFV4XhBn1GVuPO7VNZtQunaDjvsEG1m4E1JqVlPqXNRQl8NXeD+zchX+xPNZBAn/Dwlr24EpaJsQ6wXnoNSyN7oV5xXEfqa6lyFc5pU9u3UfCaVuT1V1qmVcnheXiszG0vlLPPc/+GHH452X5K4k5QvaKadjR8/PtosqyuuuCLa9GFcZWnvvfeO9iWXXNLUtTK84pRTTon2j370o6b2b4aPPvootuVVV101fr7VVltFe8KECdGmv+b8ie2/2n8OP/zwaFO+znGWYYhbbLFF3etghvZx48ZF+5FHHon2E088EW2WOaXPlLFTWi9JkydPjjbDe8m6664bba4QwgzwfRU+T3IcoQ/jvKqZcBqOQdWs8jwH2x73oZ986aWX5n0TwG/QjTHGGGOMMcaYFsAP6MYYY4wxxhhjTAvQ5fqsb33rW3VtZkN/+umno33uueeW9meWQ8phmSGRMlvKbFISuBQpGRdlQJRXjhgxorQ/JUV9EZZPVd5b73PKOykDJJQ7U/pDiTuloSz/zsgXW5U999wz2pRPMes/MwdL0m677RZtZigdPHhwtCm5oaSQ8ptqZtAalNGxDihZpKyYGYxPP/300rH4Hfv0hhtuWNduRyizZJnSJ9HvDRkyJNosa65KwRAQbkOJdCpMpy9Bqdq7774bbZYDM+hK5ZUmOEZQKkqb9cTwGY4FtFnHDCGgD2Q/o0Sy6j8pQWb9c/WL/kozWcApU0z5s2ZDB1gXf/jDH6K9yy67RHufffaJNmXwqdCv7oRZqOnjOW+pyl8Zqse2WA2FqZGStXP7qtyz3jWxblhu/Lxafzwfr+PJJ5+se752JNU2U+2Uc2ZK1u+7775oc9WX1VZbLdoMg6Kfo4z3pptuavbSI5deemm077///g7v3wz//ve/oySdEmRK+Dk+cK7CuSNXzeC8U5K23377uvuzvZ166qnR5tzowgsvjDYl7l/72teizVVBJk2aFG2GcnDcuPLKK6NdXeGA82eGSTELP49FuXs1JKwdSD2jcSzgswbLgWE0nDdw3Oc2nD+w7bDdVUOyeSz6N7ZJPrtyrOHKZCn8Bt0YY4wxxhhjjGkB/IBujDHGGGOMMca0AD2mj6R0c/To0dGmxEAqZ1Gk3IfyacoEUlJDQplESrbN41PmQhkJM9T3B1JZRCnxocSP2XBT0j9K7e65555oU57HzIqzZs2KdkrK2I4wmyfLk/e+6aablvZheT366KPRTkkCSUpGl5IppjIp8/oo+xw5cmRpf2ZcZVZsyrraHdZbSpabykKdyuJOP8n+lAoZocSqL5HKFk3fTxmZ9MmxpB7NSNNTvot1kAozeOqpp6LNjK2U/UplOR3ll+0qca/6kZ7MRs/2kRojGoVHUcLIsBtKEA8++OBoU2LeG3MCyjjpRxjWUZVism+wD6TqqZmxNjXfSp2Xvop+rto3UhnzORfobVKre/Aeqys3kFS5U9J8zDHHRPuyyy6LNn3HCiusEG3Oq1mmbAvM6k1J9rHHHpu8VobT8TqOPPLIaE+fPj3aDNPbaKONksdthkUWWSQe49prr42fU+rNMrjjjjvqXjcztVezuJ988snRZnv93//932hz3nPmmWdGm2FMrG+GHuy6667R/va3vx1thv5xDGDm9up86YYbboj2zJkzoz18+PBosw1Szl+dT7YD7Cf0SfTnbJP0EVylgON7aj7B1aP4DMhnw2pIYSqMlO3iv/7rv6LN0IxUeBHxG3RjjDHGGGOMMaYF8AO6McYYY4wxxhjTAnSrxJ2yN0oBKAWpSn2YZTIlaUjJg5rN2jovUjJhSsiqpCTBPSn1605SmVwpTefnqbJiVknCTMasR8pU+kpZSmWZJNsOZUuUVUnpzOrMHpmS3jbTPrkvZXE8F2VjvJ6qBJvyOcr2KOViptlWpZGMk+XLdkr/RiknYf/g9pRJLb/88tGm3J0Sx74Kxwu2M35elbRTqkx/kvJd9PMsU0rcKRdkP0jJ0yiZY5tYYoklSttRmky7XWkV39zMSh+UGUplSenee+8d7RtvvDHaf/rTn6LNNsHwnZ6CGdqr8vAaVSkm+xBJrVKQCn3i5ywHljvnBJSHso008mG8J2aeprS/N0iFSpJGsnbClVuuuuqqaHNlIK5itN5660Wbdcts0wz5oQ9jWTNsg/OLiy++ONqUdlePxYzUrFv6MM7h55cFFlggXv/NN98cP2d5sM/S79NmP62uvsRy4+ozlISvvvrq0d5vv/2iffXVV0ebfWnUqFHR5mojLDOu8MK+weuurnTD77g/V/w5//zzo816SbXZVobjbKpvUd7POUFqNQn6Ks5n6bfY93gNVX/L8Z5zvVR7O+qoo6LdTMiB36AbY4wxxhhjjDEtgB/QjTHGGGOMMcaYFqBbJe6UbVAeSCgdkaTFF1882s3IG1IS3Y5K7lIL2ZOqTJFQ3tKMzK4dSMnZKJthuVEOnJI5bbLJJtFmmbGuWX6UBKVkeu0Iy5bSGsrXqmVI2XkqO3hKppjKOpta1YDbs+75eaOM05Rhsm4pU2wHiXuq3KSyNI5yM0oCKUkjlD+zXilZTPk8XhMzj5KqxLXdYJmwTdOvs41JaTltKuyD5Uibx6U8lPK51PXx+AznqGYOphy/L0jce5OUfJEwU3O13RxyyCHRvvDCC6PNOho3bly0X3jhhWg3K2nuShgGw7adyiIsldtxM9mDU/2HZc1xi6TCqTiOcCyvliH7A/fp7VVcUitLpDjrrLOife6555a+oz+gHJZyXfqSqv+od02pOmMdcNyproJRo7oywTXXXFN3uxNOOCHav/zlL6M9ZMiQaF900UWSyr65I3zwwQd68sknJZVl47ynadOmRXurrbaKNuXIXAFnxIgRpXPwmYOr6wwePDjatfuQFK9HKmdoZ5jf3XffHW0++3C1G84TWC/sG3/84x9L18pVkI444ohoc/WQ1HjJVUW6mpSP4LjKbVgmzYYRpqC8n+GeqVA1wnKnX0w94zS6Pt4Hy2Dq1KnRbvQMWQ+/QTfGGGOMMcYYY1oAP6AbY4wxxhhjjDEtQI/pIFMScMoQpLKMkDIDSiIoXUnJ2lMZN1MZ2inXonyR+/YV6XqzpOTSLH9Ke7lNKlt7Krs75SEpCV6rZAruClLSH5ZDNQM4JYwpOXqqjJqRwrGPUZKWynzNLONVuSP7CvdnVt52oJH8ivIoZpWlNI6+hGVEySIlVJQHcnvKEVdYYYVoM1t+X4IS3ZTMtVHIC9sf/RXrs5kQglQdpKS7lEWzv1bHHR6XKzeYjsO6pvz8uOOOizZ90HLLLVfan1m011xzzWiz3TA0pzdk7SmJMOdI7DOU0krlcZe+h/Mtjgup8I/UPIxwTsdy5z1w7KhmdOd9pMJTeO5U+GRX8OCDD0b71ltvjTZlzqwDthOOddV5z8orrxxthjWxjPg5od9j+abmESn/x3qiP7r//vtL5+N4w6zVK620UrQpveaYd95550kqr0LSERZaaKHYJ+lPmYF+7bXXjjZDVDgHHTZsWLQpzZekzTbbLNoMS7rpppuizeunv6asnWXIrPi777573eMzPI0y+1mzZkV7t912K10r2wdDD8aMGRPtjTbaKNrXXntttFlHXUEqtKgrw+vuvPPOaNNPM4SA/YHjbyrkjdfHfXk/qRUKqvPr1GoUnBNwG2b9Z3hECr9BN8YYY4wxxhhjWgA/oBtjjDHGGGOMMS1Aj0ncU9LbqoSUfzcjy02dIyVlT0nfU9eQykja6Nx9BUqjKC9i9m7KcSgLYWZSwszklKalZNSUzvSGtLAn4L2zHVHGJZWlYylSMrdU+aZslnsqey7lkdW+xGNRUtTbmXi7krvuuivaXI0iJVNn26f88e233452KrsxpZOEctXZs2dHuyrjbZSNvhWh76FcjNlqqz6e/eWxxx6LNjO7pjKmp8qEdcA6Y/jJlClTos0srZTxVrMws79UM263Gs1kSe+u86VWEmE/Yeblo446KtqUdFKWetppp5XOlxq7H3744Wg/99xz0aYktqdgKBlhWaVCMKS0HJ3bpfpAap5EUqsjsM7YlyiVroaqsI9Tqs9j0ddRat0VzJ49W2effbaksiQ1lT2f98VyprS1WoaURrPcWRaUxafmCPRnPAfnYqwP3kMqW3410zT7PP0e5288bleGsWVZFsuUGdp57ZMmTYo2ffGKK64YbY7D1dVjGK5AWM7bbbddtNnPKH3nfGj99deP9ujRo6PNcmIdcQxgn67Oo59++uloU+LO69hzzz2jTYl8Z8MMUjQzFnDFDM5h2Mercxv2OW7H8mWbZj/jqjmp+mcfTYX7cK7NVQ2qbZtzQPZj9iH2k8mTJ6sjtP5MzRhjjDHGGGOM6Qf4Ad0YY4wxxhhjjGkBekzi3iyUO1Dik5LGNiNZb4ZUNmt+nsou3h+gPIaSEsp0KJNaY4015nlMSk95HGYXpZSJ27c7zYREVLO4p9ofpTWprLepTO+p60jJ0nl8yrWqWWqbyTrcqqTk4NVs29OmTYs2ZXOUo1JyxT5BiSfls6xzSulSsE+MHz8+2ocffnhpu3aQtRP6YLa/VMb06neUqKX8BuuA8jbKT1kHlLKyvT///PPRZuZgShsnTJhQOjclkOxT06dPj/Y666xT97p7mpSUsdF4Oz8hX6nwGsp/uXrBL37xi2hTisps1FdccUWHr4P30OzqAd0Fw2DoQ+mr2OYZZiOV/XFqXEjVJ+89Va+pNsLt2T/Z34YPH17ah36WfY7Xwb7b1SyzzDLab7/9JEmbbLJJ/Pyee+6JNkNoZsyYEW1KYDkOVEMMUnVA6T5lz6mwS5ZpanUjQl/IeRzLuVqXrENKhVMhJ6zbz3/+85Kk6667ru71zIsPP/wwhlEy0znLg76YfpXbX3DBBdGuhhstvfTS0ebck/XNMmHGdIbRcD502GGHRfuBBx6INucDG264YbQ5v+ZKFBMnTixd69ixY6M9atSoaNM/sD1RIj8/z0f1uO+++6L94x//ONq8F15XauWh6tyRZc2wwFRIJeuMcvTLLrss2uzHHNPZnlnuZOrUqdHm3EAqr8bA/kRfTF+VOkeK9pq1GWOMMcYYY4wxfRQ/oBtjjDHGGGOMMS1Ar2dxr5KSSlFOk5L0puxUBvhm5FfcppHEvS9mcWddUL7z0ksvRZtlQokVpT8pKFGlFIaylmbk2P0FShtZN2zTqazspJkVFbgv+wPriW1izTXXLB2LGZApn+tqmVV3kJKD/+lPfyr9TTkz64bSOsofmW2YUmbWJSVTlFYxIzhlcpTEU/bLbK/SJ+un1WHbYvlQqrvllluW9mG9UW6WCo+izLQZP89jsh+kyparXVTl+OwTPHerZ3QnXemPU+Nyaj5w3HHHRZvZetlnKHHsDGxPrJfeWE0klQ2dUkr2jZ122qm0P8uF4SOpcB72gVRGcPYrbs/j0C/yvLyfav+5/PLLo01JaSoLfHdQa4+U31PaTFg+DHd55plnol2VtjKUM5WJPVU39CWcK/FzyoaZUZqfU5beKGyDdZUav+nr6Cdrfbmz4YkLLrhgHE8573z11VejvfHGG0ebvuDZZ5+t+/nQoUNL52DdcK6z7bbbRptlwNAjZimnVJ4y+lRYFucG3JdjPccZqSy7X3vttaM9bty4aDPzOf1WLdxgfqn1++985zvxM7ZnjqupMZlUwyEpWadN3nnnnWizHI8++ui6+5577rnRXmGFFaJNiTvDo7gqD+dSnHtJza1ExfKorq4zL/wG3RhjjDHGGGOMaQH8gG6MMcYYY4wxxrQALZfFPbUYPaVuKelPSqZIGUIqMys/pySBVOUm/ZWUvIzyJ0p2UlDO+8QTT0SbspNUPbY7lKZRxpeSpUtl2S/Lgn0jJc9OhXk0s0pBSqLOax08eHBpnylTpkSbfTolN24HKBOVpBEjRkSbZUFJWyqbfTMZ+VPZc5nlmHL6lLReaj+JO9sc5ZEsh6o/aNR3alBOSuknz8d+xjJlCAHPxQz+3GbZZZeNdjX7K9sIM+2mZIC9SUp+zvGwmhm5lnlZkrbZZpt5nqMZufxPfvKTaHOMZr+85ppr5nmcRqFqqdUrejv0IDUnSa3aQZ8rlcPPODY3I3Fnm+Q2qRVcCCW9qRUxqqEqlGHzuukHmlnhorMsuOCC8Ro412GbTkm9WbZs99XVS1JzmdSclPXEYzWT0Z3b0w8x2zazz1czzqdkvAyv4HyG7bC2mgB9akeptRu2N2YQpwSZ5UT/tOeee0a7KnG/9957o80s8LR57vPOOy/aLBvK/FnOO++8c7Qpxz/55JOj/fjjj0f7oIMOivYGG2xQutYTTzwx2myPrD+GAnDc74o+M2fOHP3hD3+QVJ5jcAxkn+F1VeXhNar+mPJ1PiMwRJDtiSEBBxxwQLSvvfbaaO+6667RZhgKr5XZ9idNmhRt9rGqX23GB7I/cJvqqkD18Bt0Y4wxxhhjjDGmBfADujHGGGOMMcYY0wK0nMQ9lbWVpCR3hLKElDysmezulLA0kun09QzjlA5R2kSJCMuK2aVTMKMhs1pTmkSbEpd2hPKWVNujpLYKpWfNtGlun8r6TthnUrL5VBhJVTbGc3P/qnyu1aEcitk/pbJ0kPJLlktqJQSSynqakscz4y6z2bJ/UL7YjqRCL9g/qpmB6YtSIVEpuWaqzrgvt6EMl/XEcmd/Hz16dOla6UOZbZZS0VYhNbZNmzYt2lW5HuuJ99ooW3Q9GDJAKSr73l133dWhY1bvp5mwoBdffLFD5+hqWIb0Fwz5YDtsJHGnz+A4Tf/E7NQcp/k5w0LYbillZbmxz1ACXK0PXh9lxrzX+ZFMdwTK+5sJP+F1pcZfqXz/rLfU+MixORX6mdqe5ct64njRKNQtdR+p+QLLqZY9PZWNe14MGDAgSph5jGHDhkWb5cf5IjObb7311tF+6KGHSufYbLPNok2pdmqFBM51GNqTqlOOCY899li011tvvWgzFITH5PxDKmcXZzugfJ31zTGyupJIZxgwYED0B5SfU8pO38PQx1QYRVV6zzCRWohEdX/6AtpshwxroB9h1n76Kl43fVUqnFQq+8COrjTGbPsp/AbdGGOMMcYYY4xpAfyAbowxxhhjjDHGtAAtJ3FvJstzM3LylIw3dRzKRfg5JQ2UvPQ3UrJPlglljZR+pKDkhtunsh6mZN3tAttVSoreSMafkq2lJJopaQ1t7ks71R9YB5QcVbOEpyTuzfTLVoLS3Wo5UwrIdkr5LcsrJV9866236m7P+ua5Vl111Wgzgy23ZyZUqSxNbWaFhd4mJaWkdJBZc6XyygEpUisKpFYqoPyOUrpqVvYalBRS3rv22muXtrvzzjvrXlNPrRRSu8eOjqXcfvPNN+/6C6vAjMaUBN54442dPmZVppjySezvDMHqDehf2JfZz3m91fbJeqN/onwzlRGcEl2Ww6abbhrtlAyex+R4wWsdNGhQ6Vr59zrrrBNt+rpUxuTehjLsRrLuZkIATd5Wn3zySUnSpZdeGj+vSeelsmyfY8L48eOj/eyzz0abcmepLCNnBvQdd9wx2pTFUxZdDbOqwTH9mWeeiTbnvMzczrAAbvPwww+XjssVKzjfZngX5xDsM5MnT657rR1hwIABUdrOPsyVSHgt9B2UjXOFE9pSea7D8Z6fp1YmoL9hOTIci3VGCT77JI/P66s+g9B/8juGujBkhyvHVOu2Hn6DbowxxhhjjDHGtAB+QDfGGGOMMcYYY1oAP6AbY4wxxhhjjDEtQI8F9XZmGTLGwTZDM8tHpa6J+/K8qZjQ/kBqGSmWFWMtGBfUDFyugjFljPUk7R6DTlL5DxqVIdtfaumy1HIszcSpp3IvpPoV4x+5ZEj13LTbLQadcU9Vf8Qlo5iLgfXB2ObU0nWMzWQbZ2wyl5vaeOONo81YZi4DV10qhzFx7RCDnqJRXCf9RmoJNZYv64M2t08ts8n6ZlwZ4wLZDhh/J6XHkuryWN1FR8bj1Lbsy1zSSCq316OPPjra++yzzzzPd/zxx0d7woQJ0T788MOjXY0j7Q5YR+w/vQHjLFP5D9hu77///tJ3jM1lnC39E4+bmvfwOJwTNBMHyiWmGO956623lq6VcaeMZ2ff4FJUpu+ywAILxBhzxoRzbsp2xTYyZsyYup9Xc0kxzwj9/QMPPBDt1BKBhLHwnA+xX86aNavuvmzPXAasOk4wZpqx8OzHnFfTruZB6QyLLLKIRo4cKam8jNn5558fbc5huSxcKodLNZ9EaqlClmNqrOdYxfkZ50ace6XGfdZ3agm56na0WR9sU8x3UFs+sBF+g26MMcYYY4wxxrQAfkA3xhhjjDHGGGNagB7TDKektFUoDaDUIUVqaajUsmApqW9K7p5a7qfR/n0FyktYDpSkUI5WlXHOCy7NklqCjOeqLo/TzqTa25AhQ5L7UF7DpR8orUqVESWLKfk54TWxjlPLWzRaHi4lI2oHKCOrSrFYB5TZ0W9R/pxaMjAl96KMi8urfP7zn482+xz3rUpy263cCdsfJX6UJkrlpVQogWZbTi1dx88pSWMdUIbIvsgxhfvyuhuF56SWuuou3nvvPd1+++2SyuMt/QjDILgEEO+bZVMNS+LSQqeddlq0d9hhh2jT/99yyy3RPvPMM6O9zTbbRPukk05K3NH8kRq76Rt7KvQgxezZs6O9xhprRJvL8lGKWV26jH6b90JfxXbIPpMKdUvNCfh5aikotpeqX+U5aktsSeU+1BfnW+aTfPzxx9HPc7zl3PS2226L9oYbbhjt0aNHR5uhGXfddVfpHByjKX/nGEo5N6XvXEqT40BqGTgu28p+mAqHYp+WyjJ1XvfNN98c7e233z7a7FuUzncFxxxzTLRrsndJOvXUU6NNSTfrj/dIKbpU9rscQ1Njd+rZMrUMLn1e6jiEn1evlfXDcBy2BS6zNmLEiGjvu+++0d5vv/3qnttv0I0xxhhjjDHGmBbAD+jGGGOMMcYYY0wL0NJpsVOS9VTG9ZRNuUFKxpDKqk36WxZ3ym4ofyON5B/1tmE5U+aWkoxSIpfK7t4usBxS7ZByqCopqTnrhpLsVMbqZjKpsw+kZIrMSFqtG15rSmrUDrz++uvRrvoFZiim1JR+glI33juzGFNC3MzKFZSA8jjsWzymVK6rrsjm2t1QOkZZIKV0M2bMKO1DCd8GG2wQbdZHKtSD/YN1xv7EbejrKLXn55QlVyW5vA62sZ4I4/nXv/4Vy4plxutl+dO/sL3xWldZZZXSOSjfo6yPctR777032o8++mi0t9xyy2hTHk85Pv1Ld8nPuWLATjvt1C3naJZUWBnvfc6cOdGutjfeC/0H/XZqXKBvW3XVVetuk5oHsI9R4soxntdT/ZttjPfal1Z0MWkWWmghrbvuupLKcw/W/5e//OVo09cz5IlZvGlL5bHixhtvjDbbK8ObOB8aPnx4tDkf4NyZczWGAvI6eHy2+WrYKMdChggNGzYs2lylgRLzvfbaS11BrU+zD3MVD9oTJ06MNiXxHHe4GpCUDkljmbL+uX0qbHbllVeONn0efU0zz3ccg6S0r/uP//iPaLNuNt9883meg/gNujHGGGOMMcYY0wL4Ad0YY4wxxhhjjGkBekwn1GzWTcoLn3766WhT0kBpBW3KwPh5KkM4j0n5RIr+lsWdUNpIKPGgjI6kpKSUBKXqNyWJb0fYfiiVaVZ+/qUvfSnalNVSisVzpOSy3CYlu2cdsG6YOXTjjTdOXitlsc2uhNCKUFZXDeGoZkqvQUkb65lSf8qaWX88H7eh/eyzz0Y7Fb5T9UfVbLCtDqWDlNWy/VF+Lkm77757tJmNl+WSksZRPss6o/yO4SesJ7Zv+kBKjquhHV/4wheinZKTdxfLLLOMDjzwwKa3ZzlTPsmstfxcKpctQxEoa6cPoyxyn332iXZVOl+jJ7Kqsy5/8YtfRPvYY4/t9nNXYcgK28vQoUOjzbZKfyGVV4qgH+N29CU8H2WglNenVtnh9XGb1LjOTNhSuQ+kwitSUnvTt1h44YXjihxcmaO72H///bv9HO1OaiWsemy33XbRnjx5ct1tpk+fXvqbPol9nmMMVzvieL366qs3fW3tgN+gG2OMMcYYY4wxLYAf0I0xxhhjjDHGmBag5VJhMmMoZVmUoFNyR8kspdTNSNYpd+RxmPGPEi1KS6ukssa3M5SaMMPvwIEDo005b0qCnpK4U75G6Rzlb6xHtod2hG0pteIA23+VH/zgB91yXd1BalWERvfXijDMpiqrZNsnvF9Krdk/mM1z/Pjx0aYMfvvtt697zFR5Urq62mqrla5p2223rXutrQoz5dImDz74YHL/lASa0nRCn02JLv0V903VPX0Ux5SqjHeNNdaIdqOVG1oBhiLR7utQPn7ooYf23oVIWm+99aLNfj516tRo/+xnP4t2Ncs550wcvzkm0dddf/310WY5sJ889dRT0aYUlT5sxx13jHbKb/F6pLJUf8qUKdFmRusttthCxpj2Z5111mn4dw2GvfUX+saTpDHGGGOMMcYY0+b4Ad0YY4wxxhhjjGkBekzi3ijDMBk1alS0KeuivCklX6eEiplHeb5URl9Ktyi9phRr9OjRyevuK7J2wqyZu+66a7QpYVt66aWjnZLRpspm0KBB0abkk2XODNdsD+0Iy2qttdaKNjMVjxkzJrl/KsN7K64gwEzMzz//fLQ32mij3ricTnPOOedEuyobpb/Za6+9os1QGGYbnTlzZrQpl2+UDb/GF7/4xbqff/nLX57nvn0J+p6qjJ0hBJSgp1aXoJ/nmMLjsM6bybxPOT7Pm5LpS30zPKqv8dOf/rRXz0955/e///1o33333dHebbfdos3Mxp2hNzLV16DE/Tvf+U60t9xyy2hXfbExxvQ1PBswxhhjjDHGGGNaAD+gG2OMMcYYY4wxLUBIyWbrbhzC65JmdN/l9EuGZFm27Lw3K+O66DZcH62F66N16FRdSK6PbsJ9o7VwfbQO9lWthftGa+H6aC3q1keHHtCNMcYYY4wxxhjTPVjibowxxhhjjDHGtAB+QDfGGGOMMcYYY1oAP6AbY4wxxhhjjDEtgB/QjTHGGGOMMcaYFsAP6MYYY4wxxhhjTAvgB3RjjDHGGGOMMaYF8AO6McYYY4wxxhjTAvgB3RhjjDHGGGOMaQH8gG6MMcYYY4wxxrQA/x++jgad8nfpNgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1008x144 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show a single example for the different classes\n",
    "number_classes = len(class_labels)\n",
    "plt.figure(figsize=(14, 2))\n",
    "for i in range(number_classes):\n",
    "    j = np.where(train_outputs==i)[0][0]\n",
    "    plt.subplot(1, number_classes, i+1)\n",
    "    plt.imshow(train_inputs[j, :, :], cmap=\"binary\")\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.title(class_labels[i])\n",
    "    plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x144 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Show the mean for the different classes\n",
    "number_classes = len(class_labels)\n",
    "plt.figure(figsize=(14, 2))\n",
    "for i in range(number_classes):\n",
    "    j = train_outputs == i\n",
    "    plt.subplot(1, number_classes, i+1)\n",
    "    plt.imshow(np.mean(train_inputs[j, :, :], 0), cmap=\"binary\")\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "    plt.title(class_labels[i])\n",
    "    plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02. Create a Simple Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "1875/1875 [==============================] - 1s 524us/step - loss: 0.8536 - accuracy: 0.6912\n",
      "Epoch 2/10\n",
      "1875/1875 [==============================] - 1s 548us/step - loss: 0.4217 - accuracy: 0.8462\n",
      "Epoch 3/10\n",
      "1875/1875 [==============================] - 1s 533us/step - loss: 0.3769 - accuracy: 0.8615\n",
      "Epoch 4/10\n",
      "1875/1875 [==============================] - 1s 554us/step - loss: 0.3460 - accuracy: 0.8729\n",
      "Epoch 5/10\n",
      "1875/1875 [==============================] - 1s 541us/step - loss: 0.3254 - accuracy: 0.8790\n",
      "Epoch 6/10\n",
      "1875/1875 [==============================] - 1s 561us/step - loss: 0.3187 - accuracy: 0.8823\n",
      "Epoch 7/10\n",
      "1875/1875 [==============================] - 1s 604us/step - loss: 0.3005 - accuracy: 0.8910\n",
      "Epoch 8/10\n",
      "1875/1875 [==============================] - 1s 631us/step - loss: 0.2905 - accuracy: 0.8919\n",
      "Epoch 9/10\n",
      "1875/1875 [==============================] - 1s 545us/step - loss: 0.2791 - accuracy: 0.8974\n",
      "Epoch 10/10\n",
      "1875/1875 [==============================] - 1s 595us/step - loss: 0.2738 - accuracy: 0.9001\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1de3ba6edf0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Build the model (with one input layer flattened, one hidden layer dense, and one output layer dense)\n",
    "model = tf.keras.Sequential([\n",
    "    tf.keras.layers.Flatten(input_shape=np.shape(train_inputs)[1:3]),\n",
    "    tf.keras.layers.Dense(128, \n",
    "                          activation=\"relu\", \n",
    "                          kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.01),\n",
    "                          bias_initializer='zeros'),\n",
    "    tf.keras.layers.Dense(10, \n",
    "                          kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.0, stddev=0.01),\n",
    "                          bias_initializer='zeros')\n",
    "])\n",
    "\n",
    "# Compile the model (with gradient descent optimizer)\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=0.1),\n",
    "              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "# Train the model\n",
    "model.fit(train_inputs, train_outputs, epochs=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01. Single neuron and linear regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01.1 Create a function (single linear neuron) with some inputs and outputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    }
   ],
   "source": [
    "%reset\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Define the true weights and bias for a single linear neuron\n",
    "# (see also http://d2l.ai/chapter_linear-networks/linear-regression-scratch.html)\n",
    "true_weights = np.array([2, -3.4])\n",
    "true_bias = 4.2\n",
    "\n",
    "# Create some inputs using a standard normal distribution\n",
    "number_examples = 1000\n",
    "number_features = len(true_weights)\n",
    "true_inputs = np.random.normal(loc=0.0, scale=1.0, size=(number_examples, number_features))\n",
    "\n",
    "# Create some noise for all the examples using a normal distribution\n",
    "true_noise = np.random.normal(loc=0.0, scale=0.01, size=number_examples)\n",
    "    \n",
    "# Compute the true outputs using the inputs, and the true weights, bias, and noise\n",
    "true_outputs = np.matmul(true_inputs, true_weights) + true_bias + true_noise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01.2. Learn the parameters of the neuron using gradient descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; loss: 2.8178068093399515\n",
      "Epoch: 1; loss: 0.008657554420596639\n",
      "Epoch: 2; loss: 7.830017943958494e-05\n",
      "Epoch: 3; loss: 5.141891440363032e-05\n",
      "Epoch: 4; loss: 5.1363440814342625e-05\n",
      "Epoch: 5; loss: 5.1365079908663894e-05\n",
      "Epoch: 6; loss: 5.136518882777341e-05\n",
      "Epoch: 7; loss: 5.136519515922528e-05\n",
      "Epoch: 8; loss: 5.136519552823079e-05\n",
      "Epoch: 9; loss: 5.1365195549856344e-05\n",
      "\n",
      "Predicted weights: [ 1.99999494 -3.40075876]\n",
      "Predicted bias: 4.200677829374865\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 10\n",
    "learning_rate = 0.03\n",
    "\n",
    "# Initialize the predicted weights and bias\n",
    "predicted_weights = np.random.normal(loc=0.0, scale=0.01, size=number_features)\n",
    "predicted_bias = 0\n",
    "\n",
    "# Initialize the loss for all the batches\n",
    "number_batches = int(np.ceil(number_examples/batch_size))\n",
    "predicted_loss = np.zeros(number_batches)\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_examples, batch_size):\n",
    "        \n",
    "        # Derive the end index of the batch\n",
    "        j2 = min(j+batch_size, number_examples)\n",
    "    \n",
    "        # Compute the predicted outputs using the inputs, and the predicted weights and bias\n",
    "        predicted_outputs = np.matmul(true_inputs[j:j2, :], predicted_weights) + predicted_bias\n",
    "\n",
    "        # Compute the difference between the predicted outputs and the true outputs\n",
    "        output_differences = predicted_outputs-true_outputs[j:j2]\n",
    "\n",
    "        # Compute the loss using the mean squared error\n",
    "        predicted_loss[k] = np.mean(0.5*np.power(output_differences, 2))\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Update the predicted weights and bias using gradient descent, with the derivative of the loss function\n",
    "            predicted_weights -= learning_rate*np.mean(true_inputs[j:j2, :]*(output_differences)[:, np.newaxis], axis=0)\n",
    "            predicted_bias -= learning_rate*np.mean(output_differences, axis=0)\n",
    "            \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "    \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; loss: {np.mean(predicted_loss)}\")\n",
    "    \n",
    "# Print the predicted weights and bias\n",
    "print(\"\")\n",
    "print(f\"Predicted weights: {predicted_weights}\")\n",
    "print(f\"Predicted bias: {predicted_bias}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01.3. Learn the parameters of the neuron using gradient descent in Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "100/100 [==============================] - 0s 354us/step - loss: 8.5697\n",
      "Epoch 2/10\n",
      "100/100 [==============================] - 0s 343us/step - loss: 1.5144e-04\n",
      "Epoch 3/10\n",
      "100/100 [==============================] - 0s 354us/step - loss: 1.0111e-04\n",
      "Epoch 4/10\n",
      "100/100 [==============================] - 0s 354us/step - loss: 9.9907e-05\n",
      "Epoch 5/10\n",
      "100/100 [==============================] - 0s 374us/step - loss: 9.6224e-05\n",
      "Epoch 6/10\n",
      "100/100 [==============================] - 0s 343us/step - loss: 9.2783e-05\n",
      "Epoch 7/10\n",
      "100/100 [==============================] - 0s 343us/step - loss: 1.0346e-04\n",
      "Epoch 8/10\n",
      "100/100 [==============================] - 0s 343us/step - loss: 1.0498e-04\n",
      "Epoch 9/10\n",
      "100/100 [==============================] - 0s 343us/step - loss: 9.9771e-05\n",
      "Epoch 10/10\n",
      "100/100 [==============================] - 0s 354us/step - loss: 9.7006e-05\n",
      "\n",
      "Predicted weights: [ 1.9996102 -3.3997617]\n",
      "Predicted bias: 4.199385166168213\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 10\n",
    "learning_rate = 0.03\n",
    "\n",
    "# Initialize the model (as a feedforward NN)\n",
    "model = tf.keras.Sequential()\n",
    "\n",
    "# Add an input with the number of features\n",
    "model.add(tf.keras.Input(shape=number_features))\n",
    "\n",
    "# Add a densely-connected NN layer without activation and with initialized weights and bias\n",
    "model.add(tf.keras.layers.Dense(1, activation=None, \\\n",
    "                                kernel_initializer=tf.initializers.RandomNormal(mean=0, stddev=0.01), \\\n",
    "                                bias_initializer=\"zeros\"))\n",
    "\n",
    "# Configure the model for training with gradient descent optimizer and mean squared error loss\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate),\n",
    "              loss=\"mean_squared_error\")\n",
    "\n",
    "# Train the model give the batch size and number of epochs\n",
    "model.fit(x=true_inputs, y=true_outputs, batch_size=batch_size, epochs=number_epochs, verbose=1)\n",
    "\n",
    "# Print the predicted weights and bias\n",
    "print(\"\")\n",
    "print(f\"Predicted weights: {model.get_weights()[0][:, 0]}\")\n",
    "print(f\"Predicted bias: {model.get_weights()[1][0]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01.4. Learn the parameters of the neuron using an evolutionary algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; loss: 26.16919771857581\n",
      "Epoch: 1; loss: 15.89573684352735\n",
      "Epoch: 2; loss: 8.374283380005487\n",
      "Epoch: 3; loss: 2.9675768340124478\n",
      "Epoch: 4; loss: 0.38137886645304675\n",
      "Epoch: 5; loss: 0.0005220220825590036\n",
      "Epoch: 6; loss: 0.00048325837539071447\n",
      "Epoch: 7; loss: 0.0005137403673791562\n",
      "Epoch: 8; loss: 0.0005089096714666468\n",
      "Epoch: 9; loss: 0.0004962522573057658\n",
      "\n",
      "Predicted weights: [ 1.9938385 -3.4027235]\n",
      "Predicted bias: 4.209371000895826\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 10\n",
    "number_individuals = 10\n",
    "number_parents = 2\n",
    "mutation_rate = 0.01\n",
    "\n",
    "# Initialize the predicted weights and bias for all the individuals\n",
    "predicted_weights = np.random.normal(loc=0.0, scale=0.01, size=(number_features, number_individuals))\n",
    "predicted_bias = np.zeros((1, number_individuals))\n",
    "\n",
    "# Initialize the loss for all the batches and for all the individuals\n",
    "number_batches = int(np.ceil(number_examples/batch_size))\n",
    "predicted_loss = np.zeros((number_batches, number_individuals))\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_examples, batch_size):\n",
    "        \n",
    "        # Derive the end index of the batch\n",
    "        j2 = min(j+batch_size, number_examples)\n",
    "    \n",
    "        # Compute the predicted outputs using the inputs, and the predicted weights and bias, for every individual\n",
    "        predicted_outputs = np.matmul(true_inputs[j:j2, :], predicted_weights) + predicted_bias\n",
    "\n",
    "        # Compute the loss using the mean squared error, for every individual\n",
    "        predicted_loss[k, :] = np.mean(np.power(predicted_outputs-true_outputs[j:j2, np.newaxis], 2), axis=0)\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "        \n",
    "            # Get the indices of the parents (the fittest individuals)\n",
    "            parent_indices = np.argsort(predicted_loss[k, :])[0:number_parents]\n",
    "\n",
    "            # Compute the mutation scale using the root mean square error\n",
    "#             mutation_scale = mutation_rate*np.mean(np.sqrt(predicted_loss[k, parent_indices]))\n",
    "            mutation_scale = mutation_rate\n",
    "            \n",
    "            # Update the predicted weights and bias using evolutionary algorithm, doing crossover and mutation\n",
    "            predicted_weights = np.mean(predicted_weights[:, parent_indices], axis=1)[:, np.newaxis] \\\n",
    "            + np.random.normal(loc=0.0, scale=mutation_scale, size=(number_features, number_individuals))\n",
    "            predicted_bias = np.mean(predicted_bias[:, parent_indices]) \\\n",
    "            + np.random.normal(loc=0.0, scale=mutation_scale, size=(1, number_individuals))\n",
    "        \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "        \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; loss: {np.mean(predicted_loss)}\")\n",
    "    \n",
    "# Print the predicted weights and bias\n",
    "print(\"\")\n",
    "print(f\"Predicted weights: {np.mean(predicted_weights, axis=1)}\")\n",
    "print(f\"Predicted bias: {np.mean(predicted_bias)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 01.4.2. Learn the parameters of the neuron using a simpler evolutionary algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; loss: 14.065245619831437\n",
      "Epoch: 1; loss: 10.475700426308524\n",
      "Epoch: 2; loss: 7.542908621351353\n",
      "Epoch: 3; loss: 5.159025379365726\n",
      "Epoch: 4; loss: 3.122533523693872\n",
      "Epoch: 5; loss: 1.5003200038468014\n",
      "Epoch: 6; loss: 0.5791979401322016\n",
      "Epoch: 7; loss: 0.09645098729289182\n",
      "Epoch: 8; loss: 0.0001001751696473215\n",
      "Epoch: 9; loss: 7.551244142200755e-05\n",
      "\n",
      "Predicted weights: [ 2.00399397 -3.40051534]\n",
      "Predicted bias: [4.20423564]\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 10\n",
    "mutation_scale = 0.01\n",
    "\n",
    "# Initialize the predicted weights and bias\n",
    "predicted_weights = np.random.normal(loc=0.0, scale=0.01, size=number_features)\n",
    "predicted_bias = 0\n",
    "\n",
    "# Initialize the loss for all the batches\n",
    "number_batches = int(np.ceil(number_examples/batch_size))\n",
    "predicted_loss = np.zeros(number_batches)\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_examples, batch_size):\n",
    "        \n",
    "        # Derive the end index of the batch\n",
    "        j2 = min(j+batch_size, number_examples)\n",
    "    \n",
    "        # Compute the predicted outputs using the inputs, and the predicted weights and bias\n",
    "        predicted_outputs = np.matmul(true_inputs[j:j2, :], predicted_weights) + predicted_bias\n",
    "        \n",
    "        # Compute the loss using the mean squared error\n",
    "        predicted_loss[k] = np.mean(0.5*np.power(predicted_outputs-true_outputs[j:j2], 2))\n",
    "        \n",
    "        # Initialize the next loss\n",
    "        predicted_loss2 = np.inf                    \n",
    "        \n",
    "        # While the next predicted loss is higher\n",
    "        while predicted_loss2 >= predicted_loss[k]:\n",
    "            \n",
    "            # Mutate the weights and biases\n",
    "            predicted_weights2 = predicted_weights + np.random.normal(loc=0.0, scale=mutation_scale, size=number_features)\n",
    "            predicted_bias2 = predicted_bias + np.random.normal(loc=0.0, scale=mutation_scale, size=1)\n",
    "            \n",
    "            # Compute the new outputs and loss\n",
    "            predicted_outputs2 = np.matmul(true_inputs[j:j2, :], predicted_weights2) + predicted_bias2\n",
    "            predicted_loss2 = np.mean(0.5*np.power(predicted_outputs2-true_outputs[j:j2], 2))\n",
    "            \n",
    "        # Update the weights, biases, and loss\n",
    "        predicted_weights = predicted_weights2\n",
    "        predicted_bias = predicted_bias2\n",
    "        predicted_loss[k] = predicted_loss2\n",
    "        \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "    \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; loss: {np.mean(predicted_loss)}\")\n",
    "    \n",
    "# Print the predicted weights and bias\n",
    "print(\"\")\n",
    "print(f\"Predicted weights: {predicted_weights}\")\n",
    "print(f\"Predicted bias: {predicted_bias}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. Single neuron and softmax regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02.1. Prepare a dataset for a multiclass classification problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1224x720 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%reset\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Import the fashion-MNIST dataset\n",
    "fashion_mnist = tf.keras.datasets.fashion_mnist\n",
    "(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', \\\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "\n",
    "# Show some of the data\n",
    "plt.figure(figsize=(17, 10))\n",
    "for i in range(10):\n",
    "    plt.subplot(1, 10, i+1)\n",
    "    plt.imshow(train_images[i], cmap=plt.cm.binary)\n",
    "    plt.title(class_names[train_labels[i]])\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()\n",
    "\n",
    "# Get the number of train and test examples and the sizes of the inputs and outputs\n",
    "number_train = np.shape(train_images)[0]\n",
    "number_test = np.shape(test_images)[0]\n",
    "input_size = np.shape(train_images)[1]*np.shape(train_images)[2]\n",
    "output_size = len(class_names)\n",
    "\n",
    "# Reshape the inputs and normalize them\n",
    "train_inputs = np.reshape(train_images, (number_train, input_size))\n",
    "train_inputs = train_inputs/255\n",
    "test_inputs = np.reshape(test_images, (number_test, input_size))\n",
    "test_inputs = test_inputs/255\n",
    "\n",
    "# Transform the outputs from label numbers to one-hot vectors\n",
    "train_outputs = np.zeros((number_train, output_size))\n",
    "for i in range(number_train):\n",
    "    train_outputs[i, train_labels[i]] = 1\n",
    "test_outputs = np.zeros((number_test, output_size))\n",
    "for i in range(number_test):\n",
    "    test_outputs[i, test_labels[i]] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02.2. Learn the parameters of a neuron using gradient descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 0.7839464409853965; train accuracy: 0.7499058067375886; test accuracy: 0.1351\n",
      "Epoch: 1; train loss: 0.5700196939640748; train accuracy: 0.812638519503546; test accuracy: 0.7855\n",
      "Epoch: 2; train loss: 0.5250399792070662; train accuracy: 0.8255984042553192; test accuracy: 0.811\n",
      "Epoch: 3; train loss: 0.5009203389810575; train accuracy: 0.8316655585106383; test accuracy: 0.8194\n",
      "Epoch: 4; train loss: 0.485130030500342; train accuracy: 0.8365359042553191; test accuracy: 0.8244\n",
      "Epoch: 5; train loss: 0.47369480369247396; train accuracy: 0.84026484929078; test accuracy: 0.827\n",
      "Epoch: 6; train loss: 0.46489115482651205; train accuracy: 0.8426750886524822; test accuracy: 0.8289\n",
      "Epoch: 7; train loss: 0.4578281227460323; train accuracy: 0.844919104609929; test accuracy: 0.8323\n",
      "Epoch: 8; train loss: 0.4519897178943545; train accuracy: 0.8466145833333333; test accuracy: 0.8332\n",
      "Epoch: 9; train loss: 0.44705253709351034; train accuracy: 0.8478280141843971; test accuracy: 0.8343\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "learning_rate = 0.1\n",
    "\n",
    "# Initialize the weights and biases\n",
    "train_weights = np.random.normal(loc=0.0, scale=0.01, size=(input_size, output_size))\n",
    "train_biases = np.zeros(output_size)\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros(number_batches)\n",
    "train_accuracy = np.zeros(number_batches)\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the predicted test outputs using the test inputs, and the learned weights and biases\n",
    "    test_outputs2 = np.matmul(test_inputs, train_weights) + train_biases\n",
    "    \n",
    "    # Compute the conditional probabilities of each class using the softmax function\n",
    "    # (modified to avoid numerical stability issues)\n",
    "    test_outputs2 = test_outputs2-np.max(test_outputs2, axis=1)[:, np.newaxis]\n",
    "    test_exp = np.exp(test_outputs2)\n",
    "    test_softmax = test_exp/np.sum(test_exp, axis=1)[:, np.newaxis]\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(test_softmax, axis=1)==test_labels)\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the predicted train outputs using the train inputs, and the learned weights and biases\n",
    "        train_outputs2 = np.matmul(train_inputs[j:j2, :], train_weights) + train_biases\n",
    "        \n",
    "        # Compute the conditional probabilities of each class using the softmax function\n",
    "        # (modified to avoid numerical stability issues)\n",
    "        train_outputs2 = train_outputs2-np.max(train_outputs2, axis=1)[:, np.newaxis]\n",
    "        train_exp = np.exp(train_outputs2)\n",
    "        train_softmax = train_exp/np.sum(train_exp, axis=1)[:, np.newaxis]\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax), axis=1))\n",
    "        train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]\\\n",
    "                                        *(train_outputs2-np.log(np.sum(train_exp, axis=1)[:, np.newaxis])), axis=1))\n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k] = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Compute the derivative of the loss wrt the output (logit before softmax)\n",
    "            train_derivative = train_softmax-train_outputs[j:j2, :]\n",
    "            \n",
    "            # Get the real batch size\n",
    "            batch_size2 = j2-j\n",
    "            \n",
    "            # Update the weights and biases using gradient descent\n",
    "            train_weights = train_weights-learning_rate*np.matmul(train_inputs[j:j2, :].T, train_derivative)/batch_size2\n",
    "            train_biases = train_biases-learning_rate*np.sum(train_derivative, axis=0)/batch_size2\n",
    "            \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "        \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02.3. Make predictions using the trained neuron"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1224x720 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute the predicted test outputs using the test inputs, and the learned weights and biases\n",
    "test_outputs2 = np.matmul(test_inputs, train_weights) + train_biases\n",
    "\n",
    "# Compute the conditional probabilities of each class using the softmax function\n",
    "# (modified to avoid numerical stability issues)\n",
    "test_outputs2 = test_outputs2-np.max(test_outputs2, axis=1)[:, np.newaxis]\n",
    "test_exp = np.exp(test_outputs2)\n",
    "test_softmax = test_exp/np.sum(test_exp, axis=1)[:, np.newaxis]\n",
    "\n",
    "# Compute the predicted labels\n",
    "test_labels2 = np.argmax(test_softmax, axis=1)\n",
    "\n",
    "# Show the data with the true and predicted labels\n",
    "plt.figure(figsize=(17, 10))\n",
    "for i in range(10):\n",
    "    plt.subplot(1, 10, i+1)\n",
    "    plt.imshow(test_images[i], cmap=plt.cm.binary)\n",
    "    plt.title(class_names[test_labels[i]] + \"\\n\" + class_names[test_labels2[i]])\n",
    "    plt.xticks([])\n",
    "    plt.yticks([])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02.4. Learn the parameters of a neuron using gradient descent in Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "235/235 [==============================] - 0s 786us/step - loss: 1.0260 - accuracy: 0.6745\n",
      "Epoch 2/10\n",
      "235/235 [==============================] - 0s 778us/step - loss: 0.5864 - accuracy: 0.8079\n",
      "Epoch 3/10\n",
      "235/235 [==============================] - 0s 765us/step - loss: 0.5351 - accuracy: 0.8228\n",
      "Epoch 4/10\n",
      "235/235 [==============================] - 0s 782us/step - loss: 0.5028 - accuracy: 0.8317\n",
      "Epoch 5/10\n",
      "235/235 [==============================] - 0s 799us/step - loss: 0.4893 - accuracy: 0.8365\n",
      "Epoch 6/10\n",
      "235/235 [==============================] - 0s 774us/step - loss: 0.4764 - accuracy: 0.8387\n",
      "Epoch 7/10\n",
      "235/235 [==============================] - 0s 782us/step - loss: 0.4682 - accuracy: 0.8408\n",
      "Epoch 8/10\n",
      "235/235 [==============================] - 0s 821us/step - loss: 0.4630 - accuracy: 0.8431\n",
      "Epoch 9/10\n",
      "235/235 [==============================] - 0s 765us/step - loss: 0.4537 - accuracy: 0.8467\n",
      "Epoch 10/10\n",
      "235/235 [==============================] - 0s 765us/step - loss: 0.4402 - accuracy: 0.8507\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x1fdd3c56bb0>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "learning_rate = 0.1\n",
    "\n",
    "# Initialize the model (as a feedforward NN)\n",
    "model = tf.keras.Sequential()\n",
    "\n",
    "# Add an input with the number of features\n",
    "model.add(tf.keras.Input(shape=input_size))\n",
    "\n",
    "# Add a densely-connected NN layer without activation and with initialized weights and bias\n",
    "model.add(tf.keras.layers.Dense(output_size, activation=None, \\\n",
    "                                kernel_initializer=tf.initializers.RandomNormal(mean=0, stddev=0.01), \\\n",
    "                                bias_initializer=\"zeros\"))\n",
    "\n",
    "# Configure the model for training with gradient descent optimizer and cross-entropy loss\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate), \\\n",
    "              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True), \\\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "# Train the model give the batch size and number of epochs\n",
    "model.fit(x=train_inputs, y=train_outputs, batch_size=batch_size, epochs=number_epochs, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02.5. Learn the parameters of a neuron using an EA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 1.4465094193881702; train accuracy: 0.5345279255319149; test accuracy: 0.07\n",
      "Epoch: 1; train loss: 0.9218235883082819; train accuracy: 0.6845528590425531; test accuracy: 0.644\n",
      "Epoch: 2; train loss: 0.8139263195166209; train accuracy: 0.7183649157801419; test accuracy: 0.7024\n",
      "Epoch: 3; train loss: 0.760241497606201; train accuracy: 0.7354892508865248; test accuracy: 0.7257\n",
      "Epoch: 4; train loss: 0.7459400614672582; train accuracy: 0.739726285460993; test accuracy: 0.7304\n",
      "Epoch: 5; train loss: 0.7301011253673003; train accuracy: 0.7481776374113476; test accuracy: 0.7404\n",
      "Epoch: 6; train loss: 0.7234255716094935; train accuracy: 0.752698359929078; test accuracy: 0.7444\n",
      "Epoch: 7; train loss: 0.7211583417899639; train accuracy: 0.7531155806737588; test accuracy: 0.7407\n",
      "Epoch: 8; train loss: 0.7126968935196831; train accuracy: 0.757130429964539; test accuracy: 0.749\n",
      "Epoch: 9; train loss: 0.6986442258115251; train accuracy: 0.763071254432624; test accuracy: 0.7504\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "number_individuals = 10\n",
    "number_parents = 2\n",
    "mutation_rate = 0.01\n",
    "\n",
    "# Initialize the weights and biases for all the individuals\n",
    "train_weights = np.random.normal(loc=0.0, scale=0.01, size=(input_size, output_size, number_individuals))\n",
    "train_biases = np.zeros((output_size, number_individuals))\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches and for all the individuals\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros((number_batches, number_individuals))\n",
    "train_accuracy = np.zeros((number_batches, number_individuals))\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the predicted test outputs using the test inputs, and the learned weights and biases\n",
    "    test_outputs2 = np.matmul(test_inputs, np.mean(train_weights, axis=2)) + np.mean(train_biases, axis=1)[np.newaxis, :]\n",
    "    \n",
    "    # Compute the conditional probabilities of each class using the softmax function\n",
    "    # (modified to avoid numerical stability issues)\n",
    "    test_outputs2 = test_outputs2-np.max(test_outputs2, axis=1)[:, np.newaxis]\n",
    "    test_exp = np.exp(test_outputs2)\n",
    "    test_softmax = test_exp/np.sum(test_exp, axis=1)[:, np.newaxis]\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(test_softmax, axis=1)==test_labels)\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the predicted train outputs using the train inputs, and the learned weights and biases, for every individual\n",
    "        train_outputs2 = np.tensordot(train_inputs[j:j2, :], train_weights, axes=(1,0)) + train_biases[np.newaxis, :, :]\n",
    "        \n",
    "        # Compute the conditional probabilities of each class using the softmax function\n",
    "        # (modified to avoid numerical stability issues)\n",
    "        train_outputs2 = train_outputs2-np.max(train_outputs2, axis=1)[:, np.newaxis, :]\n",
    "        train_exp = np.exp(train_outputs2)\n",
    "        train_softmax = train_exp/np.sum(train_exp, axis=1)[:, np.newaxis, :]\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :, np.newaxis]*np.log(train_softmax), axis=1), axis=0)\n",
    "        train_loss[k, :] = np.mean(-np.sum(train_outputs[j:j2, :, np.newaxis]\\\n",
    "                                        *(train_outputs2-np.log(np.sum(train_exp, axis=1)[:, np.newaxis, :])), axis=1), axis=0)\n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k, :] = np.mean(np.argmax(train_softmax, axis=1) == train_labels[j:j2, np.newaxis], axis=0)\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Get the indices of the parents (the fittest individuals)\n",
    "            parent_indices = np.argsort(train_loss[k, :])[0:number_parents]\n",
    "\n",
    "            # Compute the mutation scale using the root mean square error\n",
    "#             mutation_scale = 0.001*np.mean(np.sqrt(train_loss[k, parent_indices]))\n",
    "            mutation_scale = mutation_rate\n",
    "            \n",
    "            # Update the weights and bias using EA, doing crossover and mutation\n",
    "            train_weights = np.mean(train_weights[:, :, parent_indices], axis=2)[:, :, np.newaxis] \\\n",
    "            + np.random.normal(loc=0.0, scale=mutation_scale, size=(input_size, output_size, number_individuals))\n",
    "            train_biases = np.mean(train_biases[:, parent_indices], axis=1)[:, np.newaxis] \\\n",
    "            + np.random.normal(loc=0.0, scale=mutation_scale, size=(output_size, number_individuals))\n",
    "            \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "        \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 02.5.2. Learn the parameters of a neuron using a simpler EA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 1.6669687573807246; train accuracy: 0.40667664007092197; test accuracy: 0.1006\n",
      "Epoch: 1; train loss: 1.0842577369341604; train accuracy: 0.6159242021276595; test accuracy: 0.5588\n",
      "Epoch: 2; train loss: 0.971574929310999; train accuracy: 0.6558455230496455; test accuracy: 0.6419\n",
      "Epoch: 3; train loss: 0.9513512098495406; train accuracy: 0.6691267730496455; test accuracy: 0.6501\n",
      "Epoch: 4; train loss: 0.9715518269528978; train accuracy: 0.669143395390071; test accuracy: 0.6593\n",
      "Epoch: 5; train loss: 0.9650695856565277; train accuracy: 0.6797595301418439; test accuracy: 0.6616\n",
      "Epoch: 6; train loss: 0.9746718683890051; train accuracy: 0.686330895390071; test accuracy: 0.6762\n",
      "Epoch: 7; train loss: 0.9905188469594617; train accuracy: 0.6892564273049646; test accuracy: 0.6739\n",
      "Epoch: 8; train loss: 1.0133462676471632; train accuracy: 0.6878102836879434; test accuracy: 0.6816\n",
      "Epoch: 9; train loss: 1.037961006505807; train accuracy: 0.6847573138297872; test accuracy: 0.686\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "mutation_scale = 0.01\n",
    "\n",
    "# Initialize the weights and biases\n",
    "train_weights = np.random.normal(loc=0.0, scale=0.01, size=(input_size, output_size))\n",
    "train_biases = np.zeros(output_size)\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros(number_batches)\n",
    "train_accuracy = np.zeros(number_batches)\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the predicted test outputs using the test inputs, and the learned weights and biases\n",
    "    test_outputs2 = np.matmul(test_inputs, train_weights) + train_biases\n",
    "    \n",
    "    # Compute the conditional probabilities of each class using the softmax function\n",
    "    # (modified to avoid numerical stability issues)\n",
    "    test_outputs2 = test_outputs2-np.max(test_outputs2, axis=1)[:, np.newaxis]\n",
    "    test_exp = np.exp(test_outputs2)\n",
    "    test_softmax = test_exp/np.sum(test_exp, axis=1)[:, np.newaxis]\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(test_softmax, axis=1)==test_labels)\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the predicted train outputs using the train inputs, and the learned weights and biases\n",
    "        train_outputs2 = np.matmul(train_inputs[j:j2, :], train_weights) + train_biases\n",
    "        \n",
    "        # Compute the conditional probabilities of each class using the softmax function\n",
    "        # (modified to avoid numerical stability issues)\n",
    "        train_outputs2 = train_outputs2-np.max(train_outputs2, axis=1)[:, np.newaxis]\n",
    "        train_exp = np.exp(train_outputs2)\n",
    "        train_softmax = train_exp/np.sum(train_exp, axis=1)[:, np.newaxis]\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax), axis=1))\n",
    "        train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]\\\n",
    "                                        *(train_outputs2-np.log(np.sum(train_exp, axis=1)[:, np.newaxis])), axis=1))\n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k] = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Initialize the next loss\n",
    "            train_loss2 = np.inf\n",
    "#             train_accuracy2 = -np.inf\n",
    "            \n",
    "            # While the next loss is higher\n",
    "            while train_loss2 >= train_loss[k]:# or train_accuracy2 <= train_accuracy[k]:\n",
    "                \n",
    "                # Mutate the weights and biases\n",
    "                train_weights2 = train_weights + np.random.normal(loc=0.0, scale=mutation_scale, size=(input_size, output_size))\n",
    "                train_biases2 = train_biases + np.random.normal(loc=0.0, scale=mutation_scale, size=output_size)\n",
    "\n",
    "                # Compute the new outputs and loss\n",
    "                train_outputs2 = np.matmul(train_inputs[j:j2, :], train_weights2) + train_biases2\n",
    "                train_outputs2 = train_outputs2-np.max(train_outputs2, axis=1)[:, np.newaxis]\n",
    "                train_exp = np.exp(train_outputs2)\n",
    "                train_softmax = train_exp/np.sum(train_exp, axis=1)[:, np.newaxis]\n",
    "                train_loss2 = np.mean(-np.sum(train_outputs[j:j2, :]\n",
    "                                              *(train_outputs2-np.log(np.sum(train_exp, axis=1)[:, np.newaxis])), axis=1))\n",
    "                train_accuracy2 = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "                \n",
    "            # Update the weights, biases, and loss\n",
    "            train_weights = train_weights2\n",
    "            train_biases = train_biases2\n",
    "            train_loss[k] = train_loss2\n",
    "            train_accuracy[k] = train_accuracy2\n",
    "            \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "        \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 2.1308145928524476; train accuracy: 0.30716976950354613; test accuracy: 0.1179\n",
      "Epoch: 1; train loss: 2.2848647202960986; train accuracy: 0.37810837765957445; test accuracy: 0.3671\n",
      "Epoch: 2; train loss: 2.5426527338954594; train accuracy: 0.396376329787234; test accuracy: 0.3993\n",
      "Epoch: 3; train loss: 2.7162418431508804; train accuracy: 0.41008421985815596; test accuracy: 0.4089\n",
      "Epoch: 4; train loss: 2.8975665119167444; train accuracy: 0.4136801861702128; test accuracy: 0.4118\n",
      "Epoch: 5; train loss: 3.0758243317869702; train accuracy: 0.41410128546099295; test accuracy: 0.4155\n",
      "Epoch: 6; train loss: 3.226125933482712; train accuracy: 0.41739804964539; test accuracy: 0.4048\n",
      "Epoch: 7; train loss: 3.382754012556159; train accuracy: 0.41597406914893614; test accuracy: 0.4184\n",
      "Epoch: 8; train loss: 3.485164522865303; train accuracy: 0.4184618794326241; test accuracy: 0.4193\n",
      "Epoch: 9; train loss: 3.5719290231225984; train accuracy: 0.4213652482269504; test accuracy: 0.4173\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "mutation_scale = 0.01\n",
    "\n",
    "# Initialize the weights and biases\n",
    "train_weights = np.random.normal(loc=0.0, scale=0.01, size=(input_size, output_size))\n",
    "train_biases = np.zeros(output_size)\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros(number_batches)\n",
    "train_accuracy = np.zeros(number_batches)\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the predicted test outputs using the test inputs, and the learned weights and biases\n",
    "    test_outputs2 = np.matmul(np.sin(2*np.pi*test_inputs), train_weights)#/np.sum(train_weights, axis=0)\n",
    "#     # Compute the conditional probabilities of each class using the softmax function\n",
    "#     # (modified to avoid numerical stability issues)\n",
    "#     test_outputs2 = test_outputs2-np.max(test_outputs2, axis=1)[:, np.newaxis]\n",
    "#     test_exp = np.exp(test_outputs2)\n",
    "#     test_softmax = test_exp/np.sum(test_exp, axis=1)[:, np.newaxis]\n",
    "    test_softmax = (test_outputs2+1)/2\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(test_softmax, axis=1)==test_labels)\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the predicted train outputs using the train inputs, and the learned weights and biases\n",
    "        train_outputs2 = np.matmul(np.sin(2*np.pi*train_inputs[j:j2, :]), train_weights)#/np.sum(train_weights, axis=0)\n",
    "        \n",
    "#         # Compute the conditional probabilities of each class using the softmax function\n",
    "#         # (modified to avoid numerical stability issues)\n",
    "#         train_outputs2 = train_outputs2-np.max(train_outputs2, axis=1)[:, np.newaxis]\n",
    "#         train_exp = np.exp(train_outputs2)\n",
    "#         train_softmax = train_exp/np.sum(train_exp, axis=1)[:, np.newaxis]\n",
    "        train_softmax = (train_outputs2+1)/2\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax), axis=1))\n",
    "        train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]\\\n",
    "                                        *(train_outputs2-np.log(np.sum(np.exp(train_outputs2), axis=1)[:, np.newaxis])), axis=1))\n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k] = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Initialize the next loss\n",
    "            train_loss2 = np.inf\n",
    "#             train_accuracy2 = -np.inf\n",
    "            \n",
    "            # While the next loss is higher\n",
    "            while train_loss2 >= train_loss[k]:# or train_accuracy2 <= train_accuracy[k]:\n",
    "                \n",
    "                # Mutate the weights and biases\n",
    "                train_weights2 = train_weights + np.random.normal(loc=0.0, scale=mutation_scale, size=(input_size, output_size))\n",
    "#                 train_biases2 = train_biases + np.random.normal(loc=0.0, scale=mutation_scale, size=output_size)\n",
    "\n",
    "                # Compute the new outputs and loss\n",
    "                train_outputs2 = np.matmul(np.sin(2*np.pi*train_inputs[j:j2, :]), train_weights2)#/np.sum(train_weights, axis=0)\n",
    "#                 train_outputs2 = train_outputs2-np.max(train_outputs2, axis=1)[:, np.newaxis]\n",
    "#                 train_exp = np.exp(train_outputs2)\n",
    "#                 train_softmax = train_exp/np.sum(train_exp, axis=1)[:, np.newaxis]\n",
    "                train_softmax = (train_outputs2+1)/2\n",
    "#                 train_loss2 = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax+), axis=1))\n",
    "                train_loss2 = np.mean(-np.sum(train_outputs[j:j2, :]\n",
    "                                              *(train_outputs2-np.log(np.sum(np.exp(train_outputs2), axis=1)[:, np.newaxis])), axis=1))\n",
    "                train_accuracy2 = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "                \n",
    "            # Update the weights, biases, and loss\n",
    "            train_weights = train_weights2\n",
    "            train_loss[k] = train_loss2\n",
    "            train_accuracy[k] = train_accuracy2\n",
    "            \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "        \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 03. Multilayer Perceptrons (MLP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03.1. Prepare the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])? y\n"
     ]
    }
   ],
   "source": [
    "%reset\n",
    "\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "\n",
    "# Import the fashion-MNIST dataset\n",
    "fashion_mnist = tf.keras.datasets.fashion_mnist\n",
    "(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()\n",
    "class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', \\\n",
    "               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']\n",
    "\n",
    "# Get the number of train and test examples and the sizes of the inputs and outputs\n",
    "number_train = np.shape(train_images)[0]\n",
    "number_test = np.shape(test_images)[0]\n",
    "input_size = np.shape(train_images)[1]*np.shape(train_images)[2]\n",
    "output_size = len(class_names)\n",
    "\n",
    "# Reshape the inputs and normalize them\n",
    "train_inputs = np.reshape(train_images, (number_train, input_size))\n",
    "train_inputs = train_inputs/255\n",
    "test_inputs = np.reshape(test_images, (number_test, input_size))\n",
    "test_inputs = test_inputs/255\n",
    "\n",
    "# Transform the outputs from label numbers to one-hot vectors\n",
    "train_outputs = np.zeros((number_train, output_size))\n",
    "for i in range(number_train):\n",
    "    train_outputs[i, train_labels[i]] = 1\n",
    "test_outputs = np.zeros((number_test, output_size))\n",
    "for i in range(number_test):\n",
    "    test_outputs[i, test_labels[i]] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03.2. Implement MLP from scratch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 1.0607180408162504; train accuracy: 0.6413674645390072; test accuracy: 0.0971\n",
      "Epoch: 1; train loss: 0.5964279677328973; train accuracy: 0.7924645390070922; test accuracy: 0.7485\n",
      "Epoch: 2; train loss: 0.5176993692926929; train accuracy: 0.8206006205673758; test accuracy: 0.7828\n",
      "Epoch: 3; train loss: 0.48300689879566977; train accuracy: 0.8311558067375886; test accuracy: 0.8044\n",
      "Epoch: 4; train loss: 0.4633890443970928; train accuracy: 0.838813164893617; test accuracy: 0.8142\n",
      "Epoch: 5; train loss: 0.4501571659694062; train accuracy: 0.8435837765957447; test accuracy: 0.824\n",
      "Epoch: 6; train loss: 0.4403532995980453; train accuracy: 0.8466422872340426; test accuracy: 0.83\n",
      "Epoch: 7; train loss: 0.43276002610598463; train accuracy: 0.8499501329787233; test accuracy: 0.8321\n",
      "Epoch: 8; train loss: 0.42677810724924364; train accuracy: 0.8518284574468085; test accuracy: 0.8349\n",
      "Epoch: 9; train loss: 0.42199852108351055; train accuracy: 0.8532912234042553; test accuracy: 0.8374\n"
     ]
    }
   ],
   "source": [
    "# import matplotlib.pyplot as plt\n",
    "# from IPython import display\n",
    "\n",
    "# Define the training parameters\n",
    "hidden_size = 256\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "learning_rate = 0.1\n",
    "\n",
    "# Initialize the weights and biases\n",
    "model_weights0 = np.random.normal(loc=0.0, scale=0.01, size=(input_size, hidden_size))\n",
    "model_biases0 = np.zeros(hidden_size)\n",
    "model_weights1 = np.random.normal(loc=0.0, scale=0.01, size=(hidden_size, output_size))\n",
    "model_biases1 = np.random.normal(loc=0.0, scale=0.01, size=output_size)\n",
    "\n",
    "# W0 = model_weights0\n",
    "# B0 = model_biases0\n",
    "W1 = model_weights1\n",
    "# B1 = model_biases1\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros(number_batches)\n",
    "train_accuracy = np.zeros(number_batches)\n",
    "\n",
    "# Define a function to compute the forward pass\n",
    "def forward(model_inputs, model_weights0, model_biases0, model_weights1, model_biases1): \n",
    "    \n",
    "    # Compute the predicted outputs using the inputs, and the learned weights and biases\n",
    "    model_outputs0 = np.matmul(model_inputs, model_weights0) + model_biases0\n",
    "    model_outputs0[model_outputs0<0] = 0\n",
    "    model_outputs1 = np.matmul(model_outputs0, model_weights1) + model_biases1\n",
    "    \n",
    "    # Compute the conditional probabilities of each class using the softmax function\n",
    "    # (modified to avoid numerical stability issues)\n",
    "    model_outputs1 = model_outputs1-np.max(model_outputs1, axis=1)[:, np.newaxis]\n",
    "    model_exp = np.exp(model_outputs1)\n",
    "    model_softmax = model_exp/np.sum(model_exp, axis=1)[:, np.newaxis]\n",
    "    \n",
    "    return model_outputs0, model_outputs1, model_exp, model_softmax\n",
    "\n",
    "# plt.figure(figsize=(14, 4))\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the forward pass\n",
    "    _, _, _, test_softmax \\\n",
    "    = forward(test_inputs, model_weights0, model_biases0, model_weights1, model_biases1)\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(test_softmax, axis=1)==test_labels)\n",
    "    \n",
    "#     display.clear_output(wait=True)\n",
    "#     display.display(plt.gcf())\n",
    "#     plt.imshow(model_weights1.T, aspect=\"auto\", cmap=\"jet\", origin=\"lower\")\n",
    "#     plt.tight_layout()\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the forward pass\n",
    "        train_outputs0, train_outputs1, train_exp, train_softmax \\\n",
    "        = forward(train_inputs[j:j2, :], model_weights0, model_biases0, model_weights1, model_biases1)\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax), axis=1))\n",
    "        train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]\\\n",
    "                                        *(train_outputs1-np.log(np.sum(train_exp, axis=1)[:, np.newaxis])), axis=1))        \n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k] = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "             # Compute the derivative of the loss wrt the output of the output layer (logit before softmax)\n",
    "            train_derivative1 = train_softmax-train_outputs[j:j2, :]\n",
    "            \n",
    "            # Derive the derivative of the loss wrt the output of the hidden layer (using the chain rule)\n",
    "            train_derivative0 = np.matmul(train_derivative1, model_weights1.T)\n",
    "            \n",
    "            # Get the real batch size\n",
    "            batch_size2 = j2-j\n",
    "                        \n",
    "            # Update the weights and biases of the output layer using gradient descent\n",
    "            model_weights1 -= learning_rate*np.matmul(train_outputs0.T, train_derivative1)/batch_size2\n",
    "            model_biases1 -= learning_rate*np.sum(train_derivative1, axis=0)/batch_size2\n",
    "            \n",
    "            # Update the weights and biases of the hidden layer using gradient descent\n",
    "            model_weights0 -= learning_rate*np.matmul(train_inputs[j:j2, :].T, train_derivative0)/batch_size2\n",
    "            model_biases0 -= learning_rate*np.sum(train_derivative0, axis=0)/batch_size2\n",
    "            \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "        \n",
    "    W1 = np.dstack((W1, model_weights1))\n",
    "        \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03.3. Implement MLP using Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "\n",
    "# Define the training parameters\n",
    "hidden_size = 256\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "learning_rate = 0.1\n",
    "\n",
    "# Initialize the model (as a feedforward NN)\n",
    "model = tf.keras.Sequential()\n",
    "\n",
    "# Add an input with the number of features\n",
    "model.add(tf.keras.Input(shape=input_size))\n",
    "\n",
    "# Add a densely-connected NN layer with ReLU activation and with initialized weights and bias\n",
    "model.add(tf.keras.layers.Dense(hidden_size, activation=\"relu\", \\\n",
    "                                kernel_initializer=tf.initializers.RandomNormal(mean=0, stddev=0.01), \\\n",
    "                                bias_initializer=\"zeros\"))\n",
    "\n",
    "# Add another densely-connected NN layer without activation and with initialized weights and bias\n",
    "model.add(tf.keras.layers.Dense(output_size, activation=None, \\\n",
    "                                kernel_initializer=tf.initializers.RandomNormal(mean=0, stddev=0.01), \\\n",
    "                                bias_initializer=tf.initializers.RandomNormal(mean=0, stddev=0.01)))\n",
    "\n",
    "# Configure the model for training with gradient descent optimizer and cross-entropy loss\n",
    "model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate), \\\n",
    "              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True), \\\n",
    "              metrics=[\"accuracy\"])\n",
    "\n",
    "# Train the model give the batch size and number of epochs\n",
    "model.fit(x=train_inputs, y=train_outputs, batch_size=batch_size, epochs=number_epochs, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 03.2. Implement MLP using a simple EA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 2.3016685329420863; train accuracy: 0.05867132092198581; test accuracy: 0.0214\n",
      "Epoch: 1; train loss: 2.2969709028740954; train accuracy: 0.11259973404255319; test accuracy: 0.1005\n",
      "Epoch: 2; train loss: 2.291961105122568; train accuracy: 0.1590702570921986; test accuracy: 0.1236\n",
      "Epoch: 3; train loss: 2.2873925397058295; train accuracy: 0.20234929078014183; test accuracy: 0.1836\n",
      "Epoch: 4; train loss: 2.2826620979108836; train accuracy: 0.20568484042553192; test accuracy: 0.2038\n",
      "Epoch: 5; train loss: 2.2772904263434426; train accuracy: 0.22007978723404256; test accuracy: 0.2138\n",
      "Epoch: 6; train loss: 2.2722073920829033; train accuracy: 0.2244847074468085; test accuracy: 0.2198\n",
      "Epoch: 7; train loss: 2.26668056899557; train accuracy: 0.2260416666666667; test accuracy: 0.2232\n",
      "Epoch: 8; train loss: 2.2615394522758874; train accuracy: 0.24273049645390074; test accuracy: 0.233\n",
      "Epoch: 9; train loss: 2.255754853677083; train accuracy: 0.2441655585106383; test accuracy: 0.2421\n"
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "hidden_size = 256\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "mutation_scale = 0.01\n",
    "\n",
    "# Initialize the weights and biases\n",
    "model_weights0 = np.random.normal(loc=0.0, scale=0.01, size=(input_size, hidden_size))\n",
    "model_biases0 = np.zeros(hidden_size)\n",
    "model_weights1 = np.random.normal(loc=0.0, scale=0.01, size=(hidden_size, output_size))\n",
    "model_biases1 = np.random.normal(loc=0.0, scale=0.01, size=output_size)\n",
    "\n",
    "W1 = model_weights1\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros(number_batches)\n",
    "train_accuracy = np.zeros(number_batches)\n",
    "\n",
    "# Define a function to compute the forward pass\n",
    "def forward(model_inputs, model_weights0, model_biases0, model_weights1, model_biases1): \n",
    "    \n",
    "    # Compute the predicted outputs using the inputs, and the learned weights and biases\n",
    "    model_outputs0 = np.matmul(model_inputs, model_weights0) + model_biases0\n",
    "    model_outputs0[model_outputs0<0] = 0\n",
    "    model_outputs1 = np.matmul(model_outputs0, model_weights1) + model_biases1\n",
    "    \n",
    "    # Compute the conditional probabilities of each class using the softmax function\n",
    "    # (modified to avoid numerical stability issues)\n",
    "    model_outputs1 = model_outputs1-np.max(model_outputs1, axis=1)[:, np.newaxis]\n",
    "    model_exp = np.exp(model_outputs1)\n",
    "    model_softmax = model_exp/np.sum(model_exp, axis=1)[:, np.newaxis]\n",
    "    \n",
    "    return model_outputs0, model_outputs1, model_exp, model_softmax\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the forward pass\n",
    "    _, _, _, test_softmax \\\n",
    "    = forward(test_inputs, model_weights0, model_biases0, model_weights1, model_biases1)\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(test_softmax, axis=1)==test_labels)\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the forward pass\n",
    "        train_outputs0, train_outputs1, train_exp, train_softmax \\\n",
    "        = forward(train_inputs[j:j2, :], model_weights0, model_biases0, model_weights1, model_biases1)\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax), axis=1))\n",
    "        train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]\\\n",
    "                                        *(train_outputs1-np.log(np.sum(train_exp, axis=1)[:, np.newaxis])), axis=1))\n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k] = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Initialize the next loss\n",
    "            train_loss2 = np.inf\n",
    "            \n",
    "            # While the next loss is higher\n",
    "            while train_loss2 >= train_loss[k]:\n",
    "                \n",
    "                # Mutate the weights and biases\n",
    "                model_weights02 = model_weights0 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_weights0), size=(input_size, hidden_size))\n",
    "                model_biases02 = model_biases0 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_biases0), size=hidden_size)\n",
    "                model_weights12 = model_weights1 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_weights1), size=(hidden_size, output_size))\n",
    "                model_biases12 = model_biases1 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_biases1), size=output_size)\n",
    "                \n",
    "                # Compute the new outputs and loss\n",
    "                _, train_outputs1, train_exp, train_softmax \\\n",
    "                = forward(train_inputs[j:j2, :], model_weights02, model_biases02, model_weights12, model_biases12)\n",
    "                train_loss2 = np.mean(-np.sum(train_outputs[j:j2, :]\\\n",
    "                                                *(train_outputs1-np.log(np.sum(train_exp, axis=1)[:, np.newaxis])), axis=1))\n",
    "                train_accuracy2 = np.mean(np.argmax(train_softmax, axis=1)==train_labels[j:j2])\n",
    "                \n",
    "            # Update the weights, biases, and loss\n",
    "            model_weights0 = model_weights02\n",
    "            model_biases0 = model_biases02\n",
    "            model_weights1 = model_weights12\n",
    "            model_biases1 = model_biases12\n",
    "            train_loss[k] = train_loss2\n",
    "            train_accuracy[k] = train_accuracy2\n",
    "        \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "    \n",
    "    W1 = np.dstack((W1, model_weights1))\n",
    "    \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0; train loss: 0.5024610468903078; train accuracy: 0.08619237588652483; test accuracy: 0.0833\n",
      "Epoch: 1; train loss: 0.5018278921754775; train accuracy: 0.08732823581560283; test accuracy: 0.0846\n",
      "Epoch: 2; train loss: 0.5012072354307798; train accuracy: 0.08732823581560283; test accuracy: 0.0834\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-a6126afe983e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     48\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     49\u001b[0m         \u001b[1;31m# Compute the forward pass\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 50\u001b[1;33m         \u001b[0mtrain_outputs1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_inputs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mj\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mj2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel_weights0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel_biases0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel_weights1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel_biases1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     51\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     52\u001b[0m         \u001b[1;31m# Compute the cross-entropy loss given the true train outputs\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-14-a6126afe983e>\u001b[0m in \u001b[0;36mforward\u001b[1;34m(model_inputs, model_weights0, model_biases0, model_weights1, model_biases1)\u001b[0m\n\u001b[0;32m     22\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     23\u001b[0m     \u001b[1;31m# Compute the predicted outputs using the inputs, and the learned weights and biases\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 24\u001b[1;33m     \u001b[0mmodel_outputs0\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mmodel_inputs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel_weights0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     25\u001b[0m     \u001b[0mmodel_outputs1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpi\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mmodel_outputs0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel_weights1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     26\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# Define the training parameters\n",
    "hidden_size = 256\n",
    "number_epochs = 10\n",
    "batch_size = 256\n",
    "mutation_scale = 0.001\n",
    "\n",
    "# Initialize the weights and biases\n",
    "model_weights0 = np.random.normal(loc=0.0, scale=0.01, size=(input_size, hidden_size))\n",
    "model_biases0 = np.zeros(hidden_size)\n",
    "model_weights1 = np.random.normal(loc=0.0, scale=0.01, size=(hidden_size, output_size))\n",
    "model_biases1 = np.random.normal(loc=0.0, scale=0.01, size=output_size)\n",
    "\n",
    "W1 = model_weights1\n",
    "\n",
    "# Initialize the loss and the accuracy for all the batches\n",
    "number_batches = int(np.ceil(number_train/batch_size))\n",
    "train_loss = np.zeros(number_batches)\n",
    "train_accuracy = np.zeros(number_batches)\n",
    "\n",
    "# Define a function to compute the forward pass\n",
    "def forward(model_inputs, model_weights0, model_biases0, model_weights1, model_biases1): \n",
    "    \n",
    "    # Compute the predicted outputs using the inputs, and the learned weights and biases\n",
    "    model_outputs0 = np.matmul(np.sin(2*np.pi*model_inputs), model_weights0)\n",
    "    model_outputs1 = np.matmul(np.sin(np.pi*model_outputs0), model_weights1)\n",
    "    \n",
    "    # Compute the conditional probabilities of each class using the softmax function\n",
    "    # (modified to avoid numerical stability issues)\n",
    "    model_outputs1 = (model_outputs1+1)/2\n",
    "    \n",
    "    return model_outputs1\n",
    "\n",
    "# Loop over the epochs\n",
    "for i in range(number_epochs):\n",
    "    \n",
    "    # Compute the forward pass\n",
    "    model_outputs1 = forward(test_inputs, model_weights0, model_biases0, model_weights1, model_biases1)\n",
    "    \n",
    "    # Compute the classification accuracy given the true test labels\n",
    "    test_accuracy = np.mean(np.argmax(model_outputs1, axis=1)==test_labels)\n",
    "    \n",
    "    # Loop over the batches\n",
    "    k = 0\n",
    "    for j in range(0, number_train, batch_size):\n",
    "        \n",
    "        # Derive the end index for the current batch\n",
    "        j2 = min(j+batch_size, number_train)\n",
    "    \n",
    "        # Compute the forward pass\n",
    "        train_outputs1 = forward(train_inputs[j:j2, :], model_weights0, model_biases0, model_weights1, model_biases1)\n",
    "        \n",
    "        # Compute the cross-entropy loss given the true train outputs\n",
    "        # (rewritten to avoid numerical stability issues)\n",
    "#         train_loss[k] = np.mean(-np.sum(train_outputs[j:j2, :]*np.log(train_softmax), axis=1))\n",
    "        train_loss[k] = np.mean(np.abs(train_outputs[j:j2, :]-train_outputs1))\n",
    "        \n",
    "        # Compute the classification accuracy given the true train labels\n",
    "        train_accuracy[k] = np.mean(np.argmax(train_outputs1, axis=1)==train_labels[j:j2])\n",
    "        \n",
    "        # Do not need to make the last updates after computing the last loss\n",
    "        if i < number_epochs-1 or k < number_batches-1:\n",
    "            \n",
    "            # Initialize the next loss\n",
    "            train_loss2 = np.inf\n",
    "            \n",
    "            # While the next loss is higher\n",
    "            while train_loss2 >= train_loss[k]:\n",
    "                \n",
    "                # Mutate the weights and biases\n",
    "                model_weights02 = model_weights0 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_weights0), size=(input_size, hidden_size))\n",
    "                model_biases02 = model_biases0 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_biases0), size=hidden_size)\n",
    "                model_weights12 = model_weights1 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_weights1), size=(hidden_size, output_size))\n",
    "                model_biases12 = model_biases1 + np.random.normal(loc=0.0, scale=mutation_scale*np.std(model_biases1), size=output_size)\n",
    "                \n",
    "                # Compute the new outputs and loss\n",
    "                train_outputs1 = forward(train_inputs[j:j2, :], model_weights02, model_biases02, model_weights12, model_biases12)\n",
    "                train_loss2 = np.mean(np.abs(train_outputs[j:j2, :]-train_outputs1))\n",
    "                train_accuracy2 = np.mean(np.argmax(train_outputs1, axis=1)==train_labels[j:j2])\n",
    "                \n",
    "            # Update the weights, biases, and loss\n",
    "            model_weights0 = model_weights02\n",
    "            model_weights1 = model_weights12\n",
    "            train_loss[k] = train_loss2\n",
    "            train_accuracy[k] = train_accuracy2\n",
    "        \n",
    "        # Update the index\n",
    "        k = k+1\n",
    "    \n",
    "    W1 = np.dstack((W1, model_weights1))\n",
    "    \n",
    "    # Print the epoch and loss\n",
    "    print(f\"Epoch: {i}; train loss: {np.mean(train_loss)}; train accuracy: {np.mean(train_accuracy)}; test accuracy: {test_accuracy}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}