ord-dev.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "06099fca-7f97-4e11-8019-c9e859dee043",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "UNIT_CONVERTER = 24.5\n",
    "data = pd.read_excel('media/data/order2024.xlsx', engine=\"openpyxl\")\n",
    "\n",
    "    # Rename columns\n",
    "data = data.rename(columns={\n",
    "        \"กำหนดส่ง\": \"due_date\",\n",
    "        \"แผ่นหน้า\": \"front_sheet\",\n",
    "        \"ลอน C\": \"c_wave\",\n",
    "        \"แผ่นกลาง\": \"middle_sheet\",\n",
    "        \"ลอน B\": \"b_wave\",\n",
    "        \"แผ่นหลัง\": \"back_sheet\",\n",
    "        \"จน.ชั้น\": \"level\",\n",
    "        \"กว้างผลิต\": \"width\",\n",
    "        \"ยาวผลิต\": \"length\",\n",
    "        \"ทับเส้นซ้าย\": \"left_edge_cut\",\n",
    "        \"ทับเส้นกลาง\": \"middle_edge_cut\",\n",
    "        \"ทับเส้นขวา\": \"right_edge_cut\",\n",
    "        \"เลขที่ใบสั่งขาย\": \"order_number\",\n",
    "        \"ชนิดส่วนประกอบ\": \"component_type\",\n",
    "        \"จำนวนสั่งขาย\": \"quantity\",\n",
    "        \"จำนวนสั่งผลิต\": \"production_quantity\",localhost\n",
    "        \"ประเภททับเส้น\": \"edge_type\",\n",
    "        \"สถานะใบสั่ง\": \"order_status\",\n",
    "        \"% ที่เกิน\": \"excess_percentage\"\n",
    "    })\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b02bd1d5-a3e6-41a3-9a7f-26d250826101",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_9298/1617615471.py:4: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '11.102' has dtype incompatible with int64, please explicitly cast to a compatible dtype first.\n",
      "  data.at[index, 'width'] = round(row[\"width\"] / UNIT_CONVERTER, 4)\n",
      "/tmp/ipykernel_9298/1617615471.py:5: FutureWarning: Setting an item of incompatible dtype is deprecated and will raise an error in a future version of pandas. Value '13.0204' has dtype incompatible with int64, please explicitly cast to a compatible dtype first.\n",
      "  data.at[index, 'length'] = round(row[\"length\"] / UNIT_CONVERTER, 4)\n"
     ]
    }
   ],
   "source": [
    "import uuid\n",
    "\n",
    "for index, row in data.iterrows():\n",
    "    data.at[index, 'width'] = round(row[\"width\"] / UNIT_CONVERTER, 4)\n",
    "    data.at[index, 'length'] = round(row[\"length\"] / UNIT_CONVERTER, 4)\n",
    "    data.at[index, 'id'] = uuid.uuid4()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec1802f-6b22-440e-895b-e7c282267240",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "adee5719-2c3b-4803-bd3f-89b3619dcb8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "start_date = pd.to_datetime('2024-08-1')\n",
    "stop_date = pd.to_datetime('2024-08-7')\n",
    "\n",
    "\n",
    "dated_data = data[(data['due_date'] >= start_date) & (data['due_date'] <= stop_date)].reset_index(drop=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f519121e-9cdc-4aaa-9014-49aeec87da62",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "LEGACY_FILTER = [\n",
    "    \"front_sheet\",\n",
    "    \"c_wave\",\n",
    "    \"middle_sheet\",\n",
    "    \"b_wave\",\n",
    "    \"back_sheet\",\n",
    "]\n",
    "\n",
    "def legacy_filter_order(data):\n",
    "        legacy_filters = LEGACY_FILTER\n",
    "        ordplan = pd.DataFrame(None)\n",
    "        best_index=0\n",
    "        most_compat_plan = 0\n",
    "        indices = list(range(len(data)))\n",
    "        random.shuffle(indices)\n",
    "\n",
    "        for index in indices:\n",
    "            init_order = data.iloc[index]\n",
    "            # Create a mask for matching orders using all legacy filters\n",
    "            mask = (data[legacy_filters].eq(init_order[legacy_filters])).all(axis=1)\n",
    "            # Apply the mask and reset the index\n",
    "            ordplan = data.loc[mask].reset_index(drop=True)\n",
    "            if len(ordplan)>most_compat_plan:\n",
    "                best_index=index\n",
    "                most_compat_plan=len(ordplan)\n",
    "\n",
    "        init_order = data.iloc[best_index]\n",
    "        mask = (data[legacy_filters].eq(init_order[legacy_filters])).all(axis=1)\n",
    "        ordplan = data.loc[mask].reset_index(drop=True)\n",
    "        data = ordplan\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "184f0605-e810-493e-bbf2-0e9c4e239c9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "filtered_data = legacy_filter_order(dated_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "02deb038-b716-4294-ad03-0039acb2c3be",
   "metadata": {},
   "outputs": [],
   "source": [
    "from icecream import ic\n",
    "import numpy as np\n",
    "from dataclasses import dataclass\n",
    "from typing import Any, Dict\n",
    "from numpy import roll\n",
    "import pandas as pd\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "91de1fe3-899d-43f2-ba6d-2804ce3023fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# from modules.ordplan import ORD\n",
    "\n",
    "# legacy_data = ORD(filtered_data, deadline_range = 30, size=temp_size).get()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "af0972df-4e6b-40e4-b8c7-ea70befa62fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "\n",
    "from ortools.linear_solver import pywraplp\n",
    "# from ordplan_project.settings import ROLL_PAPER\n",
    "\n",
    "ROLL_PAPER = [66, 68, 70, 73, 74, 75, 79, 82, 85, 88, 91, 93, 95, 97]\n",
    "@dataclass\n",
    "class LP:\n",
    "    results: Dict[str, Any]\n",
    "    def run(self):\n",
    "        roll_paper = ROLL_PAPER\n",
    "        results = self.results\n",
    "        if results is None:\n",
    "            raise ValueError('Results is empty!')\n",
    "        solver = pywraplp.Solver.CreateSolver(\"SAT\")\n",
    "\n",
    "        variables = {\n",
    "            f'{roll}' :  solver.IntVar(0, 1,f'{roll}')\n",
    "            for roll in roll_paper\n",
    "        }\n",
    "\n",
    "        solver.Add(\n",
    "            sum(variables[f'{roll}'] for roll in roll_paper) <= 1\n",
    "        )\n",
    "\n",
    "        solver.Add(\n",
    "            sum(roll * variables[f'{roll}'] for roll in roll_paper) - results['fitness'] <= 3\n",
    "        )\n",
    "\n",
    "        solver.Add(\n",
    "            sum(roll * variables[f'{roll}'] for roll in roll_paper) - results['fitness'] >= 1\n",
    "        )\n",
    "\n",
    "        solver.Minimize(\n",
    "             sum(roll * variables[f'{roll}'] for roll in roll_paper) - results['fitness']\n",
    "        )\n",
    "\n",
    "        status = solver.Solve()\n",
    "\n",
    "        if status != pywraplp.Solver.OPTIMAL:\n",
    "            self.output = None\n",
    "            return self\n",
    "\n",
    "        output = {'new_trim': float, 'old_fitness': float, 'new_roll':int}\n",
    "        new_trim = solver.Objective().Value()\n",
    "\n",
    "        output['new_trim']= new_trim\n",
    "        output['old_fitness']= results['fitness']\n",
    "        output['new_roll'] = sum(variables[f'{roll}'].solution_value()*roll for roll in roll_paper)\n",
    "        self.output = output\n",
    "        return self\n",
    "\n",
    "    def get(self):\n",
    "        return self.output\n",
    "\n",
    "\n",
    "def main():\n",
    "    results = {'fitness': 69.1836}\n",
    "    model = LP(results)\n",
    "    model.run()\n",
    "    print(model.get())\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "97177665-d4bd-4153-8cc0-5a3452ffeafd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from django.conf import settings\n",
    "\n",
    "from dataclasses import dataclass, field\n",
    "from pandas import DataFrame\n",
    "import pygad\n",
    "import numpy\n",
    "import pandas as pd\n",
    "from typing import Callable, Dict, Any, List, Optional\n",
    "from icecream import ic\n",
    "\n",
    "from order_optimization.container import ModelInterface\n",
    "\n",
    "from ordplan_project.settings import MIN_TRIM,PENALTY_VALUE\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class GA(ModelInterface):\n",
    "    orders: DataFrame\n",
    "    size: float = 66\n",
    "    num_generations: int = 50\n",
    "    out_range: int = 6\n",
    "    showOutput: bool = False\n",
    "    save_solutions: bool = False\n",
    "    showZero: bool = False\n",
    "    selector: Dict[str, Any] | None = None\n",
    "    set_progress: Callable | None = None\n",
    "    current_generation: int = 0\n",
    "    _penalty:int = 0 \n",
    "    _penalty_value:int = PENALTY_VALUE\n",
    "    blade:Optional[int] = None\n",
    "    seed:Optional[int] = None\n",
    "    parent_selection_type:str =\"tournament\"\n",
    "    crossover_type:str =\"uniform\"\n",
    "    mutation_probability:Optional[List[int]]=None\n",
    "    mutation_percent_genes:List[int] = field(default_factory=lambda: [25,5])\n",
    "    crossover_probability:float=None\n",
    "    \n",
    "    def __post_init__(self):\n",
    "        if self.orders is None:\n",
    "            raise ValueError(\"Orders is empty!\")\n",
    "        self.orders = self.orders[self.orders['quantity'] > 0].reset_index(drop=True)\n",
    "        self._paper_size  = self.size\n",
    "        self.model = pygad.GA(\n",
    "            num_generations=self.num_generations,\n",
    "            num_parents_mating=60,\n",
    "            fitness_func=self.fitness_function,\n",
    "            sol_per_pop=120,\n",
    "            num_genes=len(self.orders),\n",
    "\n",
    "            gene_type=int,\n",
    "            init_range_low=0,\n",
    "            init_range_high=self.out_range,\n",
    "            parent_selection_type=self.parent_selection_type,\n",
    "            crossover_type=self.crossover_type,\n",
    "            mutation_type=\"adaptive\",\n",
    "            mutation_probability=self.mutation_probability,\n",
    "            mutation_percent_genes=self.mutation_percent_genes,\n",
    "            crossover_probability=self.crossover_probability,\n",
    "            on_generation=self.on_gen,\n",
    "            save_solutions=self.save_solutions,\n",
    "            stop_criteria=\"saturate_7\",\n",
    "            suppress_warnings=True,\n",
    "            random_seed=self.seed\n",
    "        )\n",
    "\n",
    "        \n",
    "    def paper_type_logic(self, solution):\n",
    "        init_type = None\n",
    "        orders = self.orders\n",
    "        match orders[\"edge_type\"][self.get_first_solution(solution)]:\n",
    "            case \"X\":\n",
    "                init_type = 1\n",
    "            case \"N\":\n",
    "                init_type = 2\n",
    "            case \"W\":\n",
    "                init_type = 2\n",
    "\n",
    "        if init_type is not None:\n",
    "            for index, out in enumerate(solution):\n",
    "                if out >= 1:\n",
    "                    match init_type:\n",
    "                        case 1:\n",
    "                            if orders[\"edge_type\"][index] not in [\n",
    "                                \"X\",\n",
    "                                \"Y\",\n",
    "                            ]:  # Changed OR to AND condition\n",
    "                                self._penalty += self._penalty_value\n",
    "                        case 2:\n",
    "                            if orders[\"edge_type\"][index] == \"X\":\n",
    "                                self._penalty += self._penalty_value\n",
    "\n",
    "    def least_order_logic(self, solution):\n",
    "        init_order = None\n",
    "        orders = self.orders\n",
    "\n",
    "        init_order = orders[\"quantity\"][self.get_first_solution(solution)]\n",
    "\n",
    "        for index, out in enumerate(solution):\n",
    "            if out >= 1 and orders[\"quantity\"][index] < init_order:\n",
    "                self._penalty += self._penalty_value\n",
    "\n",
    "    @staticmethod\n",
    "    def get_first_solution(solution) -> int:\n",
    "        for index, out in enumerate(solution):\n",
    "            if out >= 1:\n",
    "                return index\n",
    "        return 0\n",
    "\n",
    "    def paper_out_logic(self, solution):\n",
    "        if sum(solution) > 5:\n",
    "            if sum(solution) <= 6:\n",
    "                init = 0\n",
    "                for index, out in enumerate(solution):\n",
    "                    if out>=1:\n",
    "                        if self.orders['edge_type'][index]=='X' and init==0:\n",
    "                            init = 1\n",
    "                            continue\n",
    "                        if self.orders['edge_type'][index]=='Y' and init==1:\n",
    "                            return                \n",
    "            \n",
    "            self._penalty += self._penalty_value * sum(solution)  # ยิ่งเกิน ยิ่ง _penaltyเยอะ\n",
    "        \n",
    "        \n",
    "        order_length = 0\n",
    "        for index, out in enumerate(solution):\n",
    "            if out >= 1:\n",
    "                order_length += 1\n",
    "        if order_length > 2:\n",
    "            self._penalty += self._penalty_value * order_length  # ยิ่งเกิน ยิ่ง _penaltyเยอะ\n",
    "\n",
    "    def paper_size_logic(self, _output):\n",
    "        if _output > self._paper_size :  # ถ้าผลรวมมีค่ามากกว่า roll กำหนดขึ้น _penalty\n",
    "            self._penalty += self._penalty_value * (\n",
    "                _output - self._paper_size \n",
    "            )  # ยิ่งเกิน ยิ่ง _penaltyเยอะ\n",
    "\n",
    "    def paper_trim_logic(self, _fitness_values):\n",
    "        if abs(_fitness_values) <= MIN_TRIM:  # ถ้าผลรวมมีค่าน้อยกว่า _penalty > เงื่อนไขบริษัท\n",
    "            self._penalty += self._penalty_value\n",
    "\n",
    "    def selector_logic(self, solution: List[int])->List[int]:\n",
    "        if self.selector is None:\n",
    "            return solution\n",
    "        \n",
    "        try:\n",
    "            solution[0] = self.selector[\"out\"] #lock the first to be out (the first order is also the selector, manage by ORD)\n",
    "        except KeyError:\n",
    "            pass\n",
    "\n",
    "        if solution[0] == 0: \n",
    "            solution[0] += 1\n",
    "\n",
    "        return solution\n",
    "\n",
    "    def fitness_function(self, ga_instance, solution, solution_idx):\n",
    "        self._penalty = 0\n",
    "\n",
    "        solution = self.selector_logic(solution)\n",
    "\n",
    "        self.paper_type_logic(solution)\n",
    "\n",
    "        self.least_order_logic(solution)\n",
    "\n",
    "        self.paper_out_logic(solution)\n",
    "\n",
    "        _output = numpy.sum(solution * self.orders[\"width\"])  # ผลรวมของตัดกว้างทั้งหมด\n",
    "\n",
    "        _fitness_values = -self._paper_size  + _output  # ผลต่างของกระดาษที่มีกับออเดอร์ ยิ่งเยอะยิ่งดี\n",
    "        self.paper_trim_logic(_fitness_values)\n",
    "        return _fitness_values - self._penalty  # ลบด้วย _penalty\n",
    "\n",
    "    def on_gen(self, ga_instance):\n",
    "\n",
    "        self.current_generation += 1\n",
    "        if self.set_progress:\n",
    "            progress = (self.current_generation / self.num_generations) * 100\n",
    "            self.set_progress(progress)\n",
    "\n",
    "        orders = self.orders\n",
    "\n",
    "        solution = ga_instance.best_solution()[0]\n",
    "\n",
    "        _output = pd.DataFrame(\n",
    "            {   \n",
    "                \"id\": orders['id'].unique(),\n",
    "                \"blade\": 0,\n",
    "                \"order_number\": orders[\"order_number\"],\n",
    "                \"num_orders\": orders[\"quantity\"],\n",
    "                \"component_type\": orders[\"component_type\"],\n",
    "                \"cut_width\": orders[\"width\"],\n",
    "                \"cut_len\": orders[\"length\"],\n",
    "                \"type\": orders[\"edge_type\"],\n",
    "                \"deadline\": orders[\"due_date\"],\n",
    "                \"front_sheet\": orders[\"front_sheet\"],\n",
    "                \"c_wave\": orders[\"c_wave\"],\n",
    "                \"middle_sheet\": orders[\"middle_sheet\"],\n",
    "                \"b_wave\": orders[\"b_wave\"],\n",
    "                \"back_sheet\": orders[\"back_sheet\"],\n",
    "                \"num_layers\": orders[\"level\"],\n",
    "                \"left_line\": orders[\"left_edge_cut\"],\n",
    "                \"center_line\": orders[\"middle_edge_cut\"],\n",
    "                \"right_line\": orders[\"right_edge_cut\"],\n",
    "                \"out\": solution,\n",
    "            }\n",
    "        )\n",
    "\n",
    "        if not self.showZero:\n",
    "            _output = _output[_output[\"out\"] >= 1]\n",
    "        _output = _output.reset_index(drop=True)\n",
    "\n",
    "\n",
    "        _output = self.blade_logic(_output)\n",
    "\n",
    "        self._fitness_values = ga_instance.best_solution()[1]\n",
    "        self._output = _output\n",
    "\n",
    "        if self.showOutput:\n",
    "            self.show(ga_instance, _output)\n",
    "\n",
    "    def blade_logic(self, output: DataFrame) -> DataFrame:\n",
    "        blade_list: List[Dict[str,int]] = []\n",
    "        for idx in output.index:\n",
    "            blade_val = idx+1\n",
    "            if self.blade is not None:\n",
    "                blade_val = self.blade\n",
    "            blade_list.append({\"blade\": blade_val})\n",
    "\n",
    "        blade_df = pd.DataFrame(blade_list)\n",
    "        output = pd.concat([output, blade_df], axis=1)\n",
    "        return output\n",
    "\n",
    "    def show(self, ga_instance, _output):\n",
    "        _paper_size  = self._paper_size \n",
    "        print(\"Generation : \", ga_instance.generations_completed)\n",
    "        print(\"Solution :\")\n",
    "\n",
    "        with pd.option_context(\n",
    "            \"display.max_columns\",\n",
    "            None,\n",
    "            \"display.width\",\n",
    "            None,\n",
    "            \"display.colheader_justify\",\n",
    "            \"left\",\n",
    "        ):\n",
    "            print(_output.to_string(index=False))\n",
    "\n",
    "        print(\"Roll :\", _paper_size )\n",
    "        print(\"Used :\", _paper_size  + self._fitness_values)\n",
    "        print(\"Trim :\", abs(self._fitness_values))\n",
    "        print(\"\\n\")\n",
    "\n",
    "    @property\n",
    "    def output(self) -> DataFrame:\n",
    "        return self._output\n",
    "    \n",
    "    @property\n",
    "    def fitness_values(self) -> float:\n",
    "        return self._fitness_values\n",
    "\n",
    "    @property\n",
    "    def penalty(self) -> int:\n",
    "        return self._penalty\n",
    "    \n",
    "    @penalty.setter\n",
    "    def penalty(self, penalty:int) -> None:\n",
    "        self._penalty = penalty\n",
    "\n",
    "    @property\n",
    "    def PAPER_SIZE(self) -> float:\n",
    "        return self._paper_size \n",
    "\n",
    "    @PAPER_SIZE.setter\n",
    "    def PAPER_SIZE (self, size: float):\n",
    "        self._paper_size  = size\n",
    "    \n",
    "    @property\n",
    "    def run(self) -> Callable:\n",
    "        return self.model.run\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0438104d-6f4c-4e35-a707-7c90caf6228a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Any ,Optional\n",
    "\n",
    "@dataclass\n",
    "class HD:\n",
    "    ROLL_PAPER = [66, 68, 70, 73, 74, 75, 79, 82, 85, 88, 91, 93, 95, 97]\n",
    "\n",
    "    x:int = 10 \n",
    "    h_type:str = 'ff'\n",
    "\n",
    "    def __post_init__(self):\n",
    "        self.temp_size = min(self.ROLL_PAPER)\n",
    "        self.ff_list = []\n",
    "        self.ffa_list = []\n",
    "        self.ffd_list = []\n",
    "\n",
    "        match(self.h_type):\n",
    "            case 'ff':\n",
    "                self.ff_list = [[] for _ in range(self.x)]\n",
    "            case 'ffa':\n",
    "                self.ffa_list = [[] for _ in range(self.x)]\n",
    "\n",
    "        ff_list = self.ff_list\n",
    "        ffa_list = self.ffa_list\n",
    "        ffd_list = self.ffd_list\n",
    "        for item, id in zip(filtered_data['width'], filtered_data['id']):\n",
    "            ff_list = self.first_fit(ff_list, item, id)\n",
    "        \n",
    "        # print(width_sum_formatter(ff_list))\n",
    "        ff_df = self.df_formatter(ff_list)\n",
    "        \n",
    "        desc_filtered_data = filtered_data.sort_values('width', ascending=False)\n",
    "        for item, id in zip(desc_filtered_data['width'], desc_filtered_data['id']):\n",
    "            ffd_list = self.first_fit(ffd_list, item, id)\n",
    "        \n",
    "        # print(width_sum_formatter(ffd_list))\n",
    "        ffd_df = self.df_formatter(ffd_list)\n",
    "        \n",
    "        asc_filtered_data = filtered_data.sort_values('width', ascending=True)\n",
    "        for item, id in zip(asc_filtered_data['width'], asc_filtered_data['id']):\n",
    "            ffa_list = self.first_fit(ffa_list, item, id)\n",
    "            \n",
    "        # print(width_sum_formatter(ffa_list))\n",
    "        ffa_df = self.df_formatter(ffa_list)\n",
    "        \n",
    "        heuristic_data_id = pd.concat([ffd_df, ff_df, ffa_df])\n",
    "        heuristic_data_id = heuristic_data_id.drop_duplicates('id').reset_index(drop=True)\n",
    "        \n",
    "        self.heuristic_data = filtered_data[filtered_data['id'].isin(heuristic_data_id['id'])].reset_index(drop=True)\n",
    "    \n",
    "    \n",
    "    def is_fit(self, data_list, item):\n",
    "        return sum([row[0] for row in data_list]) + item - self.temp_size < 0\n",
    "\n",
    "    @staticmethod\n",
    "    def get_width(data_list):\n",
    "        return [row[0] for row in data_list]\n",
    "    \n",
    "    \n",
    "    def width_sum_formatter(self, data_list):\n",
    "        output = \"\"\n",
    "        for index, _ in enumerate(data_list):\n",
    "            output+= str(round(sum(self.get_width(data_list[index])),4))+\" | \"\n",
    "        return output\n",
    "\n",
    "    @staticmethod\n",
    "    def df_formatter(data_list):\n",
    "        combined_data = []\n",
    "        for data in data_list:\n",
    "            combined_data += data\n",
    "        return pd.DataFrame(combined_data, columns=['width', 'id'])\n",
    "\n",
    "\n",
    "    def first_fit(self,data_list, item, id):\n",
    "        for data in data_list:\n",
    "            if self.is_fit(data, item):\n",
    "                data.append((item, id))\n",
    "                return data_list\n",
    "        return data_list\n",
    "\n",
    "    def get(self) -> pd.DataFrame:    \n",
    "        return self.heuristic_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "706ce63d-bf9f-4549-bc17-b561bb034521",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ordplan_project.settings import MAX_TRIM, MIN_TRIM\n",
    "from typing import Dict, Any\n",
    "\n",
    "def is_trim_fit(trim: float):\n",
    "    \"\"\"\n",
    "    Check if trim exceed min/max tirm.\n",
    "    \"\"\"\n",
    "    return trim <= MAX_TRIM and trim >= MIN_TRIM\n",
    "\n",
    "\n",
    "def handle_switcher(used) -> Dict[str,Any]:\n",
    "    if is_trim_fit(used):\n",
    "        return\n",
    "    switcher = LP({'fitness': used}).run().get()\n",
    "    # ic(switcher,used)\n",
    "    return switcher\n",
    "\n",
    "def update_acc_list(acc_list,ga_instance,hd_instance,elapsed_times):\n",
    "        temp_acc_str = \"\"\n",
    "        temp_acc_str+='Parameters -> '\n",
    "        \n",
    "        parameters = (\n",
    "            \"parent:\" +ga_instance.parent_selection_type + \" | \" +\n",
    "            \"co proba:\" +str(ga_instance.crossover_probability) + \" | \" +\n",
    "            \"crossover:\" +ga_instance.crossover_type + \" | \" +\n",
    "            str(ga_instance.mutation_probability) + \" | \" +\n",
    "            str(ga_instance.mutation_percent_genes) + \" | \" +\n",
    "            \"heu type:\" +hd_instance.h_type +\"\\n\"\n",
    "        )\n",
    "        \n",
    "        temp_acc_str+=parameters\n",
    "        \n",
    "        accuracy = (passed_trim / count) * 100.00 if count != 0 else 0.0\n",
    "        temp_acc_str += \"Accuracy -> {:.2f}%\".format(accuracy)\n",
    "    \n",
    "        total_seconds = sum(elapsed_times)\n",
    "        \n",
    "        minutes, seconds = divmod(total_seconds, 60)\n",
    "        \n",
    "        time_spent_str = f\"{int(minutes)}:{int(seconds):02d}\"\n",
    "        \n",
    "        temp_acc_str += f\"\\nTime Spent -> {time_spent_str}\"\n",
    "\n",
    "        temp_acc_str += \"\\n\"\n",
    "        \n",
    "        acc_list.append(temp_acc_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "54a57026-e456-478e-8298-40861deb1255",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_9298/1734814982.py:45: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  heuristic_data_id = pd.concat([ffd_df, ff_df, ffa_df])\n",
      "/tmp/ipykernel_9298/1734814982.py:45: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  heuristic_data_id = pd.concat([ffd_df, ff_df, ffa_df])\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style>\n",
       "</style>\n",
       "<div class=\"enlighten\">\n",
       "  <div class=\"enlighten-bar\">\n",
       "    <pre>Types 100%|██████████████████████████████████████████████████████| 16/16 [2h 27:53&lt;00:00, 0.00 it/s]</pre>\n",
       "  </div>\n",
       "  <div class=\"enlighten-bar\">\n",
       "    <pre>Count 100%|██████████████████████████████████████████████████| 1600/1600 [2h 37:09&lt;00:00, 0.17 it/s]</pre>\n",
       "  </div>\n",
       "</div>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "import itertools\n",
    "import time\n",
    "\n",
    "import enlighten\n",
    "\n",
    "\n",
    "crossover_types = [\"two_points\", \"uniform\"]\n",
    "mutation_proba = [None,[0.25, 0.05]]\n",
    "crossover_proba = [None, 0.65]\n",
    "acc_list = []\n",
    "\n",
    "x = 20\n",
    "count = 100\n",
    "\n",
    "hd_instances = []\n",
    "h_types = [\"ff\", \"ffa\"]\n",
    "for h_type in h_types:\n",
    "    hd_instance = HD(h_type=h_type, x=x)\n",
    "    hd_instances.append(hd_instance)\n",
    "\n",
    "temp_size = hd_instance.temp_size\n",
    "\n",
    "manager = enlighten.get_manager()\n",
    "types = manager.counter(total=len(list((itertools.product(crossover_types, mutation_proba, crossover_proba, hd_instances)))), desc='Types', unit='it')\n",
    "counts = manager.counter(total=count*len(list((itertools.product(crossover_types, mutation_proba, crossover_proba, hd_instances)))), desc='Count', unit='it')\n",
    "\n",
    "for crossover_prob, crossover, mutation, hd_instance in itertools.product(crossover_proba, crossover_types, mutation_proba,hd_instances):\n",
    "    heuristic_data = hd_instance.get()\n",
    "    elapsed_times = []\n",
    "    passed_trim = 0\n",
    "    types.update()\n",
    "    for i in range(count):\n",
    "        counts.update()\n",
    "        start_time = time.time()\n",
    "        ga_instance = GA(\n",
    "            heuristic_data,\n",
    "            size=temp_size,\n",
    "            num_generations=50,\n",
    "            out_range=5,\n",
    "            seed=i,\n",
    "            parent_selection_type=\"tournament\",\n",
    "            crossover_type=crossover,\n",
    "            mutation_probability=mutation,\n",
    "            crossover_probability=crossover_prob\n",
    "        )\n",
    "        ga_instance.run()\n",
    "        size = ga_instance.PAPER_SIZE\n",
    "        trim = abs(ga_instance.fitness_values)\n",
    "        used = ga_instance.PAPER_SIZE+ga_instance.fitness_values\n",
    "        switcher = handle_switcher(used)\n",
    "    \n",
    "        if switcher is not None:\n",
    "            size = switcher[\"new_roll\"]\n",
    "            trim = switcher[\"new_trim\"]\n",
    "    \n",
    "        # print(size)\n",
    "        # print(used)\n",
    "        # print(trim)\n",
    "        if trim < 3:\n",
    "            passed_trim+=1\n",
    "        end_time = time.time()\n",
    "        elapsed_time = end_time - start_time\n",
    "        elapsed_times.append(elapsed_time)\n",
    "\n",
    "\n",
    "    update_acc_list(acc_list,ga_instance,hd_instance,elapsed_times)\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f627f918-895e-4751-81fb-4fc1813e1810",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parameters -> parent:tournament | co proba:None | crossover:two_points | None | [25, 5] | heu type:ff\n",
      "Accuracy -> 67.00%\n",
      "Time Spent -> 9:56\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:two_points | None | [25, 5] | heu type:ffa\n",
      "Accuracy -> 55.00%\n",
      "Time Spent -> 10:29\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:two_points | [0.25, 0.05] | [25, 5] | heu type:ff\n",
      "Accuracy -> 56.00%\n",
      "Time Spent -> 9:14\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:two_points | [0.25, 0.05] | [25, 5] | heu type:ffa\n",
      "Accuracy -> 70.00%\n",
      "Time Spent -> 10:43\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:uniform | None | [25, 5] | heu type:ff\n",
      "Accuracy -> 55.00%\n",
      "Time Spent -> 8:15\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:uniform | None | [25, 5] | heu type:ffa\n",
      "Accuracy -> 58.00%\n",
      "Time Spent -> 9:12\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:uniform | [0.25, 0.05] | [25, 5] | heu type:ff\n",
      "Accuracy -> 47.00%\n",
      "Time Spent -> 11:57\n",
      "\n",
      "Parameters -> parent:tournament | co proba:None | crossover:uniform | [0.25, 0.05] | [25, 5] | heu type:ffa\n",
      "Accuracy -> 64.00%\n",
      "Time Spent -> 10:35\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:two_points | None | [25, 5] | heu type:ff\n",
      "Accuracy -> 62.00%\n",
      "Time Spent -> 10:01\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:two_points | None | [25, 5] | heu type:ffa\n",
      "Accuracy -> 56.00%\n",
      "Time Spent -> 10:28\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:two_points | [0.25, 0.05] | [25, 5] | heu type:ff\n",
      "Accuracy -> 65.00%\n",
      "Time Spent -> 9:39\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:two_points | [0.25, 0.05] | [25, 5] | heu type:ffa\n",
      "Accuracy -> 51.00%\n",
      "Time Spent -> 10:03\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:uniform | None | [25, 5] | heu type:ff\n",
      "Accuracy -> 47.00%\n",
      "Time Spent -> 8:21\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:uniform | None | [25, 5] | heu type:ffa\n",
      "Accuracy -> 59.00%\n",
      "Time Spent -> 9:47\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:uniform | [0.25, 0.05] | [25, 5] | heu type:ff\n",
      "Accuracy -> 63.00%\n",
      "Time Spent -> 9:03\n",
      "\n",
      "Parameters -> parent:tournament | co proba:0.65 | crossover:uniform | [0.25, 0.05] | [25, 5] | heu type:ffa\n",
      "Accuracy -> 63.00%\n",
      "Time Spent -> 9:21\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for i in acc_list:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9c1e2023-9a21-4706-bca8-33ebecae72d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[NbConvertApp] Converting notebook ord-dev.ipynb to script\n",
      "[NbConvertApp] Writing 20210 bytes to ord-dev.py\n"
     ]
    }
   ],
   "source": [
    "!jupyter nbconvert --to script ord-dev.ipynb"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}