examples/tanaka_multiobjective.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "df25a30b",
   "metadata": {},
   "source": [
    "# Tanaka function\n",
    "---\n",
    "Description:\n",
    "\n",
    "- Optimization (min)\n",
    "- Multi-objective (2)\n",
    "- Constraints (2)\n",
    "---\n",
    "\n",
    "Minimize the equations given by:\n",
    "\n",
    "\\begin{cases}\n",
    "      f_{1}\\left(\\mathbf{x}\\right) = x, \\\\\n",
    "      f_{2}\\left(\\mathbf{x}\\right) = y, \\\\\n",
    "\\end{cases}\n",
    "\n",
    "subject to:\n",
    "\n",
    "\\begin{cases}\n",
    "      C_{1}\\left(\\mathbf{x}\\right) = x^{2} + y^{2} - 1 - 0.1\\cos\\left(16 \\arctan(x/y) \\right) \\geq 0, \\\\\n",
    "      C_{2}\\left(\\mathbf{x}\\right) = \\left(x - 0.5\\right)^{2} + \\left(y - 0.5\\right)^{2} \\leq 0.5 \\\\\n",
    "\\end{cases}\n",
    "\n",
    "where:\n",
    "\n",
    "\\begin{cases}\n",
    "      0\\le x \\le \\pi, \\\\\n",
    "      0\\le y \\le \\pi. \\\\\n",
    "\\end{cases}\n",
    "\n",
    "The constrained Pareto-optimal solutions lie on the boundary of the first constraint. Since the constraint function is periodic and the second constraint function must also be satisfied, not all solutions on the boundary of the first constraint are Pareto-optimal. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb448d0a",
   "metadata": {},
   "source": [
    "### First we import python libraries and set up the directory of our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a7e3adb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "import numpy as np\n",
    "from math import fsum, isclose\n",
    "\n",
    "PROJECT_DIR = os.path.abspath('..')\n",
    "sys.path.append(PROJECT_DIR)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbab465f",
   "metadata": {},
   "source": [
    "### Here we import all our custom GA code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "247088c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import main classes.\n",
    "from pygenalgo.genome.gene import Gene\n",
    "from pygenalgo.genome.chromosome import Chromosome\n",
    "from pygenalgo.engines.standard_ga import StandardGA\n",
    "\n",
    "# Import Selection Operator(s).\n",
    "from pygenalgo.operators.selection.linear_rank_selector import LinearRankSelector\n",
    "\n",
    "# Import Crossover Operator(s).\n",
    "from pygenalgo.operators.crossover.uniform_crossover import UniformCrossover\n",
    "\n",
    "# Import Mutation Operator(s).\n",
    "from pygenalgo.operators.mutation.random_mutator import RandomMutator"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e91fb6e2",
   "metadata": {},
   "source": [
    "### Define the multi-objective function, which plays also the role of the 'fitness' function.\n",
    "\n",
    "In addition, we define the 'rand_fx' which takes the role of the 'random()' method of the Genes. Every \n",
    "time we want to 'mutate' a gene this function will be called that returns 'valid', but random values for \n",
    "the gene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "be1afc07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multi-objective function.\n",
    "def fun_Tanaka(individual: Chromosome, f_min: bool = True):\n",
    "    \n",
    "    # Set the penalty coefficient.\n",
    "    p_coeff = 0.8\n",
    "    \n",
    "    # Extract genes from the chromosome.\n",
    "    x1, x2 = [gene.value for gene in individual.genome]\n",
    "    \n",
    "    # Compute each objective function.\n",
    "    f1, f2 = x1, x2\n",
    "    \n",
    "    # Avoid \"division by zero\" errors.\n",
    "    if isclose(x2, 0.0):\n",
    "        x2 += 0.0001\n",
    "    # _end_if_\n",
    "    \n",
    "    # Compute the constraints.\n",
    "    C1 = min(0.0, x1**2 + x2**2 - 1.0 - 0.1*np.cos(16.0 * np.arctan(x1/x2)))**2\n",
    "    C2 = max(0.0, (x1 - 0.5)**2 + (x2 - 0.5)**2 - 0.5)**2\n",
    "    \n",
    "    # Compute the final value.\n",
    "    f_val = fsum([0.5*f1, 0.5*f2, p_coeff*C1, p_coeff*C2])\n",
    "\n",
    "    # Condition for termination.\n",
    "    solution_found = False\n",
    "\n",
    "    # Assign the fitness value (check for minimization).\n",
    "    fit_value = -f_val if f_min else f_val\n",
    "    \n",
    "    # Return the solution tuple.\n",
    "    return fit_value, solution_found\n",
    "# _end_def_\n",
    "\n",
    "# Random functions:\n",
    "rand_fx = lambda: np.random.uniform(0.0, np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5304ee70",
   "metadata": {},
   "source": [
    "Here we set the GA parameters, such as number of genes, number of chromosomes, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "57fb9f33",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the number of chromosomes.\n",
    "N = 100\n",
    "\n",
    "# Initial population.\n",
    "population = [Chromosome([Gene(np.random.uniform(0.0, np.pi), rand_fx),\n",
    "                          Gene(np.random.uniform(0.0, np.pi), rand_fx)], np.nan, True)\n",
    "              for _ in range(N)]\n",
    "\n",
    "# Create the StandardGA object that will carry on the optimization.\n",
    "test_GA = StandardGA(initial_pop=population,\n",
    "                     fit_func=fun_Tanaka,\n",
    "                     select_op=LinearRankSelector(),\n",
    "                     mutate_op=RandomMutator(0.15),\n",
    "                     crossx_op=UniformCrossover(0.85))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "517084eb",
   "metadata": {},
   "source": [
    "### Optimization process.\n",
    "\n",
    "Here we call the GA object (either directly, or through the method run()). We set a number of parameter, such as the maximum iterations (i.e. epochs), tolerance for the fitness convergences, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "828f50a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial Avg. Fitness = -20.3098.\n",
      "Final   Avg. Fitness = -3.0220.\n",
      "Elapsed time: 0.980 seconds.\n"
     ]
    }
   ],
   "source": [
    "test_GA(epochs=500, elitism=True, f_tol=1.0e-6, verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b04ddaf2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1=0.93485, x2=0.00235\n",
      "\n",
      "f1(x1, x2) = 0.93485\n",
      "f2(x1, x2) = 0.00235\n"
     ]
    }
   ],
   "source": [
    "x1, x2 = [gene.value for gene in test_GA.best_chromosome().genome]\n",
    "\n",
    "f1, f2 = x1, x2\n",
    "\n",
    "print(f\"x1={x1:.5f}, x2={x2:.5f}\", end='\\n\\n')\n",
    "print(f\"f1(x1, x2) = {f1:.5f}\")\n",
    "print(f\"f2(x1, x2) = {f2:.5f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "574e346b",
   "metadata": {},
   "source": [
    "**Note that the above solution is indeed in the Pareto-optimal solutions!**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c73558d0",
   "metadata": {},
   "source": [
    "### End of file"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "venv_tf",
   "language": "python",
   "name": "venv_tf"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}