From 592bef2676c1fa5c50c22d787972c3148d401049 Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Mon, 27 Feb 2023 18:07:42 -0500 Subject: [PATCH 1/7] Created using Colaboratory --- protogenv2_2.ipynb | 144 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+) create mode 100644 protogenv2_2.ipynb diff --git a/protogenv2_2.ipynb b/protogenv2_2.ipynb new file mode 100644 index 0000000..1cb21b8 --- /dev/null +++ b/protogenv2_2.ipynb @@ -0,0 +1,144 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "IwnIO6CIIDgT" + }, + "outputs": [], + "source": [ + "# Go fetch the code\n", + "!git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui\n", + "!git clone https://github.com/yfszzx/stable-diffusion-webui-images-browser stable-diffusion-webui/extensions/stable-diffusion-webui-images-browser" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TCS-rfghIHu6" + }, + "outputs": [], + "source": [ + "# fetch and install extensions\n", + "!curl -Lo Style-Empire.ckpt https://civitai.com/api/download/models/2179\n", + "!mv \"Style-Empire.ckpt\" \"stable-diffusion-webui/embeddings/Style-Empire\"\n", + "!curl -Lo Style-Empire-neg.ckpt https://civitai.com/api/download/models/2179?type=Negative&format=Other\n", + "!mv \"Style-Empire-neg.ckpt\" \"stable-diffusion-webui/embeddings/Style-Empire-neg\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sypWSuUGILiX" + }, + "outputs": [], + "source": [ + "# fetch and install model\n", + "!curl -Lo protogenv2.2.ckpt https://huggingface.co/darkstorm2150/Protogen_v2.2_Official_Release/resolve/main/Protogen_V2.2.ckpt\n", + "!mv \"protogenv2.2.ckpt\" \"stable-diffusion-webui/models/Stable-diffusion\"\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "afA1ckX1lEO9" + }, + "outputs": [], + "source": [ + "# fetch and install model\n", + "!curl -Lo RealisticVision_v13.safetensors https://civitai.com/api/download/models/6987?type=Model&format=SafeTensor\n", + "!mv \"RealisticVision_v13.safetensors\" \"stable-diffusion-webui/models/Stable-diffusion\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "F0ulcE8AO7dC" + }, + "outputs": [], + "source": [ + "# fix cannot add middleware after launch error\n", + "!pip install fastapi==0.90.1\n", + "!pip install safetensors==0.2.7\n", + "!pip install pyngrok" + ] + }, + { + "cell_type": "code", + "source": [ + "from pyngrok import ngrok\n", + "token = input('please enter your ngrok token\\n sign up for a free account at https://ngrok.com\\n')\n", + "ngrok.set_auth_token(token)\n", + "\n", + "for tunnel in ngrok.get_tunnels():\n", + " ngrok.disconnect(tunnel.public_url)\n", + "http_tunnel = ngrok.connect(addr=7860)\n", + "print(str(http_tunnel))" + ], + "metadata": { + "id": "Z-doWj7sAZF2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ypb5Rxs1IRq3" + }, + "outputs": [], + "source": [ + "# Now we set the web ui version we want to use. Main branch is unfortunately broken pretty often.\n", + "%cd stable-diffusion-webui\n", + "#!git checkout 93fad28\n", + "!git pull" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "kzVqjlAOIUpX" + }, + "outputs": [], + "source": [ + "# Lets light this candle\n", + "!COMMANDLINE_ARGS=\"--disable-safe-unpickle --no-half-vae --xformers --reinstall-xformers --enable-insecure-extension-access\" REQS_FILE=\"requirements.txt\" python launch.py" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [], + "include_colab_link": true + }, + "gpuClass": "premium", + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 454c633d799e5475386240e0f6967ded8ba13d88 Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Wed, 19 Jun 2024 17:54:46 -0400 Subject: [PATCH 2/7] Created using Colab --- SortitionGameTheory.ipynb | 345 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 345 insertions(+) create mode 100644 SortitionGameTheory.ipynb diff --git a/SortitionGameTheory.ipynb b/SortitionGameTheory.ipynb new file mode 100644 index 0000000..c656fc8 --- /dev/null +++ b/SortitionGameTheory.ipynb @@ -0,0 +1,345 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMQ20VwUQIBQI88doxYYXZy", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "id": "4pO5Z9hMvlUb" + }, + "outputs": [], + "source": [ + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Original functions and classes\n", + "\n", + "class Citizen:\n", + " def __init__(self, id, morality, competence):\n", + " self.id = id\n", + " self.morality = morality\n", + " self.competence = competence\n", + " self.payoff = 0\n", + "\n", + "class SortitionGovernment:\n", + " def __init__(self, population_size, num_officials,goodness_function,morality_mean=0.5):\n", + " self.population_size = population_size\n", + " self.num_officials = num_officials\n", + " self.citizens = [Citizen(i, random.gauss(morality_mean, 0.5), random.gauss(0.5, 0.5)) for i in range(population_size)]\n", + " self.societal_position = np.array([random.uniform(0, 1), random.uniform(0, 1)]) # Initialize at a random location\n", + " self.goodness_function = goodness_function\n", + " self.societal_path = [self.societal_position.copy()] # Track societal position over time\n", + " self.goodness_values = [] # Track goodness values over time\n", + "\n", + " def select_officials(self):\n", + " self.officials = random.sample(self.citizens, self.num_officials)\n", + "\n", + " def provide_steering_inputs(self, direction_maximization, direction_minimization):\n", + " total_weight = 0\n", + " weighted_steering_input = np.array([0.0, 0.0])\n", + "\n", + " for official in self.officials:\n", + " # Each official provides a steering input proportional to their morality and competence\n", + " direction = direction_maximization if official.morality > 0 else direction_minimization\n", + " steering_input = direction * official.competence * abs(official.morality)\n", + " weight = official.competence\n", + " total_weight += weight\n", + " weighted_steering_input += steering_input * weight\n", + "\n", + " # Calculate the weighted average of the steering inputs\n", + " if total_weight > 0:\n", + " societal_steering_input = weighted_steering_input / total_weight\n", + " else:\n", + " societal_steering_input = weighted_steering_input\n", + "\n", + " return societal_steering_input\n", + "\n", + " def update_societal_position(self, steering_inputs):\n", + " # Update the societal position based on steering inputs\n", + " self.societal_position += steering_inputs\n", + " self.societal_path.append(self.societal_position.copy()) # Track the new position\n", + "\n", + " def evaluate_goodness(self):\n", + " # Evaluate the societal goodness function once per epoch with the societal position\n", + " total_goodness, direction_maximization, direction_minimization = self.goodness_function(self.societal_position)\n", + " self.goodness_values.append(total_goodness)\n", + " payout = total_goodness\n", + " # Distribute the payout equally to all citizens\n", + " for citizen in self.citizens:\n", + " citizen.payoff += payout\n", + " return total_goodness, direction_maximization, direction_minimization\n", + "\n", + " def count_bad_actors(self):\n", + " return sum(1 for citizen in self.citizens if citizen.morality < 0)\n", + "\n", + "\n", + " def simulate(self, rounds):\n", + " payoffs_over_time = []\n", + " direction_maximizations_over_time = []\n", + " direction_minimizations_over_time = []\n", + "\n", + " for _ in range(rounds):\n", + " self.select_officials()\n", + " _, direction_maximization, direction_minimization = self.evaluate_goodness()\n", + " steering_inputs = self.provide_steering_inputs(direction_maximization, direction_minimization)\n", + " self.update_societal_position(steering_inputs)\n", + " total_goodness, direction_maximization, direction_minimization = self.evaluate_goodness()\n", + " payoffs_over_time.append([citizen.payoff for citizen in self.citizens])\n", + " direction_maximizations_over_time.append(direction_maximization)\n", + " direction_minimizations_over_time.append(direction_minimization)\n", + "\n", + " return payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, self.societal_path, self.goodness_values\n", + "\n", + "def plot_quartiles(payoffs_over_time):\n", + " payoffs_over_time = np.array(payoffs_over_time)\n", + " rounds = payoffs_over_time.shape[0]\n", + "\n", + " # Calculate quartiles\n", + " quartile_indices = [int(0.25 * payoffs_over_time.shape[1]), int(0.5 * payoffs_over_time.shape[1]), int(0.75 * payoffs_over_time.shape[1])]\n", + "\n", + " # Calculate average payoff for each quartile over time\n", + " avg_quartile_payoffs = np.zeros((rounds, 4))\n", + " for t in range(rounds):\n", + " sorted_payoffs = np.sort(payoffs_over_time[t])\n", + " avg_quartile_payoffs[t, 0] = np.mean(sorted_payoffs[:quartile_indices[0]])\n", + " avg_quartile_payoffs[t, 1] = np.mean(sorted_payoffs[quartile_indices[0]:quartile_indices[1]])\n", + " avg_quartile_payoffs[t, 2] = np.mean(sorted_payoffs[quartile_indices[1]:quartile_indices[2]])\n", + " avg_quartile_payoffs[t, 3] = np.mean(sorted_payoffs[quartile_indices[2]:])\n", + "\n", + " # Plotting\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 0], label='Q1 (0-25%)')\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 1], label='Q2 (25-50%)')\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 2], label='Q3 (50-75%)')\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 3], label='Q4 (75-100%)')\n", + "\n", + " plt.xlabel('Rounds')\n", + " plt.ylabel('Average Total Payoff')\n", + " plt.title('Average Total Payoff Over Time by Quartile')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "def plot_derivatives(direction_maximizations_over_time, direction_minimizations_over_time):\n", + " rounds = len(direction_maximizations_over_time)\n", + " max_values = np.linalg.norm(direction_maximizations_over_time, axis=1) # Compute the norm of the maximization directions\n", + " min_values = np.linalg.norm(direction_minimizations_over_time, axis=1) # Compute the norm of the minimization directions\n", + " plt.plot(range(rounds), max_values, label='Direction of Maximization')\n", + " plt.plot(range(rounds), min_values, label='Direction of Minimization')\n", + "\n", + " plt.xlabel('Rounds')\n", + " plt.ylabel('Direction Value')\n", + " plt.title('Direction of Maximization and Minimization Over Time')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "def goodness_function(societal_position):\n", + " # Parameters for the positive peak\n", + " center_positive = np.array([0.25, 0.25])\n", + " sigma_positive = 0.05\n", + " amplitude_positive = 1.0\n", + "\n", + " # Parameters for the negative peak\n", + " center_negative = np.array([0.75, 0.75])\n", + " sigma_negative = 0.05\n", + " amplitude_negative = -1.0\n", + "\n", + " # Calculate the positive Gaussian\n", + " dist_positive = np.sum((societal_position - center_positive)**2)\n", + " total_goodness_positive = amplitude_positive * np.exp(-dist_positive / (2 * sigma_positive**2))\n", + "\n", + " # Calculate the negative Gaussian\n", + " dist_negative = np.sum((societal_position - center_negative)**2)\n", + " total_goodness_negative = amplitude_negative * np.exp(-dist_negative / (2 * sigma_negative**2))\n", + "\n", + " # Combine the two peaks\n", + " total_goodness = total_goodness_positive + total_goodness_negative\n", + "\n", + " # Calculate the direction of maximization (towards the positive peak)\n", + " direction_maximization = center_positive - societal_position\n", + "\n", + " # Calculate the direction of minimization (towards the negative peak)\n", + " direction_minimization = center_negative - societal_position\n", + "\n", + " return total_goodness, direction_maximization, direction_minimization\n", + "\n", + "def plot_societal_path(societal_path, goodness_function):\n", + " # Create a grid for the goodness function\n", + " x = np.linspace(0, 1, 100)\n", + " y = np.linspace(0, 1, 100)\n", + " X, Y = np.meshgrid(x, y)\n", + " Z = np.array([[goodness_function(np.array([xi, yi]))[0] for xi, yi in zip(x_row, y_row)] for x_row, y_row in zip(X, Y)])\n", + "\n", + " # Plot the goodness function as a contour plot\n", + " plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n", + " plt.colorbar(label='Goodness Value')\n", + "\n", + " # Plot the societal path on top of the contour plot\n", + " societal_path = np.array(societal_path)\n", + " plt.scatter(societal_path[:, 0], societal_path[:, 1], c=np.arange(len(societal_path)), cmap='cool', edgecolor='k',label='Societal Path') # Color path by steps\n", + " plt.colorbar(label='Step')\n", + "\n", + " plt.xlabel('X Position')\n", + " plt.ylabel('Y Position')\n", + " plt.title('Path of Societal Position on Goodness Manifold')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "source": [ + "class SortitionSimulation:\n", + " def __init__(self, population_size=100, num_officials=10, rounds=50, num_runs=10):\n", + " self.population_size = population_size\n", + " self.num_officials = num_officials\n", + " self.rounds = rounds\n", + " self.num_runs = num_runs\n", + "\n", + " def run_simulation(self, morality_mean):\n", + " avg_payoffs = []\n", + " bad_actors_counts = []\n", + "\n", + " for _ in range(self.num_runs):\n", + " government = SortitionGovernment(self.population_size, self.num_officials, goodness_function, morality_mean)\n", + " payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = government.simulate(self.rounds)\n", + " avg_payoffs.append(np.mean(payoffs_over_time[-1])) # Average payoff at the last round\n", + " bad_actors_counts.append(government.count_bad_actors())\n", + "\n", + " return np.mean(avg_payoffs), np.std(avg_payoffs), np.mean(bad_actors_counts), np.std(bad_actors_counts)\n", + "\n", + " def plot_bad_actors_impact(self, morality_means):\n", + " avg_payoffs = []\n", + " std_payoffs = []\n", + " avg_bad_actors_counts = []\n", + " std_bad_actors_counts = []\n", + "\n", + " for morality_mean in morality_means:\n", + " avg_payoff, std_payoff, avg_bad_actors, std_bad_actors = self.run_simulation(morality_mean)\n", + " avg_payoffs.append(avg_payoff)\n", + " std_payoffs.append(std_payoff)\n", + " avg_bad_actors_counts.append(avg_bad_actors)\n", + " std_bad_actors_counts.append(std_bad_actors)\n", + "\n", + " # Plotting\n", + " plt.errorbar(avg_bad_actors_counts, avg_payoffs, yerr=std_payoffs, fmt='o', capsize=5)\n", + " plt.xlabel('Average Number of Bad Actors')\n", + " plt.ylabel('Average Payoff at Last Round')\n", + " plt.title('Impact of Number of Bad Actors on Average Payoff')\n", + " plt.show()\n", + "\n" + ], + "metadata": { + "id": "1_ijU0uFDdIm" + }, + "execution_count": 62, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Parameters for individual simulations\n", + "population_size = 100\n", + "num_officials = 10\n", + "rounds = 50\n", + "\n", + "# Run individual simulation\n", + "sortition_gov = SortitionGovernment(population_size, num_officials, goodness_function)\n", + "payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = sortition_gov.simulate(rounds)\n", + "\n", + "# Plotting results by quartile\n", + "plot_quartiles(payoffs_over_time)\n", + "\n", + "# Plotting societal path on the goodness manifold\n", + "plot_societal_path(societal_path, goodness_function)\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 927 + }, + "id": "kZ-214hTDjAT", + "outputId": "0e3935e8-c761-4592-edfa-5b78dfd56272" + }, + "execution_count": 68, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "simulation = SortitionSimulation(population_size, num_officials, rounds, num_runs=10)\n", + "morality_means = np.linspace(-1, 1, 25)\n", + "simulation.plot_bad_actors_impact(morality_means)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "0tORPRsmVCSz", + "outputId": "8a2b3dd2-83ea-486a-a3d0-e9f8690775ed" + }, + "execution_count": 67, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 1b6a44fc92449d9cc9034eed6913737375db432a Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Wed, 19 Jun 2024 17:56:30 -0400 Subject: [PATCH 3/7] Delete SortitionGameTheory.ipynb --- SortitionGameTheory.ipynb | 345 -------------------------------------- 1 file changed, 345 deletions(-) delete mode 100644 SortitionGameTheory.ipynb diff --git a/SortitionGameTheory.ipynb b/SortitionGameTheory.ipynb deleted file mode 100644 index c656fc8..0000000 --- a/SortitionGameTheory.ipynb +++ /dev/null @@ -1,345 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "authorship_tag": "ABX9TyMQ20VwUQIBQI88doxYYXZy", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "id": "4pO5Z9hMvlUb" - }, - "outputs": [], - "source": [ - "import random\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Original functions and classes\n", - "\n", - "class Citizen:\n", - " def __init__(self, id, morality, competence):\n", - " self.id = id\n", - " self.morality = morality\n", - " self.competence = competence\n", - " self.payoff = 0\n", - "\n", - "class SortitionGovernment:\n", - " def __init__(self, population_size, num_officials,goodness_function,morality_mean=0.5):\n", - " self.population_size = population_size\n", - " self.num_officials = num_officials\n", - " self.citizens = [Citizen(i, random.gauss(morality_mean, 0.5), random.gauss(0.5, 0.5)) for i in range(population_size)]\n", - " self.societal_position = np.array([random.uniform(0, 1), random.uniform(0, 1)]) # Initialize at a random location\n", - " self.goodness_function = goodness_function\n", - " self.societal_path = [self.societal_position.copy()] # Track societal position over time\n", - " self.goodness_values = [] # Track goodness values over time\n", - "\n", - " def select_officials(self):\n", - " self.officials = random.sample(self.citizens, self.num_officials)\n", - "\n", - " def provide_steering_inputs(self, direction_maximization, direction_minimization):\n", - " total_weight = 0\n", - " weighted_steering_input = np.array([0.0, 0.0])\n", - "\n", - " for official in self.officials:\n", - " # Each official provides a steering input proportional to their morality and competence\n", - " direction = direction_maximization if official.morality > 0 else direction_minimization\n", - " steering_input = direction * official.competence * abs(official.morality)\n", - " weight = official.competence\n", - " total_weight += weight\n", - " weighted_steering_input += steering_input * weight\n", - "\n", - " # Calculate the weighted average of the steering inputs\n", - " if total_weight > 0:\n", - " societal_steering_input = weighted_steering_input / total_weight\n", - " else:\n", - " societal_steering_input = weighted_steering_input\n", - "\n", - " return societal_steering_input\n", - "\n", - " def update_societal_position(self, steering_inputs):\n", - " # Update the societal position based on steering inputs\n", - " self.societal_position += steering_inputs\n", - " self.societal_path.append(self.societal_position.copy()) # Track the new position\n", - "\n", - " def evaluate_goodness(self):\n", - " # Evaluate the societal goodness function once per epoch with the societal position\n", - " total_goodness, direction_maximization, direction_minimization = self.goodness_function(self.societal_position)\n", - " self.goodness_values.append(total_goodness)\n", - " payout = total_goodness\n", - " # Distribute the payout equally to all citizens\n", - " for citizen in self.citizens:\n", - " citizen.payoff += payout\n", - " return total_goodness, direction_maximization, direction_minimization\n", - "\n", - " def count_bad_actors(self):\n", - " return sum(1 for citizen in self.citizens if citizen.morality < 0)\n", - "\n", - "\n", - " def simulate(self, rounds):\n", - " payoffs_over_time = []\n", - " direction_maximizations_over_time = []\n", - " direction_minimizations_over_time = []\n", - "\n", - " for _ in range(rounds):\n", - " self.select_officials()\n", - " _, direction_maximization, direction_minimization = self.evaluate_goodness()\n", - " steering_inputs = self.provide_steering_inputs(direction_maximization, direction_minimization)\n", - " self.update_societal_position(steering_inputs)\n", - " total_goodness, direction_maximization, direction_minimization = self.evaluate_goodness()\n", - " payoffs_over_time.append([citizen.payoff for citizen in self.citizens])\n", - " direction_maximizations_over_time.append(direction_maximization)\n", - " direction_minimizations_over_time.append(direction_minimization)\n", - "\n", - " return payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, self.societal_path, self.goodness_values\n", - "\n", - "def plot_quartiles(payoffs_over_time):\n", - " payoffs_over_time = np.array(payoffs_over_time)\n", - " rounds = payoffs_over_time.shape[0]\n", - "\n", - " # Calculate quartiles\n", - " quartile_indices = [int(0.25 * payoffs_over_time.shape[1]), int(0.5 * payoffs_over_time.shape[1]), int(0.75 * payoffs_over_time.shape[1])]\n", - "\n", - " # Calculate average payoff for each quartile over time\n", - " avg_quartile_payoffs = np.zeros((rounds, 4))\n", - " for t in range(rounds):\n", - " sorted_payoffs = np.sort(payoffs_over_time[t])\n", - " avg_quartile_payoffs[t, 0] = np.mean(sorted_payoffs[:quartile_indices[0]])\n", - " avg_quartile_payoffs[t, 1] = np.mean(sorted_payoffs[quartile_indices[0]:quartile_indices[1]])\n", - " avg_quartile_payoffs[t, 2] = np.mean(sorted_payoffs[quartile_indices[1]:quartile_indices[2]])\n", - " avg_quartile_payoffs[t, 3] = np.mean(sorted_payoffs[quartile_indices[2]:])\n", - "\n", - " # Plotting\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 0], label='Q1 (0-25%)')\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 1], label='Q2 (25-50%)')\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 2], label='Q3 (50-75%)')\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 3], label='Q4 (75-100%)')\n", - "\n", - " plt.xlabel('Rounds')\n", - " plt.ylabel('Average Total Payoff')\n", - " plt.title('Average Total Payoff Over Time by Quartile')\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "def plot_derivatives(direction_maximizations_over_time, direction_minimizations_over_time):\n", - " rounds = len(direction_maximizations_over_time)\n", - " max_values = np.linalg.norm(direction_maximizations_over_time, axis=1) # Compute the norm of the maximization directions\n", - " min_values = np.linalg.norm(direction_minimizations_over_time, axis=1) # Compute the norm of the minimization directions\n", - " plt.plot(range(rounds), max_values, label='Direction of Maximization')\n", - " plt.plot(range(rounds), min_values, label='Direction of Minimization')\n", - "\n", - " plt.xlabel('Rounds')\n", - " plt.ylabel('Direction Value')\n", - " plt.title('Direction of Maximization and Minimization Over Time')\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "def goodness_function(societal_position):\n", - " # Parameters for the positive peak\n", - " center_positive = np.array([0.25, 0.25])\n", - " sigma_positive = 0.05\n", - " amplitude_positive = 1.0\n", - "\n", - " # Parameters for the negative peak\n", - " center_negative = np.array([0.75, 0.75])\n", - " sigma_negative = 0.05\n", - " amplitude_negative = -1.0\n", - "\n", - " # Calculate the positive Gaussian\n", - " dist_positive = np.sum((societal_position - center_positive)**2)\n", - " total_goodness_positive = amplitude_positive * np.exp(-dist_positive / (2 * sigma_positive**2))\n", - "\n", - " # Calculate the negative Gaussian\n", - " dist_negative = np.sum((societal_position - center_negative)**2)\n", - " total_goodness_negative = amplitude_negative * np.exp(-dist_negative / (2 * sigma_negative**2))\n", - "\n", - " # Combine the two peaks\n", - " total_goodness = total_goodness_positive + total_goodness_negative\n", - "\n", - " # Calculate the direction of maximization (towards the positive peak)\n", - " direction_maximization = center_positive - societal_position\n", - "\n", - " # Calculate the direction of minimization (towards the negative peak)\n", - " direction_minimization = center_negative - societal_position\n", - "\n", - " return total_goodness, direction_maximization, direction_minimization\n", - "\n", - "def plot_societal_path(societal_path, goodness_function):\n", - " # Create a grid for the goodness function\n", - " x = np.linspace(0, 1, 100)\n", - " y = np.linspace(0, 1, 100)\n", - " X, Y = np.meshgrid(x, y)\n", - " Z = np.array([[goodness_function(np.array([xi, yi]))[0] for xi, yi in zip(x_row, y_row)] for x_row, y_row in zip(X, Y)])\n", - "\n", - " # Plot the goodness function as a contour plot\n", - " plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n", - " plt.colorbar(label='Goodness Value')\n", - "\n", - " # Plot the societal path on top of the contour plot\n", - " societal_path = np.array(societal_path)\n", - " plt.scatter(societal_path[:, 0], societal_path[:, 1], c=np.arange(len(societal_path)), cmap='cool', edgecolor='k',label='Societal Path') # Color path by steps\n", - " plt.colorbar(label='Step')\n", - "\n", - " plt.xlabel('X Position')\n", - " plt.ylabel('Y Position')\n", - " plt.title('Path of Societal Position on Goodness Manifold')\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "source": [ - "class SortitionSimulation:\n", - " def __init__(self, population_size=100, num_officials=10, rounds=50, num_runs=10):\n", - " self.population_size = population_size\n", - " self.num_officials = num_officials\n", - " self.rounds = rounds\n", - " self.num_runs = num_runs\n", - "\n", - " def run_simulation(self, morality_mean):\n", - " avg_payoffs = []\n", - " bad_actors_counts = []\n", - "\n", - " for _ in range(self.num_runs):\n", - " government = SortitionGovernment(self.population_size, self.num_officials, goodness_function, morality_mean)\n", - " payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = government.simulate(self.rounds)\n", - " avg_payoffs.append(np.mean(payoffs_over_time[-1])) # Average payoff at the last round\n", - " bad_actors_counts.append(government.count_bad_actors())\n", - "\n", - " return np.mean(avg_payoffs), np.std(avg_payoffs), np.mean(bad_actors_counts), np.std(bad_actors_counts)\n", - "\n", - " def plot_bad_actors_impact(self, morality_means):\n", - " avg_payoffs = []\n", - " std_payoffs = []\n", - " avg_bad_actors_counts = []\n", - " std_bad_actors_counts = []\n", - "\n", - " for morality_mean in morality_means:\n", - " avg_payoff, std_payoff, avg_bad_actors, std_bad_actors = self.run_simulation(morality_mean)\n", - " avg_payoffs.append(avg_payoff)\n", - " std_payoffs.append(std_payoff)\n", - " avg_bad_actors_counts.append(avg_bad_actors)\n", - " std_bad_actors_counts.append(std_bad_actors)\n", - "\n", - " # Plotting\n", - " plt.errorbar(avg_bad_actors_counts, avg_payoffs, yerr=std_payoffs, fmt='o', capsize=5)\n", - " plt.xlabel('Average Number of Bad Actors')\n", - " plt.ylabel('Average Payoff at Last Round')\n", - " plt.title('Impact of Number of Bad Actors on Average Payoff')\n", - " plt.show()\n", - "\n" - ], - "metadata": { - "id": "1_ijU0uFDdIm" - }, - "execution_count": 62, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Parameters for individual simulations\n", - "population_size = 100\n", - "num_officials = 10\n", - "rounds = 50\n", - "\n", - "# Run individual simulation\n", - "sortition_gov = SortitionGovernment(population_size, num_officials, goodness_function)\n", - "payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = sortition_gov.simulate(rounds)\n", - "\n", - "# Plotting results by quartile\n", - "plot_quartiles(payoffs_over_time)\n", - "\n", - "# Plotting societal path on the goodness manifold\n", - "plot_societal_path(societal_path, goodness_function)\n", - "\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 927 - }, - "id": "kZ-214hTDjAT", - "outputId": "0e3935e8-c761-4592-edfa-5b78dfd56272" - }, - "execution_count": 68, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "simulation = SortitionSimulation(population_size, num_officials, rounds, num_runs=10)\n", - "morality_means = np.linspace(-1, 1, 25)\n", - "simulation.plot_bad_actors_impact(morality_means)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "0tORPRsmVCSz", - "outputId": "8a2b3dd2-83ea-486a-a3d0-e9f8690775ed" - }, - "execution_count": 67, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file From c1121f38e76650fe4ff7e5a8bfa7ec60996c98c5 Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Wed, 19 Jun 2024 17:58:31 -0400 Subject: [PATCH 4/7] Created using Colab --- SortitionGameTheory.ipynb | 345 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 345 insertions(+) create mode 100644 SortitionGameTheory.ipynb diff --git a/SortitionGameTheory.ipynb b/SortitionGameTheory.ipynb new file mode 100644 index 0000000..c656fc8 --- /dev/null +++ b/SortitionGameTheory.ipynb @@ -0,0 +1,345 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMQ20VwUQIBQI88doxYYXZy", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "id": "4pO5Z9hMvlUb" + }, + "outputs": [], + "source": [ + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Original functions and classes\n", + "\n", + "class Citizen:\n", + " def __init__(self, id, morality, competence):\n", + " self.id = id\n", + " self.morality = morality\n", + " self.competence = competence\n", + " self.payoff = 0\n", + "\n", + "class SortitionGovernment:\n", + " def __init__(self, population_size, num_officials,goodness_function,morality_mean=0.5):\n", + " self.population_size = population_size\n", + " self.num_officials = num_officials\n", + " self.citizens = [Citizen(i, random.gauss(morality_mean, 0.5), random.gauss(0.5, 0.5)) for i in range(population_size)]\n", + " self.societal_position = np.array([random.uniform(0, 1), random.uniform(0, 1)]) # Initialize at a random location\n", + " self.goodness_function = goodness_function\n", + " self.societal_path = [self.societal_position.copy()] # Track societal position over time\n", + " self.goodness_values = [] # Track goodness values over time\n", + "\n", + " def select_officials(self):\n", + " self.officials = random.sample(self.citizens, self.num_officials)\n", + "\n", + " def provide_steering_inputs(self, direction_maximization, direction_minimization):\n", + " total_weight = 0\n", + " weighted_steering_input = np.array([0.0, 0.0])\n", + "\n", + " for official in self.officials:\n", + " # Each official provides a steering input proportional to their morality and competence\n", + " direction = direction_maximization if official.morality > 0 else direction_minimization\n", + " steering_input = direction * official.competence * abs(official.morality)\n", + " weight = official.competence\n", + " total_weight += weight\n", + " weighted_steering_input += steering_input * weight\n", + "\n", + " # Calculate the weighted average of the steering inputs\n", + " if total_weight > 0:\n", + " societal_steering_input = weighted_steering_input / total_weight\n", + " else:\n", + " societal_steering_input = weighted_steering_input\n", + "\n", + " return societal_steering_input\n", + "\n", + " def update_societal_position(self, steering_inputs):\n", + " # Update the societal position based on steering inputs\n", + " self.societal_position += steering_inputs\n", + " self.societal_path.append(self.societal_position.copy()) # Track the new position\n", + "\n", + " def evaluate_goodness(self):\n", + " # Evaluate the societal goodness function once per epoch with the societal position\n", + " total_goodness, direction_maximization, direction_minimization = self.goodness_function(self.societal_position)\n", + " self.goodness_values.append(total_goodness)\n", + " payout = total_goodness\n", + " # Distribute the payout equally to all citizens\n", + " for citizen in self.citizens:\n", + " citizen.payoff += payout\n", + " return total_goodness, direction_maximization, direction_minimization\n", + "\n", + " def count_bad_actors(self):\n", + " return sum(1 for citizen in self.citizens if citizen.morality < 0)\n", + "\n", + "\n", + " def simulate(self, rounds):\n", + " payoffs_over_time = []\n", + " direction_maximizations_over_time = []\n", + " direction_minimizations_over_time = []\n", + "\n", + " for _ in range(rounds):\n", + " self.select_officials()\n", + " _, direction_maximization, direction_minimization = self.evaluate_goodness()\n", + " steering_inputs = self.provide_steering_inputs(direction_maximization, direction_minimization)\n", + " self.update_societal_position(steering_inputs)\n", + " total_goodness, direction_maximization, direction_minimization = self.evaluate_goodness()\n", + " payoffs_over_time.append([citizen.payoff for citizen in self.citizens])\n", + " direction_maximizations_over_time.append(direction_maximization)\n", + " direction_minimizations_over_time.append(direction_minimization)\n", + "\n", + " return payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, self.societal_path, self.goodness_values\n", + "\n", + "def plot_quartiles(payoffs_over_time):\n", + " payoffs_over_time = np.array(payoffs_over_time)\n", + " rounds = payoffs_over_time.shape[0]\n", + "\n", + " # Calculate quartiles\n", + " quartile_indices = [int(0.25 * payoffs_over_time.shape[1]), int(0.5 * payoffs_over_time.shape[1]), int(0.75 * payoffs_over_time.shape[1])]\n", + "\n", + " # Calculate average payoff for each quartile over time\n", + " avg_quartile_payoffs = np.zeros((rounds, 4))\n", + " for t in range(rounds):\n", + " sorted_payoffs = np.sort(payoffs_over_time[t])\n", + " avg_quartile_payoffs[t, 0] = np.mean(sorted_payoffs[:quartile_indices[0]])\n", + " avg_quartile_payoffs[t, 1] = np.mean(sorted_payoffs[quartile_indices[0]:quartile_indices[1]])\n", + " avg_quartile_payoffs[t, 2] = np.mean(sorted_payoffs[quartile_indices[1]:quartile_indices[2]])\n", + " avg_quartile_payoffs[t, 3] = np.mean(sorted_payoffs[quartile_indices[2]:])\n", + "\n", + " # Plotting\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 0], label='Q1 (0-25%)')\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 1], label='Q2 (25-50%)')\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 2], label='Q3 (50-75%)')\n", + " plt.plot(range(rounds), avg_quartile_payoffs[:, 3], label='Q4 (75-100%)')\n", + "\n", + " plt.xlabel('Rounds')\n", + " plt.ylabel('Average Total Payoff')\n", + " plt.title('Average Total Payoff Over Time by Quartile')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "def plot_derivatives(direction_maximizations_over_time, direction_minimizations_over_time):\n", + " rounds = len(direction_maximizations_over_time)\n", + " max_values = np.linalg.norm(direction_maximizations_over_time, axis=1) # Compute the norm of the maximization directions\n", + " min_values = np.linalg.norm(direction_minimizations_over_time, axis=1) # Compute the norm of the minimization directions\n", + " plt.plot(range(rounds), max_values, label='Direction of Maximization')\n", + " plt.plot(range(rounds), min_values, label='Direction of Minimization')\n", + "\n", + " plt.xlabel('Rounds')\n", + " plt.ylabel('Direction Value')\n", + " plt.title('Direction of Maximization and Minimization Over Time')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "def goodness_function(societal_position):\n", + " # Parameters for the positive peak\n", + " center_positive = np.array([0.25, 0.25])\n", + " sigma_positive = 0.05\n", + " amplitude_positive = 1.0\n", + "\n", + " # Parameters for the negative peak\n", + " center_negative = np.array([0.75, 0.75])\n", + " sigma_negative = 0.05\n", + " amplitude_negative = -1.0\n", + "\n", + " # Calculate the positive Gaussian\n", + " dist_positive = np.sum((societal_position - center_positive)**2)\n", + " total_goodness_positive = amplitude_positive * np.exp(-dist_positive / (2 * sigma_positive**2))\n", + "\n", + " # Calculate the negative Gaussian\n", + " dist_negative = np.sum((societal_position - center_negative)**2)\n", + " total_goodness_negative = amplitude_negative * np.exp(-dist_negative / (2 * sigma_negative**2))\n", + "\n", + " # Combine the two peaks\n", + " total_goodness = total_goodness_positive + total_goodness_negative\n", + "\n", + " # Calculate the direction of maximization (towards the positive peak)\n", + " direction_maximization = center_positive - societal_position\n", + "\n", + " # Calculate the direction of minimization (towards the negative peak)\n", + " direction_minimization = center_negative - societal_position\n", + "\n", + " return total_goodness, direction_maximization, direction_minimization\n", + "\n", + "def plot_societal_path(societal_path, goodness_function):\n", + " # Create a grid for the goodness function\n", + " x = np.linspace(0, 1, 100)\n", + " y = np.linspace(0, 1, 100)\n", + " X, Y = np.meshgrid(x, y)\n", + " Z = np.array([[goodness_function(np.array([xi, yi]))[0] for xi, yi in zip(x_row, y_row)] for x_row, y_row in zip(X, Y)])\n", + "\n", + " # Plot the goodness function as a contour plot\n", + " plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n", + " plt.colorbar(label='Goodness Value')\n", + "\n", + " # Plot the societal path on top of the contour plot\n", + " societal_path = np.array(societal_path)\n", + " plt.scatter(societal_path[:, 0], societal_path[:, 1], c=np.arange(len(societal_path)), cmap='cool', edgecolor='k',label='Societal Path') # Color path by steps\n", + " plt.colorbar(label='Step')\n", + "\n", + " plt.xlabel('X Position')\n", + " plt.ylabel('Y Position')\n", + " plt.title('Path of Societal Position on Goodness Manifold')\n", + " plt.legend()\n", + " plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "source": [ + "class SortitionSimulation:\n", + " def __init__(self, population_size=100, num_officials=10, rounds=50, num_runs=10):\n", + " self.population_size = population_size\n", + " self.num_officials = num_officials\n", + " self.rounds = rounds\n", + " self.num_runs = num_runs\n", + "\n", + " def run_simulation(self, morality_mean):\n", + " avg_payoffs = []\n", + " bad_actors_counts = []\n", + "\n", + " for _ in range(self.num_runs):\n", + " government = SortitionGovernment(self.population_size, self.num_officials, goodness_function, morality_mean)\n", + " payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = government.simulate(self.rounds)\n", + " avg_payoffs.append(np.mean(payoffs_over_time[-1])) # Average payoff at the last round\n", + " bad_actors_counts.append(government.count_bad_actors())\n", + "\n", + " return np.mean(avg_payoffs), np.std(avg_payoffs), np.mean(bad_actors_counts), np.std(bad_actors_counts)\n", + "\n", + " def plot_bad_actors_impact(self, morality_means):\n", + " avg_payoffs = []\n", + " std_payoffs = []\n", + " avg_bad_actors_counts = []\n", + " std_bad_actors_counts = []\n", + "\n", + " for morality_mean in morality_means:\n", + " avg_payoff, std_payoff, avg_bad_actors, std_bad_actors = self.run_simulation(morality_mean)\n", + " avg_payoffs.append(avg_payoff)\n", + " std_payoffs.append(std_payoff)\n", + " avg_bad_actors_counts.append(avg_bad_actors)\n", + " std_bad_actors_counts.append(std_bad_actors)\n", + "\n", + " # Plotting\n", + " plt.errorbar(avg_bad_actors_counts, avg_payoffs, yerr=std_payoffs, fmt='o', capsize=5)\n", + " plt.xlabel('Average Number of Bad Actors')\n", + " plt.ylabel('Average Payoff at Last Round')\n", + " plt.title('Impact of Number of Bad Actors on Average Payoff')\n", + " plt.show()\n", + "\n" + ], + "metadata": { + "id": "1_ijU0uFDdIm" + }, + "execution_count": 62, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Parameters for individual simulations\n", + "population_size = 100\n", + "num_officials = 10\n", + "rounds = 50\n", + "\n", + "# Run individual simulation\n", + "sortition_gov = SortitionGovernment(population_size, num_officials, goodness_function)\n", + "payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = sortition_gov.simulate(rounds)\n", + "\n", + "# Plotting results by quartile\n", + "plot_quartiles(payoffs_over_time)\n", + "\n", + "# Plotting societal path on the goodness manifold\n", + "plot_societal_path(societal_path, goodness_function)\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 927 + }, + "id": "kZ-214hTDjAT", + "outputId": "0e3935e8-c761-4592-edfa-5b78dfd56272" + }, + "execution_count": 68, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "simulation = SortitionSimulation(population_size, num_officials, rounds, num_runs=10)\n", + "morality_means = np.linspace(-1, 1, 25)\n", + "simulation.plot_bad_actors_impact(morality_means)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "0tORPRsmVCSz", + "outputId": "8a2b3dd2-83ea-486a-a3d0-e9f8690775ed" + }, + "execution_count": 67, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From d90f6acac2b9b3c01bb51ab30894bb2a39f7ab4b Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Wed, 19 Jun 2024 18:00:50 -0400 Subject: [PATCH 5/7] Delete SortitionGameTheory.ipynb --- SortitionGameTheory.ipynb | 345 -------------------------------------- 1 file changed, 345 deletions(-) delete mode 100644 SortitionGameTheory.ipynb diff --git a/SortitionGameTheory.ipynb b/SortitionGameTheory.ipynb deleted file mode 100644 index c656fc8..0000000 --- a/SortitionGameTheory.ipynb +++ /dev/null @@ -1,345 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "authorship_tag": "ABX9TyMQ20VwUQIBQI88doxYYXZy", - "include_colab_link": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "id": "4pO5Z9hMvlUb" - }, - "outputs": [], - "source": [ - "import random\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Original functions and classes\n", - "\n", - "class Citizen:\n", - " def __init__(self, id, morality, competence):\n", - " self.id = id\n", - " self.morality = morality\n", - " self.competence = competence\n", - " self.payoff = 0\n", - "\n", - "class SortitionGovernment:\n", - " def __init__(self, population_size, num_officials,goodness_function,morality_mean=0.5):\n", - " self.population_size = population_size\n", - " self.num_officials = num_officials\n", - " self.citizens = [Citizen(i, random.gauss(morality_mean, 0.5), random.gauss(0.5, 0.5)) for i in range(population_size)]\n", - " self.societal_position = np.array([random.uniform(0, 1), random.uniform(0, 1)]) # Initialize at a random location\n", - " self.goodness_function = goodness_function\n", - " self.societal_path = [self.societal_position.copy()] # Track societal position over time\n", - " self.goodness_values = [] # Track goodness values over time\n", - "\n", - " def select_officials(self):\n", - " self.officials = random.sample(self.citizens, self.num_officials)\n", - "\n", - " def provide_steering_inputs(self, direction_maximization, direction_minimization):\n", - " total_weight = 0\n", - " weighted_steering_input = np.array([0.0, 0.0])\n", - "\n", - " for official in self.officials:\n", - " # Each official provides a steering input proportional to their morality and competence\n", - " direction = direction_maximization if official.morality > 0 else direction_minimization\n", - " steering_input = direction * official.competence * abs(official.morality)\n", - " weight = official.competence\n", - " total_weight += weight\n", - " weighted_steering_input += steering_input * weight\n", - "\n", - " # Calculate the weighted average of the steering inputs\n", - " if total_weight > 0:\n", - " societal_steering_input = weighted_steering_input / total_weight\n", - " else:\n", - " societal_steering_input = weighted_steering_input\n", - "\n", - " return societal_steering_input\n", - "\n", - " def update_societal_position(self, steering_inputs):\n", - " # Update the societal position based on steering inputs\n", - " self.societal_position += steering_inputs\n", - " self.societal_path.append(self.societal_position.copy()) # Track the new position\n", - "\n", - " def evaluate_goodness(self):\n", - " # Evaluate the societal goodness function once per epoch with the societal position\n", - " total_goodness, direction_maximization, direction_minimization = self.goodness_function(self.societal_position)\n", - " self.goodness_values.append(total_goodness)\n", - " payout = total_goodness\n", - " # Distribute the payout equally to all citizens\n", - " for citizen in self.citizens:\n", - " citizen.payoff += payout\n", - " return total_goodness, direction_maximization, direction_minimization\n", - "\n", - " def count_bad_actors(self):\n", - " return sum(1 for citizen in self.citizens if citizen.morality < 0)\n", - "\n", - "\n", - " def simulate(self, rounds):\n", - " payoffs_over_time = []\n", - " direction_maximizations_over_time = []\n", - " direction_minimizations_over_time = []\n", - "\n", - " for _ in range(rounds):\n", - " self.select_officials()\n", - " _, direction_maximization, direction_minimization = self.evaluate_goodness()\n", - " steering_inputs = self.provide_steering_inputs(direction_maximization, direction_minimization)\n", - " self.update_societal_position(steering_inputs)\n", - " total_goodness, direction_maximization, direction_minimization = self.evaluate_goodness()\n", - " payoffs_over_time.append([citizen.payoff for citizen in self.citizens])\n", - " direction_maximizations_over_time.append(direction_maximization)\n", - " direction_minimizations_over_time.append(direction_minimization)\n", - "\n", - " return payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, self.societal_path, self.goodness_values\n", - "\n", - "def plot_quartiles(payoffs_over_time):\n", - " payoffs_over_time = np.array(payoffs_over_time)\n", - " rounds = payoffs_over_time.shape[0]\n", - "\n", - " # Calculate quartiles\n", - " quartile_indices = [int(0.25 * payoffs_over_time.shape[1]), int(0.5 * payoffs_over_time.shape[1]), int(0.75 * payoffs_over_time.shape[1])]\n", - "\n", - " # Calculate average payoff for each quartile over time\n", - " avg_quartile_payoffs = np.zeros((rounds, 4))\n", - " for t in range(rounds):\n", - " sorted_payoffs = np.sort(payoffs_over_time[t])\n", - " avg_quartile_payoffs[t, 0] = np.mean(sorted_payoffs[:quartile_indices[0]])\n", - " avg_quartile_payoffs[t, 1] = np.mean(sorted_payoffs[quartile_indices[0]:quartile_indices[1]])\n", - " avg_quartile_payoffs[t, 2] = np.mean(sorted_payoffs[quartile_indices[1]:quartile_indices[2]])\n", - " avg_quartile_payoffs[t, 3] = np.mean(sorted_payoffs[quartile_indices[2]:])\n", - "\n", - " # Plotting\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 0], label='Q1 (0-25%)')\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 1], label='Q2 (25-50%)')\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 2], label='Q3 (50-75%)')\n", - " plt.plot(range(rounds), avg_quartile_payoffs[:, 3], label='Q4 (75-100%)')\n", - "\n", - " plt.xlabel('Rounds')\n", - " plt.ylabel('Average Total Payoff')\n", - " plt.title('Average Total Payoff Over Time by Quartile')\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "def plot_derivatives(direction_maximizations_over_time, direction_minimizations_over_time):\n", - " rounds = len(direction_maximizations_over_time)\n", - " max_values = np.linalg.norm(direction_maximizations_over_time, axis=1) # Compute the norm of the maximization directions\n", - " min_values = np.linalg.norm(direction_minimizations_over_time, axis=1) # Compute the norm of the minimization directions\n", - " plt.plot(range(rounds), max_values, label='Direction of Maximization')\n", - " plt.plot(range(rounds), min_values, label='Direction of Minimization')\n", - "\n", - " plt.xlabel('Rounds')\n", - " plt.ylabel('Direction Value')\n", - " plt.title('Direction of Maximization and Minimization Over Time')\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "def goodness_function(societal_position):\n", - " # Parameters for the positive peak\n", - " center_positive = np.array([0.25, 0.25])\n", - " sigma_positive = 0.05\n", - " amplitude_positive = 1.0\n", - "\n", - " # Parameters for the negative peak\n", - " center_negative = np.array([0.75, 0.75])\n", - " sigma_negative = 0.05\n", - " amplitude_negative = -1.0\n", - "\n", - " # Calculate the positive Gaussian\n", - " dist_positive = np.sum((societal_position - center_positive)**2)\n", - " total_goodness_positive = amplitude_positive * np.exp(-dist_positive / (2 * sigma_positive**2))\n", - "\n", - " # Calculate the negative Gaussian\n", - " dist_negative = np.sum((societal_position - center_negative)**2)\n", - " total_goodness_negative = amplitude_negative * np.exp(-dist_negative / (2 * sigma_negative**2))\n", - "\n", - " # Combine the two peaks\n", - " total_goodness = total_goodness_positive + total_goodness_negative\n", - "\n", - " # Calculate the direction of maximization (towards the positive peak)\n", - " direction_maximization = center_positive - societal_position\n", - "\n", - " # Calculate the direction of minimization (towards the negative peak)\n", - " direction_minimization = center_negative - societal_position\n", - "\n", - " return total_goodness, direction_maximization, direction_minimization\n", - "\n", - "def plot_societal_path(societal_path, goodness_function):\n", - " # Create a grid for the goodness function\n", - " x = np.linspace(0, 1, 100)\n", - " y = np.linspace(0, 1, 100)\n", - " X, Y = np.meshgrid(x, y)\n", - " Z = np.array([[goodness_function(np.array([xi, yi]))[0] for xi, yi in zip(x_row, y_row)] for x_row, y_row in zip(X, Y)])\n", - "\n", - " # Plot the goodness function as a contour plot\n", - " plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n", - " plt.colorbar(label='Goodness Value')\n", - "\n", - " # Plot the societal path on top of the contour plot\n", - " societal_path = np.array(societal_path)\n", - " plt.scatter(societal_path[:, 0], societal_path[:, 1], c=np.arange(len(societal_path)), cmap='cool', edgecolor='k',label='Societal Path') # Color path by steps\n", - " plt.colorbar(label='Step')\n", - "\n", - " plt.xlabel('X Position')\n", - " plt.ylabel('Y Position')\n", - " plt.title('Path of Societal Position on Goodness Manifold')\n", - " plt.legend()\n", - " plt.show()\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "source": [ - "class SortitionSimulation:\n", - " def __init__(self, population_size=100, num_officials=10, rounds=50, num_runs=10):\n", - " self.population_size = population_size\n", - " self.num_officials = num_officials\n", - " self.rounds = rounds\n", - " self.num_runs = num_runs\n", - "\n", - " def run_simulation(self, morality_mean):\n", - " avg_payoffs = []\n", - " bad_actors_counts = []\n", - "\n", - " for _ in range(self.num_runs):\n", - " government = SortitionGovernment(self.population_size, self.num_officials, goodness_function, morality_mean)\n", - " payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = government.simulate(self.rounds)\n", - " avg_payoffs.append(np.mean(payoffs_over_time[-1])) # Average payoff at the last round\n", - " bad_actors_counts.append(government.count_bad_actors())\n", - "\n", - " return np.mean(avg_payoffs), np.std(avg_payoffs), np.mean(bad_actors_counts), np.std(bad_actors_counts)\n", - "\n", - " def plot_bad_actors_impact(self, morality_means):\n", - " avg_payoffs = []\n", - " std_payoffs = []\n", - " avg_bad_actors_counts = []\n", - " std_bad_actors_counts = []\n", - "\n", - " for morality_mean in morality_means:\n", - " avg_payoff, std_payoff, avg_bad_actors, std_bad_actors = self.run_simulation(morality_mean)\n", - " avg_payoffs.append(avg_payoff)\n", - " std_payoffs.append(std_payoff)\n", - " avg_bad_actors_counts.append(avg_bad_actors)\n", - " std_bad_actors_counts.append(std_bad_actors)\n", - "\n", - " # Plotting\n", - " plt.errorbar(avg_bad_actors_counts, avg_payoffs, yerr=std_payoffs, fmt='o', capsize=5)\n", - " plt.xlabel('Average Number of Bad Actors')\n", - " plt.ylabel('Average Payoff at Last Round')\n", - " plt.title('Impact of Number of Bad Actors on Average Payoff')\n", - " plt.show()\n", - "\n" - ], - "metadata": { - "id": "1_ijU0uFDdIm" - }, - "execution_count": 62, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Parameters for individual simulations\n", - "population_size = 100\n", - "num_officials = 10\n", - "rounds = 50\n", - "\n", - "# Run individual simulation\n", - "sortition_gov = SortitionGovernment(population_size, num_officials, goodness_function)\n", - "payoffs_over_time, direction_maximizations_over_time, direction_minimizations_over_time, societal_path, goodness_values = sortition_gov.simulate(rounds)\n", - "\n", - "# Plotting results by quartile\n", - "plot_quartiles(payoffs_over_time)\n", - "\n", - "# Plotting societal path on the goodness manifold\n", - "plot_societal_path(societal_path, goodness_function)\n", - "\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 927 - }, - "id": "kZ-214hTDjAT", - "outputId": "0e3935e8-c761-4592-edfa-5b78dfd56272" - }, - "execution_count": 68, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "simulation = SortitionSimulation(population_size, num_officials, rounds, num_runs=10)\n", - "morality_means = np.linspace(-1, 1, 25)\n", - "simulation.plot_bad_actors_impact(morality_means)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "id": "0tORPRsmVCSz", - "outputId": "8a2b3dd2-83ea-486a-a3d0-e9f8690775ed" - }, - "execution_count": 67, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHHCAYAAACr0swBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1kklEQVR4nO3dd1hT1/8H8HdYYQeQrai4xT0RHDhwVIu1tWodrVrrwFVRa7VDtMtVt63afi22gq3Vaqu2WnHXihO14h4oDhAXBEX2+f3hjysxARJICOP9ep485p577r2f3CTk47nnniMTQggQERERkQoTYwdAREREVBoxSSIiIiLSgEkSERERkQZMkoiIiIg0YJJEREREpAGTJCIiIiINmCQRERERacAkiYiIiEgDJklEREREGjBJogpn3bp1qFevHszNzeHg4GDscIpk7dq1kMlkOHHihLFD0cqVK1fQrVs3KBQKyGQy/P7778YOCQDQsWNHdOzY0dhhEJU5+X2njx8/Dn9/f9jY2EAmk+H06dNGjbO4mCSVI2Xth7Mgf/31F2bNmqX3/V68eBHDhg1DzZo18f333+O7777Lt+6sWbMgk8ng5uaG1NRUtfXVq1fHq6++qvcYy6OhQ4fi7Nmz+PLLL7Fu3Tq0bNlSY70bN25AJpOpPOzt7dG0aVOsWLEC2dnZJRy5quzsbHh6ekImk2HHjh1F3s/69euxZMkS/QVWRv3111+QyWTw9PRETk6OscMpVTp27KjyPXByckKrVq3www8/lIpzpek7nZmZiX79+uHRo0dYvHgx1q1bh2rVqhk71GIxM3YARJr89ddf+Oabb/SeKO3fvx85OTlYunQpatWqpdU2iYmJWLlyJaZMmaLXWCqKZ8+eISoqCh9//DHGjx+v1TYDBw5Ez549AQDJycn466+/MGHCBNy8eRMLFiwwZLgF2rt3L+Lj41G9enVERETglVdeKdJ+1q9fj5iYGEyaNEm/AZYxERERqF69Om7cuIG9e/ciMDDQ2CGVKlWqVMGcOXMAAPfv38dPP/2EESNG4PLly5g7d67R4srvO33x4kXcvHkT33//Pd577z2jxadPbEmiCiUxMREAdLrM1rRpUyxYsADPnj0zUFSl19OnT4u9j/v37wPQ7Zw3b94cQ4YMwZAhQzBu3Dhs374drVq1wvr164sdT3GEh4ejefPmCAkJwe+//66X86MvWVlZyMjIMHYYWnv69Cn++OMPTJ48Gc2aNUNERESJxyCEKNXfa4VCIX0PQkJC8O+//6JKlSpYsWIFMjMzjRZXft/povx9Le2YJJVzw4YNg62tLeLi4vDqq6/C1tYWlStXxjfffAMAOHv2LDp37gwbGxtUq1ZN7Uco9xLewYMHMXr0aFSqVAn29vZ455138PjxY5W6f/zxB3r16gVPT0/I5XLUrFkTn3/+ucZLJEePHkXPnj3h6OgIGxsbNG7cGEuXLpVizo0vb3NzYb799ls0aNAAcrkcnp6eGDduHJKSkqT11atXR2hoKADAxcUFMplMq5aqmTNn4t69e1i5cmWB9fbv3w+ZTIb9+/erlOdeQlq7dq1UVtz3JVdqamqh7wsA7NixA+3bt4eNjQ3s7OzQq1cvnDt3TqVObkzXrl1Dz549YWdnh8GDBxf4mk+dOoVXXnkF9vb2sLW1RZcuXXDkyBFp/axZs6Tm9g8++AAymQzVq1cvcJ+a5F72NDNTbfzW5TP33XffoWbNmrCyskLr1q3xzz//6BTDs2fPsGXLFrz11lvo378/nj17hj/++ENj3R07diAgIAB2dnawt7dXSfA6duyIP//8Ezdv3pQ+23nPSWJiIkaMGAE3NzdYWlqiSZMm+PHHH1X2n/uZ+vrrr7FkyRLUrFkTcrkc58+fBwAsX74cDRo0gLW1NRwdHdGyZUutEkxdj517TuVyOVq1aoXjx49rfT63bNmCZ8+eoV+/fnjrrbewefNmpKWlSesbNmyITp06qW2Xk5ODypUr480331QpW7JkCRo0aABLS0u4ublh9OjRat+F3Evkf//9N1q2bAkrKyusXr0aABAWFobOnTvD1dUVcrkcPj4+Gr/zOTk5mDVrFjw9PWFtbY1OnTrh/PnzqF69OoYNG6ZSNykpCZMmTYKXlxfkcjlq1aqFefPmFflymbW1Ndq0aYOnT5/i/v37uHnzJsaOHYu6devCysoKlSpVQr9+/XDjxg1pm+vXr0Mmk2Hx4sVq+zt8+DBkMhl+/vlnqayo3+lhw4YhICAAANCvXz/IZLLy0d9PULkRFhYmAIjjx49LZUOHDhWWlpbCx8dHjBkzRnzzzTfC399fABBhYWHC09NTfPDBB2L58uWiQYMGwtTUVFy/fl1tn40aNRLt27cXy5YtE+PGjRMmJiaiQ4cOIicnR6rbp08f0b9/f7FgwQKxcuVK0a9fPwFATJ06VSXOXbt2CQsLC1GtWjURGhoqVq5cKSZOnCgCAwOFEEIcPnxYdO3aVQAQ69atkx4FCQ0NFQBEYGCgWL58uRg/frwwNTUVrVq1EhkZGUIIIbZs2SJef/11AUCsXLlSrFu3Tpw5c6bQfd6/f1907txZuLm5idTUVGl9tWrVRK9evaTlffv2CQBi3759KvuJjY2Vzrcx3peffvpJyGQy0aNHD7F8+XIxb948Ub16deHg4CBiY2NVYpLL5aJmzZpi6NChYtWqVeKnn37K9/zExMQIGxsb4eHhIT7//HMxd+5c4e3tLeRyuThy5IgQQogzZ86IxYsXCwBi4MCBYt26dWLLli357jP3XM2ePVvcv39f3L9/X1y7dk2sWLFCmJmZiU8//VSlvrafuf/9738CgPD39xfLli0TkyZNEg4ODqJGjRoiICAg33jy+uWXX4RMJhNxcXFCCCE6d+4sevbsqVYvLCxMyGQy0bBhQ/Hll1+Kb775Rrz33nvi7bffFkI8//w3bdpUODs7S5/t3HOSmpoq6tevL8zNzUVISIhYtmyZaN++vQAglixZonaefHx8RI0aNcTcuXPF4sWLxc2bN8V3330nAIg333xTrF69WixdulSMGDFCTJw4scDXp+uxmzVrJmrVqiXmzZsn5s+fL5ydnUWVKlWk71thevToIbp06SKEEOLmzZtCJpOJX3/9VVr/2WefCRMTExEfH6+y3YEDBwQAsXHjRqnsvffeE2ZmZmLkyJFi1apV4sMPPxQ2NjYq338hnn9na9WqJRwdHcX06dPFqlWrpO9rq1atxLBhw8TixYvF8uXLRbdu3QQAsWLFCpXjT5s2TQAQQUFBYsWKFWLkyJGiSpUqwtnZWQwdOlSq9/TpU9G4cWNRqVIl8dFHH4lVq1aJd955R8hkMvH+++8Xen4CAgJEgwYN1MqbN28uTE1NxdOnT8XGjRtFkyZNxMyZM8V3330nPvroI+Ho6CiqVasmnj59Km3Ttm1b0aJFC7V9jR07VtjZ2Ul1i/OdPnz4sPjoo48EADFx4kSxbt06sWvXrkJfZ2nHJKkcyS9JAiC++uorqezx48fCyspKyGQy8csvv0jlFy9eFABEaGio2j5btGih8sdm/vz5AoD4448/pLK8CUSu0aNHC2tra5GWliaEECIrK0t4e3uLatWqicePH6vUzfvDPm7cOKFtDp+YmCgsLCxEt27dRHZ2tlS+YsUKAUD88MMPUlnexKcweevm/mFetGiRtL64SVJJvC8pKSnCwcFBjBw5UiWmhIQEoVAoVMpzY5o+fXqh50aI5wmKhYWFuHbtmlR29+5dYWdnJzp06KD2+hcsWFDoPnPranoEBwerfEaE0O4zl5GRIVxdXUXTpk1Fenq6VC83mdA2SXr11VdF27ZtVbY3MzMTiYmJUllSUpKws7MTvr6+4tmzZyrb5429V69eolq1amrHWLJkiQAgwsPDpbKMjAzh5+cnbG1thVKpFEK8OE/29vYqxxdCiNdee03jj2thdD12pUqVxKNHj6S6f/zxhwAgtm3bVuix7t27J8zMzMT3338vlfn7+4vXXntNWr506ZIAIJYvX66y7dixY4Wtra303v/zzz8CgIiIiFCpt3PnTrXyatWqCQBi586dajFp+ix1795d1KhRQ1pOSEgQZmZmok+fPir1Zs2aJQCoJEmff/65sLGxEZcvX1apO336dGFqaiol2/kJCAgQ9erVk/6zcOHCBTFx4kQpQcsv5qioKAFA5T84q1evFgDEhQsXpLKMjAy1xK643+ncv4F5E9iyjpfbKoi8negcHBxQt25d2NjYoH///lJ53bp14eDggOvXr6ttP2rUKJibm0vLwcHBMDMzw19//SWVWVlZSc9TUlLw4MEDtG/fHqmpqbh48SKA5025sbGxmDRpktp1a20uqWmye/duZGRkYNKkSTAxefGRHjlyJOzt7fHnn38Wab95dejQAZ06dcL8+fP12ofB0O9LZGQkkpKSMHDgQDx48EB6mJqawtfXF/v27VPbZ3BwcKFxZ2dnY9euXejTpw9q1KghlXt4eGDQoEE4dOgQlEqldidBg1GjRiEyMhKRkZH47bffMG7cOKxevRqTJ09WqafNZ+7EiRNITEzEmDFjYGFhIdUfNmwYFAqFVvE8fPgQf//9NwYOHCiV9e3bFzKZDL/++qtUFhkZiZSUFEyfPh2WlpYq+9Dm8/3XX3/B3d1d5Tjm5uaYOHEinjx5ggMHDqjU79u3L1xcXFTKHBwccPv2bZ0ufRXl2AMGDICjo6O03L59ewDQ+Dl92S+//AITExP07dtXKhs4cCB27NghXSKrU6cOmjZtig0bNkh1srOzsWnTJgQFBUnv/caNG6FQKNC1a1eVz3iLFi1ga2ur9hn39vZG9+7d1WLK+1lKTk7GgwcPEBAQgOvXryM5ORkAsGfPHmRlZWHs2LEq206YMEFtfxs3bkT79u3h6OioEldgYCCys7Nx8ODBQs/TxYsX4eLiAhcXF9SvXx/Lly9Hr1698MMPP6jFnJmZiYcPH6JWrVpwcHBAdHS0tK5///6wtLRU6ff1999/48GDBxgyZIh0bg35nS6reHdbBWBpaan2h1ShUKBKlSpqf7gVCoXGPi21a9dWWba1tYWHh4fKte9z587hk08+wd69e9W+TLl/ZK5duwbgeX8Dfbl58yaA58lEXhYWFqhRo4a0vrhmzZqFgIAArFq1CiEhIcXeX0m8L1euXAEAdO7cWWMM9vb2KstmZmaoUqVKobHfv38fqampauccAOrXr4+cnBzcunULDRo0KHRfmtSuXVvlTqc33ngDMpkMS5YswbvvvotGjRoB0O4zl/v+v3yuzM3NVX4MCrJhwwZkZmaiWbNmuHr1qlTu6+uLiIgIjBs3DkDxP983b95E7dq1VZJ94Pk5zftacnl7e6vt48MPP8Tu3bvRunVr1KpVC926dcOgQYPQtm1bvR67atWqKsu5CZOmz+nLwsPD0bp1azx8+BAPHz4EADRr1gwZGRnYuHEjRo0aBeB5IvbRRx/hzp07qFy5Mvbv34/ExEQMGDBA2teVK1eQnJwMV1dXjcfK7UycS9M5A4B///0XoaGhiIqKUhvyIzk5GQqFQjoHL98Z6+TkpJIw5sb133//qX3H84tLk+rVq+P777+HTCaDpaUlateurfI6nz17hjlz5iAsLAx37tyBEEIl5lwODg4ICgrC+vXr8fnnnwN4fmdh5cqVpb8Nhv5Ol1VMkioAU1NTncrzftG0lZSUhICAANjb2+Ozzz5DzZo1YWlpiejoaHz44YelYlyP4urQoQM6duyI+fPnY8yYMWrr82spyG9sn5J4X3LP+7p16+Du7q62/uWO0HK5XO1HsrTo0qULVqxYgYMHD6JRo0Yl+pnL/R94fonG9evXtU649ClvS0Ku+vXr49KlS9i+fTt27tyJ3377Dd9++y1mzpyJ2bNn6+3YRf2cXrlyRWrlejlxBZ6f67xJ0owZM7Bx40ZMmjQJv/76KxQKBXr06CHVz8nJgaura753x72cpGg6Z9euXUOXLl1Qr149LFq0CF5eXrCwsMBff/2FxYsXF+mzlJOTg65du2LatGka19epU6fQfdjY2BQ4LMKECRMQFhaGSZMmwc/PTxrY8a233lKL+Z133sHGjRtx+PBhNGrUCFu3bsXYsWNL7fe9tGCSRFq5cuWKyp0mT548QXx8vDSWzf79+/Hw4UNs3rwZHTp0kOrFxsaq7KdmzZoAgJiYmAK//Lpcesu90+LSpUsqP1QZGRmIjY3V69grs2bNQseOHaU7YvLK/Z9k3jvqAPX/getTYe9L7vl2dXXV63lwcXGBtbU1Ll26pLbu4sWLMDExgZeXl96OBzy/xR14/hoB7T9zuZ+PK1euqLSoZWZmIjY2Fk2aNCnwuLGxsTh8+DDGjx8v3b2TKycnB2+//TbWr1+PTz75ROXzXdA4XPl9vqtVq4b//vsPOTk5Kj9euZcOtR2Yz8bGBgMGDMCAAQOQkZGBN954A19++SVmzJihdhlQ38cuTEREBMzNzbFu3Tq1ROvQoUNYtmwZ4uLiULVqVXh7e6N169bYsGEDxo8fj82bN6NPnz6Qy+XSNjVr1sTu3bvRtm1bjQmQNrZt24b09HRs3bpVpYXs5Ut1uefg6tWrKi1SDx8+VGtBq1mzJp48eWLQsZ82bdqEoUOHYuHChVJZWlqa2t8gAOjRowdcXFwQEREBX19fpKam4u2335bWG+M7XRYwhSStfPfddyrjcqxcuRJZWVnSYHq5f+zy/i8yIyMD3377rcp+mjdvDm9vbyxZskTti5x3WxsbGwDqCYcmgYGBsLCwwLJly1T2sWbNGiQnJ6NXr17avUgtBAQEoGPHjpg3b57K7crA8z+gpqaman0NXj4H+lTY+9K9e3fY29vjq6++0jiuSu54J7oyNTVFt27d8Mcff6hccr137x7Wr1+Pdu3aqV3KK65t27YBgJTUaPuZa9myJVxcXLBq1SqVcYTWrl2r1ecrt4Vi2rRpePPNN1Ue/fv3R0BAgFSnW7dusLOzw5w5c9Q+Hy9/vvNeDsnVs2dPJCQkqPTDycrKwvLly2Fra6uWpGmSe/kql4WFBXx8fCCEKHBsHX0cWxsRERFo3749BgwYoHY+P/jgAwBQuSV9wIABOHLkCH744Qc8ePBA5VIb8Ly/TXZ2tnQZKa+srCyt3mNNn6Xk5GSEhYWp1OvSpQvMzMzUhgZYsWKF2j779++PqKgo/P3332rrkpKSpKS/OExNTdVa7pYvX66x9drMzAwDBw7Er7/+irVr16JRo0Zo3Lixyr5K+jtdFrAlibSSkZGBLl26oH///rh06RK+/fZbtGvXDr179wYA+Pv7w9HREUOHDsXEiRMhk8mwbt06tS+wiYkJVq5ciaCgIDRt2hTDhw+Hh4cHLl68iHPnzkl/UFq0aAEAmDhxIrp37w5TU1O89dZbGmNzcXHBjBkzMHv2bPTo0QO9e/eWYmzVqpXUMVFfQkNDNY7folAo0K9fPyxfvhwymQw1a9bE9u3btep7UFSFvS/29vZYuXIl3n77bTRv3hxvvfUWXFxcEBcXhz///BNt27bV+AdeG1988QUiIyPRrl07jB07FmZmZli9ejXS09Mxf/78Yr2u6OhohIeHA3jeIXvPnj347bff4O/vj27dugHQ/jNnbm6OL774AqNHj0bnzp0xYMAAxMbGIiwsTKtLZBEREWjatGm+/4vu3bs3JkyYgOjoaDRv3hyLFy/Ge++9h1atWmHQoEFwdHTEmTNnkJqaKo051KJFC2zYsAGTJ09Gq1atYGtri6CgIIwaNQqrV6/GsGHDcPLkSVSvXh2bNm3Cv//+iyVLlsDOzq7QeLt16wZ3d3e0bdsWbm5uuHDhAlasWIFevXoVuL0+jl2Yo0eP4urVq/mOvF65cmU0b94cERER+PDDDwE8TzamTp2KqVOnwsnJSa1lJiAgAKNHj8acOXNw+vRpdOvWDebm5rhy5Qo2btyIpUuXqoyppEm3bt1gYWGBoKAgjB49Gk+ePMH3338PV1dXxMfHS/Xc3Nzw/vvvY+HChejduzd69OiBM2fOYMeOHXB2dlZpIfzggw+wdetWvPrqqxg2bBhatGiBp0+f4uzZs9i0aRNu3LgBZ2fnop5KAMCrr76KdevWQaFQwMfHB1FRUdi9ezcqVaqksf4777yDZcuWYd++fZg3b57aekN+p8ssY9xSR4aR3xAANjY2anXzG4Pj5dvac/d54MABMWrUKOHo6ChsbW3F4MGDxcOHD1W2/ffff0WbNm2ElZWV8PT0FNOmTRN///23xtviDx06JLp27Srs7OyEjY2NaNy4scqtvllZWWLChAnCxcVFyGQyrYYDWLFihahXr54wNzcXbm5uIjg4WG2YgaIOAfCygIAAAUDlXAkhxP3790Xfvn2FtbW1cHR0FKNHjxYxMTEahwAoqfdFiOe35nbv3l0oFAphaWkpatasKYYNGyZOnDhRaEwFiY6OFt27dxe2trbC2tpadOrUSRw+fFilTnGHADAzMxM1atQQH3zwgUhJSVGpr8tn7ttvv5XGfGnZsqU4ePCgCAgIKHAIgJMnTwoAauMz5XXjxg0BQISEhEhlW7duFf7+/sLKykrY29uL1q1bi59//lla/+TJEzFo0CDh4OAgAKgMB3Dv3j0xfPhw4ezsLCwsLESjRo1UPjt5z5Omc7p69WrRoUMHUalSJWncqw8++EAkJyfn+xr0dWy8NFTFyyZMmCAAqNxi/rLc2+nzjmHWtm1bAUC89957+W733XffiRYtWggrKythZ2cnGjVqJKZNmybu3r0r1Xn5e5TX1q1bRePGjYWlpaWoXr26mDdvnvjhhx8EAJXxxLKyssSnn34q3N3dhZWVlejcubO4cOGCqFSpkhgzZozKPlNSUsSMGTNErVq1hIWFhXB2dhb+/v7i66+/LnQ8qfz+FuT1+PFj6f2ytbUV3bt3FxcvXhTVqlVTubU/rwYNGggTExNx+/ZtjeuL850uj0MAyIQoQm9QqjDWrl2L4cOH4/jx4/lOSkpEVJElJSXB0dERX3zxBT7++GNjh1OgZs2awcnJCXv27DF2KGUC+yQRERFpSdM4aUuWLAGAUj8Nx4kTJ3D69Gm88847xg6lzGCfJCIiIi1t2LABa9euRc+ePWFra4tDhw7h559/Rrdu3Qodi8pYYmJicPLkSSxcuBAeHh5qnd8pf0ySiIiItNS4cWOYmZlh/vz5UCqVUmfuL774wtih5WvTpk347LPPULduXfz888/5DgNB6tgniYiIiEgD9kkiIiIi0oBJEhEREZEG7JOko5ycHNy9exd2dnZFnrWeiIiISpYQAikpKfD09NR6zjomSTq6e/duhZy/hoiIqDy4desWqlSpolVdJkk6yh2a/9atWxVyHhsiIqKySKlUwsvLS6cpdpgk6Sj3Epu9vT2TJCIiojJGl64y7LhNREREpAGTJCIiIiINmCQRERERacAkiYiIiEgDJklEREREGjBJIiIiItKASRIRERGRBmUqSTp48CCCgoLg6ekJmUyG33//XWW9EAIzZ86Eh4cHrKysEBgYiCtXrqjUefToEQYPHgx7e3s4ODhgxIgRePLkSQm+CiIiIioLylSS9PTpUzRp0gTffPONxvXz58/HsmXLsGrVKhw9ehQ2Njbo3r070tLSpDqDBw/GuXPnEBkZie3bt+PgwYMYNWpUSb0EIiIiKiNkQghh7CCKQiaTYcuWLejTpw+A561Inp6emDJlCqZOnQoASE5OhpubG9auXYu33noLFy5cgI+PD44fP46WLVsCAHbu3ImePXvi9u3b8PT0LPS4SqUSCoUCycnJHHGbiIiojCjK73eZakkqSGxsLBISEhAYGCiVKRQK+Pr6IioqCgAQFRUFBwcHKUECgMDAQJiYmODo0aMa95ueng6lUqnyICIiovKv3CRJCQkJAAA3NzeVcjc3N2ldQkICXF1dVdabmZnByclJqvOyOXPmQKFQSA8vLy8DRE9ERESlTblJkgxlxowZSE5Olh63bt0ydkhERERUAsyMHYC+uLu7AwDu3bsHDw8PqfzevXto2rSpVCcxMVFlu6ysLDx69Eja/mVyuRxyuVyvsSYq05CYkq7zdq52crjaW+o1FiIiItKs3CRJ3t7ecHd3x549e6SkSKlU4ujRowgODgYA+Pn5ISkpCSdPnkSLFi0AAHv37kVOTg58fX1LLNaIo3FYuudK4RVf8n6X2hjsW5UJFhERUQkoU0nSkydPcPXqVWk5NjYWp0+fhpOTE6pWrYpJkybhiy++QO3ateHt7Y1PP/0Unp6e0h1w9evXR48ePTBy5EisWrUKmZmZGD9+PN566y2t7mzTl8G+VdHVR7Xv1NP0LAz47ggAYFaQD5pVdYSpiUyljqudvFgJVkjXOkUPmoiIqIIpU0MA7N+/H506dVIrHzp0KNauXQshBEJDQ/Hdd98hKSkJ7dq1w7fffos6dV4kB48ePcL48eOxbds2mJiYoG/fvli2bBlsbW21isEQQwDsjInHp7+fw/0nL1qInG0t8F67GrC3MsPj1Ew4WpujgacCyc8y8OhpplTPycYCcjMTrRIstiQREVFFVZTf7zKVJJUG+k6SdsbEIzg8GkV9E3o18sCJm49wT/kiwfJQWCI0yAc9GnoUsCUREVHFUaHHSSqLsnMEZm87r3OC9NEr9bB9Qjt89Eo9/Hk2XiVBAoCE5DQEh0djZ0y8/oIlIiKqYJgkGdGx2EeIT04rvGIeMgBhh2+gjpsdwg7f0FgnN+mave08snPYUEhERFQUZarjdnmTmKJbggQ8T4Dik9OwLupGgQlWbr0Nx+PQuIqDTsdg/yUiIiImSUblalf0ROTmo1St6n20JUbnffNOOCIiIiZJRtXa2wkeCkskJKfp3C+pmpO1VvW+er2hSktSWmY23lz1fC67+X0bwcLMVG0bJxsLxNxJ1rg/tjIREVFFwSTJiExNZAgN8kFweLRO2znbWqBZVUc421rgwZMMjXVkANwVlhjQqqrKcACpGVnS82m/ndU5ZrYyERFRRcEkych6NPTAyiHNMWXjGTxNz9ZqmwdPMvDGysPSsgxQaYnKTYlCg3zUxkvKa9MYP1iav2hJytvK9PK6XK52+p2ihYiIqLRikmQEL8/dVsXRGov6NcHo/29RGt3BG2lZOfjj1F0kPVMdOHJMhxrwr+UslZ27k4xFuy+rDAPgruU4ST6e9rC2ePERyNvK9PI6IiKiioa/gkZQ2NQiqw/Gaiwf7FsVowJqqpQ1rKxAz8YeaDRrFwBg7fBWaF/bpcAWJCIiIiockyQj0DR3mzZc7eRqrVDA88tkuWzlZrgQr9S4LTtcExERaY9JkhG42lsWOWFZHHm5wFao3D5FL2OHayIiIt0wSSpjitMKRURERNpjklTGFKcVioiIiLTHuduIiIiINGCSRERERKQBk6QKJjvnxbCTx2IfqSwTERHRC0ySKpCdMfEIXHRAWh4Wdhzt5u3Fzph4I0ZFRERUOjFJqiB2xsQjODxaZWRuAEhITkNweDQTJSIiopfw7rYKIDtHYPa289B0YU3g+Vxvs7edx66QDlL5+btKjXO35YeDVRIRUXnDJKkCOBb7CPHJafmuFwDik9Nw8uZjqSy/QSnzw8EqiYiovGGSVAEkpuSfIOV1T/mi3qwgHzSr6ghTExnSMrOlpGnTGD+NLUwcrJKIiMobJkkVgKuddpfB5u64KD2fte08PBSWCA3yQYc6LlK5j6c9rC34sSEiovKPHbcrgNbeTvBQWEJWSL3HqZkqy7mduiPP3zNccERERKUUk6QKwNREhtAgHwBQS5QKSpxyO3rP+etiAbWIiIjKJyZJFUSPhh5YOaQ5XO1V+w452VgUuJ0AkKDUrk8TERFRecIkqQLp0dADuycHSMtrh7fCJ73qGzEiIiKi0otJUgVjavLiAltrbye4K6yMGA0REVHpxSSpgiusU7cMgDsHiSQiogqISVIFp02n7hk965VoTERERKUBkyTKt1O3u8ISK4c0R1cfNyNFRkREZDwcFZAAPE+U2tZyRqNZuwA879TdvrYLTE1kSM3IMnJ0REREJa9ctSRVr14dMplM7TFu3DgAQMeOHdXWjRkzxshRlx4vd+rOu0xERFTRlKuWpOPHjyM7O1tajomJQdeuXdGvXz+pbOTIkfjss8+kZWtr6xKNkYiIiMqGcpUkubi4qCzPnTsXNWvWREDAi7GBrK2t4e7uXtKhERERURlTri635ZWRkYHw8HC8++67kMleXDaKiIiAs7MzGjZsiBkzZiA1NdWIURIREVFpVa5akvL6/fffkZSUhGHDhkllgwYNQrVq1eDp6Yn//vsPH374IS5duoTNmzfnu5/09HSkp6dLy0ql0pBhExERUSlRbpOkNWvW4JVXXoGnp6dUNmrUKOl5o0aN4OHhgS5duuDatWuoWbOmxv3MmTMHs2fPNni8hpCoTENiSrpKWVrmiz5b5+8qYWluqnEdERFRRVcuk6SbN29i9+7dBbYQAYCvry8A4OrVq/kmSTNmzMDkyZOlZaVSCS8vL/0Fa0ARR+OwdM+VfNe/uSqqBKMhIiIqW8plkhQWFgZXV1f06tWrwHqnT58GAHh4eORbRy6XQy6X57u+NBvsW1WngSDTMrM1Jk7ZOUJ6fiz2kTR+EhERUXlW7pKknJwchIWFYejQoTAze/Hyrl27hvXr16Nnz56oVKkS/vvvP4SEhKBDhw5o3LixESM2HFd7S7jqMO+apkEjd8bEI3TrOWl5WNhxeCgsERrkgx4N808uiYiIyrpyd3fb7t27ERcXh3fffVel3MLCArt370a3bt1Qr149TJkyBX379sW2bduMFGnptzMmHsHh0binVO3XlJCchuDwaOyMiTdSZERERIZX7lqSunXrBiGEWrmXlxcOHDhghIjKpuwcgdnbzkP9TAICzye/nb3tPLr6uBv90pumDuracLWT69TSRkREFUu5S5JIP07efIz45LR81wsA8clpOBb7CH41K5VcYBoU1kE9P+93qY2QrnUMEBEREZUHTJJIo/tatswkpuSfSJUUTR3U83ZC3zTGT2Wog1yudmWzQz4REZUMJkkVVGFjKD1NV+/ErYmrnfEvV2nqoJ63E7qPpz2sLfhRJyIi3fCXo4Iq7BLVrG3nC9xeBsBdYYnW3k56joyIiKh0YJJUQWkzhtLhqw/w1Y6LauW53bRDg3yM3mmbiIjIUJgkVVDajKHUsLICVStZI3TrOZVhANw5ThIREVUATJKoQD0aeqBtLWc0mrULALB2eCu9j7jNW/iJiKg0YpJEhcqbELX2dtL7JTbewk9ERKURkyQyOt7CT0REpRGTJDI63sJPRESlUbmbu42IiIhIH5gkEREREWnAJImIiIhIAyZJRERERBowSSIiIiLSgEkSERERkQZMkoiIiIg0YJJEREREpAGTJCIiIiINmCQRERERacAkiYiIiEgDJklEREREGmg1a+jkyZO13uGiRYuKHAwRERFRaaFVknTq1CmV5ejoaGRlZaFu3boAgMuXL8PU1BQtWrTQf4RUohKVaUhMSVcpS8vMlp6fv6uEpbmp2naudnK42lsaPD4iIqKSolWStG/fPun5okWLYGdnhx9//BGOjo4AgMePH2P48OFo3769YaKkEhNxNA5L91zJd/2bq6I0lr/fpTZCutYxVFhEREQlTqskKa+FCxdi165dUoIEAI6Ojvjiiy/QrVs3TJkyRa8BUska7FsVXX3cdN7O1U5ugGiIiIiMR+ckSalU4v79+2rl9+/fR0pKil6CIuNxtbfkZTMiIiIU4e62119/HcOHD8fmzZtx+/Zt3L59G7/99htGjBiBN954wxAxEhEREZU4nVuSVq1ahalTp2LQoEHIzMx8vhMzM4wYMQILFizQe4BERERExqBzkmRtbY1vv/0WCxYswLVr1wAANWvWhI2Njd6DIyIiIjIWnZOkXDY2NmjcuLE+YyEiIiIqNXROkp4+fYq5c+diz549SExMRE5Ojsr669ev6y04IiIiImPROUl67733cODAAbz99tvw8PCATCYzRFxFMmvWLMyePVulrG7durh48SIAIC0tDVOmTMEvv/yC9PR0dO/eHd9++y3c3HS/5Z2IiIjKN52TpB07duDPP/9E27ZtDRFPsTVo0AC7d++Wls3MXrzEkJAQ/Pnnn9i4cSMUCgXGjx+PN954A//++68xQqUCZOcI6fmx2EdoX9sFpibaJ+TF3Z6IiEjnJMnR0RFOTk6GiEUvzMzM4O7urlaenJyMNWvWYP369ejcuTMAICwsDPXr18eRI0fQpk2bkg6V8rEzJh6hW89Jy8PCjsNDYYnQIB/0aOhh8O2JiIiAIoyT9Pnnn2PmzJlITU01RDzFduXKFXh6eqJGjRoYPHgw4uLiAAAnT55EZmYmAgMDpbr16tVD1apVERWleaoNAEhPT4dSqVR5kOHsjIlHcHg07ilV549LSE5DcHg0dsbEG3R7IiKiXEWaluTatWtwc3ND9erVYW5urrI+Ojpab8HpytfXF2vXrkXdunURHx+P2bNno3379oiJiUFCQgIsLCzg4OCgso2bmxsSEhLy3eecOXPU+jmRYWTnCMzedh5CwzoBQAZg9rbz6OrjrvHSWXG3JyIiykvnJKlPnz4GCEM/XnnlFel548aN4evri2rVquHXX3+FlZVVkfY5Y8YMTJ48WVpWKpXw8vIqdqyk7ljsI8Qnp+W7XgCIT07DsdhH8KtZSe/bExER5aVzkhQaGmqIOAzCwcEBderUwdWrV9G1a1dkZGQgKSlJpTXp3r17Gvsw5ZLL5ZDLOXlrSUhMyT/B0aZecbcnIiLKS+c+SWXJkydPcO3aNXh4eKBFixYwNzfHnj17pPWXLl1CXFwc/Pz8jBgl5XK1025i3fzqFXd7IiKivHRuSTIxMSlwbKTs7OxiBVQcU6dORVBQEKpVq4a7d+8iNDQUpqamGDhwIBQKBUaMGIHJkyfDyckJ9vb2mDBhAvz8/HhnWynR2tsJHgpLJCSnaexXJAPgrrBEa2/Nd1cWd3siIqK8dE6StmzZorKcmZmJU6dO4ccffzR6B+fbt29j4MCBePjwIVxcXNCuXTscOXIELi4uAIDFixfDxMQEffv2VRlMkkoHUxMZQoN8EBweDRmgkujkpuWhQT75drou7vZERER5yYQQmv7TrbP169djw4YN+OOPP/Sxu1JLqVRCoVAgOTkZ9vb2xg6nXMod5yjvbfxFGSepqNsTEVH5U5Tfb70lSdevX0fjxo3x5MkTfeyu1GKSVDJS0jLRaNYuAMDa4a10HjG7uNsTEVH5UpTfb7103H727BmWLVuGypUr62N3RCoJTWtvJ50TnOJuT0REVKRpSfJ23BZCICUlBdbW1ggPD9drcERERETGonOStGTJEpVlExMTuLi4wNfXF46OjvqKi4iIiMiodE6Shg4daog4iIiIiEoVnZMkAEhKSsKaNWtw4cIFAECDBg3w7rvvQqFQ6DU4IiIiImPRueP2iRMnULNmTSxevBiPHj3Co0ePsGjRItSsWdOok9sSERER6ZPOLUkhISHo3bs3vv/+e5iZPd88KysL7733HiZNmoSDBw/qPUgiIiKikqZzknTixAmVBAkAzMzMMG3aNLRs2VKvwREREREZi86X2+zt7REXF6dWfuvWLdjZ2eklKCIiIiJj0zlJGjBgAEaMGIENGzbg1q1buHXrFn755Re89957GDhwoCFiJCIiIipxOl9u+/rrryGTyfDOO+8gKysLAGBubo7g4GDMnTtX7wESERERGYPOSZKFhQWWLl2KOXPm4Nq1awCAmjVrwtraGs+ePdN7gETGlqhMQ2JKeuEVX+JqJ4ervaUBIiIiopJQpHGSAMDa2hqNGjUCAKSnp2PRokWYP38+EhIS9BYcUWkQcTQOS/dc0Xm797vURkjXOgaIiIiISoLWSVJ6ejpmzZqFyMhIWFhYYNq0aejTpw/CwsLw8ccfw9TUFCEhIYaMlcgoBvtWRVcfN5WytMxsvLkqCgCwaYwfLM1N1bZztZOXSHxERGQYWidJM2fOxOrVqxEYGIjDhw+jX79+GD58OI4cOYJFixahX79+MDVV/6EgKutc7S3VLpulZmRJz3087WFtUeRGWSIiKqW0/su+ceNG/PTTT+jduzdiYmLQuHFjZGVl4cyZM5DJZIaMkYiIiKjEaT0EwO3bt9GiRQsAQMOGDSGXyxESEsIEiYiIiMolrZOk7OxsWFhYSMtmZmawtbU1SFBERERExqb15TYhBIYNGwa5/Hln1LS0NIwZMwY2NjYq9TZv3qzfCImIiIiMQOskaejQoSrLQ4YM0XswRERERKWF1klSWFiYIeMgIiIiKlV0nruNiIiIqCJgkkRERESkAZMkIiIiIg2YJBERERFpoPNcCgcPHoS/vz/MzFQ3zcrKwuHDh9GhQwe9BUcVQ6IyDYkp6SplaZnZ0vPzd5X5zo328nQhRERE+qJzktSpUyfEx8fD1dVVpTw5ORmdOnVCdnZ2PlsSaRZxNA5L91zJd33uRLIve79LbYR0rWOosIiIqILTOUkSQmiciuThw4dqA0sSaWOwb1V09XHTeTtXO7kBoiEiInpO6yTpjTfeAADIZDKVkbeB51OW/Pfff/D399d/hFTuudpb8rIZERGVOlonSQqFAsDzliQ7OztYWVlJ6ywsLNCmTRuMHDlS/xESERERGYHOI25Xr14dU6dO5aU1IiIiKtd0HgJg2rRpKn2Sbt68iSVLlmDXrl16Dawo5syZg1atWsHOzg6urq7o06cPLl26pFKnY8eOkMlkKo8xY8YYKWLSh0RlGmLuJKs8zt9VSuvP31WqrY+5k4xEZZoRoyYiotJO547br732Gt544w2MGTMGSUlJaN26NSwsLPDgwQMsWrQIwcHBhohTKwcOHMC4cePQqlUrZGVl4aOPPkK3bt1w/vx5lZavkSNH4rPPPpOWra2tjREu6Ykx7o7LzhHS82Oxj9C+tgtMTdRvaCAiorJL5yQpOjoaixcvBgBs2rQJ7u7uOHXqFH777TfMnDnTqEnSzp07VZbXrl0LV1dXnDx5UmX8Jmtra7i7u5d0eGQgJX133M6YeIRuPSctDws7Dg+FJUKDfNCjoUeR9klERKWPzklSamoq7OzsAAC7du3CG2+8ARMTE7Rp0wY3b97Ue4DFkZycDABwcnJSKY+IiEB4eDjc3d0RFBSETz/9NN/WpPT0dKSnvxjoUKlUaqxHxlOSd8ftjIlHcHg0xEvlCclpCA6PxsohzZkoERGVEzr3SapVqxZ+//133Lp1C3///Te6desGAEhMTIS9vb3eAyyqnJwcTJo0CW3btkXDhg2l8kGDBiE8PBz79u3DjBkzsG7dOgwZMiTf/cyZMwcKhUJ6eHl5lUT4VApl5wjM3nZeLUECIJXN3nZe5VIcERGVXTIhhE5/0Tdt2oRBgwYhOzsbXbp0kTpsz5kzBwcPHsSOHTsMEqiugoODsWPHDhw6dAhVqlTJt97evXvRpUsXXL16FTVr1lRbr6klycvLC8nJyaUqKSTDi7r2EAO/P1JovZ9HtoFfzUolEBEREWlLqVRCoVDo9Put8+W2N998E+3atUN8fDyaNGkilXfp0gWvv/66rrsziPHjx2P79u04ePBggQkSAPj6+gJAvkmSXC5XGTiTKq7EFO3uhtO2HhERlW46J0kA4O7urtbxuXXr1noJqDiEEJgwYQK2bNmC/fv3w9vbu9BtTp8+DQDw8GA/EiqYq512/Z60rUdERKVbkZKkEydO4Ndff0VcXBwyMjJU1m3evFkvgRXFuHHjsH79evzxxx+ws7NDQkICgOejhVtZWeHatWtYv349evbsiUqVKuG///5DSEgIOnTogMaNGxstbiobWns7wUNhiYTkNI39kmQA3BWWaO3tpGEtERGVNTp33P7ll1/g7++PCxcuYMuWLcjMzMS5c+ewd+9eaeoSY1m5ciWSk5PRsWNHeHh4SI8NGzYAeD59yu7du9GtWzfUq1cPU6ZMQd++fbFt2zajxk1lg6mJDKFBPgCeJ0R55S6HBvlwvCQionJC547bjRs3xujRozFu3DjY2dnhzJkz8Pb2xujRo+Hh4YHZs2cbKtZSoSgdv6h8yR0n6Z7yRYd+jpNERFS6FeX3W+ckycbGBufOnUP16tVRqVIl7N+/H40aNcKFCxfQuXNnxMfHFyn4soJJEgFASlomGs16fmfn2uGtOOI2EVEpV5Tfb50vtzk6OiIlJQUAULlyZcTExAAAkpKSkJqaquvuiMqkvAlRa28nJkhEROWQzh23O3TogMjISDRq1Aj9+vXD+++/j7179yIyMhJdunQxRIxE9P8SlWlITEkvvOJLXO3kJTYqORFReaFzkrRixQqkpT0fB+bjjz+Gubk5Dh8+jL59++KTTz7Re4BE9EJhk/nmpziT+RIRVVQ6J0l550EzMTHB9OnTATyf0+306dPw9/fXX3REpELTZL5pmdl4c1UUAGDTGD9YmpuqbVfUyXyJiCqyIo2TpMmVK1fQvn17ZGdn62uXRPQSTZP5pmZkSc99PO1hbaG3rzURUYWmc8dtIiIiooqASRIRERGRBkySiIiIiDTQuvPC1q1bC1wfGxtb7GCIiIiISgutk6Q+ffoUWkcm44B6REREVD5onSTl5OQYMg4iIiKiUoV9kojKuOycF9MvHot9pLJMRERFxwFViMqwnTHxCN16TloeFnYcHgpLhAb5oEdDjyLvl9OfEBExSSIqs3bGxCM4PBovtxslJKchODwaK4c0L3KixOlPiIiYJBGVSdk5ArO3nVdLkABAAJABmL3tPLr6uMPURPcbKjj9CRERkySiMulY7CPEJ6flu14AiE9Ow7HYR/CrWUnn/XP6EyKiInTcrlGjBh4+fKhWnpSUhBo1auglKCIqWGJK/glSUeoREZE6nZOkGzduaJzENj09HXfu3NFLUERUMFc77TpHa1uPiIjUFWnE7b///hsKhUJazs7Oxp49e1C9enW9BkdUGmi60yst88V/FM7fVebbP8dQd3q19naCh8ISCclpGvslyQC4KyzR2tvJIMcnIqoIdB5xWyaTYejQoSrrzM3NUb16dSxcuFCvwRGVBoXd6ZXbmfllhrzTy9REhtAgHwSHR0MGqCRKud20Q4N8itRpOz8vj8fUvraLXvdPRFTayIQQOo085+3tjePHj8PZ2dlQMZVqSqUSCoUCycnJsLe3N3Y4VAJK85hBueMk3VO+iE8f4yQZ6zhERIZSlN9vnZOkio5JEpU2KWmZaDRrFwBg7fBWem/hyW88ptwjFGc8JiKiklKU3+8i3cP79OlTHDhwAHFxccjIyFBZN3HixKLskoiKKG9C1NrbSe+X2Aw5HhMRUWmmc5J06tQp9OzZE6mpqXj69CmcnJzw4MEDWFtbw9XVlUkSUTli6PGYiIhKM52HAAgJCUFQUBAeP34MKysrHDlyBDdv3kSLFi3w9ddfGyJGIjISjsdERBWZzknS6dOnMWXKFJiYmMDU1BTp6enw8vLC/Pnz8dFHHxkiRiIyEo7HREQVmc6X28zNzWFi8jy3cnV1RVxcHOrXrw+FQoFbt27pPUAiMp7SNh6TpjsNs3MEzt1NxuPUTDham6OBp0Ktf1RJ3GlIROWPzklSs2bNcPz4cdSuXRsBAQGYOXMmHjx4gHXr1qFhw4aGiJGIjMQY4zEVpLAxq/JjyDGriKj80jlJ+uqrr5CSkgIA+PLLL/HOO+8gODgYtWvXxg8//KD3AInoBWOM/t2joQdWDmmuNk6SuxHGSRrsWxVdfdwAAIevPsBXOy7mW/ejV+rBv9bz8dxc7eQlEh8RlS8cJ0lHHCeJjGlx5GWjtaQYejwmXWTnCLSbtzffO+9yLwMe+rBzmRmaoDQPWkpUHpTYOEnlwTfffIMFCxYgISEBTZo0wfLly9G6dWtjh0VUoLwtKbrQR0uKIcdj0lV5HJqAlxKJSp8KmSRt2LABkydPxqpVq+Dr64slS5age/fuuHTpElxdXY0dHlG+XO0t2WoAww1NkJ0jcCz2ERJT0uBqZ1miyaCmBDgtM1uaG3DTGL98L6USkWFUyCRp0aJFGDlyJIYPHw4AWLVqFf7880/88MMPmD59upGjI6LC6GNogpcvbx2++gDf/XMdD568mEXA2dYCo9rXkPo2Pd+nYS5vaUqAUzOypOc+nvawtqiQf7KJjKbCfeMyMjJw8uRJzJgxQyozMTFBYGAgoqI0z+ZORKWLPoYm0Oby1oMnGWqdw3l5i6ji0CpJcnJywuXLl+Hs7Ix3330XS5cuhZ2dnaFjM4gHDx4gOzsbbm6qzdpubm64eFH9Tpn09HSkp7/436ZSqTR4jESkWd7Wn+H+1fO9u038//oL8c+/r5paf3Ivb2XnCIz48bhKC9LLnG0tsGZoK5iayMrs5S12DCfSnVZJUkZGBpRKJZydnfHjjz9i3rx5ZTZJ0tWcOXMwe/ZsY4dBVKKMMdSANnTp3Jw3gdLU+pN7eSvq2sMCEyTgeYtSakZ2iXcCz8550U52LPZRse4oZMdwIt1plST5+fmhT58+aNGiBYQQmDhxIqysrDTWLe1jJTk7O8PU1BT37t1TKb937x7c3d3V6s+YMQOTJ0+WlpVKJby8vAweJ5ExFfaDmtuZ+GWG/kHV1LlZ2xG381Na56fbGROP0K3npOVhYcfhUYyxqdgxnEh3WiVJ4eHhWLx4Ma5duwYASE5ORlpa2ZzQ0sLCAi1atMCePXvQp08fAEBOTg727NmD8ePHq9WXy+WQy/lHgioWYw41UOD+87m7r4mXQ9H3WQrnp9sZE4/g8Gi1/lYJyWkIDo/GyiHNdU6U2DGcSHdafSPc3Nwwd+5cAIC3tzfWrVuHSpXKxtgjmkyePBlDhw5Fy5Yt0bp1ayxZsgRPnz6V7nYjqugqwlADuZcUrS1M4WxrUWifJGsLU8TcSTb4JcXsHIHZ285r7JAu8LxT+uxt59HVx73MDJRJVFbp3HG7U6dOsLCwMHRcBjVgwADcv38fM2fOREJCApo2bYqdO3eqdeYmovJLlz46D55k4LVv/gVg+EuKZWWgTHYEp4qgwnbcHj9+vMbLa0RUMbx8SVGXcZIMqbT2kXoZO4JTRVDhOm4TEQHqlxQbVlZgRPsaRhtxW4qrBPtIFefuOXYEp4pA547bMpmsTHfcJiLKj6mJzOhzveljoExtFPfuOXYEp4qgQnbcJiIqrUxNZAgN8kFweDRkgEqilNvGExrkU6wWLkPcPUdUHpnoukFsbCwTJCIiA+rR0AMrhzSHq73qpSl3hWWxE5jC7p4Dnt89l/dSHFFFpXOSBAAHDhxAUFAQatWqhVq1aqF37974559/9B0bEVGF1aOhB3ZPDpCW1w5vhUMfdi52C48ud88RVXQ6J0nh4eEIDAyEtbU1Jk6cKHXi7tKlC9avX2+IGImIKqS8l9T01Ym8rNw9R1Qa6Nyr7ssvv8T8+fMREhIilU2cOBGLFi3C559/jkGDBuk1QCIi0p/SOMI4UWmlc0vS9evXERQUpFbeu3dvxMbG6iUoIiIyjNy75/Jrk5IB8NDD3XNE5YHOLUleXl7Ys2cPatWqpVK+e/duTvxKRFREmkawTsvMlp6fv6vMd9whXUawLom754jKC52TpClTpmDixIk4ffo0/P39AQD//vsv1q5di6VLl+o9QCKiiqCwEaxzB2l8WVFGsM69ey506zncU75IzNx1GCdJk+IMTklUGsmEEDrf57llyxYsXLgQFy5cAADUr18fH3zwAV577TW9B1jaKJVKKBQKJCcnw97e3tjhEFE5YYy50FLSMtFo1i4Az++eK05Skzs4Zd6kS5fBKYkMrSi/30VKkioyJklEVF6kZmTBZ+bfAIDzn3Uv8gjZ+Q1OmZtucXBKKg2K8vutc8ftoUOH4uDBgzoHR0RE5Q8Hp6TyTOckKTk5GYGBgahduza++uor3LlzxxBxERFRGcDBKak807lt9ffff8f9+/exbt06/PjjjwgNDUVgYCBGjBiB1157Debm5oaIk4iISqHSMjilMfp0UflXpAvQLi4umDx5MiZPnozo6GiEhYXh7bffhq2tLYYMGYKxY8eidu3a+o6ViIiKyFBDDJSWwSkLuzswP0W5O5AqjqL10vt/8fHxiIyMRGRkJExNTdGzZ0+cPXsWPj4+aqNyExGR8RhqiIHcwSkTktM09kuS4fnQAoYenHKwb1V09XFTKUvLzJZe16YxfvkmgUT50TlJyszMxNatWxEWFoZdu3ahcePGmDRpEgYNGiT1Ft+yZQveffddJklERKWEpiRCG4UlEaVlcEpXe0u1Fq/UjCzpuY+nfZHv3qOKS+dPjIeHB3JycjBw4EAcO3YMTZs2VavTqVMnODg46CE8IiLSB01JhL4YanBKImPTOUlavHgx+vXrB0vL/L9sDg4OnMeNiKgC6dHQA21rOettcEqi0kDnJOntt982RBxERFTG5U2IWns7MUGiMq9IF2hPnDiBX3/9FXFxccjIyFBZt3nzZr0ERkRERGRMOg8m+csvv8Df3x8XLlzAli1bkJmZiXPnzmHv3r1QKBSGiJGIiIioxOmcJH311VdYvHgxtm3bBgsLCyxduhQXL15E//79UbVqVUPESERERFTidE6Srl27hl69egEALCws8PTpU8hkMoSEhOC7777Te4BERERExqBzkuTo6IiUlBQAQOXKlRETEwMASEpKQmpqqn6jIyIiKqK8k+oei33ESXZJZzonSR06dEBkZCQAoF+/fnj//fcxcuRIDBw4EF26dNF7gERERLraGROPwEUHpOVhYcfRbt5e7IyJN2JUVNbofHfbihUrkJb2fKLCjz/+GObm5jh8+DD69u2LTz75RO8BEhER6WJnTDyCw6PVpklJSE5DcHg0Vg5pzgEuSSs6JUk3btxAZGQkMjIyEBAQgIYNG2L69OmGio2IiEgn2TkCs7ed1ziPnMDzqVJmbzuPrj7uHMeJCqV1krRv3z68+uqrePbs2fMNzczwww8/YMiQIQYLjoiISqdEZRoSU9JVytIys6Xn5+8q851Q1lDTowDP+x7FJ6flu14AiE9Ow7HYR/CrWclgcVD5oHWS9Omnn6Jr165YuXIlLC0t8cknn2DatGlMkoiIKqCIo3FYuudKvuvfXBWlsfz9LrUR0rWOocJCYkr+CVJR6lHFpnWSFBMTg8OHD8PD4/l13AULFmD16tV4+PAhKlViNk5EVJEM9q2Krj5uOm/naic3QDR5969dK5W29ahi0zpJUiqVcHZ2lpatra1hZWWF5OTkUpEk3bhxA59//jn27t2LhIQEeHp6YsiQIfj4449hYWEh1fH29lbbNioqCm3atCnpkImIyixXe0uDXjYrqtbeTvBQWCIhOU1jvyQZAHeFJVp7O5V0aFQG6dRx+++//1aZeiQnJwd79uyRxkoCgN69e+svOh1cvHgROTk5WL16NWrVqoWYmBiMHDkST58+xddff61Sd/fu3WjQoIG0XBqSPCIiKj5TExlCg3wQHB4NGaCSKOV20w4N8mGnbdKKTAih1ehaJiaFD6kkk8mQnZ1daL2SsmDBAqxcuRLXr18H8KIl6dSpU2jatGmR9qlUKqFQKJCcnAx7e3s9RktERPqyMyYeoVvP4Z7yRedyD4UlQoN8ePt/BVWU32+tW5JycnKKHJixJCcnw8lJvUm1d+/eSEtLQ506dTBt2rQCW7/S09ORnv7iS6ZUKg0SKxER6U+Phh5oW8sZjWbtAgCsHd4K7Wu7sAWJdKLziNtlxdWrV7F8+XKMHj1aKrO1tcXChQuxceNG/Pnnn2jXrh369OmDrVu35rufOXPmQKFQSA8vL6+SCJ+IiIopb0LU2tuJCRLpTOvLbcYyffp0zJs3r8A6Fy5cQL169aTlO3fuICAgAB07dsT//ve/Ard95513EBsbi3/++Ufjek0tSV5eXrzcRkRUyqVmZMFn5t8AgPOfdYe1hc6TTFA5YtDLbcYyZcoUDBs2rMA6NWrUkJ7fvXsXnTp1gr+/P7777rtC9+/r6yvNRaeJXC6HXG7YW1aJiIio9Cn1SZKLiwtcXFy0qnvnzh106tQJLVq0QFhYmFadzU+fPi2N/URERESUq9QnSdq6c+cOOnbsiGrVquHrr7/G/fv3pXXu7u4AgB9//BEWFhZo1qwZAGDz5s344YcfCr0kR0RERBVPkZKkpKQkbNq0CdeuXcMHH3wAJycnREdHw83NDZUrV9Z3jFqJjIzE1atXcfXqVVSpUkVlXd5uV59//jlu3rwJMzMz1KtXDxs2bMCbb75Z0uESERFRKadzx+3//vsPgYGBUCgUuHHjBi5duoQaNWrgk08+QVxcHH766SdDxVoqcJwkIqKywdAdtzVN8qsNQ0/yS5qVSMftyZMnY9iwYZg/fz7s7Oyk8p49e2LQoEG67o6IiKhMKmyS3/wYepJf0h+dk6Tjx49j9erVauWVK1dGQkKCXoIiIiLShaZWnbTMFzNAnL+rhKW5qdp2xWnV0TTJb1pmNt5cFQUA2DTGL99jUtmgc5Ikl8s1jjp9+fJlre9CIyIi0qfCWnVyE5eXFadVR9Mkv6kZWdJzH097js1Uxun87vXu3RufffYZfv31VwDP52uLi4vDhx9+iL59++o9QCIiosJoatXRBlt1qCA6J0kLFy7Em2++CVdXVzx79gwBAQFISEiAn58fvvzyS0PESEREVCBNrTpExaVzkqRQKBAZGYlDhw7hv//+w5MnT9C8eXMEBgYaIj4iIiIioyjyxdJ27dqhXbt2+oyFiIiIqNTQOUlatmyZxnKZTAZLS0vUqlULHTp0gKmpeo9+IiIiorJC5yRp8eLFuH//PlJTU+Ho6AgAePz4MaytrWFra4vExETUqFED+/btg5eXl94DJiIiIioJhc8A+5KvvvoKrVq1wpUrV/Dw4UM8fPgQly9fhq+vL5YuXYq4uDi4u7sjJCTEEPESERERlQidW5I++eQT/Pbbb6hZs6ZUVqtWLXz99dfo27cvrl+/jvnz53M4ACIiIirTdG5Jio+PR1ZWllp5VlaWNOK2p6cnUlJSih8dERERkZHonCR16tQJo0ePxqlTp6SyU6dOITg4GJ07dwYAnD17Ft7e3vqLkoiIiKiE6ZwkrVmzBk5OTmjRogXkcjnkcjlatmwJJycnrFmzBgBga2uLhQsX6j1YIiIiopKic58kd3d3REZG4uLFi7h8+TIAoG7duqhbt65Up1OnTvqLkIiIiMgIijyYZL169VCvXj19xkJERERUahQpSbp9+za2bt2KuLg4ZGRkqKxbtGiRXgIjIiIiMiadk6Q9e/agd+/eqFGjBi5evIiGDRvixo0bEEKgefPmhoiRiIiIqMTp3HF7xowZmDp1Ks6ePQtLS0v89ttvuHXrFgICAtCvXz9DxEhERERU4nROki5cuIB33nkHAGBmZoZnz57B1tYWn332GebNm6f3AImIiIiMQeckycbGRuqH5OHhgWvXrknrHjx4oL/IiIiIiIxI5z5Jbdq0waFDh1C/fn307NkTU6ZMwdmzZ7F582a0adPGEDESERERlTidk6RFixbhyZMnAIDZs2fjyZMn2LBhA2rXrs0724iIiKjc0ClJys7Oxu3bt9G4cWMAzy+9rVq1yiCBERERERmTTn2STE1N0a1bNzx+/NhQ8RARERGVCjp33G7YsCGuX79uiFiIiIiISg2dk6QvvvgCU6dOxfbt2xEfHw+lUqnyICIiIioPdO643bNnTwBA7969IZPJpHIhBGQyGbKzs/UXHREREZGR6Jwk7du3zxBxEBEREZUqOidJAQEBhoiDiIiIqFTRuU8SAPzzzz8YMmQI/P39cefOHQDAunXrcOjQIb0GR0RERGQsOidJv/32G7p37w4rKytER0cjPT0dAJCcnIyvvvpK7wESERERGUOR7m5btWoVvv/+e5ibm0vlbdu2RXR0tF6D01X16tUhk8lUHnPnzlWp899//6F9+/awtLSEl5cX5s+fb6RoiYiI8peoTEPMnWSdH4nKNGOHXm7o3Cfp0qVL6NChg1q5QqFAUlKSPmIqls8++wwjR46Ulu3s7KTnSqUS3bp1Q2BgIFatWoWzZ8/i3XffhYODA0aNGmWMcImIqBzJzhHS82Oxj9C+tgtMTWQFbJG/iKNxWLrnis7bvd+lNkK61inSMUmVzkmSu7s7rl69iurVq6uUHzp0CDVq1NBXXEVmZ2cHd3d3jesiIiKQkZGBH374ARYWFmjQoAFOnz6NRYsWMUkiIqJi2RkTj9Ct56TlYWHH4aGwRGiQD3o09NB5f4N9q6Krj5tKWVpmNt5cFQUA2DTGD5bmpmrbudrJdT4Waabz5baRI0fi/fffx9GjRyGTyXD37l1ERERg6tSpCA4ONkSMOpk7dy4qVaqEZs2aYcGCBcjKypLWRUVFoUOHDrCwsJDKunfvjkuXLuU71Up6ejoHzCQiogLtjIlHcHg07inTVcoTktMQHB6NnTHxOu/T1d4SDSsrVB4+nvbSeh9Pe7X1DSsr4GpvWezXQ8/p3JI0ffp05OTkoEuXLkhNTUWHDh0gl8sxdepUTJgwwRAxam3ixIlo3rw5nJyccPjwYcyYMQPx8fFYtGgRACAhIQHe3t4q27i5uUnrHB0d1fY5Z84czJ492/DBExFRmZSdIzB723kIDesEABmA2dvOo6uPe5EvvZFx6NySJJPJ8PHHH+PRo0eIiYnBkSNHcP/+fXz++eeGiA/Tp09X64z98uPixYsAgMmTJ6Njx45o3LgxxowZg4ULF2L58uXSHXhFMWPGDCQnJ0uPW7du6eulERFROXAs9hHik/PvLC0AxCen4Vjso5ILivRC55ak8PBwvPHGG7C2toaPj48hYlIxZcoUDBs2rMA6+fWF8vX1RVZWFm7cuIG6devC3d0d9+7dU6mTu5xfPya5XA65nNd3iYhIs8QU7e4m07YelR46J0khISEYM2YMevfujSFDhqB79+4wNVXvOKYvLi4ucHFxKdK2p0+fhomJCVxdXQEAfn5++Pjjj5GZmSkNXxAZGYm6detqvNRGRERUGFc77foAaVuPSg+dL7fFx8fjl19+gUwmQ//+/eHh4YFx48bh8OHDhohPa1FRUViyZAnOnDmD69evIyIiAiEhIRgyZIiUAA0aNAgWFhYYMWIEzp07hw0bNmDp0qWYPHmyUWMnIqKyq7W3EzwUlsivt5EMgIfCEq29nUoyLNIDnZMkMzMzvPrqq4iIiEBiYiIWL16MGzduoFOnTqhZs6YhYtSKXC7HL7/8goCAADRo0ABffvklQkJC8N1330l1FAoFdu3ahdjYWLRo0QJTpkzBzJkzefs/EREVmamJDKFBz7ufvJwo5S6HBvmw03YZpPPltrysra3RvXt3PH78GDdv3sSFCxf0FZfOmjdvjiNHjhRar3Hjxvjnn39KICIiIqooejT0wMohzRG69ZzKMADuxRgniYyvSElSamoqtmzZgoiICOzZswdeXl4YOHAgNm3apO/4iIiIyoQeDT3QtpYzGs3aBQBYO7xVsUbcJuPTOUl66623sH37dlhbW6N///749NNP4efnZ4jYiIiIypS8CVFrbycmSGWczkmSqakpfv31V413tcXExKBhw4Z6C46IiIjIWHROkiIiIlSWU1JS8PPPP+N///sfTp48iezsbL0FR0RERGQsRe64ffDgQaxZswa//fYbPD098cYbb+Cbb77RZ2xERESkB4nKNCSm6D77hKudvELPBadTkpSQkIC1a9dizZo1UCqV6N+/P9LT0/H777+XyOjbREREpLuIo3FYuueKztu936U2QrrWMUBEZYPWSVJQUBAOHjyIXr16YcmSJejRowdMTU2xatUqQ8ZHRERExTTYtyq6+riplKVlZuPNVVEAgE1j/GBprj57hqtdxZ6WS+skaceOHZg4cSKCg4NRu3ZtQ8ZEREREeuRqb6l22Sw1I0t67uNpD2uLYg2dWC5pPeL2oUOHkJKSghYtWsDX1xcrVqzAgwcPDBkbERERkdFonSS1adMG33//PeLj4zF69Gj88ssv8PT0RE5ODiIjI5GSkmLIOImIiIhKlM5zt9nY2ODdd9/FoUOHcPbsWUyZMgVz586Fq6srevfubYgYiYiICEB2jpCeH4t9pLJM+qdzkpRX3bp1MX/+fNy+fRs///yzvmIiIiKil+yMiUfgogPS8rCw42g3by92xsQbMaryrVhJUi5TU1P06dMHW7du1cfuiIiIKI+dMfEIDo9WmTwXABKS0xAcHs1EyUD0kiQRERGRYWTnCMzedh6aLqzlls3edp6X3gyASRIREVEpdiz2EeKT0/JdLwDEJ6fhWOyjkguqgmCSREREVIolpuSfIBWlHmmPSRIREVEp5mqn3dxp2tYj7TFJIiIiKsVaezvBQ2EJWT7rZQA8FJZo7e1UkmFVCEySiIiISjFTExlCg55PIv9yopS7HBrkA1OT/NIoKiomSURERKVcj4YeWDmkOVztVSecdVdYYuWQ5ujR0MNIkZVvnM2OiIioDOjR0ANtazmj0axdAIC1w1uhfW0XtiAZEFuSiIiIyoi8CVFrbycmSAbGJImIiIhIAyZJRERERBowSSIiIiLSgEkSERERkQZMkoiIiIg0YJJEREREpAGTJCIiIiINmCQRERERacAkiYiIiEiDcjMtyf79+9GpUyeN644dO4ZWrVrhxo0b8Pb2VlsfFRWFNm3aGDpEIiIqRxKVaUhMSVcpS8vMlp6fv6uEpbmp2naudnK42lsaPL7CZOcI6fmx2Eec4kSDcpMk+fv7Iz4+XqXs008/xZ49e9CyZUuV8t27d6NBgwbScqVKlUokRiIiKj8ijsZh6Z4r+a5/c1WUxvL3u9RGSNc6hgpLKztj4hG69Zy0PCzsODwUlggN8uFkuXmUmyTJwsIC7u7u0nJmZib++OMPTJgwATKZamZcqVIllbpERES6GuxbFV193HTeztVOboBotLczJh7B4dEQL5UnJKchODwaK4c0Z6L0/8pNkvSyrVu34uHDhxg+fLjaut69eyMtLQ116tTBtGnT0Lt3byNESEREZZmrvWWpuGymi+wcgdnbzqslSAAgAMgAzN52Hl193HnpDeW44/aaNWvQvXt3VKlSRSqztbXFwoULsXHjRvz5559o164d+vTpg61bt+a7n/T0dCiVSpUHERFRWXQs9hHik9PyXS8AxCen4Vjso5ILqhQr9S1J06dPx7x58wqsc+HCBdSrV09avn37Nv7++2/8+uuvKvWcnZ0xefJkablVq1a4e/cuFixYkG9r0pw5czB79uxivAIiIqLSITEl/wQpr+i4x7Cz1C5FKC0d0Q2h1CdJU6ZMwbBhwwqsU6NGDZXlsLAwVKpUSavLaL6+voiMjMx3/YwZM1QSK6VSCS8vr0L3S0REVNq42mmXzCz4+xIW/H1Jq7qloSO6oZT6JMnFxQUuLi5a1xdCICwsDO+88w7Mzc0LrX/69Gl4eOTfQU0ul0MuN24nOyIiIn1o7e0ED4UlEpLTNPZLAgBnWwusGdoKpiYypGVmS3fpbRrjl++QBuVVqU+SdLV3717ExsbivffeU1v3448/wsLCAs2aNQMAbN68GT/88AP+97//lXSYREREBTLEOEymJjKEBvkgODwaMkAlUcrtpv1Fn4Zo4uUAAEjNyJLW+3jaw9qi3KUNBSp3r3bNmjXw9/dX6aOU1+eff46bN2/CzMwM9erVw4YNG/Dmm2+WcJREREQFM9Q4TD0aemDlkOYI3XoO95QvkjB3jpOkRiaEyK/FjTRQKpVQKBRITk6Gvb29scMhIqJySlNLkja07UidkpaJRrN2AQDWDm+lccTt1Iws+Mz8GwBw/rPuZbolqSi/32X31RIREZVjhh6HKW9C1NrbieMiaVBux0kiIiIiKg4mSUREREQaMEkiIiIi0oB9koiIiEhFbqdxbYYcyKu8jb7NJImIiIhUaBp+IL8hB/Iqb6NvM0kiIiIiFYN9q8LGwhSrD17Hw6cZausryujbTJKIiIhIRXTcY8zZcTHfqUvuJD3Da00rl2hMxsCO20RERCTJzhGYve18vgkSAMz56yKyc8r/WNRMkoiIiEhyLPYR4pPTCqyToEzDsdhHJRSR8fByGxEREUkSUwpOkF6uZ+jpU4yJSRIRERFJXO20S1xy6xU2EW9+ysKdcEySiIiISNLa2wkeCkskJKfl2y/JycYCLao5Anh+J1xXHzeV9WmZ2dKQAWX5TjgmSURERCQxNZEhNMgHweHRkAEaE6VHTzMQsGAfQoN80KOhh9pls9SMLOm5j6c9rC3KZrrBjttERESkokdDD6wc0hyu9vm39iQkpyE4PBo7Y+JLMLKSxSSJiIiI1PRo6IG/J3XId31uC9PsbefL7XAATJKIiIhIo9O3kgpcLwDEJ6sPB5A3aToW+6jMJlFMkoiIiEij+1re2p932ICdMfEIXHRAWh4Wdhzt5u0tk5flmCQRERGRRi5a3oGWOxzAzph4BIdH455SNbkqq/2XmCQRERGRRrm3+edHBsBDYYnW3k4FTmdSVvsvMUkiIiIijUxNZPmuy10TGuQDUxNZodOZ5Nd/qTRjkkRERESFennwR3eFJVYOaY4eDT0A6D6dSVlQNkd3IiIiohK1bUJb+H61FwCwdngrtK/totLSpOt0JmUBkyQiIiIqVN6EqLW3k9qluMKmM5HheetTa28nAGVjYlwmSURERFRshU1nIgAM96+OmDvJOHc3GdvO3EXUdd37J5XkxLhMkoiIiMo5Ta02aZnZ0vPzd5VIzcjCo6eZKnVsLF5MTHsxXqlSP3fS2rwtO7nTmYRuPac2DAAAfLXjok5xO9taYFT7GvCv5SyVleTEuDIhRNm5F68UUCqVUCgUSE5Ohr29vbHDISIiKtTiyMtYuueKQfatqWUnJS0TjWbtAgDMCvJBs6qOOHr9oc5JUu4FvbwdxIuqKL/fbEkiIiIq5wb7VkVXH7cC6zx6mq7WkuRkYwEnGwsAz1ue3lwVBQDYNMZPpSXpZXn7K/Vv5QW5mSnGhJ/UOW6B54nS7G3n0dXHvcAhCQyBSRIREVE552pvqVNnZ106VSempEt18+tUXdgYSgXJO76SX81KRdpHUTFJIiIiIhURR+MKvDyX26L0soGtvTDYt5paf6fouMfFjskY4yuxT5KO2CeJiIjKO11akiKO3MTPx28ZOCLg55FtitWSxD5JREREVGy6XJ4L6VoHg9tUK7BOdo7AiB+P48GTDJ1jeXl8pZJUZqYl+fLLL+Hv7w9ra2s4ODhorBMXF4devXrB2toarq6u+OCDD5CVlaVSZ//+/WjevDnkcjlq1aqFtWvXGj54IiKicsrV3hINKys0PnI7dZuayDCqfQ2d9/3y/HAlrcy0JGVkZKBfv37w8/PDmjVr1NZnZ2ejV69ecHd3x+HDhxEfH4933nkH5ubm+OqrrwAAsbGx6NWrF8aMGYOIiAjs2bMH7733Hjw8PNC9e/eSfklERETlWmF9mwpT6f/HSariaI2YO8kASnbE7TLXJ2nt2rWYNGkSkpKSVMp37NiBV199FXfv3oWb2/PbHFetWoUPP/wQ9+/fh4WFBT788EP8+eefiImJkbZ76623kJSUhJ07d2p1fPZJIiIi0o6mvk3ZOcIoI25X6D5JUVFRaNSokZQgAUD37t0RHByMc+fOoVmzZoiKikJgYKDKdt27d8ekSZPy3W96ejrS01+8wUqlMt+6RERE9EJ+fZuaeDkgsL5bkeduKynlJklKSEhQSZAASMsJCQkF1lEqlXj27BmsrKzU9jtnzhzMnj3bQFETERFVTLqO3WQMRu24PX36dMhksgIfFy/qNoS5vs2YMQPJycnS49Ytw9/mSERERMZn1JakKVOmYNiwYQXWqVFDu97w7u7uOHbsmErZvXv3pHW5/+aW5a1jb2+vsRUJAORyOeTykmvaIyIiotLBqEmSi4sLXFxc9LIvPz8/fPnll0hMTISrqysAIDIyEvb29vDx8ZHq/PXXXyrbRUZGws/PTy8xEBERUflRZsZJiouLw+nTpxEXF4fs7GycPn0ap0+fxpMnTwAA3bp1g4+PD95++22cOXMGf//9Nz755BOMGzdOagkaM2YMrl+/jmnTpuHixYv49ttv8euvvyIkJMSYL42IiIhKoTIzBMCwYcPw448/qpXv27cPHTt2BADcvHkTwcHB2L9/P2xsbDB06FDMnTsXZmYvGsz279+PkJAQnD9/HlWqVMGnn35a6CW/vDgEABERUdlTlN/vMpMklRZMkoiIiMqeovx+l5nLbUREREQliUkSERERkQZMkoiIiIg0YJJEREREpAGTJCIiIiINmCQRERERacAkiYiIiEgDo05LUhblDiulVCqNHAkRERFpK/d3W5fhIZkk6SglJQUA4OXlZeRIiIiISFcpKSlQKBRa1eWI2zrKycnB3bt3YWdnB5lMVmh9pVIJLy8v3Lp1iyN0lzCee+PgeTcennvj4bk3Dl3OuxACKSkp8PT0hImJdr2N2JKkIxMTE1SpUkXn7ezt7fnFMRKee+PgeTcennvj4bk3Dm3Pu7YtSLnYcZuIiIhIAyZJRERERBowSTIwuVyO0NBQyOVyY4dS4fDcGwfPu/Hw3BsPz71xGPq8s+M2ERERkQZsSSIiIiLSgEkSERERkQZMkoiIiIg0YJJEREREpAGTJAP75ptvUL16dVhaWsLX1xfHjh0zdkjlypw5c9CqVSvY2dnB1dUVffr0waVLl1TqpKWlYdy4cahUqRJsbW3Rt29f3Lt3z0gRl09z586FTCbDpEmTpDKed8O5c+cOhgwZgkqVKsHKygqNGjXCiRMnpPVCCMycORMeHh6wsrJCYGAgrly5YsSIy4fs7Gx8+umn8Pb2hpWVFWrWrInPP/9cZS4wnvviO3jwIIKCguDp6QmZTIbff/9dZb025/jRo0cYPHgw7O3t4eDggBEjRuDJkyc6x8IkyYA2bNiAyZMnIzQ0FNHR0WjSpAm6d++OxMREY4dWbhw4cADjxo3DkSNHEBkZiczMTHTr1g1Pnz6V6oSEhGDbtm3YuHEjDhw4gLt37+KNN94wYtTly/Hjx7F69Wo0btxYpZzn3TAeP36Mtm3bwtzcHDt27MD58+excOFCODo6SnXmz5+PZcuWYdWqVTh69ChsbGzQvXt3pKWlGTHysm/evHlYuXIlVqxYgQsXLmDevHmYP38+li9fLtXhuS++p0+fokmTJvjmm280rtfmHA8ePBjnzp1DZGQktm/fjoMHD2LUqFG6ByPIYFq3bi3GjRsnLWdnZwtPT08xZ84cI0ZVviUmJgoA4sCBA0IIIZKSkoS5ubnYuHGjVOfChQsCgIiKijJWmOVGSkqKqF27toiMjBQBAQHi/fffF0LwvBvShx9+KNq1a5fv+pycHOHu7i4WLFgglSUlJQm5XC5+/vnnkgix3OrVq5d49913VcreeOMNMXjwYCEEz70hABBbtmyRlrU5x+fPnxcAxPHjx6U6O3bsEDKZTNy5c0en47MlyUAyMjJw8uRJBAYGSmUmJiYIDAxEVFSUESMr35KTkwEATk5OAICTJ08iMzNT5X2oV68eqlatyvdBD8aNG4devXqpnF+A592Qtm7dipYtW6Jfv35wdXVFs2bN8P3330vrY2NjkZCQoHLuFQoFfH19ee6Lyd/fH3v27MHly5cBAGfOnMGhQ4fwyiuvAOC5LwnanOOoqCg4ODigZcuWUp3AwECYmJjg6NGjOh2PE9wayIMHD5CdnQ03NzeVcjc3N1y8eNFIUZVvOTk5mDRpEtq2bYuGDRsCABISEmBhYQEHBweVum5ubkhISDBClOXHL7/8gujoaBw/flxtHc+74Vy/fh0rV67E5MmT8dFHH+H48eOYOHEiLCwsMHToUOn8avrbw3NfPNOnT4dSqUS9evVgamqK7OxsfPnllxg8eDAA8NyXAG3OcUJCAlxdXVXWm5mZwcnJSef3gUkSlRvjxo1DTEwMDh06ZOxQyr1bt27h/fffR2RkJCwtLY0dToWSk5ODli1b4quvvgIANGvWDDExMVi1ahWGDh1q5OjKt19//RURERFYv349GjRogNOnT2PSpEnw9PTkuS+neLnNQJydnWFqaqp2N8+9e/fg7u5upKjKr/Hjx2P79u3Yt28fqlSpIpW7u7sjIyMDSUlJKvX5PhTPyZMnkZiYiObNm8PMzAxmZmY4cOAAli1bBjMzM7i5ufG8G4iHhwd8fHxUyurXr4+4uDgAkM4v//bo3wcffIDp06fjrbfeQqNGjfD2228jJCQEc+bMAcBzXxK0Ocfu7u5qN0hlZWXh0aNHOr8PTJIMxMLCAi1atMCePXukspycHOzZswd+fn5GjKx8EUJg/Pjx2LJlC/bu3Qtvb2+V9S1atIC5ubnK+3Dp0iXExcXxfSiGLl264OzZszh9+rT0aNmyJQYPHiw953k3jLZt26oNc3H58mVUq1YNAODt7Q13d3eVc69UKnH06FGe+2JKTU2FiYnqz6apqSlycnIA8NyXBG3OsZ+fH5KSknDy5Empzt69e5GTkwNfX1/dDlisbudUoF9++UXI5XKxdu1acf78eTFq1Cjh4OAgEhISjB1auREcHCwUCoXYv3+/iI+Plx6pqalSnTFjxoiqVauKvXv3ihMnTgg/Pz/h5+dnxKjLp7x3twnB824ox44dE2ZmZuLLL78UV65cEREREcLa2lqEh4dLdebOnSscHBzEH3/8If777z/x2muvCW9vb/Hs2TMjRl72DR06VFSuXFls375dxMbGis2bNwtnZ2cxbdo0qQ7PffGlpKSIU6dOiVOnTgkAYtGiReLUqVPi5s2bQgjtznGPHj1Es2bNxNGjR8WhQ4dE7dq1xcCBA3WOhUmSgS1fvlxUrVpVWFhYiNatW4sjR44YO6RyBYDGR1hYmFTn2bNnYuzYscLR0VFYW1uL119/XcTHxxsv6HLq5SSJ591wtm3bJho2bCjkcrmoV6+e+O6771TW5+TkiE8//VS4ubkJuVwuunTpIi5dumSkaMsPpVIp3n//fVG1alVhaWkpatSoIT7++GORnp4u1eG5L759+/Zp/Ls+dOhQIYR25/jhw4di4MCBwtbWVtjb24vhw4eLlJQUnWORCZFnqFAiIiIiAsA+SUREREQaMUkiIiIi0oBJEhEREZEGTJKIiIiINGCSRERERKQBkyQiIiIiDZgkEREREWnAJImIyrVZs2ahadOmxg5DxXfffQcvLy+YmJhgyZIlJX786tWrG+W4RGUNkySiEhYVFQVTU1P06tXL2KGUCJlMBktLS9y8eVOlvE+fPhg2bJhxgjIipVKJ8ePH48MPP8SdO3cwatQojfVkMpn0MDMzQ9WqVTF58mSkp6eXWKy3b9+GhYUFGjZsqPO2HTt2xKRJk/QfFFEJYpJEVMLWrFmDCRMm4ODBg7h7965BjyWEQFZWlkGPoQ2ZTIaZM2caOwy9yszMLNJ2cXFxyMzMRK9eveDh4QFra+t864aFhSE+Ph6xsbH49ttvsW7dOnzxxRdFDVlna9euRf/+/aUJRI0hIyPDKMclApgkEZWoJ0+eYMOGDQgODkavXr2wdu1aad2gQYMwYMAAlfqZmZlwdnbGTz/9BADIycnBnDlz4O3tDSsrKzRp0gSbNm2S6u/fvx8ymQw7duxAixYtIJfLcejQIVy7dg2vvfYa3NzcYGtri1atWmH37t0qx4qPj0evXr1gZWUFb29vrF+/Xu2yTFJSEt577z24uLjA3t4enTt3xpkzZwp93ePHj0d4eDhiYmLyraPpElDTpk0xa9YsaVkmk2H16tV49dVXYW1tjfr16yMqKgpXr15Fx44dYWNjA39/f1y7dk1t/6tXr4aXlxesra3Rv39/JCcnq6z/3//+h/r168PS0hL16tXDt99+K627ceMGZDIZNmzYgICAAFhaWiIiIkLj64iLi8Nrr70GW1tb2Nvbo3///rh37x6A50lHo0aNAAA1atSATCbDjRs38j0nDg4OcHd3h5eXF1599VW89tpriI6OltZr874mJiYiKChIel/zi/tlQgiEhYXh7bffxqBBg7BmzRq1Ov/++y86duwIa2trODo6onv37nj8+DGGDRuGAwcOYOnSpVJrWO7rPHDgAFq3bg25XA4PDw9Mnz5dJZHv2LEjxo8fj0mTJsHZ2Rndu3eHEAKzZs1C1apVIZfL4enpiYkTJ2r1OoiKpZjz0BGRDtasWSNatmwphHg+SWnNmjVFTk6OEEKI7du3CysrK5VJGLdt2yasrKyEUqkUQgjxxRdfiHr16omdO3eKa9euibCwMCGXy8X+/fuFEC8mhmzcuLHYtWuXuHr1qnj48KE4ffq0WLVqlTh79qy4fPmy+OSTT4SlpaU0q7YQQgQGBoqmTZuKI0eOiJMnT4qAgABhZWUlFi9erFInKChIHD9+XFy+fFlMmTJFVKpUSTx8+DDf1wxAbNmyRfTu3Vv06tVLKn/ttdekCSuFEKJatWoqxxJCiCZNmojQ0FCVfVWuXFls2LBBXLp0SfTp00dUr15ddO7cWezcuVOcP39etGnTRvTo0UPaJjQ0VNjY2IjOnTuLU6dOiQMHDohatWqJQYMGSXXCw8OFh4eH+O2338T169fFb7/9JpycnMTatWuFEELExsYKAKJ69epSnbt376q91uzsbNG0aVPRrl07ceLECXHkyBHRokULERAQIIQQIjU1VezevVsAEMeOHRPx8fEiKyurwPOW69KlS8Lb21vMnj1bKtPmfX3llVdEkyZNRFRUlDhx4oTw9/dXe1812bNnj3B3dxdZWVni7Nmzws7OTjx58kRaf+rUKSGXy0VwcLA4ffq0iImJEcuXLxf3798XSUlJws/PT4wcOVLEx8dLr/P27dvC2tpajB07Vly4cEFs2bJFODs7q7zHAQEBwtbWVnzwwQfi4sWL4uLFi2Ljxo3C3t5e/PXXX+LmzZvi6NGjapP6EhkCkySiEuTv7y+WLFkihBAiMzNTODs7i3379qks//TTT1L9gQMHigEDBgghhEhLSxPW1tbi8OHDKvscMWKEGDhwoBDiRZL0+++/FxpLgwYNxPLly4UQQly4cEEAEMePH5fWX7lyRQCQfkz/+ecfYW9vL9LS0lT2U7NmTbF69ep8j5P7Y3/u3DlhamoqDh48KIQoepL0ySefSMtRUVECgFizZo1U9vPPPwtLS0tpOTQ0VJiamorbt29LZTt27BAmJiYiPj5eeg3r169XOfbnn38u/Pz8hBAvkqTc9y4/u3btEqampiIuLk4qO3funJQUCfE8uQAgYmNjC9wXAGFpaSlsbGyEXC4XAMSrr74qMjIyCtwu7/t66dIllWML8eK9LixJGjRokJg0aZK03KRJExEWFiYtDxw4ULRt2zbf7QMCAsT777+vUvbRRx+JunXrSv8xEEKIb775Rtja2ors7Gxpu2bNmqlst3DhQlGnTp1CXzuRvvFyG1EJuXTpEo4dO4aBAwcCAMzMzDBgwADpMoaZmRn69+8vXQ55+vQp/vjjDwwePBgAcPXqVaSmpqJr166wtbWVHj/99JPa5aWWLVuqLD958gRTp05F/fr14eDgAFtbW1y4cAFxcXFSbGZmZmjevLm0Ta1ateDo6CgtnzlzBk+ePEGlSpVUjh8bG6vx8tbLfHx88M4772D69Om6njoVjRs3lp67ubkBgHQJK7csLS0NSqVSKqtatSoqV64sLfv5+SEnJweXLl3C06dPce3aNYwYMULldX3xxReFnteXXbhwAV5eXvDy8pLKfHx84ODggAsXLuj8WhcvXozTp0/jzJkz2L59Oy5fvoy3335bWl/Y+3rhwgWYmZmhRYsW0jb16tWDg4NDgcdNSkrC5s2bMWTIEKlsyJAhKpfcTp8+jS5duuj0ei5cuAA/Pz/IZDKprG3btnjy5Alu374tleWNFwD69euHZ8+eoUaNGhg5ciS2bNlSKvraUflnZuwAiCqKNWvWICsrC56enlKZEAJyuRwrVqyAQqHA4MGDERAQgMTERERGRsLKygo9evQA8PwHEQD+/PNPlR98AJDL5SrLNjY2KstTp05FZGQkvv76a9SqVQtWVlZ48803deoU++TJE3h4eGD//v1q6wr70c01e/Zs1KlTB7///rvaOhMTEwghVMo0dY42NzeXnuf+2Goqy8nJ0Sqm3PP6/fffw9fXV2WdqampyvLL59XQ3N3dUatWLQBA3bp1kZKSgoEDB+KLL75ArVq19PK+arJ+/XqkpaWpnA8hBHJycnD58mXUqVMHVlZWxTpGQV4+z15eXrh06RJ2796NyMhIjB07FgsWLMCBAwdU3nsifWNLElEJyMrKwk8//YSFCxfi9OnT0uPMmTPw9PTEzz//DADw9/eHl5cXNmzYgIiICPTr10/6EfDx8YFcLkdcXBxq1aql8sjbcqHJv//+i2HDhuH1119Ho0aN4O7urtJhuG7dusjKysKpU6eksqtXr+Lx48fScvPmzZGQkAAzMzO14zs7O2t1Hry8vDB+/Hh89NFHyM7OVlnn4uKC+Ph4aVmpVCI2Nlar/RYmLi5O5U7CI0eOwMTEBHXr1oWbmxs8PT1x/fp1tdfl7e2t03Hq16+PW7du4datW1LZ+fPnkZSUBB8fn2K/jtyk7dmzZwAKf1/r1auHrKwsnDx5Uiq7dOkSkpKSCjzOmjVrMGXKFLXPavv27fHDDz8AeN6it2fPnnz3YWFhofYe53a0z5sM//vvv7Czs0OVKlUKjMnKygpBQUFYtmwZ9u/fj6ioKJw9e7bAbYiKiy1JRCVg+/btePz4MUaMGAGFQqGyrm/fvlizZg3GjBkD4PldbqtWrcLly5exb98+qZ6dnR2mTp2KkJAQ5OTkoF27dkhOTsa///4Le3t7DB06NN/j165dG5s3b0ZQUBBkMhk+/fRTlZaWevXqITAwEKNGjcLKlSthbm6OKVOmwMrKSmqZCQwMhJ+fH/r06YP58+ejTp06uHv3Lv7880+8/vrrhV6KyjVjxgx8//33iI2NVbmbr3Pnzli7di2CgoLg4OCAmTNnqrXkFJWlpSWGDh2Kr7/+GkqlEhMnTkT//v3h7u4O4HkL18SJE6FQKNCjRw+kp6fjxIkTePz4MSZPnqz1cQIDA9GoUSMMHjwYS5YsQVZWFsaOHYuAgACtz09eSUlJSEhIQE5ODq5cuYLPPvsMderUQf369QEU/r7WrVsXPXr0wOjRo7Fy5UqYmZlh0qRJBbYCnT59GtHR0YiIiEC9evVU1g0cOBCfffYZvvjiC8yYMQONGjXC2LFjMWbMGFhYWGDfvn3o168fnJ2dUb16dRw9ehQ3btyAra0tnJycMHbsWCxZsgQTJkzA+PHjcenSJYSGhmLy5MkwMcn//+xr165FdnY2fH19YW1tjfDwcFhZWaFatWo6n1MinRi3SxRRxfDqq6+Knj17alx39OhRAUCcOXNGCCHE+fPnBQBRrVo1lQ6uQgiRk5MjlixZIurWrSvMzc2Fi4uL6N69uzhw4IAQ4kXH7cePH6tsFxsbKzp16iSsrKyEl5eXWLFihVrH2rt374pXXnlFyOVyUa1aNbF+/Xrh6uoqVq1aJdVRKpViwoQJwtPTU5ibmwsvLy8xePBglY7KL8NLd2kJIcRXX30lAKh03E5OThYDBgwQ9vb2wsvLS6xdu1Zjx+28+8rtUH3q1Cmp7OVzEBoaKpo0aSK+/fZb4enpKSwtLcWbb74pHj16pBJTRESEaNq0qbCwsBCOjo6iQ4cOYvPmzfkeJz83b94UvXv3FjY2NsLOzk7069dPJCQkSOt16bid+5DJZMLDw0MMGDBAXLt2TeX1F/a+xsfHi169egm5XC6qVq0qfvrpJ42d5HONHz9e+Pj4aFwXHx8vTExMxB9//CGEEGL//v3C399fyOVy4eDgILp37y6d90uXLok2bdoIKysrlde7f/9+0apVK2FhYSHc3d3Fhx9+KDIzM6VjaOrwvWXLFuHr6yvs7e2FjY2NaNOmjdi9e3eB549IH2RCvNQJgIgIz0db9vLywu7du3XuoEtEVB4wSSIiAMDevXvx5MkTNGrUCPHx8Zg2bRru3LmDy5cvs3MsEVVI7JNERACe30n20Ucf4fr167Czs4O/vz8iIiKYIBFRhcWWJCIiIiINOAQAERERkQZMkoiIiIg0YJJEREREpAGTJCIiIiINmCQRERERacAkiYiIiEgDJklEREREGjBJIiIiItKASRIRERGRBv8He1la4pTEnpYAAAAASUVORK5CYII=\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file From 8b554717ee0ef631fab3b76fc459bde2b9e00bb1 Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Sat, 6 Sep 2025 02:04:24 -0400 Subject: [PATCH 6/7] global best selection, unstable as population size increases --- MNIST_Evolutionary_vs_Adam_Training.ipynb | 1919 +++++++++++++++++++++ 1 file changed, 1919 insertions(+) create mode 100644 MNIST_Evolutionary_vs_Adam_Training.ipynb diff --git a/MNIST_Evolutionary_vs_Adam_Training.ipynb b/MNIST_Evolutionary_vs_Adam_Training.ipynb new file mode 100644 index 0000000..6465336 --- /dev/null +++ b/MNIST_Evolutionary_vs_Adam_Training.ipynb @@ -0,0 +1,1919 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torchvision\n", + "import torchvision.transforms as transforms\n", + "import os\n", + "from tqdm import tqdm\n", + "import matplotlib.pyplot as plt\n", + "import itertools\n", + "\n", + "# --- 1. Hyperparameters and Configuration ---\n", + "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "INPUT_SIZE = 28 * 28 # MNIST image dimensions\n", + "NUM_CLASSES = 10\n", + "BATCH_SIZE = 1024 # Increased for faster debugging iterations\n", + "LEARNING_RATE_ADAM = 0.001\n", + "EPOCHS = 5 # Number of epochs for both Adam and EA\n", + "\n", + "# Evolutionary Algorithm Parameters\n", + "POPULATION_SIZE = 500 # Number of models in the population\n", + "BATCHES_PER_GENERATION = 3 # Number of batches to evaluate generation on before evolutionary step\n", + "MUTATION_RESET_PROB = 0.00001 # Probability for each weight to be reset to a new random value.\n", + "SELECTION_RATE = 0.2 # Top 20% of models are selected for reproduction\n", + "ELITISM_RATE = 0.05 # Keep the top 5% of models unchanged in the next generation\n", + "\n", + "# --- 2. Model Architecture ---\n", + "# A simple MLP suitable for MNIST\n", + "class SimpleNet(nn.Module):\n", + " def __init__(self):\n", + " super(SimpleNet, self).__init__()\n", + " self.fc1 = nn.Linear(INPUT_SIZE, 256)\n", + " self.relu1 = nn.ReLU()\n", + " self.fc2 = nn.Linear(256, 128)\n", + " self.relu2 = nn.ReLU()\n", + " self.fc3 = nn.Linear(128, NUM_CLASSES)\n", + "\n", + " def forward(self, x):\n", + " x = x.view(-1, INPUT_SIZE) # Flatten the image\n", + " out = self.fc1(x)\n", + " out = self.relu1(out)\n", + " out = self.fc2(out)\n", + " out = self.relu2(out)\n", + " out = self.fc3(out)\n", + " return out\n", + "\n", + "# --- 3. Evolutionary Operators ---\n", + "def crossover(parent1, parent2):\n", + " \"\"\"Performs uniform crossover between two parent models.\"\"\"\n", + " child = SimpleNet().to(DEVICE)\n", + " child_dict = child.state_dict()\n", + " parent1_dict = parent1.state_dict()\n", + " parent2_dict = parent2.state_dict()\n", + "\n", + " for key in parent1_dict.keys():\n", + " # Create a random binary mask\n", + " mask = torch.randint(0, 2, size=parent1_dict[key].shape, device=DEVICE).float()\n", + " # Combine weights from both parents\n", + " child_dict[key] = (parent1_dict[key] * mask) + (parent2_dict[key] * (1 - mask))\n", + "\n", + " child.load_state_dict(child_dict)\n", + " return child\n", + "\n", + "def mutate(model):\n", + " \"\"\"\n", + " Performs reset mutation. A small fraction of weights are reset to new\n", + " random values drawn from a standard normal distribution.\n", + " \"\"\"\n", + " with torch.no_grad():\n", + " for param in model.parameters():\n", + " # Create a boolean mask to select which individual weights to mutate\n", + " mask = torch.rand_like(param.data) < MUTATION_RESET_PROB\n", + "\n", + " # Generate new random weights for the selected positions\n", + " new_weights = torch.randn_like(param.data)\n", + "\n", + " # Apply the mask: keep old weights where mask is False,\n", + " # and use new random weights where mask is True.\n", + " param.data[mask] = new_weights[mask]\n", + " return model\n", + "\n", + "# --- 4. Data Loading ---\n", + "def get_data_loaders():\n", + " \"\"\"Prepares the MNIST train and test data loaders.\"\"\"\n", + " transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])\n", + " data_path = './data'\n", + " if not os.path.exists(data_path): os.makedirs(data_path)\n", + " train_dataset = torchvision.datasets.MNIST(root=data_path, train=True, transform=transform, download=True)\n", + " test_dataset = torchvision.datasets.MNIST(root=data_path, train=False, transform=transform, download=True)\n", + " train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n", + " test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=False)\n", + " return train_loader, test_loader\n", + "\n", + "# --- 5. Evaluation Function ---\n", + "def evaluate_model(model, loader):\n", + " \"\"\"Calculates the accuracy of a model on a given data loader.\"\"\"\n", + " model.eval()\n", + " with torch.no_grad():\n", + " correct, total = 0, 0\n", + " for images, labels in loader:\n", + " images, labels = images.to(DEVICE), labels.to(DEVICE)\n", + " outputs = model(images)\n", + " _, predicted = torch.max(outputs.data, 1)\n", + " total += labels.size(0)\n", + " correct += (predicted == labels).sum().item()\n", + " return 100 * correct / total\n", + "\n", + "# --- 6. Plotting Function ---\n", + "def plot_performance(adam_history, ea_history):\n", + " \"\"\"Plots the sample efficiency of Adam vs. EA.\"\"\"\n", + " plt.figure(figsize=(12, 7))\n", + "\n", + " if adam_history:\n", + " adam_batches, adam_accs = zip(*adam_history)\n", + " plt.plot(adam_batches, adam_accs, label='Adam Optimizer', color='blue', marker='o', markersize=4, linestyle='--')\n", + "\n", + " if ea_history:\n", + " ea_batches, ea_accs = zip(*ea_history)\n", + " plt.plot(ea_batches, ea_accs, label='Evolutionary Algorithm', color='green', marker='x', markersize=4)\n", + "\n", + " plt.title('Sample Efficiency: Adam vs. Evolutionary Algorithm')\n", + " plt.xlabel('Number of Batches Processed')\n", + " plt.ylabel('Test Accuracy (%)')\n", + " plt.grid(True)\n", + " plt.legend()\n", + " plt.tight_layout()\n", + " plt.savefig('performance_comparison.png')\n", + " print(\"\\nPerformance plot saved to 'performance_comparison.png'\")\n", + " plt.show()\n", + "\n", + "# --- 7. Main Execution ---\n", + "def main():\n", + " if not torch.cuda.is_available():\n", + " print(\"CUDA not available. This script is designed for GPU acceleration.\")\n", + " return\n", + "\n", + " print(f\"Using device: {DEVICE}\")\n", + " train_loader, test_loader = get_data_loaders()\n", + " loss_fn = nn.CrossEntropyLoss()\n", + "\n", + " total_batches_per_epoch = len(train_loader)\n", + " total_batches = total_batches_per_epoch * EPOCHS\n", + " NUM_GENERATIONS = total_batches // BATCHES_PER_GENERATION\n", + "\n", + " print(f\"Both algorithms will run for approx {total_batches} batches.\")\n", + " print(f\"EA will run for {NUM_GENERATIONS} generations of {BATCHES_PER_GENERATION} batches each.\")\n", + "\n", + " adam_history = []\n", + " ea_history = []\n", + "\n", + " # --- Part A: Train a population with an Evolutionary Algorithm ---\n", + " print(\"\\n--- Training Population with Evolutionary Algorithm ---\")\n", + " population = [SimpleNet().to(DEVICE) for _ in range(POPULATION_SIZE)]\n", + " for model in population: model.eval()\n", + " streams = [torch.cuda.Stream() for _ in range(POPULATION_SIZE)]\n", + "\n", + " batch_counter_ea = 0\n", + " train_iterator = iter(itertools.cycle(train_loader))\n", + "\n", + " for generation in tqdm(range(NUM_GENERATIONS), desc=\"EA Generations\"):\n", + " # --- IMPROVEMENT: Aggregate fitness over multiple batches for stability ---\n", + " cumulative_fitness_scores = torch.zeros(POPULATION_SIZE, device=DEVICE)\n", + "\n", + " for batch_idx in range(BATCHES_PER_GENERATION):\n", + " images, labels = next(train_iterator)\n", + " images, labels = images.to(DEVICE), labels.to(DEVICE)\n", + "\n", + " with torch.no_grad():\n", + " for i in range(POPULATION_SIZE):\n", + " with torch.cuda.stream(streams[i]):\n", + " outputs = population[i](images)\n", + " loss = loss_fn(outputs, labels)\n", + " # Accumulate the fitness (negative loss) from each batch\n", + " cumulative_fitness_scores[i] += -loss\n", + "\n", + " torch.cuda.synchronize() # Wait for all streams to finish their batch\n", + "\n", + " batch_counter_ea += BATCHES_PER_GENERATION\n", + "\n", + " # Use the stable, cumulative fitness for selection and diagnostics\n", + " fitness_scores = cumulative_fitness_scores\n", + "\n", + " best_fitness = fitness_scores.max().item() / BATCHES_PER_GENERATION # Average per batch\n", + " avg_fitness = fitness_scores.mean().item() / BATCHES_PER_GENERATION # Average per batch\n", + " print(f\"\\n[Gen {generation+1}/{NUM_GENERATIONS}] Best Fitness: {best_fitness:.4f}, Pop Avg Fitness: {avg_fitness:.4f}\")\n", + "\n", + " # --- Selection ---\n", + " sorted_indices = torch.argsort(fitness_scores, descending=True)\n", + " num_elites = int(POPULATION_SIZE * SELECTION_RATE)\n", + " elite_indices = sorted_indices[:num_elites]\n", + "\n", + " # --- Reproduction with True Elitism ---\n", + " num_to_keep = int(POPULATION_SIZE * ELITISM_RATE)\n", + "\n", + " # Start the new population with the best, unchanged models\n", + " new_population = [population[i] for i in elite_indices[:num_to_keep]]\n", + "\n", + " # Fill the rest of the population with children from the elite pool\n", + " num_children_to_create = POPULATION_SIZE - num_to_keep\n", + " with torch.no_grad():\n", + " for _ in range(num_children_to_create):\n", + " p1_idx = elite_indices[torch.randint(0, num_elites, (1,)).item()]\n", + " p2_idx = elite_indices[torch.randint(0, num_elites, (1,)).item()]\n", + " parent1 = population[p1_idx]\n", + " parent2 = population[p2_idx]\n", + " child = crossover(parent1, parent2)\n", + " child = mutate(child)\n", + " child.eval()\n", + " new_population.append(child)\n", + " population = new_population\n", + "\n", + " # --- Track Performance ---\n", + " accuracy = evaluate_model(population[0], test_loader)\n", + " ea_history.append((batch_counter_ea, accuracy))\n", + " print(f\" -> Best Model Test Accuracy: {accuracy:.2f}%\")\n", + "\n", + " # --- Part B: Train a model with Adam Optimizer (Baseline) ---\n", + " print(\"\\n--- Training Baseline Model with Adam Optimizer ---\")\n", + " adam_model = SimpleNet().to(DEVICE)\n", + " optimizer = torch.optim.Adam(adam_model.parameters(), lr=LEARNING_RATE_ADAM)\n", + " batch_counter = 0\n", + "\n", + " for epoch in range(EPOCHS):\n", + " adam_model.train()\n", + " for images, labels in tqdm(train_loader, desc=f\"Adam Epoch {epoch+1}/{EPOCHS}\"):\n", + " images, labels = images.to(DEVICE), labels.to(DEVICE)\n", + " outputs = adam_model(images)\n", + " loss = loss_fn(outputs, labels)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " batch_counter += 1\n", + " if batch_counter % BATCHES_PER_GENERATION == 0 or batch_counter >= total_batches:\n", + " accuracy = evaluate_model(adam_model, test_loader)\n", + " adam_history.append((batch_counter, accuracy))\n", + "\n", + " # --- Final Comparison ---\n", + " print(\"\\n--- Final Results ---\")\n", + " adam_accuracy = evaluate_model(adam_model, test_loader) if adam_history else 0\n", + " ea_accuracy = evaluate_model(population[0], test_loader) if ea_history else 0\n", + " print(f\"Final Adam Model Accuracy: {adam_accuracy:.2f}%\")\n", + " print(f\"Final Best EA Model Accuracy: {ea_accuracy:.2f}%\")\n", + "\n", + " # --- Plotting ---\n", + " plot_performance(adam_history, ea_history)\n", + "\n", + "if __name__ == \"__main__\":\n", + " main()\n", + "\n", + "\n" + ], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using device: cuda\n", + "Both algorithms will run for approx 295 batches.\n", + "EA will run for 98 generations of 3 batches each.\n", + "\n", + "--- Training Population with Evolutionary Algorithm ---\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 0%| | 0/98 [00:00 Best Model Test Accuracy: 10.41%\n", + "\n", + "[Gen 2/98] Best Fitness: -2.2891, Pop Avg Fitness: -2.3053\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 2%|▏ | 2/98 [00:09<08:00, 5.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 11.85%\n", + "\n", + "[Gen 3/98] Best Fitness: -2.2847, Pop Avg Fitness: -2.3054\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 3%|▎ | 3/98 [00:14<07:52, 4.98s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 11.85%\n", + "\n", + "[Gen 4/98] Best Fitness: -2.2765, Pop Avg Fitness: -2.3042\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 4%|▍ | 4/98 [00:19<07:43, 4.93s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 5/98] Best Fitness: -2.2766, Pop Avg Fitness: -2.3039\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 5%|▌ | 5/98 [00:25<07:54, 5.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 6/98] Best Fitness: -2.2724, Pop Avg Fitness: -2.3025\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 6%|▌ | 6/98 [00:29<07:33, 4.93s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 7/98] Best Fitness: -2.2768, Pop Avg Fitness: -2.3020\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 7%|▋ | 7/98 [00:35<07:50, 5.17s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 8/98] Best Fitness: -2.2746, Pop Avg Fitness: -2.3011\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 8%|▊ | 8/98 [00:40<07:31, 5.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 9/98] Best Fitness: -2.2737, Pop Avg Fitness: -2.3021\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 9%|▉ | 9/98 [00:44<07:16, 4.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 10/98] Best Fitness: -2.2780, Pop Avg Fitness: -2.3039\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 10%|█ | 10/98 [00:50<07:23, 5.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 11/98] Best Fitness: -2.2741, Pop Avg Fitness: -2.3012\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 11%|█ | 11/98 [00:54<07:13, 4.99s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 12/98] Best Fitness: -2.2784, Pop Avg Fitness: -2.3032\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 12%|█▏ | 12/98 [01:00<07:19, 5.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 17.94%\n", + "\n", + "[Gen 13/98] Best Fitness: -2.2767, Pop Avg Fitness: -2.3014\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 13%|█▎ | 13/98 [01:05<07:03, 4.99s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 14/98] Best Fitness: -2.2771, Pop Avg Fitness: -2.3010\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 14%|█▍ | 14/98 [01:10<07:12, 5.15s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 15/98] Best Fitness: -2.2753, Pop Avg Fitness: -2.2992\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 15%|█▌ | 15/98 [01:15<07:08, 5.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 13.73%\n", + "\n", + "[Gen 16/98] Best Fitness: -2.2746, Pop Avg Fitness: -2.2973\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 16%|█▋ | 16/98 [01:20<06:53, 5.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 24.61%\n", + "\n", + "[Gen 17/98] Best Fitness: -2.2697, Pop Avg Fitness: -2.2934\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 17%|█▋ | 17/98 [01:26<07:05, 5.26s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 18.22%\n", + "\n", + "[Gen 18/98] Best Fitness: -2.2676, Pop Avg Fitness: -2.2885\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 18%|█▊ | 18/98 [01:30<06:46, 5.09s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 22.46%\n", + "\n", + "[Gen 19/98] Best Fitness: -2.2640, Pop Avg Fitness: -2.2835\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 19%|█▉ | 19/98 [01:36<06:55, 5.26s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 25.68%\n", + "\n", + "[Gen 20/98] Best Fitness: -2.2630, Pop Avg Fitness: -2.2770\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 20%|██ | 20/98 [01:41<06:30, 5.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 10.71%\n", + "\n", + "[Gen 21/98] Best Fitness: -2.2566, Pop Avg Fitness: -2.2746\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 21%|██▏ | 21/98 [01:45<06:05, 4.75s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 25.36%\n", + "\n", + "[Gen 22/98] Best Fitness: -2.2524, Pop Avg Fitness: -2.2716\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 22%|██▏ | 22/98 [01:50<06:09, 4.87s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 24.24%\n", + "\n", + "[Gen 23/98] Best Fitness: -2.2504, Pop Avg Fitness: -2.2684\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 23%|██▎ | 23/98 [01:54<05:48, 4.65s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 30.25%\n", + "\n", + "[Gen 24/98] Best Fitness: -2.2488, Pop Avg Fitness: -2.2665\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 24%|██▍ | 24/98 [01:58<05:35, 4.53s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 19.94%\n", + "\n", + "[Gen 25/98] Best Fitness: -2.2393, Pop Avg Fitness: -2.2606\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 26%|██▌ | 25/98 [02:03<05:42, 4.70s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 15.35%\n", + "\n", + "[Gen 26/98] Best Fitness: -2.2396, Pop Avg Fitness: -2.2549\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 27%|██▋ | 26/98 [02:07<05:26, 4.54s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 25.58%\n", + "\n", + "[Gen 27/98] Best Fitness: -2.2249, Pop Avg Fitness: -2.2495\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 28%|██▊ | 27/98 [02:12<05:28, 4.63s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 29.27%\n", + "\n", + "[Gen 28/98] Best Fitness: -2.2271, Pop Avg Fitness: -2.2472\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 29%|██▊ | 28/98 [02:17<05:15, 4.50s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 22.35%\n", + "\n", + "[Gen 29/98] Best Fitness: -2.2173, Pop Avg Fitness: -2.2406\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 30%|██▉ | 29/98 [02:21<05:07, 4.45s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 31.88%\n", + "\n", + "[Gen 30/98] Best Fitness: -2.2168, Pop Avg Fitness: -2.2359\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 31%|███ | 30/98 [02:26<05:10, 4.57s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 31.88%\n", + "\n", + "[Gen 31/98] Best Fitness: -2.2001, Pop Avg Fitness: -2.2303\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 32%|███▏ | 31/98 [02:30<04:55, 4.42s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 26.36%\n", + "\n", + "[Gen 32/98] Best Fitness: -2.1924, Pop Avg Fitness: -2.2241\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 33%|███▎ | 32/98 [02:34<04:50, 4.39s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 22.14%\n", + "\n", + "[Gen 33/98] Best Fitness: -2.1895, Pop Avg Fitness: -2.2192\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 34%|███▎ | 33/98 [02:39<04:54, 4.54s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 24.95%\n", + "\n", + "[Gen 34/98] Best Fitness: -2.1673, Pop Avg Fitness: -2.2108\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 35%|███▍ | 34/98 [02:43<04:41, 4.39s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 32.35%\n", + "\n", + "[Gen 35/98] Best Fitness: -2.1649, Pop Avg Fitness: -2.1991\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 36%|███▌ | 35/98 [02:48<04:39, 4.44s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 32.35%\n", + "\n", + "[Gen 36/98] Best Fitness: -2.1541, Pop Avg Fitness: -2.1868\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 37%|███▋ | 36/98 [02:52<04:37, 4.47s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 31.22%\n", + "\n", + "[Gen 37/98] Best Fitness: -2.1471, Pop Avg Fitness: -2.1797\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 38%|███▊ | 37/98 [02:56<04:25, 4.35s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 22.85%\n", + "\n", + "[Gen 38/98] Best Fitness: -2.1362, Pop Avg Fitness: -2.1685\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 39%|███▉ | 38/98 [03:01<04:32, 4.55s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 23.29%\n", + "\n", + "[Gen 39/98] Best Fitness: -2.1250, Pop Avg Fitness: -2.1709\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 40%|███▉ | 39/98 [03:05<04:19, 4.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 33.21%\n", + "\n", + "[Gen 40/98] Best Fitness: -2.1173, Pop Avg Fitness: -2.1454\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 41%|████ | 40/98 [03:09<04:09, 4.31s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 33.21%\n", + "\n", + "[Gen 41/98] Best Fitness: -2.1189, Pop Avg Fitness: -2.1460\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 42%|████▏ | 41/98 [03:14<04:13, 4.45s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 38.08%\n", + "\n", + "[Gen 42/98] Best Fitness: -2.1092, Pop Avg Fitness: -2.1330\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 43%|████▎ | 42/98 [03:18<04:06, 4.41s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 28.33%\n", + "\n", + "[Gen 43/98] Best Fitness: -2.0944, Pop Avg Fitness: -2.1277\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 44%|████▍ | 43/98 [03:23<03:57, 4.31s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 27.23%\n", + "\n", + "[Gen 44/98] Best Fitness: -2.0768, Pop Avg Fitness: -2.1170\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 45%|████▍ | 44/98 [03:28<04:06, 4.56s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 35.24%\n", + "\n", + "[Gen 45/98] Best Fitness: -2.0563, Pop Avg Fitness: -2.1001\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 46%|████▌ | 45/98 [03:32<03:53, 4.41s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 34.99%\n", + "\n", + "[Gen 46/98] Best Fitness: -2.0665, Pop Avg Fitness: -2.0998\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 47%|████▋ | 46/98 [03:36<03:47, 4.38s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 34.99%\n", + "\n", + "[Gen 47/98] Best Fitness: -2.0385, Pop Avg Fitness: -2.0723\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 48%|████▊ | 47/98 [03:41<03:49, 4.51s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 34.91%\n", + "\n", + "[Gen 48/98] Best Fitness: -2.0381, Pop Avg Fitness: -2.0789\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 49%|████▉ | 48/98 [03:45<03:39, 4.39s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 33.63%\n", + "\n", + "[Gen 49/98] Best Fitness: -2.0245, Pop Avg Fitness: -2.0627\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 50%|█████ | 49/98 [03:50<03:40, 4.50s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 42.47%\n", + "\n", + "[Gen 50/98] Best Fitness: -2.0149, Pop Avg Fitness: -2.0587\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 51%|█████ | 50/98 [03:54<03:30, 4.38s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 36.66%\n", + "\n", + "[Gen 51/98] Best Fitness: -1.9794, Pop Avg Fitness: -2.0371\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 52%|█████▏ | 51/98 [03:58<03:25, 4.36s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 32.02%\n", + "\n", + "[Gen 52/98] Best Fitness: -1.9800, Pop Avg Fitness: -2.0335\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 53%|█████▎ | 52/98 [04:03<03:27, 4.50s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 37.43%\n", + "\n", + "[Gen 53/98] Best Fitness: -1.9729, Pop Avg Fitness: -2.0245\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 54%|█████▍ | 53/98 [04:07<03:17, 4.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 36.12%\n", + "\n", + "[Gen 54/98] Best Fitness: -1.9206, Pop Avg Fitness: -2.0115\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 55%|█████▌ | 54/98 [04:11<03:12, 4.37s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 39.22%\n", + "\n", + "[Gen 55/98] Best Fitness: -1.9247, Pop Avg Fitness: -1.9893\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 56%|█████▌ | 55/98 [04:16<03:14, 4.52s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 41.40%\n", + "\n", + "[Gen 56/98] Best Fitness: -1.8812, Pop Avg Fitness: -1.9693\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 57%|█████▋ | 56/98 [04:20<03:04, 4.38s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 45.98%\n", + "\n", + "[Gen 57/98] Best Fitness: -1.8936, Pop Avg Fitness: -1.9572\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 58%|█████▊ | 57/98 [04:25<03:03, 4.46s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 45.98%\n", + "\n", + "[Gen 58/98] Best Fitness: -1.8691, Pop Avg Fitness: -1.9242\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 59%|█████▉ | 58/98 [04:30<02:59, 4.48s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 39.84%\n", + "\n", + "[Gen 59/98] Best Fitness: -1.8711, Pop Avg Fitness: -1.9211\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 60%|██████ | 59/98 [04:34<02:51, 4.39s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 44.56%\n", + "\n", + "[Gen 60/98] Best Fitness: -1.8410, Pop Avg Fitness: -1.8939\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 61%|██████ | 60/98 [04:39<02:54, 4.59s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 41.58%\n", + "\n", + "[Gen 61/98] Best Fitness: -1.8059, Pop Avg Fitness: -1.8764\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 62%|██████▏ | 61/98 [04:43<02:45, 4.46s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 47.60%\n", + "\n", + "[Gen 62/98] Best Fitness: -1.8060, Pop Avg Fitness: -1.8581\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 63%|██████▎ | 62/98 [04:47<02:37, 4.38s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 39.55%\n", + "\n", + "[Gen 63/98] Best Fitness: -1.8009, Pop Avg Fitness: -1.8436\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 64%|██████▍ | 63/98 [04:52<02:38, 4.53s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 40.76%\n", + "\n", + "[Gen 64/98] Best Fitness: -1.7584, Pop Avg Fitness: -1.8165\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 65%|██████▌ | 64/98 [04:56<02:31, 4.46s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 43.08%\n", + "\n", + "[Gen 65/98] Best Fitness: -1.7635, Pop Avg Fitness: -1.8035\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 66%|██████▋ | 65/98 [05:00<02:23, 4.36s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 42.16%\n", + "\n", + "[Gen 66/98] Best Fitness: -1.7352, Pop Avg Fitness: -1.7903\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 67%|██████▋ | 66/98 [05:06<02:27, 4.60s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 48.63%\n", + "\n", + "[Gen 67/98] Best Fitness: -1.7151, Pop Avg Fitness: -1.7677\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 68%|██████▊ | 67/98 [05:10<02:18, 4.45s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 50.36%\n", + "\n", + "[Gen 68/98] Best Fitness: -1.6869, Pop Avg Fitness: -1.7435\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 69%|██████▉ | 68/98 [05:14<02:13, 4.46s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 49.06%\n", + "\n", + "[Gen 69/98] Best Fitness: -1.6980, Pop Avg Fitness: -1.7551\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 70%|███████ | 69/98 [05:19<02:11, 4.52s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 49.50%\n", + "\n", + "[Gen 70/98] Best Fitness: -1.6789, Pop Avg Fitness: -1.7233\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 71%|███████▏ | 70/98 [05:23<02:03, 4.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 49.78%\n", + "\n", + "[Gen 71/98] Best Fitness: -1.6869, Pop Avg Fitness: -1.7367\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 72%|███████▏ | 71/98 [05:28<02:01, 4.51s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 49.19%\n", + "\n", + "[Gen 72/98] Best Fitness: -1.6406, Pop Avg Fitness: -1.6963\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 73%|███████▎ | 72/98 [05:32<01:53, 4.38s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 52.44%\n", + "\n", + "[Gen 73/98] Best Fitness: -1.6397, Pop Avg Fitness: -1.6920\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 74%|███████▍ | 73/98 [05:36<01:49, 4.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 49.57%\n", + "\n", + "[Gen 74/98] Best Fitness: -1.6191, Pop Avg Fitness: -1.6638\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 76%|███████▌ | 74/98 [05:41<01:49, 4.55s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 50.43%\n", + "\n", + "[Gen 75/98] Best Fitness: -1.6108, Pop Avg Fitness: -1.6611\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 77%|███████▋ | 75/98 [05:45<01:41, 4.43s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 52.07%\n", + "\n", + "[Gen 76/98] Best Fitness: -1.6149, Pop Avg Fitness: -1.6619\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 78%|███████▊ | 76/98 [05:50<01:37, 4.45s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 56.17%\n", + "\n", + "[Gen 77/98] Best Fitness: -1.6092, Pop Avg Fitness: -1.6432\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 79%|███████▊ | 77/98 [05:54<01:34, 4.49s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 51.62%\n", + "\n", + "[Gen 78/98] Best Fitness: -1.5868, Pop Avg Fitness: -1.6356\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 80%|███████▉ | 78/98 [05:58<01:27, 4.37s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 55.50%\n", + "\n", + "[Gen 79/98] Best Fitness: -1.5907, Pop Avg Fitness: -1.6402\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 81%|████████ | 79/98 [06:03<01:26, 4.55s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 56.60%\n", + "\n", + "[Gen 80/98] Best Fitness: -1.5624, Pop Avg Fitness: -1.6015\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 82%|████████▏ | 80/98 [06:08<01:20, 4.47s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 56.78%\n", + "\n", + "[Gen 81/98] Best Fitness: -1.5446, Pop Avg Fitness: -1.5922\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 83%|████████▎ | 81/98 [06:12<01:14, 4.37s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 56.97%\n", + "\n", + "[Gen 82/98] Best Fitness: -1.5382, Pop Avg Fitness: -1.5784\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 84%|████████▎ | 82/98 [06:17<01:13, 4.57s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 56.97%\n", + "\n", + "[Gen 83/98] Best Fitness: -1.5310, Pop Avg Fitness: -1.5718\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 85%|████████▍ | 83/98 [06:21<01:06, 4.42s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 53.19%\n", + "\n", + "[Gen 84/98] Best Fitness: -1.5178, Pop Avg Fitness: -1.5556\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 86%|████████▌ | 84/98 [06:25<01:00, 4.32s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 56.67%\n", + "\n", + "[Gen 85/98] Best Fitness: -1.5000, Pop Avg Fitness: -1.5426\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 87%|████████▋ | 85/98 [06:30<00:58, 4.48s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 57.87%\n", + "\n", + "[Gen 86/98] Best Fitness: -1.4661, Pop Avg Fitness: -1.5139\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 88%|████████▊ | 86/98 [06:34<00:53, 4.42s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 58.75%\n", + "\n", + "[Gen 87/98] Best Fitness: -1.4799, Pop Avg Fitness: -1.5356\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 89%|████████▉ | 87/98 [06:39<00:48, 4.41s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 58.94%\n", + "\n", + "[Gen 88/98] Best Fitness: -1.4430, Pop Avg Fitness: -1.4835\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 90%|████████▉ | 88/98 [06:43<00:45, 4.52s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 58.94%\n", + "\n", + "[Gen 89/98] Best Fitness: -1.4568, Pop Avg Fitness: -1.5003\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 91%|█████████ | 89/98 [06:47<00:39, 4.39s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 59.86%\n", + "\n", + "[Gen 90/98] Best Fitness: -1.4416, Pop Avg Fitness: -1.4828\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 92%|█████████▏| 90/98 [06:52<00:36, 4.51s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 60.92%\n", + "\n", + "[Gen 91/98] Best Fitness: -1.4450, Pop Avg Fitness: -1.4823\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 93%|█████████▎| 91/98 [06:56<00:31, 4.44s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 59.00%\n", + "\n", + "[Gen 92/98] Best Fitness: -1.4072, Pop Avg Fitness: -1.4450\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 94%|█████████▍| 92/98 [07:01<00:26, 4.36s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 60.03%\n", + "\n", + "[Gen 93/98] Best Fitness: -1.4114, Pop Avg Fitness: -1.4548\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 95%|█████████▍| 93/98 [07:06<00:22, 4.53s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 61.85%\n", + "\n", + "[Gen 94/98] Best Fitness: -1.3933, Pop Avg Fitness: -1.4287\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 96%|█████████▌| 94/98 [07:10<00:17, 4.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 61.72%\n", + "\n", + "[Gen 95/98] Best Fitness: -1.3886, Pop Avg Fitness: -1.4261\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 97%|█████████▋| 95/98 [07:14<00:13, 4.39s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 63.41%\n", + "\n", + "[Gen 96/98] Best Fitness: -1.3887, Pop Avg Fitness: -1.4313\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 98%|█████████▊| 96/98 [07:19<00:09, 4.53s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 60.30%\n", + "\n", + "[Gen 97/98] Best Fitness: -1.3600, Pop Avg Fitness: -1.4109\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 99%|█████████▉| 97/98 [07:23<00:04, 4.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 64.12%\n", + "\n", + "[Gen 98/98] Best Fitness: -1.3686, Pop Avg Fitness: -1.4152\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "EA Generations: 100%|██████████| 98/98 [07:28<00:00, 4.57s/it]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 63.60%\n", + "\n", + "--- Training Baseline Model with Adam Optimizer ---\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Adam Epoch 1/5: 100%|██████████| 59/59 [00:48<00:00, 1.22it/s]\n", + "Adam Epoch 2/5: 100%|██████████| 59/59 [00:50<00:00, 1.17it/s]\n", + "Adam Epoch 3/5: 100%|██████████| 59/59 [00:49<00:00, 1.19it/s]\n", + "Adam Epoch 4/5: 100%|██████████| 59/59 [00:48<00:00, 1.21it/s]\n", + "Adam Epoch 5/5: 100%|██████████| 59/59 [00:52<00:00, 1.13it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "--- Final Results ---\n", + "Final Adam Model Accuracy: 94.70%\n", + "Final Best EA Model Accuracy: 63.60%\n", + "\n", + "Performance plot saved to 'performance_comparison.png'\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "yw4r6x2aSNdb", + "outputId": "d2369ef6-f041-4066-f968-b30d9d80180a" + } + } + ], + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4", + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 75bd89cf8c56d3afbbd9d7de09a21ad08078fd67 Mon Sep 17 00:00:00 2001 From: Stephan Botes Date: Sat, 6 Sep 2025 12:13:14 -0400 Subject: [PATCH 7/7] Now using tournament, much more stable at larger scale --- MNIST_Evolutionary_vs_Adam_Training.ipynb | 3826 +++++++++++++++++++-- 1 file changed, 3483 insertions(+), 343 deletions(-) diff --git a/MNIST_Evolutionary_vs_Adam_Training.ipynb b/MNIST_Evolutionary_vs_Adam_Training.ipynb index 6465336..e9289b7 100644 --- a/MNIST_Evolutionary_vs_Adam_Training.ipynb +++ b/MNIST_Evolutionary_vs_Adam_Training.ipynb @@ -31,10 +31,10 @@ "EPOCHS = 5 # Number of epochs for both Adam and EA\n", "\n", "# Evolutionary Algorithm Parameters\n", - "POPULATION_SIZE = 500 # Number of models in the population\n", - "BATCHES_PER_GENERATION = 3 # Number of batches to evaluate generation on before evolutionary step\n", - "MUTATION_RESET_PROB = 0.00001 # Probability for each weight to be reset to a new random value.\n", - "SELECTION_RATE = 0.2 # Top 20% of models are selected for reproduction\n", + "POPULATION_SIZE = 3000 # Using the size you found was more stable\n", + "BATCHES_PER_GENERATION = 1\n", + "MUTATION_RESET_PROB = 0.00001\n", + "TOURNAMENT_SIZE = 20 # Number of individuals in each selection tournament\n", "ELITISM_RATE = 0.05 # Keep the top 5% of models unchanged in the next generation\n", "\n", "# --- 2. Model Architecture ---\n", @@ -58,6 +58,18 @@ " return out\n", "\n", "# --- 3. Evolutionary Operators ---\n", + "def tournament_selection(population, fitness_scores):\n", + " \"\"\"Selects a parent using tournament selection.\"\"\"\n", + " # Get random indices for the tournament\n", + " tournament_indices = torch.randint(0, len(population), (TOURNAMENT_SIZE,))\n", + " tournament_fitnesses = fitness_scores[tournament_indices]\n", + "\n", + " # Find the winner of the tournament (best fitness)\n", + " winner_local_idx = torch.argmax(tournament_fitnesses)\n", + " winner_global_idx = tournament_indices[winner_local_idx]\n", + "\n", + " return population[winner_global_idx]\n", + "\n", "def crossover(parent1, parent2):\n", " \"\"\"Performs uniform crossover between two parent models.\"\"\"\n", " child = SimpleNet().to(DEVICE)\n", @@ -66,29 +78,18 @@ " parent2_dict = parent2.state_dict()\n", "\n", " for key in parent1_dict.keys():\n", - " # Create a random binary mask\n", " mask = torch.randint(0, 2, size=parent1_dict[key].shape, device=DEVICE).float()\n", - " # Combine weights from both parents\n", " child_dict[key] = (parent1_dict[key] * mask) + (parent2_dict[key] * (1 - mask))\n", "\n", " child.load_state_dict(child_dict)\n", " return child\n", "\n", "def mutate(model):\n", - " \"\"\"\n", - " Performs reset mutation. A small fraction of weights are reset to new\n", - " random values drawn from a standard normal distribution.\n", - " \"\"\"\n", + " \"\"\"Performs reset mutation.\"\"\"\n", " with torch.no_grad():\n", " for param in model.parameters():\n", - " # Create a boolean mask to select which individual weights to mutate\n", " mask = torch.rand_like(param.data) < MUTATION_RESET_PROB\n", - "\n", - " # Generate new random weights for the selected positions\n", " new_weights = torch.randn_like(param.data)\n", - "\n", - " # Apply the mask: keep old weights where mask is False,\n", - " # and use new random weights where mask is True.\n", " param.data[mask] = new_weights[mask]\n", " return model\n", "\n", @@ -171,7 +172,6 @@ " train_iterator = iter(itertools.cycle(train_loader))\n", "\n", " for generation in tqdm(range(NUM_GENERATIONS), desc=\"EA Generations\"):\n", - " # --- IMPROVEMENT: Aggregate fitness over multiple batches for stability ---\n", " cumulative_fitness_scores = torch.zeros(POPULATION_SIZE, device=DEVICE)\n", "\n", " for batch_idx in range(BATCHES_PER_GENERATION):\n", @@ -183,39 +183,28 @@ " with torch.cuda.stream(streams[i]):\n", " outputs = population[i](images)\n", " loss = loss_fn(outputs, labels)\n", - " # Accumulate the fitness (negative loss) from each batch\n", " cumulative_fitness_scores[i] += -loss\n", "\n", - " torch.cuda.synchronize() # Wait for all streams to finish their batch\n", + " torch.cuda.synchronize()\n", "\n", " batch_counter_ea += BATCHES_PER_GENERATION\n", - "\n", - " # Use the stable, cumulative fitness for selection and diagnostics\n", " fitness_scores = cumulative_fitness_scores\n", "\n", - " best_fitness = fitness_scores.max().item() / BATCHES_PER_GENERATION # Average per batch\n", - " avg_fitness = fitness_scores.mean().item() / BATCHES_PER_GENERATION # Average per batch\n", + " best_fitness = fitness_scores.max().item() / BATCHES_PER_GENERATION\n", + " avg_fitness = fitness_scores.mean().item() / BATCHES_PER_GENERATION\n", " print(f\"\\n[Gen {generation+1}/{NUM_GENERATIONS}] Best Fitness: {best_fitness:.4f}, Pop Avg Fitness: {avg_fitness:.4f}\")\n", "\n", - " # --- Selection ---\n", + " # --- Elitism ---\n", " sorted_indices = torch.argsort(fitness_scores, descending=True)\n", - " num_elites = int(POPULATION_SIZE * SELECTION_RATE)\n", - " elite_indices = sorted_indices[:num_elites]\n", - "\n", - " # --- Reproduction with True Elitism ---\n", " num_to_keep = int(POPULATION_SIZE * ELITISM_RATE)\n", + " new_population = [population[i] for i in sorted_indices[:num_to_keep]]\n", "\n", - " # Start the new population with the best, unchanged models\n", - " new_population = [population[i] for i in elite_indices[:num_to_keep]]\n", - "\n", - " # Fill the rest of the population with children from the elite pool\n", + " # --- Reproduction with Tournament Selection ---\n", " num_children_to_create = POPULATION_SIZE - num_to_keep\n", " with torch.no_grad():\n", " for _ in range(num_children_to_create):\n", - " p1_idx = elite_indices[torch.randint(0, num_elites, (1,)).item()]\n", - " p2_idx = elite_indices[torch.randint(0, num_elites, (1,)).item()]\n", - " parent1 = population[p1_idx]\n", - " parent2 = population[p2_idx]\n", + " parent1 = tournament_selection(population, fitness_scores)\n", + " parent2 = tournament_selection(population, fitness_scores)\n", " child = crossover(parent1, parent2)\n", " child = mutate(child)\n", " child.eval()\n", @@ -259,7 +248,6 @@ "\n", "if __name__ == \"__main__\":\n", " main()\n", - "\n", "\n" ], "outputs": [ @@ -269,7 +257,7 @@ "text": [ "Using device: cuda\n", "Both algorithms will run for approx 295 batches.\n", - "EA will run for 98 generations of 3 batches each.\n", + "EA will run for 295 generations of 1 batches each.\n", "\n", "--- Training Population with Evolutionary Algorithm ---\n" ] @@ -278,7 +266,7 @@ "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 0%| | 0/98 [00:00 Best Model Test Accuracy: 10.41%\n", + " -> Best Model Test Accuracy: 10.23%\n", "\n", - "[Gen 2/98] Best Fitness: -2.2891, Pop Avg Fitness: -2.3053\n" + "[Gen 2/295] Best Fitness: -2.2770, Pop Avg Fitness: -2.3053\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 2%|▏ | 2/98 [00:09<08:00, 5.01s/it]" + "\rEA Generations: 1%| | 2/295 [00:32<1:20:21, 16.45s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 11.85%\n", + " -> Best Model Test Accuracy: 14.65%\n", "\n", - "[Gen 3/98] Best Fitness: -2.2847, Pop Avg Fitness: -2.3054\n" + "[Gen 3/295] Best Fitness: -2.2822, Pop Avg Fitness: -2.3040\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 3%|▎ | 3/98 [00:14<07:52, 4.98s/it]" + "\rEA Generations: 1%| | 3/295 [00:48<1:18:41, 16.17s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 11.85%\n", + " -> Best Model Test Accuracy: 14.65%\n", "\n", - "[Gen 4/98] Best Fitness: -2.2765, Pop Avg Fitness: -2.3042\n" + "[Gen 4/295] Best Fitness: -2.2739, Pop Avg Fitness: -2.3041\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 4%|▍ | 4/98 [00:19<07:43, 4.93s/it]" + "\rEA Generations: 1%|▏ | 4/295 [01:04<1:17:59, 16.08s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 14.65%\n", "\n", - "[Gen 5/98] Best Fitness: -2.2766, Pop Avg Fitness: -2.3039\n" + "[Gen 5/295] Best Fitness: -2.2791, Pop Avg Fitness: -2.3031\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 5%|▌ | 5/98 [00:25<07:54, 5.11s/it]" + "\rEA Generations: 2%|▏ | 5/295 [01:21<1:18:39, 16.27s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 18.00%\n", "\n", - "[Gen 6/98] Best Fitness: -2.2724, Pop Avg Fitness: -2.3025\n" + "[Gen 6/295] Best Fitness: -2.2787, Pop Avg Fitness: -2.3024\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 6%|▌ | 6/98 [00:29<07:33, 4.93s/it]" + "\rEA Generations: 2%|▏ | 6/295 [01:36<1:17:32, 16.10s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 15.49%\n", "\n", - "[Gen 7/98] Best Fitness: -2.2768, Pop Avg Fitness: -2.3020\n" + "[Gen 7/295] Best Fitness: -2.2564, Pop Avg Fitness: -2.3044\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 7%|▋ | 7/98 [00:35<07:50, 5.17s/it]" + "\rEA Generations: 2%|▏ | 7/295 [01:52<1:16:51, 16.01s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 16.13%\n", "\n", - "[Gen 8/98] Best Fitness: -2.2746, Pop Avg Fitness: -2.3011\n" + "[Gen 8/295] Best Fitness: -2.2627, Pop Avg Fitness: -2.3018\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 8%|▊ | 8/98 [00:40<07:31, 5.01s/it]" + "\rEA Generations: 3%|▎ | 8/295 [02:09<1:17:31, 16.21s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 13.42%\n", "\n", - "[Gen 9/98] Best Fitness: -2.2737, Pop Avg Fitness: -2.3021\n" + "[Gen 9/295] Best Fitness: -2.2629, Pop Avg Fitness: -2.3028\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 9%|▉ | 9/98 [00:44<07:16, 4.91s/it]" + "\rEA Generations: 3%|▎ | 9/295 [02:25<1:16:45, 16.10s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 16.13%\n", "\n", - "[Gen 10/98] Best Fitness: -2.2780, Pop Avg Fitness: -2.3039\n" + "[Gen 10/295] Best Fitness: -2.2544, Pop Avg Fitness: -2.2980\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 10%|█ | 10/98 [00:50<07:23, 5.04s/it]" + "\rEA Generations: 3%|▎ | 10/295 [02:41<1:16:11, 16.04s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 18.09%\n", "\n", - "[Gen 11/98] Best Fitness: -2.2741, Pop Avg Fitness: -2.3012\n" + "[Gen 11/295] Best Fitness: -2.2581, Pop Avg Fitness: -2.2952\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 11%|█ | 11/98 [00:54<07:13, 4.99s/it]" + "\rEA Generations: 4%|▎ | 11/295 [02:58<1:17:11, 16.31s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 18.09%\n", "\n", - "[Gen 12/98] Best Fitness: -2.2784, Pop Avg Fitness: -2.3032\n" + "[Gen 12/295] Best Fitness: -2.2549, Pop Avg Fitness: -2.2915\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 12%|█▏ | 12/98 [01:00<07:19, 5.11s/it]" + "\rEA Generations: 4%|▍ | 12/295 [03:13<1:16:19, 16.18s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 17.94%\n", + " -> Best Model Test Accuracy: 19.68%\n", "\n", - "[Gen 13/98] Best Fitness: -2.2767, Pop Avg Fitness: -2.3014\n" + "[Gen 13/295] Best Fitness: -2.2445, Pop Avg Fitness: -2.2847\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 13%|█▎ | 13/98 [01:05<07:03, 4.99s/it]" + "\rEA Generations: 4%|▍ | 13/295 [03:29<1:15:38, 16.09s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 16.14%\n", "\n", - "[Gen 14/98] Best Fitness: -2.2771, Pop Avg Fitness: -2.3010\n" + "[Gen 14/295] Best Fitness: -2.2208, Pop Avg Fitness: -2.2811\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 14%|█▍ | 14/98 [01:10<07:12, 5.15s/it]" + "\rEA Generations: 5%|▍ | 14/295 [03:46<1:16:11, 16.27s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 15.00%\n", "\n", - "[Gen 15/98] Best Fitness: -2.2753, Pop Avg Fitness: -2.2992\n" + "[Gen 15/295] Best Fitness: -2.2165, Pop Avg Fitness: -2.2714\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 15%|█▌ | 15/98 [01:15<07:08, 5.16s/it]" + "\rEA Generations: 5%|▌ | 15/295 [04:02<1:15:18, 16.14s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 13.73%\n", + " -> Best Model Test Accuracy: 19.36%\n", "\n", - "[Gen 16/98] Best Fitness: -2.2746, Pop Avg Fitness: -2.2973\n" + "[Gen 16/295] Best Fitness: -2.2135, Pop Avg Fitness: -2.2646\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 16%|█▋ | 16/98 [01:20<06:53, 5.04s/it]" + "\rEA Generations: 5%|▌ | 16/295 [04:18<1:15:15, 16.18s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 24.61%\n", + " -> Best Model Test Accuracy: 18.16%\n", "\n", - "[Gen 17/98] Best Fitness: -2.2697, Pop Avg Fitness: -2.2934\n" + "[Gen 17/295] Best Fitness: -2.2017, Pop Avg Fitness: -2.2458\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 17%|█▋ | 17/98 [01:26<07:05, 5.26s/it]" + "\rEA Generations: 6%|▌ | 17/295 [04:35<1:15:32, 16.30s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 18.22%\n", + " -> Best Model Test Accuracy: 15.75%\n", "\n", - "[Gen 18/98] Best Fitness: -2.2676, Pop Avg Fitness: -2.2885\n" + "[Gen 18/295] Best Fitness: -2.1959, Pop Avg Fitness: -2.2360\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 18%|█▊ | 18/98 [01:30<06:46, 5.09s/it]" + "\rEA Generations: 6%|▌ | 18/295 [04:51<1:14:51, 16.21s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 22.46%\n", + " -> Best Model Test Accuracy: 17.38%\n", "\n", - "[Gen 19/98] Best Fitness: -2.2640, Pop Avg Fitness: -2.2835\n" + "[Gen 19/295] Best Fitness: -2.1600, Pop Avg Fitness: -2.2022\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 19%|█▉ | 19/98 [01:36<06:55, 5.26s/it]" + "\rEA Generations: 6%|▋ | 19/295 [05:07<1:14:07, 16.11s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 25.68%\n", + " -> Best Model Test Accuracy: 19.18%\n", "\n", - "[Gen 20/98] Best Fitness: -2.2630, Pop Avg Fitness: -2.2770\n" + "[Gen 20/295] Best Fitness: -2.1634, Pop Avg Fitness: -2.2094\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 20%|██ | 20/98 [01:41<06:30, 5.01s/it]" + "\rEA Generations: 7%|▋ | 20/295 [05:23<1:14:39, 16.29s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 10.71%\n", + " -> Best Model Test Accuracy: 22.10%\n", "\n", - "[Gen 21/98] Best Fitness: -2.2566, Pop Avg Fitness: -2.2746\n" + "[Gen 21/295] Best Fitness: -2.1562, Pop Avg Fitness: -2.1957\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 21%|██▏ | 21/98 [01:45<06:05, 4.75s/it]" + "\rEA Generations: 7%|▋ | 21/295 [05:39<1:13:50, 16.17s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 25.36%\n", + " -> Best Model Test Accuracy: 22.10%\n", "\n", - "[Gen 22/98] Best Fitness: -2.2524, Pop Avg Fitness: -2.2716\n" + "[Gen 22/295] Best Fitness: -2.1385, Pop Avg Fitness: -2.1856\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 22%|██▏ | 22/98 [01:50<06:09, 4.87s/it]" + "\rEA Generations: 7%|▋ | 22/295 [05:56<1:13:52, 16.24s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 24.24%\n", + " -> Best Model Test Accuracy: 23.12%\n", "\n", - "[Gen 23/98] Best Fitness: -2.2504, Pop Avg Fitness: -2.2684\n" + "[Gen 23/295] Best Fitness: -2.1223, Pop Avg Fitness: -2.1690\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 23%|██▎ | 23/98 [01:54<05:48, 4.65s/it]" + "\rEA Generations: 8%|▊ | 23/295 [06:12<1:14:16, 16.38s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 30.25%\n", + " -> Best Model Test Accuracy: 26.93%\n", "\n", - "[Gen 24/98] Best Fitness: -2.2488, Pop Avg Fitness: -2.2665\n" + "[Gen 24/295] Best Fitness: -2.1067, Pop Avg Fitness: -2.1548\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 24%|██▍ | 24/98 [01:58<05:35, 4.53s/it]" + "\rEA Generations: 8%|▊ | 24/295 [06:28<1:13:24, 16.25s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 19.94%\n", + " -> Best Model Test Accuracy: 25.52%\n", "\n", - "[Gen 25/98] Best Fitness: -2.2393, Pop Avg Fitness: -2.2606\n" + "[Gen 25/295] Best Fitness: -2.0641, Pop Avg Fitness: -2.1173\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 26%|██▌ | 25/98 [02:03<05:42, 4.70s/it]" + "\rEA Generations: 8%|▊ | 25/295 [06:44<1:12:32, 16.12s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 15.35%\n", + " -> Best Model Test Accuracy: 24.22%\n", "\n", - "[Gen 26/98] Best Fitness: -2.2396, Pop Avg Fitness: -2.2549\n" + "[Gen 26/295] Best Fitness: -2.0909, Pop Avg Fitness: -2.1334\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 27%|██▋ | 26/98 [02:07<05:26, 4.54s/it]" + "\rEA Generations: 9%|▉ | 26/295 [07:00<1:12:26, 16.16s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 25.58%\n", + " -> Best Model Test Accuracy: 26.06%\n", "\n", - "[Gen 27/98] Best Fitness: -2.2249, Pop Avg Fitness: -2.2495\n" + "[Gen 27/295] Best Fitness: -2.0652, Pop Avg Fitness: -2.1124\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 28%|██▊ | 27/98 [02:12<05:28, 4.63s/it]" + "\rEA Generations: 9%|▉ | 27/295 [07:16<1:12:08, 16.15s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 29.27%\n", + " -> Best Model Test Accuracy: 22.74%\n", "\n", - "[Gen 28/98] Best Fitness: -2.2271, Pop Avg Fitness: -2.2472\n" + "[Gen 28/295] Best Fitness: -2.0322, Pop Avg Fitness: -2.0939\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 29%|██▊ | 28/98 [02:17<05:15, 4.50s/it]" + "\rEA Generations: 9%|▉ | 28/295 [07:32<1:11:26, 16.06s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 22.35%\n", + " -> Best Model Test Accuracy: 27.34%\n", "\n", - "[Gen 29/98] Best Fitness: -2.2173, Pop Avg Fitness: -2.2406\n" + "[Gen 29/295] Best Fitness: -2.0138, Pop Avg Fitness: -2.0769\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 30%|██▉ | 29/98 [02:21<05:07, 4.45s/it]" + "\rEA Generations: 10%|▉ | 29/295 [07:48<1:11:18, 16.09s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 31.88%\n", + " -> Best Model Test Accuracy: 28.21%\n", "\n", - "[Gen 30/98] Best Fitness: -2.2168, Pop Avg Fitness: -2.2359\n" + "[Gen 30/295] Best Fitness: -2.0105, Pop Avg Fitness: -2.0708\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 31%|███ | 30/98 [02:26<05:10, 4.57s/it]" + "\rEA Generations: 10%|█ | 30/295 [08:05<1:11:52, 16.27s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 31.88%\n", + " -> Best Model Test Accuracy: 30.15%\n", "\n", - "[Gen 31/98] Best Fitness: -2.2001, Pop Avg Fitness: -2.2303\n" + "[Gen 31/295] Best Fitness: -1.9565, Pop Avg Fitness: -2.0279\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 32%|███▏ | 31/98 [02:30<04:55, 4.42s/it]" + "\rEA Generations: 11%|█ | 31/295 [08:21<1:11:06, 16.16s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 26.36%\n", + " -> Best Model Test Accuracy: 32.08%\n", "\n", - "[Gen 32/98] Best Fitness: -2.1924, Pop Avg Fitness: -2.2241\n" + "[Gen 32/295] Best Fitness: -1.9780, Pop Avg Fitness: -2.0401\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 33%|███▎ | 32/98 [02:34<04:50, 4.39s/it]" + "\rEA Generations: 11%|█ | 32/295 [08:37<1:10:40, 16.12s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 22.14%\n", + " -> Best Model Test Accuracy: 32.97%\n", "\n", - "[Gen 33/98] Best Fitness: -2.1895, Pop Avg Fitness: -2.2192\n" + "[Gen 33/295] Best Fitness: -1.9510, Pop Avg Fitness: -2.0072\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 34%|███▎ | 33/98 [02:39<04:54, 4.54s/it]" + "\rEA Generations: 11%|█ | 33/295 [08:53<1:10:46, 16.21s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 24.95%\n", + " -> Best Model Test Accuracy: 35.59%\n", "\n", - "[Gen 34/98] Best Fitness: -2.1673, Pop Avg Fitness: -2.2108\n" + "[Gen 34/295] Best Fitness: -1.9432, Pop Avg Fitness: -2.0075\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 35%|███▍ | 34/98 [02:43<04:41, 4.39s/it]" + "\rEA Generations: 12%|█▏ | 34/295 [09:09<1:10:03, 16.10s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 32.35%\n", + " -> Best Model Test Accuracy: 31.15%\n", "\n", - "[Gen 35/98] Best Fitness: -2.1649, Pop Avg Fitness: -2.1991\n" + "[Gen 35/295] Best Fitness: -1.9044, Pop Avg Fitness: -1.9751\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 36%|███▌ | 35/98 [02:48<04:39, 4.44s/it]" + "\rEA Generations: 12%|█▏ | 35/295 [09:25<1:09:30, 16.04s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 32.35%\n", + " -> Best Model Test Accuracy: 37.08%\n", "\n", - "[Gen 36/98] Best Fitness: -2.1541, Pop Avg Fitness: -2.1868\n" + "[Gen 36/295] Best Fitness: -1.8792, Pop Avg Fitness: -1.9500\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 37%|███▋ | 36/98 [02:52<04:37, 4.47s/it]" + "\rEA Generations: 12%|█▏ | 36/295 [09:42<1:09:45, 16.16s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 31.22%\n", + " -> Best Model Test Accuracy: 32.15%\n", "\n", - "[Gen 37/98] Best Fitness: -2.1471, Pop Avg Fitness: -2.1797\n" + "[Gen 37/295] Best Fitness: -1.8711, Pop Avg Fitness: -1.9368\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 38%|███▊ | 37/98 [02:56<04:25, 4.35s/it]" + "\rEA Generations: 13%|█▎ | 37/295 [09:58<1:09:05, 16.07s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 22.85%\n", + " -> Best Model Test Accuracy: 39.62%\n", "\n", - "[Gen 38/98] Best Fitness: -2.1362, Pop Avg Fitness: -2.1685\n" + "[Gen 38/295] Best Fitness: -1.8066, Pop Avg Fitness: -1.8799\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 39%|███▉ | 38/98 [03:01<04:32, 4.55s/it]" + "\rEA Generations: 13%|█▎ | 38/295 [10:13<1:08:17, 15.94s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 23.29%\n", + " -> Best Model Test Accuracy: 40.05%\n", "\n", - "[Gen 39/98] Best Fitness: -2.1250, Pop Avg Fitness: -2.1709\n" + "[Gen 39/295] Best Fitness: -1.7757, Pop Avg Fitness: -1.8549\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 40%|███▉ | 39/98 [03:05<04:19, 4.40s/it]" + "\rEA Generations: 13%|█▎ | 39/295 [10:30<1:09:16, 16.24s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 33.21%\n", + " -> Best Model Test Accuracy: 36.74%\n", "\n", - "[Gen 40/98] Best Fitness: -2.1173, Pop Avg Fitness: -2.1454\n" + "[Gen 40/295] Best Fitness: -1.7606, Pop Avg Fitness: -1.8393\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 41%|████ | 40/98 [03:09<04:09, 4.31s/it]" + "\rEA Generations: 14%|█▎ | 40/295 [10:46<1:08:33, 16.13s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 33.21%\n", + " -> Best Model Test Accuracy: 42.78%\n", "\n", - "[Gen 41/98] Best Fitness: -2.1189, Pop Avg Fitness: -2.1460\n" + "[Gen 41/295] Best Fitness: -1.7671, Pop Avg Fitness: -1.8273\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 42%|████▏ | 41/98 [03:14<04:13, 4.45s/it]" + "\rEA Generations: 14%|█▍ | 41/295 [11:02<1:07:55, 16.04s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 38.08%\n", + " -> Best Model Test Accuracy: 39.86%\n", "\n", - "[Gen 42/98] Best Fitness: -2.1092, Pop Avg Fitness: -2.1330\n" + "[Gen 42/295] Best Fitness: -1.7239, Pop Avg Fitness: -1.7788\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 43%|████▎ | 42/98 [03:18<04:06, 4.41s/it]" + "\rEA Generations: 14%|█▍ | 42/295 [11:18<1:08:24, 16.22s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 28.33%\n", + " -> Best Model Test Accuracy: 43.74%\n", "\n", - "[Gen 43/98] Best Fitness: -2.0944, Pop Avg Fitness: -2.1277\n" + "[Gen 43/295] Best Fitness: -1.6882, Pop Avg Fitness: -1.7528\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 44%|████▍ | 43/98 [03:23<03:57, 4.31s/it]" + "\rEA Generations: 15%|█▍ | 43/295 [11:34<1:07:35, 16.09s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 27.23%\n", + " -> Best Model Test Accuracy: 44.65%\n", "\n", - "[Gen 44/98] Best Fitness: -2.0768, Pop Avg Fitness: -2.1170\n" + "[Gen 44/295] Best Fitness: -1.6995, Pop Avg Fitness: -1.7595\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 45%|████▍ | 44/98 [03:28<04:06, 4.56s/it]" + "\rEA Generations: 15%|█▍ | 44/295 [11:50<1:07:05, 16.04s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 35.24%\n", + " -> Best Model Test Accuracy: 48.94%\n", "\n", - "[Gen 45/98] Best Fitness: -2.0563, Pop Avg Fitness: -2.1001\n" + "[Gen 45/295] Best Fitness: -1.7080, Pop Avg Fitness: -1.7688\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 46%|████▌ | 45/98 [03:32<03:53, 4.41s/it]" + "\rEA Generations: 15%|█▌ | 45/295 [12:07<1:07:22, 16.17s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 34.99%\n", + " -> Best Model Test Accuracy: 48.45%\n", "\n", - "[Gen 46/98] Best Fitness: -2.0665, Pop Avg Fitness: -2.0998\n" + "[Gen 46/295] Best Fitness: -1.6892, Pop Avg Fitness: -1.7466\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 47%|████▋ | 46/98 [03:36<03:47, 4.38s/it]" + "\rEA Generations: 16%|█▌ | 46/295 [12:22<1:06:37, 16.05s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 34.99%\n", + " -> Best Model Test Accuracy: 48.04%\n", "\n", - "[Gen 47/98] Best Fitness: -2.0385, Pop Avg Fitness: -2.0723\n" + "[Gen 47/295] Best Fitness: -1.6407, Pop Avg Fitness: -1.6986\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 48%|████▊ | 47/98 [03:41<03:49, 4.51s/it]" + "\rEA Generations: 16%|█▌ | 47/295 [12:39<1:06:31, 16.09s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 34.91%\n", + " -> Best Model Test Accuracy: 48.53%\n", "\n", - "[Gen 48/98] Best Fitness: -2.0381, Pop Avg Fitness: -2.0789\n" + "[Gen 48/295] Best Fitness: -1.6275, Pop Avg Fitness: -1.6919\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 49%|████▉ | 48/98 [03:45<03:39, 4.39s/it]" + "\rEA Generations: 16%|█▋ | 48/295 [12:55<1:06:52, 16.24s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 33.63%\n", + " -> Best Model Test Accuracy: 47.52%\n", "\n", - "[Gen 49/98] Best Fitness: -2.0245, Pop Avg Fitness: -2.0627\n" + "[Gen 49/295] Best Fitness: -1.6419, Pop Avg Fitness: -1.7113\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 50%|█████ | 49/98 [03:50<03:40, 4.50s/it]" + "\rEA Generations: 17%|█▋ | 49/295 [13:11<1:06:10, 16.14s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 42.47%\n", + " -> Best Model Test Accuracy: 51.95%\n", "\n", - "[Gen 50/98] Best Fitness: -2.0149, Pop Avg Fitness: -2.0587\n" + "[Gen 50/295] Best Fitness: -1.5876, Pop Avg Fitness: -1.6611\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 51%|█████ | 50/98 [03:54<03:30, 4.38s/it]" + "\rEA Generations: 17%|█▋ | 50/295 [13:27<1:05:34, 16.06s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 36.66%\n", + " -> Best Model Test Accuracy: 51.04%\n", "\n", - "[Gen 51/98] Best Fitness: -1.9794, Pop Avg Fitness: -2.0371\n" + "[Gen 51/295] Best Fitness: -1.5644, Pop Avg Fitness: -1.6326\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 52%|█████▏ | 51/98 [03:58<03:25, 4.36s/it]" + "\rEA Generations: 17%|█▋ | 51/295 [13:43<1:05:42, 16.16s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 32.02%\n", + " -> Best Model Test Accuracy: 53.45%\n", "\n", - "[Gen 52/98] Best Fitness: -1.9800, Pop Avg Fitness: -2.0335\n" + "[Gen 52/295] Best Fitness: -1.5465, Pop Avg Fitness: -1.6170\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 53%|█████▎ | 52/98 [04:03<03:27, 4.50s/it]" + "\rEA Generations: 18%|█▊ | 52/295 [13:59<1:05:06, 16.08s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 37.43%\n", + " -> Best Model Test Accuracy: 50.57%\n", "\n", - "[Gen 53/98] Best Fitness: -1.9729, Pop Avg Fitness: -2.0245\n" + "[Gen 53/295] Best Fitness: -1.5161, Pop Avg Fitness: -1.5935\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 54%|█████▍ | 53/98 [04:07<03:17, 4.40s/it]" + "\rEA Generations: 18%|█▊ | 53/295 [14:15<1:04:55, 16.10s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 36.12%\n", + " -> Best Model Test Accuracy: 52.99%\n", "\n", - "[Gen 54/98] Best Fitness: -1.9206, Pop Avg Fitness: -2.0115\n" + "[Gen 54/295] Best Fitness: -1.5172, Pop Avg Fitness: -1.5942\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 55%|█████▌ | 54/98 [04:11<03:12, 4.37s/it]" + "\rEA Generations: 18%|█▊ | 54/295 [14:32<1:04:57, 16.17s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 39.22%\n", + " -> Best Model Test Accuracy: 54.66%\n", "\n", - "[Gen 55/98] Best Fitness: -1.9247, Pop Avg Fitness: -1.9893\n" + "[Gen 55/295] Best Fitness: -1.4820, Pop Avg Fitness: -1.5611\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 56%|█████▌ | 55/98 [04:16<03:14, 4.52s/it]" + "\rEA Generations: 19%|█▊ | 55/295 [14:48<1:04:25, 16.10s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 41.40%\n", + " -> Best Model Test Accuracy: 54.68%\n", "\n", - "[Gen 56/98] Best Fitness: -1.8812, Pop Avg Fitness: -1.9693\n" + "[Gen 56/295] Best Fitness: -1.4750, Pop Avg Fitness: -1.5584\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 57%|█████▋ | 56/98 [04:20<03:04, 4.38s/it]" + "\rEA Generations: 19%|█▉ | 56/295 [15:04<1:03:49, 16.02s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 45.98%\n", + " -> Best Model Test Accuracy: 57.89%\n", "\n", - "[Gen 57/98] Best Fitness: -1.8936, Pop Avg Fitness: -1.9572\n" + "[Gen 57/295] Best Fitness: -1.4786, Pop Avg Fitness: -1.5424\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 58%|█████▊ | 57/98 [04:25<03:03, 4.46s/it]" + "\rEA Generations: 19%|█▉ | 57/295 [15:20<1:03:40, 16.05s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 45.98%\n", + " -> Best Model Test Accuracy: 53.32%\n", "\n", - "[Gen 58/98] Best Fitness: -1.8691, Pop Avg Fitness: -1.9242\n" + "[Gen 58/295] Best Fitness: -1.4456, Pop Avg Fitness: -1.5105\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 59%|█████▉ | 58/98 [04:30<02:59, 4.48s/it]" + "\rEA Generations: 20%|█▉ | 58/295 [15:36<1:03:35, 16.10s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 39.84%\n", + " -> Best Model Test Accuracy: 56.78%\n", "\n", - "[Gen 59/98] Best Fitness: -1.8711, Pop Avg Fitness: -1.9211\n" + "[Gen 59/295] Best Fitness: -1.4393, Pop Avg Fitness: -1.5029\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 60%|██████ | 59/98 [04:34<02:51, 4.39s/it]" + "\rEA Generations: 20%|██ | 59/295 [15:52<1:03:36, 16.17s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 44.56%\n", + " -> Best Model Test Accuracy: 57.30%\n", "\n", - "[Gen 60/98] Best Fitness: -1.8410, Pop Avg Fitness: -1.8939\n" + "[Gen 60/295] Best Fitness: -1.3934, Pop Avg Fitness: -1.4687\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 61%|██████ | 60/98 [04:39<02:54, 4.59s/it]" + "\rEA Generations: 20%|██ | 60/295 [16:09<1:04:08, 16.38s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 41.58%\n", + " -> Best Model Test Accuracy: 56.18%\n", "\n", - "[Gen 61/98] Best Fitness: -1.8059, Pop Avg Fitness: -1.8764\n" + "[Gen 61/295] Best Fitness: -1.4068, Pop Avg Fitness: -1.4645\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 62%|██████▏ | 61/98 [04:43<02:45, 4.46s/it]" + "\rEA Generations: 21%|██ | 61/295 [16:26<1:04:03, 16.43s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 47.60%\n", + " -> Best Model Test Accuracy: 58.83%\n", "\n", - "[Gen 62/98] Best Fitness: -1.8060, Pop Avg Fitness: -1.8581\n" + "[Gen 62/295] Best Fitness: -1.3801, Pop Avg Fitness: -1.4429\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 63%|██████▎ | 62/98 [04:47<02:37, 4.38s/it]" + "\rEA Generations: 21%|██ | 62/295 [16:42<1:03:17, 16.30s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 39.55%\n", + " -> Best Model Test Accuracy: 57.51%\n", "\n", - "[Gen 63/98] Best Fitness: -1.8009, Pop Avg Fitness: -1.8436\n" + "[Gen 63/295] Best Fitness: -1.3375, Pop Avg Fitness: -1.3993\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 64%|██████▍ | 63/98 [04:52<02:38, 4.53s/it]" + "\rEA Generations: 21%|██▏ | 63/295 [16:58<1:03:13, 16.35s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 40.76%\n", + " -> Best Model Test Accuracy: 59.08%\n", "\n", - "[Gen 64/98] Best Fitness: -1.7584, Pop Avg Fitness: -1.8165\n" + "[Gen 64/295] Best Fitness: -1.3526, Pop Avg Fitness: -1.4073\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 65%|██████▌ | 64/98 [04:56<02:31, 4.46s/it]" + "\rEA Generations: 22%|██▏ | 64/295 [17:14<1:02:29, 16.23s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 43.08%\n", + " -> Best Model Test Accuracy: 59.80%\n", "\n", - "[Gen 65/98] Best Fitness: -1.7635, Pop Avg Fitness: -1.8035\n" + "[Gen 65/295] Best Fitness: -1.3197, Pop Avg Fitness: -1.3899\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 66%|██████▋ | 65/98 [05:00<02:23, 4.36s/it]" + "\rEA Generations: 22%|██▏ | 65/295 [17:30<1:01:52, 16.14s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 42.16%\n", + " -> Best Model Test Accuracy: 60.27%\n", "\n", - "[Gen 66/98] Best Fitness: -1.7352, Pop Avg Fitness: -1.7903\n" + "[Gen 66/295] Best Fitness: -1.3186, Pop Avg Fitness: -1.3793\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 67%|██████▋ | 66/98 [05:06<02:27, 4.60s/it]" + "\rEA Generations: 22%|██▏ | 66/295 [17:46<1:01:48, 16.20s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 48.63%\n", + " -> Best Model Test Accuracy: 61.17%\n", "\n", - "[Gen 67/98] Best Fitness: -1.7151, Pop Avg Fitness: -1.7677\n" + "[Gen 67/295] Best Fitness: -1.2738, Pop Avg Fitness: -1.3369\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 68%|██████▊ | 67/98 [05:10<02:18, 4.45s/it]" + "\rEA Generations: 23%|██▎ | 67/295 [18:03<1:01:52, 16.28s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 50.36%\n", + " -> Best Model Test Accuracy: 59.64%\n", "\n", - "[Gen 68/98] Best Fitness: -1.6869, Pop Avg Fitness: -1.7435\n" + "[Gen 68/295] Best Fitness: -1.2704, Pop Avg Fitness: -1.3272\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 69%|██████▉ | 68/98 [05:14<02:13, 4.46s/it]" + "\rEA Generations: 23%|██▎ | 68/295 [18:19<1:01:14, 16.19s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 49.06%\n", + " -> Best Model Test Accuracy: 61.78%\n", "\n", - "[Gen 69/98] Best Fitness: -1.6980, Pop Avg Fitness: -1.7551\n" + "[Gen 69/295] Best Fitness: -1.3075, Pop Avg Fitness: -1.3619\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 70%|███████ | 69/98 [05:19<02:11, 4.52s/it]" + "\rEA Generations: 23%|██▎ | 69/295 [18:35<1:00:51, 16.16s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 49.50%\n", + " -> Best Model Test Accuracy: 61.74%\n", "\n", - "[Gen 70/98] Best Fitness: -1.6789, Pop Avg Fitness: -1.7233\n" + "[Gen 70/295] Best Fitness: -1.2680, Pop Avg Fitness: -1.3281\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 71%|███████▏ | 70/98 [05:23<02:03, 4.40s/it]" + "\rEA Generations: 24%|██▎ | 70/295 [18:51<1:00:44, 16.20s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 49.78%\n", + " -> Best Model Test Accuracy: 62.42%\n", "\n", - "[Gen 71/98] Best Fitness: -1.6869, Pop Avg Fitness: -1.7367\n" + "[Gen 71/295] Best Fitness: -1.2483, Pop Avg Fitness: -1.3075\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 72%|███████▏ | 71/98 [05:28<02:01, 4.51s/it]" + "\rEA Generations: 24%|██▍ | 71/295 [19:07<1:00:09, 16.12s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 49.19%\n", + " -> Best Model Test Accuracy: 64.14%\n", "\n", - "[Gen 72/98] Best Fitness: -1.6406, Pop Avg Fitness: -1.6963\n" + "[Gen 72/295] Best Fitness: -1.2797, Pop Avg Fitness: -1.3258\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 73%|███████▎ | 72/98 [05:32<01:53, 4.38s/it]" + "\rEA Generations: 24%|██▍ | 72/295 [19:23<59:43, 16.07s/it] " ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 52.44%\n", + " -> Best Model Test Accuracy: 60.61%\n", "\n", - "[Gen 73/98] Best Fitness: -1.6397, Pop Avg Fitness: -1.6920\n" + "[Gen 73/295] Best Fitness: -1.2094, Pop Avg Fitness: -1.2660\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 74%|███████▍ | 73/98 [05:36<01:49, 4.40s/it]" + "\rEA Generations: 25%|██▍ | 73/295 [19:39<59:55, 16.20s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 49.57%\n", + " -> Best Model Test Accuracy: 65.27%\n", "\n", - "[Gen 74/98] Best Fitness: -1.6191, Pop Avg Fitness: -1.6638\n" + "[Gen 74/295] Best Fitness: -1.2028, Pop Avg Fitness: -1.2532\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 76%|███████▌ | 74/98 [05:41<01:49, 4.55s/it]" + "\rEA Generations: 25%|██▌ | 74/295 [19:55<59:26, 16.14s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 50.43%\n", + " -> Best Model Test Accuracy: 64.70%\n", "\n", - "[Gen 75/98] Best Fitness: -1.6108, Pop Avg Fitness: -1.6611\n" + "[Gen 75/295] Best Fitness: -1.1800, Pop Avg Fitness: -1.2328\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 77%|███████▋ | 75/98 [05:45<01:41, 4.43s/it]" + "\rEA Generations: 25%|██▌ | 75/295 [20:11<58:58, 16.08s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 52.07%\n", + " -> Best Model Test Accuracy: 65.03%\n", "\n", - "[Gen 76/98] Best Fitness: -1.6149, Pop Avg Fitness: -1.6619\n" + "[Gen 76/295] Best Fitness: -1.1405, Pop Avg Fitness: -1.2036\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 78%|███████▊ | 76/98 [05:50<01:37, 4.45s/it]" + "\rEA Generations: 26%|██▌ | 76/295 [20:28<59:02, 16.18s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 56.17%\n", + " -> Best Model Test Accuracy: 66.25%\n", "\n", - "[Gen 77/98] Best Fitness: -1.6092, Pop Avg Fitness: -1.6432\n" + "[Gen 77/295] Best Fitness: -1.1664, Pop Avg Fitness: -1.2159\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 79%|███████▊ | 77/98 [05:54<01:34, 4.49s/it]" + "\rEA Generations: 26%|██▌ | 77/295 [20:44<58:21, 16.06s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 51.62%\n", + " -> Best Model Test Accuracy: 64.85%\n", "\n", - "[Gen 78/98] Best Fitness: -1.5868, Pop Avg Fitness: -1.6356\n" + "[Gen 78/295] Best Fitness: -1.1698, Pop Avg Fitness: -1.2260\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 80%|███████▉ | 78/98 [05:58<01:27, 4.37s/it]" + "\rEA Generations: 26%|██▋ | 78/295 [20:59<57:51, 16.00s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 55.50%\n", + " -> Best Model Test Accuracy: 66.97%\n", "\n", - "[Gen 79/98] Best Fitness: -1.5907, Pop Avg Fitness: -1.6402\n" + "[Gen 79/295] Best Fitness: -1.1185, Pop Avg Fitness: -1.1725\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 81%|████████ | 79/98 [06:03<01:26, 4.55s/it]" + "\rEA Generations: 27%|██▋ | 79/295 [21:16<58:19, 16.20s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 56.60%\n", + " -> Best Model Test Accuracy: 67.24%\n", "\n", - "[Gen 80/98] Best Fitness: -1.5624, Pop Avg Fitness: -1.6015\n" + "[Gen 80/295] Best Fitness: -1.1150, Pop Avg Fitness: -1.1738\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 82%|████████▏ | 80/98 [06:08<01:20, 4.47s/it]" + "\rEA Generations: 27%|██▋ | 80/295 [21:32<57:39, 16.09s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 56.78%\n", + " -> Best Model Test Accuracy: 68.08%\n", + "\n", + "[Gen 81/295] Best Fitness: -1.0861, Pop Avg Fitness: -1.1432\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 27%|██▋ | 81/295 [21:48<57:04, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 67.93%\n", + "\n", + "[Gen 82/295] Best Fitness: -1.0830, Pop Avg Fitness: -1.1281\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 28%|██▊ | 82/295 [22:04<57:33, 16.21s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 66.94%\n", + "\n", + "[Gen 83/295] Best Fitness: -1.0346, Pop Avg Fitness: -1.0988\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 28%|██▊ | 83/295 [22:20<57:01, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 67.44%\n", + "\n", + "[Gen 84/295] Best Fitness: -1.0491, Pop Avg Fitness: -1.0936\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 28%|██▊ | 84/295 [22:36<56:35, 16.09s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 67.91%\n", + "\n", + "[Gen 85/295] Best Fitness: -1.0705, Pop Avg Fitness: -1.1388\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 29%|██▉ | 85/295 [22:53<57:13, 16.35s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 68.89%\n", + "\n", + "[Gen 86/295] Best Fitness: -1.0386, Pop Avg Fitness: -1.0904\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 29%|██▉ | 86/295 [23:09<56:32, 16.23s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 69.68%\n", + "\n", + "[Gen 87/295] Best Fitness: -1.0632, Pop Avg Fitness: -1.1138\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 29%|██▉ | 87/295 [23:25<55:48, 16.10s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 70.62%\n", + "\n", + "[Gen 88/295] Best Fitness: -1.0173, Pop Avg Fitness: -1.0629\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 30%|██▉ | 88/295 [23:42<55:56, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 70.09%\n", + "\n", + "[Gen 89/295] Best Fitness: -0.9973, Pop Avg Fitness: -1.0456\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 30%|███ | 89/295 [23:57<55:10, 16.07s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 70.33%\n", + "\n", + "[Gen 90/295] Best Fitness: -0.9664, Pop Avg Fitness: -1.0180\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 31%|███ | 90/295 [24:13<54:29, 15.95s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 69.72%\n", + "\n", + "[Gen 91/295] Best Fitness: -0.9665, Pop Avg Fitness: -1.0190\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 31%|███ | 91/295 [24:30<55:03, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 72.16%\n", + "\n", + "[Gen 92/295] Best Fitness: -1.0144, Pop Avg Fitness: -1.0669\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 31%|███ | 92/295 [24:46<54:28, 16.10s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 69.66%\n", + "\n", + "[Gen 93/295] Best Fitness: -0.9763, Pop Avg Fitness: -1.0369\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 32%|███▏ | 93/295 [25:02<53:56, 16.02s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 72.26%\n", + "\n", + "[Gen 94/295] Best Fitness: -0.9442, Pop Avg Fitness: -0.9992\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 32%|███▏ | 94/295 [25:18<54:15, 16.20s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 71.93%\n", + "\n", + "[Gen 95/295] Best Fitness: -0.9361, Pop Avg Fitness: -0.9904\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 32%|███▏ | 95/295 [25:34<53:43, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 72.77%\n", + "\n", + "[Gen 96/295] Best Fitness: -0.9162, Pop Avg Fitness: -0.9699\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 33%|███▎ | 96/295 [25:50<53:11, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 71.45%\n", + "\n", + "[Gen 97/295] Best Fitness: -0.9218, Pop Avg Fitness: -0.9598\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 33%|███▎ | 97/295 [26:07<53:49, 16.31s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 72.74%\n", + "\n", + "[Gen 98/295] Best Fitness: -0.8990, Pop Avg Fitness: -0.9540\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 33%|███▎ | 98/295 [26:23<53:14, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 71.86%\n", + "\n", + "[Gen 99/295] Best Fitness: -0.8720, Pop Avg Fitness: -0.9275\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 34%|███▎ | 99/295 [26:39<52:44, 16.15s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 73.90%\n", + "\n", + "[Gen 100/295] Best Fitness: -0.8695, Pop Avg Fitness: -0.9124\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 34%|███▍ | 100/295 [26:56<53:09, 16.36s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 73.54%\n", + "\n", + "[Gen 101/295] Best Fitness: -0.8515, Pop Avg Fitness: -0.9031\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 34%|███▍ | 101/295 [27:12<52:28, 16.23s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 72.89%\n", + "\n", + "[Gen 102/295] Best Fitness: -0.8844, Pop Avg Fitness: -0.9295\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 35%|███▍ | 102/295 [27:28<51:59, 16.17s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 73.87%\n", + "\n", + "[Gen 103/295] Best Fitness: -0.8561, Pop Avg Fitness: -0.9062\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 35%|███▍ | 103/295 [27:44<51:43, 16.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 74.47%\n", + "\n", + "[Gen 104/295] Best Fitness: -0.8258, Pop Avg Fitness: -0.8767\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 35%|███▌ | 104/295 [28:00<51:27, 16.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 74.55%\n", + "\n", + "[Gen 105/295] Best Fitness: -0.8460, Pop Avg Fitness: -0.8895\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 36%|███▌ | 105/295 [28:16<50:46, 16.03s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.08%\n", + "\n", + "[Gen 106/295] Best Fitness: -0.8399, Pop Avg Fitness: -0.8781\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 36%|███▌ | 106/295 [28:32<50:53, 16.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 74.50%\n", + "\n", + "[Gen 107/295] Best Fitness: -0.8241, Pop Avg Fitness: -0.8619\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 36%|███▋ | 107/295 [28:48<50:42, 16.18s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 74.46%\n", + "\n", + "[Gen 108/295] Best Fitness: -0.8475, Pop Avg Fitness: -0.8862\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 37%|███▋ | 108/295 [29:04<50:10, 16.10s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.51%\n", + "\n", + "[Gen 109/295] Best Fitness: -0.8127, Pop Avg Fitness: -0.8504\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 37%|███▋ | 109/295 [29:20<49:54, 16.10s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.17%\n", + "\n", + "[Gen 110/295] Best Fitness: -0.7834, Pop Avg Fitness: -0.8222\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 37%|███▋ | 110/295 [29:37<49:58, 16.21s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.26%\n", + "\n", + "[Gen 111/295] Best Fitness: -0.8077, Pop Avg Fitness: -0.8444\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 38%|███▊ | 111/295 [29:53<49:26, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.46%\n", + "\n", + "[Gen 112/295] Best Fitness: -0.7633, Pop Avg Fitness: -0.8065\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 38%|███▊ | 112/295 [30:09<49:38, 16.28s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.52%\n", + "\n", + "[Gen 113/295] Best Fitness: -0.7961, Pop Avg Fitness: -0.8413\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 38%|███▊ | 113/295 [30:26<49:27, 16.31s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.68%\n", + "\n", + "[Gen 114/295] Best Fitness: -0.7492, Pop Avg Fitness: -0.7890\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 39%|███▊ | 114/295 [30:42<48:50, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.94%\n", + "\n", + "[Gen 115/295] Best Fitness: -0.7754, Pop Avg Fitness: -0.8069\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 39%|███▉ | 115/295 [30:57<48:07, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 77.43%\n", + "\n", + "[Gen 116/295] Best Fitness: -0.7547, Pop Avg Fitness: -0.7908\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 39%|███▉ | 116/295 [31:14<48:08, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 76.62%\n", + "\n", + "[Gen 117/295] Best Fitness: -0.7628, Pop Avg Fitness: -0.7994\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 40%|███▉ | 117/295 [31:30<47:43, 16.09s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 78.23%\n", + "\n", + "[Gen 118/295] Best Fitness: -0.7969, Pop Avg Fitness: -0.8327\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 40%|████ | 118/295 [31:46<47:43, 16.18s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 77.64%\n", + "\n", + "[Gen 119/295] Best Fitness: -0.7386, Pop Avg Fitness: -0.7780\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 40%|████ | 119/295 [32:03<47:50, 16.31s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 77.54%\n", + "\n", + "[Gen 120/295] Best Fitness: -0.7431, Pop Avg Fitness: -0.7730\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 41%|████ | 120/295 [32:19<47:19, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 77.05%\n", + "\n", + "[Gen 121/295] Best Fitness: -0.7347, Pop Avg Fitness: -0.7685\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 41%|████ | 121/295 [32:35<46:46, 16.13s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 78.81%\n", + "\n", + "[Gen 122/295] Best Fitness: -0.7132, Pop Avg Fitness: -0.7453\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 41%|████▏ | 122/295 [32:51<46:56, 16.28s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 78.42%\n", + "\n", + "[Gen 123/295] Best Fitness: -0.7413, Pop Avg Fitness: -0.7697\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 42%|████▏ | 123/295 [33:07<46:19, 16.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 77.48%\n", + "\n", + "[Gen 124/295] Best Fitness: -0.7359, Pop Avg Fitness: -0.7634\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 42%|████▏ | 124/295 [33:23<45:53, 16.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 78.46%\n", + "\n", + "[Gen 125/295] Best Fitness: -0.7355, Pop Avg Fitness: -0.7694\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 42%|████▏ | 125/295 [33:40<46:03, 16.26s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.60%\n", + "\n", + "[Gen 126/295] Best Fitness: -0.6922, Pop Avg Fitness: -0.7256\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 43%|████▎ | 126/295 [33:56<45:28, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.75%\n", + "\n", + "[Gen 127/295] Best Fitness: -0.7226, Pop Avg Fitness: -0.7540\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 43%|████▎ | 127/295 [34:12<45:05, 16.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 78.86%\n", + "\n", + "[Gen 128/295] Best Fitness: -0.7207, Pop Avg Fitness: -0.7584\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 43%|████▎ | 128/295 [34:28<45:12, 16.24s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.07%\n", + "\n", + "[Gen 129/295] Best Fitness: -0.7268, Pop Avg Fitness: -0.7624\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 44%|████▎ | 129/295 [34:44<44:36, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.45%\n", + "\n", + "[Gen 130/295] Best Fitness: -0.7207, Pop Avg Fitness: -0.7498\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 44%|████▍ | 130/295 [35:00<44:07, 16.05s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.35%\n", + "\n", + "[Gen 131/295] Best Fitness: -0.7126, Pop Avg Fitness: -0.7570\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 44%|████▍ | 131/295 [35:17<44:19, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 80.18%\n", + "\n", + "[Gen 132/295] Best Fitness: -0.7000, Pop Avg Fitness: -0.7350\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 45%|████▍ | 132/295 [35:32<43:47, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.61%\n", + "\n", + "[Gen 133/295] Best Fitness: -0.7127, Pop Avg Fitness: -0.7480\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 45%|████▌ | 133/295 [35:49<43:35, 16.15s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 79.72%\n", + "\n", + "[Gen 134/295] Best Fitness: -0.6703, Pop Avg Fitness: -0.7048\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 45%|████▌ | 134/295 [36:05<43:34, 16.24s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 80.11%\n", + "\n", + "[Gen 135/295] Best Fitness: -0.6432, Pop Avg Fitness: -0.6746\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 46%|████▌ | 135/295 [36:21<42:54, 16.09s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 80.66%\n", + "\n", + "[Gen 136/295] Best Fitness: -0.6521, Pop Avg Fitness: -0.6949\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 46%|████▌ | 136/295 [36:37<42:18, 15.97s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 80.72%\n", + "\n", + "[Gen 137/295] Best Fitness: -0.6794, Pop Avg Fitness: -0.7087\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 46%|████▋ | 137/295 [36:53<42:19, 16.07s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 80.90%\n", + "\n", + "[Gen 138/295] Best Fitness: -0.6290, Pop Avg Fitness: -0.6609\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 47%|████▋ | 138/295 [37:09<41:46, 15.96s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.21%\n", + "\n", + "[Gen 139/295] Best Fitness: -0.6688, Pop Avg Fitness: -0.6953\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 47%|████▋ | 139/295 [37:25<41:44, 16.05s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.63%\n", + "\n", + "[Gen 140/295] Best Fitness: -0.6509, Pop Avg Fitness: -0.6872\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 47%|████▋ | 140/295 [37:41<41:44, 16.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.17%\n", + "\n", + "[Gen 141/295] Best Fitness: -0.6314, Pop Avg Fitness: -0.6592\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 48%|████▊ | 141/295 [37:57<41:09, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.36%\n", + "\n", + "[Gen 142/295] Best Fitness: -0.5903, Pop Avg Fitness: -0.6264\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 48%|████▊ | 142/295 [38:13<40:36, 15.92s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.51%\n", + "\n", + "[Gen 143/295] Best Fitness: -0.5913, Pop Avg Fitness: -0.6231\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 48%|████▊ | 143/295 [38:29<40:23, 15.95s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.15%\n", + "\n", + "[Gen 144/295] Best Fitness: -0.6195, Pop Avg Fitness: -0.6531\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 49%|████▉ | 144/295 [38:45<40:15, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.12%\n", + "\n", + "[Gen 145/295] Best Fitness: -0.6062, Pop Avg Fitness: -0.6373\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 49%|████▉ | 145/295 [39:00<39:46, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.64%\n", + "\n", + "[Gen 146/295] Best Fitness: -0.6548, Pop Avg Fitness: -0.6849\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 49%|████▉ | 146/295 [39:16<39:19, 15.83s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.97%\n", + "\n", + "[Gen 147/295] Best Fitness: -0.5881, Pop Avg Fitness: -0.6128\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 50%|████▉ | 147/295 [39:33<39:38, 16.07s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.44%\n", + "\n", + "[Gen 148/295] Best Fitness: -0.5897, Pop Avg Fitness: -0.6131\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 50%|█████ | 148/295 [39:49<39:20, 16.06s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 81.74%\n", + "\n", + "[Gen 149/295] Best Fitness: -0.5818, Pop Avg Fitness: -0.6097\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 51%|█████ | 149/295 [40:05<38:57, 16.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.36%\n", + "\n", + "[Gen 150/295] Best Fitness: -0.5935, Pop Avg Fitness: -0.6247\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 51%|█████ | 150/295 [40:21<39:07, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.08%\n", + "\n", + "[Gen 151/295] Best Fitness: -0.6426, Pop Avg Fitness: -0.6785\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 51%|█████ | 151/295 [40:37<38:41, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.79%\n", + "\n", + "[Gen 152/295] Best Fitness: -0.5969, Pop Avg Fitness: -0.6263\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 52%|█████▏ | 152/295 [40:53<38:05, 15.98s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.93%\n", + "\n", + "[Gen 153/295] Best Fitness: -0.5783, Pop Avg Fitness: -0.6056\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 52%|█████▏ | 153/295 [41:09<38:09, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.18%\n", + "\n", + "[Gen 154/295] Best Fitness: -0.5779, Pop Avg Fitness: -0.6057\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 52%|█████▏ | 154/295 [41:26<38:03, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 82.86%\n", + "\n", + "[Gen 155/295] Best Fitness: -0.5446, Pop Avg Fitness: -0.5729\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 53%|█████▎ | 155/295 [41:41<37:25, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.17%\n", + "\n", + "[Gen 156/295] Best Fitness: -0.5821, Pop Avg Fitness: -0.6091\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 53%|█████▎ | 156/295 [41:58<37:30, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.35%\n", + "\n", + "[Gen 157/295] Best Fitness: -0.5639, Pop Avg Fitness: -0.5870\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 53%|█████▎ | 157/295 [42:14<37:03, 16.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.26%\n", + "\n", + "[Gen 158/295] Best Fitness: -0.5303, Pop Avg Fitness: -0.5592\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 54%|█████▎ | 158/295 [42:30<36:38, 16.05s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.08%\n", + "\n", + "[Gen 159/295] Best Fitness: -0.5507, Pop Avg Fitness: -0.5770\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 54%|█████▍ | 159/295 [42:46<36:45, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.10%\n", + "\n", + "[Gen 160/295] Best Fitness: -0.5266, Pop Avg Fitness: -0.5507\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 54%|█████▍ | 160/295 [43:03<36:30, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.77%\n", + "\n", + "[Gen 161/295] Best Fitness: -0.5682, Pop Avg Fitness: -0.5971\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 55%|█████▍ | 161/295 [43:19<36:01, 16.13s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.57%\n", + "\n", + "[Gen 162/295] Best Fitness: -0.5613, Pop Avg Fitness: -0.5953\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 55%|█████▍ | 162/295 [43:35<36:01, 16.26s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.66%\n", + "\n", + "[Gen 163/295] Best Fitness: -0.5143, Pop Avg Fitness: -0.5393\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 55%|█████▌ | 163/295 [43:51<35:27, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.88%\n", + "\n", + "[Gen 164/295] Best Fitness: -0.5313, Pop Avg Fitness: -0.5542\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 56%|█████▌ | 164/295 [44:07<34:53, 15.98s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.11%\n", + "\n", + "[Gen 165/295] Best Fitness: -0.5536, Pop Avg Fitness: -0.5803\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 56%|█████▌ | 165/295 [44:23<34:56, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.91%\n", + "\n", + "[Gen 166/295] Best Fitness: -0.5411, Pop Avg Fitness: -0.5674\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 56%|█████▋ | 166/295 [44:39<34:34, 16.08s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.17%\n", + "\n", + "[Gen 167/295] Best Fitness: -0.5864, Pop Avg Fitness: -0.6159\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 57%|█████▋ | 167/295 [44:55<34:02, 15.96s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.08%\n", + "\n", + "[Gen 168/295] Best Fitness: -0.5466, Pop Avg Fitness: -0.5677\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 57%|█████▋ | 168/295 [45:11<33:55, 16.03s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 83.88%\n", + "\n", + "[Gen 169/295] Best Fitness: -0.5146, Pop Avg Fitness: -0.5395\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 57%|█████▋ | 169/295 [45:27<33:51, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.71%\n", + "\n", + "[Gen 170/295] Best Fitness: -0.5497, Pop Avg Fitness: -0.5731\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 58%|█████▊ | 170/295 [45:43<33:27, 16.06s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.73%\n", + "\n", + "[Gen 171/295] Best Fitness: -0.4955, Pop Avg Fitness: -0.5196\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 58%|█████▊ | 171/295 [45:59<32:55, 15.93s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.05%\n", + "\n", + "[Gen 172/295] Best Fitness: -0.5604, Pop Avg Fitness: -0.5864\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 58%|█████▊ | 172/295 [46:15<32:58, 16.09s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.47%\n", + "\n", + "[Gen 173/295] Best Fitness: -0.4940, Pop Avg Fitness: -0.5179\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 59%|█████▊ | 173/295 [46:31<32:24, 15.93s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.48%\n", + "\n", + "[Gen 174/295] Best Fitness: -0.5294, Pop Avg Fitness: -0.5518\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 59%|█████▉ | 174/295 [46:47<32:06, 15.92s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.80%\n", + "\n", + "[Gen 175/295] Best Fitness: -0.5205, Pop Avg Fitness: -0.5433\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 59%|█████▉ | 175/295 [47:04<32:26, 16.22s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.59%\n", + "\n", + "[Gen 176/295] Best Fitness: -0.5484, Pop Avg Fitness: -0.5764\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 60%|█████▉ | 176/295 [47:20<32:01, 16.15s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.63%\n", + "\n", + "[Gen 177/295] Best Fitness: -0.5692, Pop Avg Fitness: -0.5972\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 60%|██████ | 177/295 [47:35<31:37, 16.08s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.43%\n", + "\n", + "[Gen 178/295] Best Fitness: -0.5173, Pop Avg Fitness: -0.5422\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 60%|██████ | 178/295 [47:52<31:32, 16.17s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.76%\n", + "\n", + "[Gen 179/295] Best Fitness: -0.5117, Pop Avg Fitness: -0.5369\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 61%|██████ | 179/295 [48:08<31:01, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.08%\n", + "\n", + "[Gen 180/295] Best Fitness: -0.5385, Pop Avg Fitness: -0.5620\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 61%|██████ | 180/295 [48:23<30:39, 15.99s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.83%\n", + "\n", + "[Gen 181/295] Best Fitness: -0.4829, Pop Avg Fitness: -0.5091\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 61%|██████▏ | 181/295 [48:40<30:57, 16.30s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.72%\n", + "\n", + "[Gen 182/295] Best Fitness: -0.5305, Pop Avg Fitness: -0.5583\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 62%|██████▏ | 182/295 [48:56<30:23, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.72%\n", + "\n", + "[Gen 183/295] Best Fitness: -0.5156, Pop Avg Fitness: -0.5397\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 62%|██████▏ | 183/295 [49:12<29:58, 16.06s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.09%\n", + "\n", + "[Gen 184/295] Best Fitness: -0.5369, Pop Avg Fitness: -0.5708\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 62%|██████▏ | 184/295 [49:29<29:59, 16.21s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.26%\n", + "\n", + "[Gen 185/295] Best Fitness: -0.4881, Pop Avg Fitness: -0.5198\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 63%|██████▎ | 185/295 [49:44<29:20, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.19%\n", + "\n", + "[Gen 186/295] Best Fitness: -0.5391, Pop Avg Fitness: -0.5726\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 63%|██████▎ | 186/295 [50:00<29:10, 16.06s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.83%\n", + "\n", + "[Gen 187/295] Best Fitness: -0.5100, Pop Avg Fitness: -0.5330\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 63%|██████▎ | 187/295 [50:17<29:08, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.20%\n", + "\n", + "[Gen 188/295] Best Fitness: -0.5476, Pop Avg Fitness: -0.5730\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 64%|██████▎ | 188/295 [50:33<28:36, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.34%\n", + "\n", + "[Gen 189/295] Best Fitness: -0.5331, Pop Avg Fitness: -0.5546\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 64%|██████▍ | 189/295 [50:49<28:17, 16.02s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.19%\n", + "\n", + "[Gen 190/295] Best Fitness: -0.4952, Pop Avg Fitness: -0.5205\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 64%|██████▍ | 190/295 [51:05<28:25, 16.24s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.60%\n", + "\n", + "[Gen 191/295] Best Fitness: -0.5246, Pop Avg Fitness: -0.5484\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 65%|██████▍ | 191/295 [51:22<28:10, 16.25s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.40%\n", + "\n", + "[Gen 192/295] Best Fitness: -0.5322, Pop Avg Fitness: -0.5567\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 65%|██████▌ | 192/295 [51:37<27:40, 16.13s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 84.87%\n", + "\n", + "[Gen 193/295] Best Fitness: -0.4972, Pop Avg Fitness: -0.5204\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 65%|██████▌ | 193/295 [51:54<27:25, 16.13s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.50%\n", + "\n", + "[Gen 194/295] Best Fitness: -0.4802, Pop Avg Fitness: -0.5047\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 66%|██████▌ | 194/295 [52:10<27:13, 16.18s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.40%\n", + "\n", + "[Gen 195/295] Best Fitness: -0.4832, Pop Avg Fitness: -0.5094\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 66%|██████▌ | 195/295 [52:26<26:48, 16.09s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.96%\n", + "\n", + "[Gen 196/295] Best Fitness: -0.5266, Pop Avg Fitness: -0.5501\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 66%|██████▋ | 196/295 [52:43<27:03, 16.40s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.96%\n", + "\n", + "[Gen 197/295] Best Fitness: -0.4777, Pop Avg Fitness: -0.5016\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 67%|██████▋ | 197/295 [52:59<26:37, 16.30s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.78%\n", + "\n", + "[Gen 198/295] Best Fitness: -0.5232, Pop Avg Fitness: -0.5495\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 67%|██████▋ | 198/295 [53:15<26:12, 16.21s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.72%\n", + "\n", + "[Gen 199/295] Best Fitness: -0.5081, Pop Avg Fitness: -0.5406\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 67%|██████▋ | 199/295 [53:31<26:06, 16.31s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.85%\n", + "\n", + "[Gen 200/295] Best Fitness: -0.4814, Pop Avg Fitness: -0.5043\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 68%|██████▊ | 200/295 [53:48<25:43, 16.25s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.55%\n", + "\n", + "[Gen 201/295] Best Fitness: -0.4450, Pop Avg Fitness: -0.4668\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 68%|██████▊ | 201/295 [54:03<25:17, 16.15s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.60%\n", + "\n", + "[Gen 202/295] Best Fitness: -0.4471, Pop Avg Fitness: -0.4710\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 68%|██████▊ | 202/295 [54:20<25:18, 16.32s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.74%\n", + "\n", + "[Gen 203/295] Best Fitness: -0.4832, Pop Avg Fitness: -0.5050\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 69%|██████▉ | 203/295 [54:36<24:49, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.88%\n", + "\n", + "[Gen 204/295] Best Fitness: -0.4707, Pop Avg Fitness: -0.4912\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 69%|██████▉ | 204/295 [54:52<24:22, 16.07s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.95%\n", + "\n", + "[Gen 205/295] Best Fitness: -0.5118, Pop Avg Fitness: -0.5322\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 69%|██████▉ | 205/295 [55:08<23:54, 15.94s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.01%\n", + "\n", + "[Gen 206/295] Best Fitness: -0.4579, Pop Avg Fitness: -0.4766\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 70%|██████▉ | 206/295 [55:24<23:56, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.01%\n", + "\n", + "[Gen 207/295] Best Fitness: -0.4670, Pop Avg Fitness: -0.4861\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 70%|███████ | 207/295 [55:40<23:30, 16.02s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 85.89%\n", + "\n", + "[Gen 208/295] Best Fitness: -0.4532, Pop Avg Fitness: -0.4828\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 71%|███████ | 208/295 [55:56<23:12, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.03%\n", + "\n", + "[Gen 209/295] Best Fitness: -0.4907, Pop Avg Fitness: -0.5114\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 71%|███████ | 209/295 [56:13<23:17, 16.24s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.23%\n", + "\n", + "[Gen 210/295] Best Fitness: -0.5114, Pop Avg Fitness: -0.5309\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 71%|███████ | 210/295 [56:28<22:47, 16.08s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.26%\n", + "\n", + "[Gen 211/295] Best Fitness: -0.4873, Pop Avg Fitness: -0.5119\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 72%|███████▏ | 211/295 [56:44<22:32, 16.10s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.23%\n", + "\n", + "[Gen 212/295] Best Fitness: -0.4672, Pop Avg Fitness: -0.4858\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 72%|███████▏ | 212/295 [57:01<22:24, 16.19s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.43%\n", + "\n", + "[Gen 213/295] Best Fitness: -0.4680, Pop Avg Fitness: -0.4899\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 72%|███████▏ | 213/295 [57:17<21:57, 16.06s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.34%\n", + "\n", + "[Gen 214/295] Best Fitness: -0.4290, Pop Avg Fitness: -0.4494\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 73%|███████▎ | 214/295 [57:32<21:34, 15.98s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.44%\n", + "\n", + "[Gen 215/295] Best Fitness: -0.4841, Pop Avg Fitness: -0.5082\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 73%|███████▎ | 215/295 [57:49<21:28, 16.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.47%\n", + "\n", + "[Gen 216/295] Best Fitness: -0.4513, Pop Avg Fitness: -0.4754\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 73%|███████▎ | 216/295 [58:05<21:06, 16.04s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.55%\n", + "\n", + "[Gen 217/295] Best Fitness: -0.4317, Pop Avg Fitness: -0.4543\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 74%|███████▎ | 217/295 [58:21<20:49, 16.02s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.70%\n", + "\n", + "[Gen 218/295] Best Fitness: -0.4618, Pop Avg Fitness: -0.4834\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 74%|███████▍ | 218/295 [58:37<20:43, 16.15s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.49%\n", + "\n", + "[Gen 219/295] Best Fitness: -0.4301, Pop Avg Fitness: -0.4592\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 74%|███████▍ | 219/295 [58:53<20:16, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.49%\n", + "\n", + "[Gen 220/295] Best Fitness: -0.4600, Pop Avg Fitness: -0.4819\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 75%|███████▍ | 220/295 [59:09<19:53, 15.92s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.49%\n", + "\n", + "[Gen 221/295] Best Fitness: -0.4829, Pop Avg Fitness: -0.5066\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 75%|███████▍ | 221/295 [59:25<19:39, 15.94s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.32%\n", + "\n", + "[Gen 222/295] Best Fitness: -0.4271, Pop Avg Fitness: -0.4481\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 75%|███████▌ | 222/295 [59:40<19:23, 15.95s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.75%\n", + "\n", + "[Gen 223/295] Best Fitness: -0.4287, Pop Avg Fitness: -0.4477\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 76%|███████▌ | 223/295 [59:57<19:10, 15.97s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.72%\n", + "\n", + "[Gen 224/295] Best Fitness: -0.4627, Pop Avg Fitness: -0.4933\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 76%|███████▌ | 224/295 [1:00:12<18:49, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.72%\n", + "\n", + "[Gen 225/295] Best Fitness: -0.4613, Pop Avg Fitness: -0.4815\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 76%|███████▋ | 225/295 [1:00:28<18:39, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.96%\n", + "\n", + "[Gen 226/295] Best Fitness: -0.4987, Pop Avg Fitness: -0.5205\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 77%|███████▋ | 226/295 [1:00:44<18:17, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.93%\n", + "\n", + "[Gen 227/295] Best Fitness: -0.4567, Pop Avg Fitness: -0.4762\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 77%|███████▋ | 227/295 [1:01:00<17:56, 15.84s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.95%\n", + "\n", + "[Gen 228/295] Best Fitness: -0.4309, Pop Avg Fitness: -0.4501\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 77%|███████▋ | 228/295 [1:01:16<17:52, 16.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.62%\n", + "\n", + "[Gen 229/295] Best Fitness: -0.4592, Pop Avg Fitness: -0.4778\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 78%|███████▊ | 229/295 [1:01:32<17:29, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 86.75%\n", + "\n", + "[Gen 230/295] Best Fitness: -0.4148, Pop Avg Fitness: -0.4403\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 78%|███████▊ | 230/295 [1:01:48<17:09, 15.84s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.12%\n", + "\n", + "[Gen 231/295] Best Fitness: -0.4805, Pop Avg Fitness: -0.5053\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 78%|███████▊ | 231/295 [1:02:04<17:00, 15.95s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.24%\n", + "\n", + "[Gen 232/295] Best Fitness: -0.4084, Pop Avg Fitness: -0.4268\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 79%|███████▊ | 232/295 [1:02:20<16:47, 15.99s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.32%\n", + "\n", + "[Gen 233/295] Best Fitness: -0.4436, Pop Avg Fitness: -0.4664\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 79%|███████▉ | 233/295 [1:02:36<16:24, 15.87s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.20%\n", + "\n", + "[Gen 234/295] Best Fitness: -0.4589, Pop Avg Fitness: -0.4750\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 79%|███████▉ | 234/295 [1:02:51<16:08, 15.88s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.38%\n", + "\n", + "[Gen 235/295] Best Fitness: -0.4761, Pop Avg Fitness: -0.5032\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 80%|███████▉ | 235/295 [1:03:08<15:58, 15.98s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.40%\n", + "\n", + "[Gen 236/295] Best Fitness: -0.4978, Pop Avg Fitness: -0.5215\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 80%|████████ | 236/295 [1:03:23<15:37, 15.89s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.23%\n", + "\n", + "[Gen 237/295] Best Fitness: -0.4571, Pop Avg Fitness: -0.4758\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 80%|████████ | 237/295 [1:03:39<15:15, 15.78s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.26%\n", + "\n", + "[Gen 238/295] Best Fitness: -0.4247, Pop Avg Fitness: -0.4460\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 81%|████████ | 238/295 [1:03:55<15:14, 16.05s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.52%\n", + "\n", + "[Gen 239/295] Best Fitness: -0.4610, Pop Avg Fitness: -0.4781\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 81%|████████ | 239/295 [1:04:11<14:56, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.43%\n", + "\n", + "[Gen 240/295] Best Fitness: -0.4151, Pop Avg Fitness: -0.4350\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 81%|████████▏ | 240/295 [1:04:28<14:42, 16.05s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.25%\n", + "\n", + "[Gen 241/295] Best Fitness: -0.4548, Pop Avg Fitness: -0.4723\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 82%|████████▏ | 241/295 [1:04:44<14:35, 16.21s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.61%\n", + "\n", + "[Gen 242/295] Best Fitness: -0.4415, Pop Avg Fitness: -0.4572\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 82%|████████▏ | 242/295 [1:05:00<14:14, 16.12s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.41%\n", + "\n", + "[Gen 243/295] Best Fitness: -0.4665, Pop Avg Fitness: -0.4865\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 82%|████████▏ | 243/295 [1:05:16<13:51, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.42%\n", + "\n", + "[Gen 244/295] Best Fitness: -0.4131, Pop Avg Fitness: -0.4310\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 83%|████████▎ | 244/295 [1:05:33<13:49, 16.26s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.41%\n", + "\n", + "[Gen 245/295] Best Fitness: -0.4656, Pop Avg Fitness: -0.4842\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 83%|████████▎ | 245/295 [1:05:49<13:28, 16.18s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.51%\n", + "\n", + "[Gen 246/295] Best Fitness: -0.4444, Pop Avg Fitness: -0.4639\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 83%|████████▎ | 246/295 [1:06:05<13:09, 16.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.45%\n", + "\n", + "[Gen 247/295] Best Fitness: -0.4817, Pop Avg Fitness: -0.5005\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 84%|████████▎ | 247/295 [1:06:21<13:00, 16.26s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.48%\n", + "\n", + "[Gen 248/295] Best Fitness: -0.4585, Pop Avg Fitness: -0.4788\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 84%|████████▍ | 248/295 [1:06:37<12:38, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.57%\n", + "\n", + "[Gen 249/295] Best Fitness: -0.4106, Pop Avg Fitness: -0.4282\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 84%|████████▍ | 249/295 [1:06:53<12:18, 16.07s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.63%\n", + "\n", + "[Gen 250/295] Best Fitness: -0.4550, Pop Avg Fitness: -0.4775\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 85%|████████▍ | 250/295 [1:07:10<12:11, 16.25s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.64%\n", + "\n", + "[Gen 251/295] Best Fitness: -0.4647, Pop Avg Fitness: -0.4847\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 85%|████████▌ | 251/295 [1:07:25<11:48, 16.11s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.36%\n", + "\n", + "[Gen 252/295] Best Fitness: -0.4406, Pop Avg Fitness: -0.4566\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 85%|████████▌ | 252/295 [1:07:41<11:27, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.65%\n", + "\n", + "[Gen 253/295] Best Fitness: -0.4222, Pop Avg Fitness: -0.4396\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 86%|████████▌ | 253/295 [1:07:58<11:22, 16.25s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.60%\n", + "\n", + "[Gen 254/295] Best Fitness: -0.4246, Pop Avg Fitness: -0.4446\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 86%|████████▌ | 254/295 [1:08:14<11:00, 16.10s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.69%\n", + "\n", + "[Gen 255/295] Best Fitness: -0.4717, Pop Avg Fitness: -0.4938\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 86%|████████▋ | 255/295 [1:08:30<10:42, 16.07s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.47%\n", + "\n", + "[Gen 256/295] Best Fitness: -0.4161, Pop Avg Fitness: -0.4383\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 87%|████████▋ | 256/295 [1:08:46<10:30, 16.16s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.82%\n", + "\n", + "[Gen 257/295] Best Fitness: -0.4598, Pop Avg Fitness: -0.4818\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 87%|████████▋ | 257/295 [1:09:02<10:07, 16.00s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.71%\n", + "\n", + "[Gen 258/295] Best Fitness: -0.4460, Pop Avg Fitness: -0.4673\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 87%|████████▋ | 258/295 [1:09:17<09:47, 15.89s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.59%\n", + "\n", + "[Gen 259/295] Best Fitness: -0.4151, Pop Avg Fitness: -0.4356\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 88%|████████▊ | 259/295 [1:09:34<09:36, 16.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.82%\n", + "\n", + "[Gen 260/295] Best Fitness: -0.3869, Pop Avg Fitness: -0.4068\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 88%|████████▊ | 260/295 [1:09:50<09:21, 16.03s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.64%\n", + "\n", + "[Gen 261/295] Best Fitness: -0.4032, Pop Avg Fitness: -0.4242\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 88%|████████▊ | 261/295 [1:10:05<09:00, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.54%\n", + "\n", + "[Gen 262/295] Best Fitness: -0.4244, Pop Avg Fitness: -0.4469\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 89%|████████▉ | 262/295 [1:10:21<08:41, 15.81s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.93%\n", + "\n", + "[Gen 263/295] Best Fitness: -0.4060, Pop Avg Fitness: -0.4258\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 89%|████████▉ | 263/295 [1:10:37<08:31, 15.98s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.76%\n", + "\n", + "[Gen 264/295] Best Fitness: -0.4423, Pop Avg Fitness: -0.4593\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 89%|████████▉ | 264/295 [1:10:53<08:12, 15.90s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.80%\n", + "\n", + "[Gen 265/295] Best Fitness: -0.4062, Pop Avg Fitness: -0.4260\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 90%|████████▉ | 265/295 [1:11:09<07:58, 15.93s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.84%\n", + "\n", + "[Gen 266/295] Best Fitness: -0.4100, Pop Avg Fitness: -0.4299\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 90%|█████████ | 266/295 [1:11:26<07:48, 16.14s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.81%\n", + "\n", + "[Gen 267/295] Best Fitness: -0.3973, Pop Avg Fitness: -0.4207\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 91%|█████████ | 267/295 [1:11:41<07:27, 15.97s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.96%\n", + "\n", + "[Gen 268/295] Best Fitness: -0.4398, Pop Avg Fitness: -0.4680\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 91%|█████████ | 268/295 [1:11:57<07:09, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.93%\n", + "\n", + "[Gen 269/295] Best Fitness: -0.4485, Pop Avg Fitness: -0.4677\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 91%|█████████ | 269/295 [1:12:13<06:56, 16.02s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 88.25%\n", + "\n", + "[Gen 270/295] Best Fitness: -0.4304, Pop Avg Fitness: -0.4494\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 92%|█████████▏| 270/295 [1:12:29<06:38, 15.94s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.76%\n", + "\n", + "[Gen 271/295] Best Fitness: -0.4070, Pop Avg Fitness: -0.4304\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 92%|█████████▏| 271/295 [1:12:45<06:19, 15.83s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.95%\n", + "\n", + "[Gen 272/295] Best Fitness: -0.4162, Pop Avg Fitness: -0.4348\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 92%|█████████▏| 272/295 [1:13:00<06:03, 15.82s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.96%\n", + "\n", + "[Gen 273/295] Best Fitness: -0.3745, Pop Avg Fitness: -0.3951\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 93%|█████████▎| 273/295 [1:13:17<05:50, 15.93s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.95%\n", + "\n", + "[Gen 274/295] Best Fitness: -0.4385, Pop Avg Fitness: -0.4547\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 93%|█████████▎| 274/295 [1:13:33<05:34, 15.94s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.89%\n", + "\n", + "[Gen 275/295] Best Fitness: -0.4018, Pop Avg Fitness: -0.4187\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 93%|█████████▎| 275/295 [1:13:48<05:17, 15.88s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 87.99%\n", + "\n", + "[Gen 276/295] Best Fitness: -0.3803, Pop Avg Fitness: -0.3947\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 94%|█████████▎| 276/295 [1:14:05<05:04, 16.01s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 88.08%\n", + "\n", + "[Gen 277/295] Best Fitness: -0.4040, Pop Avg Fitness: -0.4416\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\rEA Generations: 94%|█████████▍| 277/295 [1:14:20<04:46, 15.91s/it]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + " -> Best Model Test Accuracy: 88.16%\n", "\n", - "[Gen 81/98] Best Fitness: -1.5446, Pop Avg Fitness: -1.5922\n" + "[Gen 278/295] Best Fitness: -0.3778, Pop Avg Fitness: -0.3970\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 83%|████████▎ | 81/98 [06:12<01:14, 4.37s/it]" + "\rEA Generations: 94%|█████████▍| 278/295 [1:14:36<04:28, 15.78s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 56.97%\n", + " -> Best Model Test Accuracy: 88.09%\n", "\n", - "[Gen 82/98] Best Fitness: -1.5382, Pop Avg Fitness: -1.5784\n" + "[Gen 279/295] Best Fitness: -0.4032, Pop Avg Fitness: -0.4227\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 84%|████████▎ | 82/98 [06:17<01:13, 4.57s/it]" + "\rEA Generations: 95%|█████████▍| 279/295 [1:14:52<04:15, 15.96s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 56.97%\n", + " -> Best Model Test Accuracy: 88.09%\n", "\n", - "[Gen 83/98] Best Fitness: -1.5310, Pop Avg Fitness: -1.5718\n" + "[Gen 280/295] Best Fitness: -0.4329, Pop Avg Fitness: -0.4547\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 85%|████████▍ | 83/98 [06:21<01:06, 4.42s/it]" + "\rEA Generations: 95%|█████████▍| 280/295 [1:15:08<03:59, 15.94s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 53.19%\n", + " -> Best Model Test Accuracy: 88.17%\n", "\n", - "[Gen 84/98] Best Fitness: -1.5178, Pop Avg Fitness: -1.5556\n" + "[Gen 281/295] Best Fitness: -0.3684, Pop Avg Fitness: -0.3906\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 86%|████████▌ | 84/98 [06:25<01:00, 4.32s/it]" + "\rEA Generations: 95%|█████████▌| 281/295 [1:15:24<03:42, 15.86s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 56.67%\n", + " -> Best Model Test Accuracy: 88.26%\n", "\n", - "[Gen 85/98] Best Fitness: -1.5000, Pop Avg Fitness: -1.5426\n" + "[Gen 282/295] Best Fitness: -0.3640, Pop Avg Fitness: -0.3821\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 87%|████████▋ | 85/98 [06:30<00:58, 4.48s/it]" + "\rEA Generations: 96%|█████████▌| 282/295 [1:15:40<03:27, 15.94s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 57.87%\n", + " -> Best Model Test Accuracy: 88.14%\n", "\n", - "[Gen 86/98] Best Fitness: -1.4661, Pop Avg Fitness: -1.5139\n" + "[Gen 283/295] Best Fitness: -0.4138, Pop Avg Fitness: -0.4316\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 88%|████████▊ | 86/98 [06:34<00:53, 4.42s/it]" + "\rEA Generations: 96%|█████████▌| 283/295 [1:15:56<03:10, 15.91s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 58.75%\n", + " -> Best Model Test Accuracy: 87.93%\n", "\n", - "[Gen 87/98] Best Fitness: -1.4799, Pop Avg Fitness: -1.5356\n" + "[Gen 284/295] Best Fitness: -0.4093, Pop Avg Fitness: -0.4255\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 89%|████████▉ | 87/98 [06:39<00:48, 4.41s/it]" + "\rEA Generations: 96%|█████████▋| 284/295 [1:16:11<02:54, 15.86s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 58.94%\n", + " -> Best Model Test Accuracy: 88.16%\n", "\n", - "[Gen 88/98] Best Fitness: -1.4430, Pop Avg Fitness: -1.4835\n" + "[Gen 285/295] Best Fitness: -0.4472, Pop Avg Fitness: -0.4643\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 90%|████████▉ | 88/98 [06:43<00:45, 4.52s/it]" + "\rEA Generations: 97%|█████████▋| 285/295 [1:16:27<02:37, 15.76s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 58.94%\n", + " -> Best Model Test Accuracy: 87.95%\n", "\n", - "[Gen 89/98] Best Fitness: -1.4568, Pop Avg Fitness: -1.5003\n" + "[Gen 286/295] Best Fitness: -0.4089, Pop Avg Fitness: -0.4291\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 91%|█████████ | 89/98 [06:47<00:39, 4.39s/it]" + "\rEA Generations: 97%|█████████▋| 286/295 [1:16:44<02:24, 16.01s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 59.86%\n", + " -> Best Model Test Accuracy: 87.97%\n", "\n", - "[Gen 90/98] Best Fitness: -1.4416, Pop Avg Fitness: -1.4828\n" + "[Gen 287/295] Best Fitness: -0.3904, Pop Avg Fitness: -0.4107\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 92%|█████████▏| 90/98 [06:52<00:36, 4.51s/it]" + "\rEA Generations: 97%|█████████▋| 287/295 [1:16:59<02:07, 15.89s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 60.92%\n", + " -> Best Model Test Accuracy: 88.38%\n", "\n", - "[Gen 91/98] Best Fitness: -1.4450, Pop Avg Fitness: -1.4823\n" + "[Gen 288/295] Best Fitness: -0.4075, Pop Avg Fitness: -0.4217\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 93%|█████████▎| 91/98 [06:56<00:31, 4.44s/it]" + "\rEA Generations: 98%|█████████▊| 288/295 [1:17:15<01:50, 15.85s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 59.00%\n", + " -> Best Model Test Accuracy: 88.16%\n", "\n", - "[Gen 92/98] Best Fitness: -1.4072, Pop Avg Fitness: -1.4450\n" + "[Gen 289/295] Best Fitness: -0.3725, Pop Avg Fitness: -0.3888\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 94%|█████████▍| 92/98 [07:01<00:26, 4.36s/it]" + "\rEA Generations: 98%|█████████▊| 289/295 [1:17:31<01:36, 16.03s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 60.03%\n", + " -> Best Model Test Accuracy: 88.09%\n", "\n", - "[Gen 93/98] Best Fitness: -1.4114, Pop Avg Fitness: -1.4548\n" + "[Gen 290/295] Best Fitness: -0.4317, Pop Avg Fitness: -0.4522\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 95%|█████████▍| 93/98 [07:06<00:22, 4.53s/it]" + "\rEA Generations: 98%|█████████▊| 290/295 [1:17:47<01:19, 15.95s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 61.85%\n", + " -> Best Model Test Accuracy: 88.32%\n", "\n", - "[Gen 94/98] Best Fitness: -1.3933, Pop Avg Fitness: -1.4287\n" + "[Gen 291/295] Best Fitness: -0.3665, Pop Avg Fitness: -0.3800\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 96%|█████████▌| 94/98 [07:10<00:17, 4.40s/it]" + "\rEA Generations: 99%|█████████▊| 291/295 [1:18:03<01:03, 15.85s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 61.72%\n", + " -> Best Model Test Accuracy: 88.50%\n", "\n", - "[Gen 95/98] Best Fitness: -1.3886, Pop Avg Fitness: -1.4261\n" + "[Gen 292/295] Best Fitness: -0.3908, Pop Avg Fitness: -0.4204\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 97%|█████████▋| 95/98 [07:14<00:13, 4.39s/it]" + "\rEA Generations: 99%|█████████▉| 292/295 [1:18:19<00:48, 16.01s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 63.41%\n", + " -> Best Model Test Accuracy: 88.43%\n", "\n", - "[Gen 96/98] Best Fitness: -1.3887, Pop Avg Fitness: -1.4313\n" + "[Gen 293/295] Best Fitness: -0.4243, Pop Avg Fitness: -0.4409\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 98%|█████████▊| 96/98 [07:19<00:09, 4.53s/it]" + "\rEA Generations: 99%|█████████▉| 293/295 [1:18:35<00:31, 15.90s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 60.30%\n", + " -> Best Model Test Accuracy: 88.37%\n", "\n", - "[Gen 97/98] Best Fitness: -1.3600, Pop Avg Fitness: -1.4109\n" + "[Gen 294/295] Best Fitness: -0.4304, Pop Avg Fitness: -0.4483\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "\rEA Generations: 99%|█████████▉| 97/98 [07:23<00:04, 4.40s/it]" + "\rEA Generations: 100%|█████████▉| 294/295 [1:18:51<00:15, 15.87s/it]" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 64.12%\n", + " -> Best Model Test Accuracy: 88.11%\n", "\n", - "[Gen 98/98] Best Fitness: -1.3686, Pop Avg Fitness: -1.4152\n" + "[Gen 295/295] Best Fitness: -0.4539, Pop Avg Fitness: -0.4728\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ - "EA Generations: 100%|██████████| 98/98 [07:28<00:00, 4.57s/it]\n" + "EA Generations: 100%|██████████| 295/295 [1:19:07<00:00, 16.09s/it]\n" ] }, { "output_type": "stream", "name": "stdout", "text": [ - " -> Best Model Test Accuracy: 63.60%\n", + " -> Best Model Test Accuracy: 88.39%\n", "\n", "--- Training Baseline Model with Adam Optimizer ---\n" ] @@ -1861,11 +5001,11 @@ "output_type": "stream", "name": "stderr", "text": [ - "Adam Epoch 1/5: 100%|██████████| 59/59 [00:48<00:00, 1.22it/s]\n", - "Adam Epoch 2/5: 100%|██████████| 59/59 [00:50<00:00, 1.17it/s]\n", - "Adam Epoch 3/5: 100%|██████████| 59/59 [00:49<00:00, 1.19it/s]\n", - "Adam Epoch 4/5: 100%|██████████| 59/59 [00:48<00:00, 1.21it/s]\n", - "Adam Epoch 5/5: 100%|██████████| 59/59 [00:52<00:00, 1.13it/s]\n" + "Adam Epoch 1/5: 100%|██████████| 59/59 [02:00<00:00, 2.04s/it]\n", + "Adam Epoch 2/5: 100%|██████████| 59/59 [02:00<00:00, 2.04s/it]\n", + "Adam Epoch 3/5: 100%|██████████| 59/59 [02:00<00:00, 2.04s/it]\n", + "Adam Epoch 4/5: 100%|██████████| 59/59 [01:59<00:00, 2.03s/it]\n", + "Adam Epoch 5/5: 100%|██████████| 59/59 [01:59<00:00, 2.03s/it]\n" ] }, { @@ -1874,8 +5014,8 @@ "text": [ "\n", "--- Final Results ---\n", - "Final Adam Model Accuracy: 94.70%\n", - "Final Best EA Model Accuracy: 63.60%\n", + "Final Adam Model Accuracy: 94.39%\n", + "Final Best EA Model Accuracy: 88.39%\n", "\n", "Performance plot saved to 'performance_comparison.png'\n" ] @@ -1886,19 +5026,19 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": {} } ], - "execution_count": 4, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "id": "yw4r6x2aSNdb", - "outputId": "d2369ef6-f041-4066-f968-b30d9d80180a" + "outputId": "6a4be55a-4ab1-4a75-9a03-d6780f3a9ab6" } } ],