wspEHO.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import math\n",
    "import cv2\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from dataclasses import dataclass, field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipynb.fs.full.wspShannonEvaluation import wspShannonEvaluation\n",
    "from ipynb.fs.full.wspTsallisEvaluation import wspTsallisEvaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Elephant:\n",
    "    chrom: field(default_factory=lambda: [])\n",
    "    cost: float = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_elephants(elephants, fitness, n, hist, lb, ub, objFunc, q):\n",
    "    for i in range(n): # Evaluation\n",
    "        fitness[i] = -objFunc(hist, elephants[i], lb, ub, q)\n",
    "    \n",
    "    indice = np.argsort(fitness)\n",
    "    fitness.sort()\n",
    "    \n",
    "    ele = np.array(elephants)\n",
    "    sorted_elephants = ele[indice]\n",
    "\n",
    "    return sorted_elephants, fitness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CalculateClanCenter(Clan, cindex, dim, numElephantInEachClan):\n",
    "    ClanCenter = np.zeros(dim)\n",
    "\n",
    "    for Elephantindex in range(numElephantInEachClan):\n",
    "        ClanCenter = ClanCenter + Clan[cindex][Elephantindex].chrom\n",
    "\n",
    "    ClanCenter = (1/numElephantInEachClan)*ClanCenter\n",
    "    \n",
    "    return ClanCenter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ClearDups(NewClan, lb, ub):\n",
    "    \"\"\"Clear Duplicates\"\"\"\n",
    "    for i in range(len(NewClan)):\n",
    "        Chrom1 = np.sort(NewClan[i].chrom)\n",
    "        for j in range(i+1, len(NewClan)):\n",
    "            Chrom2 = np.sort(NewClan[j].chrom)\n",
    "            if np.array_equal(Chrom1, Chrom2):\n",
    "                parnum = round(len(NewClan[j].chrom) * np.random.uniform(0, 1))\n",
    "                NewClan[j].chrom[parnum] = math.floor(lb + (ub - lb + 1) * np.random.uniform(0, 1))\n",
    "\n",
    "    return NewClan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def FeasibleFunction(NewClan, n, dim, lb, ub):\n",
    "    for i in range(n):\n",
    "        NewClan[i].chrom = np.clip(NewClan[i].chrom, lb, ub)\n",
    "        NewClan[i].chrom.sort()\n",
    "\n",
    "    return NewClan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CostFunction(NewClan,hist, n, dim, lb, ub, objFunc, q):\n",
    "    for i in range(len(NewClan)):\n",
    "        threshs = NewClan[i].chrom\n",
    "        NewClan[i].cost = -objFunc(hist, threshs.astype(int), lb, ub, q)\n",
    "    \n",
    "    return NewClan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PopSort(NewClan):\n",
    "    NewClan = sorted(NewClan, key=lambda x: x.cost)\n",
    "    return NewClan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CombineClan(NewClan, n, nClan, dim):\n",
    "    j = 0\n",
    "    popindex = 0\n",
    "    Population = [Elephant(np.zeros(dim)) for w in range(n)]\n",
    "\n",
    "    while popindex < n:\n",
    "        for clanindex in range(nClan):\n",
    "            Population[popindex] = NewClan[clanindex][j]\n",
    "            popindex += 1\n",
    "\n",
    "        j += 1\n",
    "    \n",
    "    return Population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wspElephantHerding(n, dim, nkE, nClan, alpha, beta, maxGeneration, hist, lb, ub, objFunc, q):\n",
    "    \"\"\"\"\n",
    "    Elephant Herding Algorithm\n",
    "\n",
    "    :param n: number of elephants\n",
    "    :param d: dimension\n",
    "    :param nkE: (elitism parameter) how many of the best elephants to keep from one generation to the next\n",
    "    :param nClan: Number of clans\n",
    "    :param alpha: Impact facotr of matriarch\n",
    "    :param beta: attractivity factor\n",
    "    :param maxGeneration: number of max generation\n",
    "    :param hist: histogram\n",
    "\n",
    "    :return: thresholding set fi = {l1, l2, ..., ld }\n",
    "    \"\"\"\n",
    "    t = 0\n",
    "    keep = nkE\n",
    "    lb = lb + 1\n",
    "    ub = ub - 1\n",
    "    numElephantInEachClan = round(n/nClan)\n",
    "    nEvaluations = n\n",
    "    # random.seed(0) # Reset the random generator\n",
    "    # np.random.seed(0)\n",
    "\n",
    "    elephants = []\n",
    "\n",
    "    for _ in range(n): # generate elephants with d-dimensional solution\n",
    "        elephant = random.sample(range(lb,ub), dim)\n",
    "        elephant.sort()\n",
    "        elephants.append(elephant)\n",
    "\n",
    "    fitness = np.zeros(n) # Initial fitness of each elephant\n",
    "\n",
    "    chromKeep = np.zeros((keep, dim), dtype=int)\n",
    "    costKeep = np.zeros(keep)\n",
    "    Clan = [[Elephant(np.zeros(dim)) for x in range(numElephantInEachClan)] for y in range(nClan)]\n",
    "\n",
    "    # Sort all the elephants according to their fitness.\n",
    "    elephants, fitness = sort_elephants(elephants, fitness, n, hist, lb, ub, objFunc, q)\n",
    "\n",
    "    while t < maxGeneration:\n",
    "\n",
    "        \"\"\"           Elitism Strategy           \"\"\"\n",
    "        # Save the best elephants in a temporary array.\n",
    "        for i in range(keep):\n",
    "            chromKeep[i] = elephants[i]\n",
    "            costKeep[i] = fitness[i]\n",
    "\n",
    "        \"\"\"Divide the whole elephant population into some clans according to their fitness.\"\"\"\n",
    "        j = 0\n",
    "        popIndex = 0\n",
    "\n",
    "        while popIndex < n:\n",
    "            for cindex in range(nClan):\n",
    "                Clan[cindex][j] = Elephant(elephants[popIndex], fitness[popIndex])\n",
    "                popIndex += 1\n",
    "\n",
    "            j += 1\n",
    "\n",
    "        \"\"\"              Clan Updating Operator              \"\"\"\n",
    "        j = 0\n",
    "        popIndex = 0\n",
    "        NewClan = [[Elephant(np.zeros(dim)) for x in range(numElephantInEachClan)] for y in range(nClan)]\n",
    "        \n",
    "        while popIndex < n:\n",
    "            for cindex in range(nClan):\n",
    "                ClanCenter = CalculateClanCenter(Clan, cindex, dim, numElephantInEachClan)\n",
    "                NewClan[cindex][j].chrom = Clan[cindex][j].chrom + alpha * (np.array(Clan[cindex][0].chrom) - np.array(Clan[cindex][j].chrom)) * np.random.uniform(0, 1, dim)\n",
    "\n",
    "                if np.sum(NewClan[cindex][j].chrom - Clan[cindex][j].chrom) == 0:\n",
    "                    NewClan[cindex][j].chrom = beta * ClanCenter\n",
    "\n",
    "                popIndex += 1\n",
    "            \n",
    "            j+=1\n",
    "        \n",
    "        \"\"\"           Separating Operator          \"\"\"\n",
    "        for cindex in range(nClan):\n",
    "            NewClan[cindex][len(NewClan[cindex])-1].chrom = lb + (ub - lb + 1)*np.random.uniform(0, 1, dim)\n",
    "        \n",
    "        \"\"\"           Evaluate NewClan          \"\"\"\n",
    "        SavePopSize = n\n",
    "        for i in range(nClan):\n",
    "            n = numElephantInEachClan\n",
    "            # Make sure the population does not have duplicates.\n",
    "            NewClan[i] = ClearDups(NewClan[i], lb, ub)\n",
    "            # Make sure each individual is legal.\n",
    "            NewClan[i] = FeasibleFunction(NewClan[i], n , dim, lb, ub)\n",
    "            # Calculate cost\n",
    "            NewClan[i] = CostFunction(NewClan[i],hist, n, dim, lb, ub, objFunc, q)\n",
    "            # the number of fitness evaluations\n",
    "            nEvaluations = nEvaluations +  n\n",
    "            # Sort from best to worst\n",
    "            NewClan[i] = PopSort(NewClan[i])\n",
    "        n = SavePopSize\n",
    "\n",
    "        \"\"\"Combine two subpopulations into one and rank monarch butterflis\"\"\"\n",
    "        Population = CombineClan(NewClan, n, nClan, dim)\n",
    "        Population = PopSort(Population)\n",
    "        \n",
    "        \"\"\"           Elitism Strategy          \"\"\"\n",
    "        # Replace the worst with the previous generation's elites.\n",
    "        p_size = len(Population)-1\n",
    "        for k in range(keep):\n",
    "            Population[p_size-k].chrom = chromKeep[k]\n",
    "            Population[p_size-k].cost = costKeep[k]\n",
    "\n",
    "        # Sort from best to worst\n",
    "        Population = PopSort(Population)\n",
    "        \n",
    "        t+=1\n",
    "    return (Population[0].chrom).astype(int)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('tcc_env')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "50c3a715107fe4dcdc7dcc1225e41dc08fefd31cb688eb0c1f730ec66093fb86"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}