notebook.ipynb

{
  "cells": [
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Imports"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "import os\n",
        "import pathlib\n",
        "import random\n",
        "from math import sqrt\n",
        "import ujson\n",
        "\n",
        "import pandas as pd\n",
        "import plotly.express as px\n",
        "\n",
        "if \"PATH\" not in globals():\n",
        "    PATH = pathlib.Path.cwd() / \"src\"\n",
        "\n",
        "# set current working directory to the path\n",
        "os.chdir(PATH)\n",
        "print(f\"Current path: {PATH}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# update the PYTHONPATH\n",
        "!export PYTHONPATH=$PYTHONPATH:{PATH}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from src.MOO import MOO\n",
        "from src.optimizers.NSGA2 import NSGA2\n",
        "from src.optimizers.NSRA import NSRA\n",
        "from src.optimizers.NSWGE import NSWGE\n",
        "from src.problems.multitask_routing.Network import Network\n",
        "from src.problems.multitask_routing.Task import Task\n",
        "from src.problems.Solution import Solution"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Defining the parameters"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "random.seed(42)"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Layers"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# PROBLEM DEFINITION\n",
        "paramsLayerOne = {\n",
        "    \"unit\": {\n",
        "        \"tag\": \"DEVICE\",\n",
        "        \"computingSpeed\": lambda: random.randint(5, 10),\n",
        "        \"positionX\": 0,\n",
        "        \"positionY\": 0,\n",
        "        \"throughput\": 0.5,\n",
        "        \"pollution\": lambda: round(random.random(), 2),\n",
        "        \"cost\": lambda: round(random.random(), 2),\n",
        "    },\n",
        "    \"cable\": {\n",
        "        \"distance\": lambda x, y: sqrt(\n",
        "            pow(x.positionX - y.positionX, 2)\n",
        "            + pow(x.positionY - y.positionY, 2)\n",
        "        ),\n",
        "        \"propagationSpeed\": lambda: 1,\n",
        "        \"flowRate\": lambda: 1,\n",
        "    },\n",
        "    \"numberNewUnits\": 10,\n",
        "}\n",
        "\n",
        "paramsLayerTwo = {\n",
        "    \"unit\": {\n",
        "        \"tag\": \"FOG\",\n",
        "        \"computingSpeed\": lambda x: x.computingSpeed * random.randint(5, 10),\n",
        "        \"positionX\": lambda x: x.positionX + random.randint(-2, 2),\n",
        "        \"positionY\": lambda x: x.positionY + random.randint(-2, 2),\n",
        "        \"throughput\": lambda x: x.throughput * round(random.random(), 2) * 2\n",
        "        + 1,\n",
        "        \"pollution\": lambda x: (x.pollution + 1)\n",
        "        * (round(random.random(), 2) + 1),\n",
        "        \"cost\": lambda x: (x.cost + 1) * (round(random.random(), 2) + 1),\n",
        "    },\n",
        "    \"cable\": {\n",
        "        \"distance\": lambda x, y: sqrt(\n",
        "            pow(x.positionX - y.positionX, 2)\n",
        "            + pow(x.positionY - y.positionY, 2)\n",
        "        ),\n",
        "        \"propagationSpeed\": lambda: 2,\n",
        "        \"flowRate\": lambda: 3,\n",
        "    },\n",
        "    \"numberNewUnits\": 20,\n",
        "}\n",
        "\n",
        "paramsLayerThree = {\n",
        "    \"unit\": {\n",
        "        \"tag\": \"CLOUD\",\n",
        "        \"computingSpeed\": lambda x: x.computingSpeed * random.randint(50, 100),\n",
        "        \"positionX\": lambda x: x.positionX + random.randint(-5, 5),\n",
        "        \"positionY\": lambda x: x.positionY + random.randint(-5, 5),\n",
        "        \"throughput\": lambda x: x.throughput * round(random.random(), 2) * 3\n",
        "        + 1,\n",
        "        \"pollution\": lambda x: (x.pollution + 1)\n",
        "        * (round(random.random(), 2) + 1),\n",
        "        \"cost\": lambda x: (x.cost + 1) * (round(random.random(), 2) + 1),\n",
        "    },\n",
        "    \"cable\": {\n",
        "        \"distance\": lambda x, y: sqrt(\n",
        "            pow(x.positionX - y.positionX, 2)\n",
        "            + pow(x.positionY - y.positionY, 2)\n",
        "        ),\n",
        "        \"propagationSpeed\": lambda: 2,\n",
        "        \"flowRate\": lambda: 3,\n",
        "    },\n",
        "    \"numberNewUnits\": 10,\n",
        "}"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Tasks"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "tasks = tuple(\n",
        "    Task(random.randint(10, 100000), random.randint(10, 100000)) for _ in range(4)\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Network"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "optimUnits = {\n",
        "    \"processingTime\": \"Processing time (s)\",\n",
        "    \"cost\": \"Cost (€)\",\n",
        "    \"pollution\": \"Pollution (g)\",\n",
        "}\n",
        "optimDirections = {\n",
        "    \"processingTime\": \"min\",\n",
        "    \"cost\": \"min\",\n",
        "    \"pollution\": \"min\",\n",
        "}\n",
        "problem = Network(\n",
        "    \"DEVICE\",\n",
        "    tasks=tasks,\n",
        "    optimDirections=optimDirections,\n",
        "    minDepth=1,\n",
        "    maxDepth=15,\n",
        "    mutationRate=0.1,  # it should be an algorithm parameter\n",
        "    layers=[paramsLayerOne, paramsLayerTwo, paramsLayerTwo, paramsLayerThree],\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Optimization"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "nIterations = 10\n",
        "nSolutions = 100"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Optimization"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "moo = MOO(problem)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "nswge_paretos = moo.optimize(\n",
        "    NSWGE,\n",
        "    nSolutions,\n",
        "    nIterations,\n",
        "    imDir=PATH.parent / \"imgs\",\n",
        "    saveDir=PATH.parent / \"paretos\",\n",
        "    export=True,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "nsga2_paretos = moo.optimize(\n",
        "    NSGA2,\n",
        "    nSolutions,\n",
        "    nIterations,\n",
        "    imDir=PATH.parent / \"imgs\",\n",
        "    saveDir=PATH.parent / \"paretos\",\n",
        "    export=True,\n",
        "    ratioKept=0.5,\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "nsra_paretos = moo.optimize(\n",
        "    NSRA,\n",
        "    nSolutions,\n",
        "    nIterations,\n",
        "    imDir=PATH.parent / \"imgs\",\n",
        "    saveDir=PATH.parent / \"paretos\",\n",
        "    export=True,\n",
        "    ratioKept=0.5,\n",
        ")"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Evaluation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "MOO.relative_efficiency(nsra_paretos, nsga2_paretos, Solution.optimDirections, verbose=True)\n",
        "MOO.relative_efficiency(nswge_paretos, nsga2_paretos, Solution.optimDirections, verbose=True)\n",
        "MOO.relative_efficiency(nswge_paretos, nsra_paretos, Solution.optimDirections, verbose=True)\n"
      ]
    },
    {
      "attachments": {},
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "def generate_violin_plot(df, yaxis_title=\"Value\"):\n",
        "    fig = px.violin(\n",
        "        df,\n",
        "        x=\"Epoch\",\n",
        "        y=\"Value\",\n",
        "        box=True,\n",
        "        points=False,\n",
        "        hover_data=df.columns,\n",
        "        template=\"plotly_white\",\n",
        "        color_discrete_sequence=[\"#1f77b4\"],\n",
        "    )\n",
        "    fig.update_layout(\n",
        "        xaxis_title=\"Epoch\",\n",
        "        yaxis_title=yaxis_title,\n",
        "        font=dict(\n",
        "            family=\"Times New Roman\",\n",
        "            size=12,\n",
        "        ),\n",
        "    )\n",
        "    fig.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# load pareto data from json\n",
        "for file in os.listdir(PATH.parent / \"paretos\"):\n",
        "    if file.endswith(\".json\"):\n",
        "        # load file as dict\n",
        "        print(file)\n",
        "        with open(PATH.parent / \"paretos\" / file, \"r\") as f:\n",
        "            data = ujson.load(f)\n",
        "        for objective in optimDirections.keys():\n",
        "            # unstack values\n",
        "            df = (\n",
        "                pd.DataFrame.from_dict(data[objective], orient=\"index\")\n",
        "                .stack()\n",
        "                .reset_index()\n",
        "                .rename(columns={\"level_0\": \"Epoch\", 0: \"Value\"})\n",
        "                .drop(columns=\"level_1\")\n",
        "            )\n",
        "            # generate plot\n",
        "            generate_violin_plot(\n",
        "                df,\n",
        "                yaxis_title=optimUnits[objective],\n",
        "            )\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "venv",
      "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.10"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "e0fd7870c844ce9ebd94db62f42dc1165e727123798b67a6f5059ea7a11ade64"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}