✨ Add Model Code

Readme.md

@@ -0,0 +1,19 @@
+# Time Driven Cost Estimation Learning Model (TDCE)
+
+This is the open-source part of Time-Driven Cost Estimation Learning Model under the research titled "Artificial Neural Network like for Manufacturing Cost Estimation" wish to create neural network like system by using the core equation of time-driven activity-based costing.
+
+## Starting
+
+Creating ENV followed by `.env.example` and then Creating your virtual environment
+
+```
+python -m venv venv
+```
+
+Install all requirements
+
+```
+pip install -r requirement.txt
+```
+
+© 2024, Prince of Songkla University under Inteligent Automation Engineering Center

model/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+generated/

model/display_input_variation.py

@@ -0,0 +1,167 @@
+import pandas as pd
+from scipy.stats import variation, iqr
+
+
+def display_input_variation(
+    process_df,
+    material_usage_df,
+    employee_usage,
+    capital_cost_df,
+):
+    process_des = process_df.describe()
+
+    cost_dict = {
+        "data": "Total Cost",
+        "records": process_des["cost"]["count"],
+        "types": len(process_df["process_id"].unique()),
+        "min": process_des["cost"]["min"],
+        "mean": round(process_des["cost"]["mean"], 2),
+        "max": process_des["cost"]["max"],
+        "sd": process_des["cost"]["std"],
+        "variation": variation(process_df["cost"]),
+        "iqr": iqr(process_df["cost"]),
+    }
+
+    material_des = material_usage_df.describe()
+
+    material_amount = {
+        "data": "Material Amount",
+        "records": material_des["amount"]["count"],
+        "types": len(material_usage_df["name"].unique()),
+        "min": material_des["amount"]["min"],
+        "mean": round(material_des["amount"]["mean"], 2),
+        "max": material_des["amount"]["max"],
+        "sd": material_des["amount"]["std"],
+        "variation": variation(material_usage_df["amount"]),
+        "iqr": iqr(material_usage_df["amount"]),
+    }
+
+    material_unit_cost = {
+        "data": "Material Unit Cost",
+        "records": material_des["unit_cost"]["count"],
+        "types": len(material_usage_df["name"].unique()),
+        "min": material_des["unit_cost"]["min"],
+        "mean": round(material_des["unit_cost"]["mean"], 2),
+        "max": material_des["unit_cost"]["max"],
+        "sd": material_des["unit_cost"]["std"],
+        "variation": variation(material_usage_df["unit_cost"]),
+        "iqr": iqr(material_usage_df["unit_cost"]),
+    }
+
+    employee_usage["duration"] = (
+        employee_usage["duration"] * employee_usage["amount"]
+    )
+    ec_des = employee_usage.describe()
+
+    ec_unit_cost = {
+        "data": "Labor Unit Cost",
+        "records": ec_des["cost"]["count"],
+        "types": len(employee_usage["employee_name"].unique()),
+        "min": ec_des["cost"]["min"],
+        "mean": round(ec_des["cost"]["mean"], 2),
+        "max": ec_des["cost"]["max"],
+        "sd": ec_des["cost"]["std"],
+        "variation": variation(employee_usage["cost"]),
+        "iqr": iqr(employee_usage["cost"]),
+    }
+
+    ec_duration = {
+        "data": "Labor Duration",
+        "records": ec_des["duration"]["count"],
+        "types": len(employee_usage["employee_name"].unique()),
+        "min": ec_des["duration"]["min"],
+        "mean": round(ec_des["duration"]["mean"], 2),
+        "max": ec_des["duration"]["max"],
+        "sd": ec_des["duration"]["std"],
+        "variation": variation(employee_usage["duration"]),
+        "iqr": iqr(employee_usage["duration"]),
+    }
+
+    ec_day_amount = {
+        "data": "Labor Day Amount",
+        "records": ec_des["day_amount"]["count"],
+        "types": len(employee_usage["employee_name"].unique()),
+        "min": ec_des["day_amount"]["min"],
+        "mean": round(ec_des["day_amount"]["mean"], 2),
+        "max": ec_des["day_amount"]["max"],
+        "sd": ec_des["day_amount"]["std"],
+        "variation": variation(employee_usage["day_amount"]),
+        "iqr": iqr(employee_usage["day_amount"]),
+    }
+
+    capital_des = capital_cost_df.describe()
+
+    cc_unit_cost = {
+        "data": "Capital Cost",
+        "records": capital_des["cost"]["count"],
+        "types": len(capital_cost_df["name"].unique()),
+        "min": capital_des["cost"]["min"],
+        "mean": round(capital_des["cost"]["mean"], 2),
+        "max": capital_des["cost"]["max"],
+        "sd": capital_des["cost"]["std"],
+        "variation": variation(capital_cost_df["cost"]),
+        "iqr": iqr(capital_cost_df["cost"])
+    }
+
+    cc_dayamount = {
+        "data": "Capital Cost Day Amount",
+        "records": capital_des["day_amount"]["count"],
+        "types": len(capital_cost_df["name"].unique()),
+        "min": capital_des["day_amount"]["min"],
+        "mean": round(capital_des["day_amount"]["mean"], 2),
+        "max": capital_des["day_amount"]["max"],
+        "sd": capital_des["day_amount"]["std"],
+        "variation": variation(capital_cost_df["day_amount"]),
+        "iqr": iqr(capital_cost_df["day_amount"])
+    }
+
+    cc_duration = {
+        "data": "Capital Cost Duration",
+        "records": capital_des["duration"]["count"],
+        "types": len(capital_cost_df["name"].unique()),
+        "min": capital_des["duration"]["min"],
+        "mean": round(capital_des["duration"]["mean"], 2),
+        "max": capital_des["duration"]["max"],
+        "sd": capital_des["duration"]["std"],
+        "variation": variation(capital_cost_df["duration"]),
+        "iqr": iqr(capital_cost_df["duration"])
+    }
+
+    data_variation = pd.DataFrame(
+        [
+            cost_dict,
+            material_unit_cost,
+            material_amount,
+            ec_unit_cost,
+            ec_duration,
+            ec_day_amount,
+            cc_unit_cost,
+            cc_dayamount,
+            cc_duration,
+        ]
+    )
+
+    # try:
+    #     display(data_variation)
+    # except:
+    #     print("Not Run in Jupyter Notebook")
+    #     print(data_variation)
+    return data_variation
+
+
+def display_input_variation_by_directory(folder_name):
+    process_df = pd.read_csv(f"{folder_name}/generated_process_data.csv")
+    material_usage_df = pd.read_csv(
+        f"{folder_name}/generated_material_usage.csv")
+    employee_usage_df = pd.read_csv(
+        f"{folder_name}/generated_employee_usage.csv")
+    capital_cost_df = pd.read_csv(f"{folder_name}/generated_captial_cost.csv")
+
+    result_variation = display_input_variation(
+        process_df,
+        material_usage_df,
+        employee_usage_df,
+        capital_cost_df,
+    )
+
+    return result_variation

model/extractor/.gitignore

@@ -0,0 +1 @@
+__pycache__

model/extractor/adjust_data.py

@@ -0,0 +1,15 @@
+
+def adjust_to_match_process(capital_cost_usage,
+                            employee_usage,
+                            material_usage,
+                            new_process_df):
+    new_capital_cost = capital_cost_usage.copy()
+    new_capital_cost = new_capital_cost[new_capital_cost['process_id'].isin(
+        new_process_df['process_id'])]
+    new_employee_usage = employee_usage.copy()
+    new_employee_usage = new_employee_usage[
+        new_employee_usage['process_id'].isin(new_process_df['process_id'])]
+    new_material_usage = material_usage.copy()
+    new_material_usage = new_material_usage[
+        new_material_usage['process_id'].isin(new_process_df['process_id'])]
+    return new_capital_cost, new_employee_usage, new_material_usage

model/extractor/emanufac_tdabc_extractor_class.py

@@ -0,0 +1,389 @@
+import pandas as pd
+import requests
+import numpy as np
+import pickle
+
+
+class EManufacTDABCExtractor:
+    def __init__(self, api_url, api_key, profile_id, costed_place):
+        self.api_url = api_url
+        self.api_key = api_key
+        self.process_df = pd.DataFrame()
+        self.material_usage_df = pd.DataFrame()
+        self.original_material_usage_df = pd.DataFrame()
+        self.original_employee_usage_df = pd.DataFrame()
+        self.original_process_df = pd.DataFrame()
+        self.capital_cost_df = pd.DataFrame()
+        self.employee_usage_df = pd.DataFrame()
+        self.original_capital_cost_df = pd.DataFrame()
+        self.profile_id = profile_id  # Profile For TDABC
+        self.original_procedure_profile_id = ""  # Profile For Factory Current  Method
+        self.profile_element_name_for_material = "ต้นทุนวัตถุดิบ"
+        self.costed_place = costed_place
+        self.running_no_start = ""
+        self.running_no_end = ""
+
+    def set_running_no_margin(self, start, end):
+        self.running_no_start = start
+        self.running_no_end = end
+        print("Setting Successfully")
+
+    def fetch_material_usage(self, start_date, end_date, limit, page=1):
+        url = f"{self.api_url}/cost-estimation/on-type"
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        querystring = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "size": limit,
+            "page": page,
+            "profile": self.profile_id,
+            "elementType": "MATERIAL",
+            "placeRestricNotify": "true",
+            "correctPlaceOnly": "true",
+            "extractOriginalLot": "true",
+            "place": self.costed_place,
+            "specifyProfileElement": self.profile_element_name_for_material,
+            "runningNoStart": self.running_no_start,
+            "runningNoEnd": self.running_no_end,
+        }
+        response = requests.get(url, headers=headers, params=querystring)
+        try:
+            material_data = response.json()["rows"]
+        except Exception as e:
+            print("Error in fetch material", e)
+            material_data = []
+
+        self.material_usage_df = pd.DataFrame(material_data)
+        self.original_material_usage_df = pd.DataFrame(material_data)
+
+        with open("material.pickle", "wb") as handle:
+            pickle.dump(self.material_usage_df, handle)
+
+        return (self.material_usage_df,)
+
+    def fetch_employee_usage(self, start_date, end_date, limit, page=1):
+        url = f"{self.api_url}/cost-estimation/on-type"
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        querystring = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "size": limit,
+            "page": page,
+            "profile": self.profile_id,
+            "elementType": "LABOR",
+            "placeRestricNotify": "true",
+            "correctPlaceOnly": "true",
+            "place": self.costed_place,
+            "merged": "true",
+            "runningNoStart": self.running_no_start,
+            "runningNoEnd": self.running_no_end,
+        }
+        response = requests.get(url, headers=headers, params=querystring)
+        try:
+            employee_data = response.json()["rows"]
+        except Exception as e:
+            print("Error in fetch employee", e)
+            employee_data = []
+
+        self.employee_usage_df = pd.DataFrame(employee_data)
+        self.original_employee_usage_df = pd.DataFrame(employee_data)
+
+        with open("employee.pickle", "wb") as handle:
+            pickle.dump(self.employee_usage_df, handle)
+
+        return (self.employee_usage_df,)
+
+    def fetch_capital_cost_usage(self, start_date, end_date, limit, page=1):
+        url = f"{self.api_url}/cost-estimation/on-type"
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        querystring = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "size": limit,
+            "page": page,
+            "profile": self.profile_id,
+            "elementType": "CAPITAL_COST",
+            "placeRestricNotify": "true",
+            "correctPlaceOnly": "true",
+            "place": self.costed_place,
+            "merged": "true",
+            "splitCostDriver": "true",
+            "runningNoStart": self.running_no_start,
+            "runningNoEnd": self.running_no_end,
+        }
+        response = requests.get(url, headers=headers, params=querystring)
+        try:
+            capital_cost_data = response.json()["rows"]
+        except Exception as e:
+            print("Error in fetch capital cost", e)
+            capital_cost_data = []
+
+        self.capital_cost_df = pd.DataFrame(capital_cost_data)
+        self.original_capital_cost_df = pd.DataFrame(capital_cost_data)
+
+        with open("capital.pickle", "wb") as handle:
+            pickle.dump(self.capital_cost_df, handle)
+
+        return (self.capital_cost_df,)
+
+    def change_profile_element_for_material(self, new_element_name):
+        self.profile_element_name_for_material = new_element_name
+        print("Success Changing")
+
+    # Profile For Current Factory Cost Estimation Method
+    def change_profile_for_original_procedure(self, profile_id):
+        self.original_procedure_profile_id = profile_id
+        print("Success Changing")
+
+    # Get Data From Current Factory Cost Estimation Method as a Reference or Result
+    # Of our new Profile using TDABC
+    def fetch_process_data(self, start_date, end_date, limit, page=1):
+        url = f"{self.api_url}/cost-estimation"
+        headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        querystring = {
+            "startDate": start_date,
+            "endDate": end_date,
+            "size": limit,
+            "page": page,
+            "profile": self.original_procedure_profile_id,
+            "hideResultList": "true",
+            "placeRestricNotify": "true",
+            "correctPlaceOnly": "true",
+            "runningNoStart": self.running_no_start,
+            "runningNoEnd": self.running_no_end,
+            "place": self.costed_place,
+        }
+        response = requests.get(url, headers=headers, params=querystring)
+        process_data = response.json()["rows"]
+
+        self.process_df = pd.DataFrame(process_data)
+        self.original_process_df = pd.DataFrame(process_data)
+
+        with open("process.pickle", "wb") as handle:
+            pickle.dump(self.process_df, handle)
+
+        return (self.process_df,)
+
+    def load_from_pickle(self):
+
+        try:
+            with open("material.pickle", "rb") as handle:
+                material_usage_df = pickle.load(handle)
+                self.material_usage_df = material_usage_df
+                self.original_material_usage_df = material_usage_df
+        except:
+            print("Error loading material Pickle")
+
+        try:
+            with open("employee.pickle", "rb") as handle:
+                employee_usage_df = pickle.load(handle)
+                self.employee_usage_df = employee_usage_df
+                self.original_employee_usage_df = employee_usage_df
+        except:
+            print("Error loading employee Pickle")
+
+        try:
+            with open("capital.pickle", "rb") as handle:
+                capital_cost_df = pickle.load(handle)
+                self.capital_cost_df = capital_cost_df
+                self.original_capital_cost_df = capital_cost_df
+        except:
+            print("Error loading capital Pickle")
+
+        try:
+            with open("process.pickle", "rb") as handle:
+                process_df = pickle.load(handle)
+                self.process_df = process_df
+                self.original_process_df = process_df
+        except:
+            print("Error loading Process Pickle")
+
+        # self.capital_cost_df = capital_cost_df
+        print("Loaded from pickle Successfully")
+
+    def get_process_list(self):
+        return self.process_df
+
+    def get_material_usage(self):
+        return self.material_usage_df
+
+    def get_employee_usage(self):
+        return self.employee_usage_df
+
+    def get_capital_cost(self):
+        return self.capital_cost_df
+
+    def load_material_usage(self, material_usage_df):
+        self.material_usage_df = material_usage_df
+
+    def load_employee_usage(self, employee_usage_df):
+        self.employee_usage_df = employee_usage_df
+
+    def load_capital_cost(self, capital_cost_df):
+        self.capital_cost_df = capital_cost_df
+
+    def load_process(self, process_df):
+        self.process_df = process_df
+
+    def load_original_process(self, process_df):
+        self.original_process_df = process_df
+
+    def load_original_material_usage(self, material_usage_df):
+        self.original_material_usage_df = material_usage_df
+
+    def load_original_employee_usage(self, employee_usage_df):
+        self.original_employee_usage_df = employee_usage_df
+
+    def load_original_capital_cost(self, capital_cost_df):
+        self.original_capital_cost_df = capital_cost_df
+
+    def adjust_material_usage(self):
+        new_material_usage_df = pd.DataFrame()  # self.material_usage_df.copy()
+        new_material_usage_df["_id"] = self.original_material_usage_df["material_id"]
+        new_material_usage_df["process_id"] = self.original_material_usage_df[
+            "process_id"
+        ]
+        new_material_usage_df["name"] = self.original_material_usage_df["material_name"]
+        new_material_usage_df["amount"] = self.original_material_usage_df[
+            "used_quantity"
+        ]
+        new_material_usage_df["unit_cost"] = self.original_material_usage_df[
+            "unit_cost"
+        ]
+        # TODO:  Update in EManufac Code to pick the purchase date instead
+        new_material_usage_df["date"] = self.original_material_usage_df["used_date"]
+        self.material_usage_df = new_material_usage_df
+
+    def adjust_employee_usage(self):
+        new_employee_usage_df = pd.DataFrame()
+        new_employee_usage_df["_id"] = self.original_employee_usage_df[
+            "artifact_employee_id"
+        ]
+        new_employee_usage_df["employee_id"] = self.original_employee_usage_df[
+            "artifact_employee_id"
+        ]
+        new_employee_usage_df["process_id"] = self.original_employee_usage_df[
+            "process_id"
+        ]
+        new_employee_usage_df["employee_name"] = self.original_employee_usage_df[
+            "artifact_employee_name"
+        ]
+        new_employee_usage_df["amount"] = self.original_employee_usage_df[
+            "average_labor_amount"
+        ]
+        new_employee_usage_df["date"] = self.original_employee_usage_df["receipt_date"]
+
+        # If more than 1 employee (unit cost is same) we group to one, and sum the duration
+        new_employee_usage_df["duration"] = (
+            self.original_employee_usage_df["artifact_minute_use"]
+            * self.original_employee_usage_df["average_labor_amount"]
+        )
+
+        # new_employee_usage_df["type"]
+        new_employee_usage_df["type"] = "daily"
+        new_employee_usage_df['day_amount'] = 1
+        try:
+            new_employee_usage_df["cost"] = self.original_employee_usage_df[
+                "average_daily_labor_cost"
+            ]
+        except:
+            new_employee_usage_df["cost"] = 0
+
+        new_employee_usage_df = new_employee_usage_df.dropna(subset=["cost"])
+
+        self.employee_usage_df = new_employee_usage_df
+
+    def adjust_capital_cost(self):
+        new_capital_cost_df = pd.DataFrame()
+        try:
+            new_capital_cost_df["_id"] = self.original_capital_cost_df[
+                "artifact_cost_title"
+            ]
+            new_capital_cost_df["process_id"] = self.original_capital_cost_df[
+                "process_id"
+            ]
+            new_capital_cost_df["name"] = self.original_capital_cost_df[
+                "artifact_cost_title"
+            ]
+            new_capital_cost_df["cost"] = self.original_capital_cost_df[
+                "artifact_capital_cost"
+            ]
+            new_capital_cost_df["day_amount"] = self.original_capital_cost_df[
+                "average_day_amount"
+            ]
+            new_capital_cost_df["hour_amount"] = self.original_capital_cost_df[
+                "average_hour_amount"
+            ]
+            new_capital_cost_df["unit_cost"] = self.original_capital_cost_df[
+                "artifact_unit_cost"
+            ]
+            new_capital_cost_df["duration"] = self.original_capital_cost_df[
+                "artifact_used_time"
+            ]
+            new_capital_cost_df["date"] = self.original_capital_cost_df["receipt_date"]
+
+            # new_capital_cost_df["machine_hour"] = new_capital_cost_df["machineHour"]
+            # new_capital_cost_df["life_time"] = new_capital_cost_df["lifeTime"]
+            # new_capital_cost_df["day_per_month"] = new_capital_cost_df["dayPerMonth"]
+
+            zero_cost = new_capital_cost_df[new_capital_cost_df["cost"] == 0]
+            # Remove None machine usage
+            new_capital_cost_df = new_capital_cost_df.drop(zero_cost.index)
+            self.capital_cost_df = new_capital_cost_df
+        except Exception as e:
+            print("Error in adjust capital cost", e)
+
+    def adjust_process_df(self):
+        temp_process_df = self.original_process_df.copy()
+        temp_process_df = temp_process_df[temp_process_df["cost"] > 0]
+
+        self.process_df = temp_process_df
+
+    def save_material_csv(self, destination_folder_path="generated"):
+        self.material_usage_df.to_csv(
+            f"{destination_folder_path}/generated_material_usage.csv"
+        )
+        self.original_material_usage_df.to_csv(
+            f"{destination_folder_path}/original_material_usage.csv"
+        )
+
+    def save_process_csv(self, destination_folder_path="generated"):
+        self.process_df.to_csv(
+            f"{destination_folder_path}/generated_process_data.csv")
+        self.original_process_df.to_csv(
+            f"{destination_folder_path}/original_process_data.csv"
+        )
+
+    def save_employee_csv(self, destination_folder_path="generated"):
+        self.employee_usage_df.to_csv(
+            f"{destination_folder_path}/generated_employee_usage.csv"
+        )
+        self.original_employee_usage_df.to_csv(
+            f"{destination_folder_path}/original_employee_usage.csv"
+        )
+
+    def save_capital_csv(self, destination_folder_path="generated"):
+        self.capital_cost_df.to_csv(
+            f"{destination_folder_path}/generated_captial_cost.csv"
+        )
+        self.original_capital_cost_df.to_csv(
+            f"{destination_folder_path}/original_captial_cost.csv"
+        )
+
+    def save_csv(self, destination_folder_path="generated"):
+        self.save_process_csv(destination_folder_path)
+        self.save_material_csv(destination_folder_path)
+        self.save_employee_csv(destination_folder_path)
+        self.save_capital_csv(destination_folder_path)

model/extractor/shaker_augmentation.py

@@ -0,0 +1,134 @@
+# This find provide the shaker function
+# for make data into more variation
+# and augment the data for training the model
+# In first case study we will shake the data from dataset 1
+# And Create the dataset 4
+
+import pandas as pd
+
+
+def dataset_shake(dataset_name, new_dataset_name, random_rate=10):
+    # import data from dataset
+    process_df = pd.read_csv(f'data/{dataset_name}/generated_process_data.csv')
+    employee_df = pd.read_csv(
+        f'data/{dataset_name}/generated_employee_usage.csv')
+    material_df = pd.read_csv(
+        f'data/{dataset_name}/generated_material_usage.csv')
+    capitalcost_df = pd.read_csv(
+        f'data/{dataset_name}/generated_captial_cost.csv')
+
+    # Adjust Employee Cost
+    # Picking Cost
+    example_employee_ids = range(0, 12)
+    example_employee_name = ['A', 'B', "C", "D",
+                             "E", "F", "G", "H", "I", "J", "K", "L"]
+    example_cost = [27769.652, 20508.323, 811.6214, 547.8455,
+                    392.4559, 372.7312, 354.8132, 2682.522,
+                    2451.125, 24071.33, 22683.42, 22683.42]
+    example_day_amount = [26, 26, 1, 1, 1, 1, 1, 7, 7, 7, 7, 7]
+
+    picking_df = employee_df[employee_df['employee_name']
+                             == "ตัวแทนพนักงานเฉลี่ยคลังที่ 2 (ดองน้ำแข็ง)"]
+    example_picking_df = pd.DataFrame({
+        'employee_id': example_employee_ids,
+        'employee_name': example_employee_name,
+        'cost': example_cost,
+        'day_amount': example_day_amount
+    })
+
+    example_picking_df['cost'] = example_picking_df['cost'].astype(float)
+    example_picking_df['day_amount'] = example_picking_df['day_amount'].astype(
+        int)
+
+    # Update the picking_df based on the condition
+    for i in range(len(picking_df)):
+        cost_mod_index = i % 12
+        coefficient = random_rate / 2
+        if cost_mod_index % 2 == 0:
+            coefficient = -random_rate / 2
+        picking_df.loc[i, ['employee_id', 'employee_name', 'cost', 'day_amount']
+                       ] = example_picking_df.loc[cost_mod_index, ['employee_id', 'employee_name', 'cost', 'day_amount']]
+        # Update Duration +- 5%
+        picking_df.loc[i, 'duration'] = picking_df.loc[i, 'duration'] + \
+            (coefficient * picking_df.loc[i, 'duration'] / 100)
+
+    # Packing Cost
+    packing_df = employee_df[employee_df['employee_name']
+                             == "ตัวแทนพนักงานเฉลี่ยคลังที่ 3 (ปูเข้าเป็นกระป๋อง)"]
+    packing_df.reset_index(drop=True, inplace=True)
+    example_employee_ids = range(12, 24)
+    example_employee_name = ['M', 'N', "O", "P",
+                             "Q", "R", "S", "T", "U", "V", "W", "X"]
+    example_cost = [37769.652, 30508.323, 311.6214, 647.8455,
+                    492.4559, 472.7312, 454.8132, 3682.522,
+                    3451.125, 34071.33, 22683.42, 32683.42]
+    example_day_amount = [26, 26, 1, 1, 1, 1, 1, 7, 7, 7, 7, 7]
+
+    example_packing_df = pd.DataFrame({
+        'employee_id': example_employee_ids,
+        'employee_name': example_employee_name,
+        'cost': example_cost,
+        'day_amount': example_day_amount
+    })
+    example_packing_df['cost'] = example_packing_df['cost'].astype(float)
+    example_packing_df['day_amount'] = example_packing_df['day_amount'].astype(
+        int)
+
+    # Update the picking_df based on the condition
+    for i in range(len(packing_df)):
+        cost_mod_index = i % 12
+        coefficient = random_rate / 2
+        if cost_mod_index % 2 == 0:
+            coefficient = -random_rate / 2
+        packing_df.loc[i, ['employee_id', 'employee_name', 'cost', 'day_amount']
+                       ] = example_packing_df.loc[cost_mod_index, ['employee_id', 'employee_name', 'cost', 'day_amount']]
+        # Update Duration +- random_rate %
+        packing_df.loc[i, 'duration'] = packing_df.loc[i, 'duration'] + \
+            (coefficient * packing_df.loc[i, 'duration'] / 100)
+
+    # Combining
+    new_employee_df = pd.concat([picking_df, packing_df], ignore_index=True)
+
+    # Adjust Capital Cost
+    new_capital_cost = capitalcost_df.copy()
+    for i in range(len(new_capital_cost)):
+        cost_mod_index = i % random_rate
+        amout_mod_index = i % random_rate / 2
+        coefficient = 1
+        if cost_mod_index % 2 == 0:
+            coefficient = -1
+
+        # Update Cost +- 1 - 10%
+        new_capital_cost.loc[i, 'cost'] = new_capital_cost.loc[i, 'cost'] + \
+            (coefficient * cost_mod_index *
+             new_capital_cost.loc[i, 'cost'] / 100)
+        new_capital_cost.loc[i, 'duration'] = new_capital_cost.loc[i, 'duration'] + (
+            coefficient * amout_mod_index * new_capital_cost.loc[i, 'duration'] / 100)
+
+    # Adjust Material Cost
+    new_material_cost = material_df.copy()
+    for i in range(len(new_material_cost)):
+        cost_mod_index = i % random_rate
+        amout_mod_index = i % random_rate / 2
+        coefficient = 1
+        if cost_mod_index % 2 == 0:
+            coefficient = -1
+
+        # Update Cost +- 1 - 10%
+        new_material_cost.loc[i, 'unit_cost'] = new_material_cost.loc[i, 'unit_cost'] + (
+            coefficient * cost_mod_index * new_material_cost.loc[i, 'unit_cost'] / 100)
+        new_material_cost.loc[i, 'amount'] = new_material_cost.loc[i, 'amount'] + (
+            coefficient * amout_mod_index * new_material_cost.loc[i, 'amount'] / 100)
+
+    # Save data
+    process_df.to_csv(
+        f'data/{new_dataset_name}/generated_process_data.csv', index=False)
+    new_employee_df.to_csv(
+        f'data/{new_dataset_name}/generated_employee_usage.csv', index=False)
+    new_material_cost.to_csv(
+        f'data/{new_dataset_name}/generated_material_usage.csv', index=False)
+    new_capital_cost.to_csv(
+        f'data/{new_dataset_name}/generated_captial_cost.csv', index=False)
+    # Print the result
+    print(
+        f"Data from {dataset_name} has been shaken and saved as {new_dataset_name}.")

model/matrix_generator/.gitignore

@@ -0,0 +1 @@
+__pycache__

model/matrix_generator/cost_matrix_class.py

@@ -0,0 +1,550 @@
+import pandas as pd
+import numpy as np
+import importlib
+
+# fmt:off
+import cost_matrix_generator as cmg
+importlib.reload(cmg)
+# fmt:on
+
+
+class CostMatrixGenerator:
+    def __init__(self):
+        self.process_df = pd.DataFrame()
+        self.employee_usage = pd.DataFrame()
+        self.material_usage = pd.DataFrame()
+        self.capital_cost_usage = pd.DataFrame()
+        self.data_directory = "example"
+
+    def change_data_directory(self, new_directory):
+        self.data_directory = new_directory
+
+    def load_data(self):
+        self.process_df = pd.read_csv(
+            f"{self.data_directory}/generated_process_data.csv"
+        )
+        self.employee_usage = pd.read_csv(
+            f"{self.data_directory}/generated_employee_usage.csv"
+        )
+        self.material_usage = pd.read_csv(
+            f"{self.data_directory}/generated_material_usage.csv"
+        )
+        self.capital_cost_usage = pd.read_csv(
+            f"{self.data_directory}/generated_captial_cost.csv"
+        )
+
+    def remove_outlier_iqr(self, iqr_index=1.5):
+        process_df = self.process_df
+        q1 = np.percentile(process_df["cost"], 25)
+        q3 = np.percentile(process_df["cost"], 75)
+        iqr = q3 - q1
+        lower_bound = q1 - (iqr_index * iqr)
+        upper_bound = q3 + (iqr_index * iqr)
+        process_df = process_df[
+            (process_df["cost"] > lower_bound) & (
+                process_df["cost"] < upper_bound)
+        ]
+        removed_data = self.process_df[
+            ~self.process_df["process_id"].isin(process_df["process_id"])
+        ]
+        self.process_df = process_df
+        print("Outliers removed")
+        print(f"Amount of process to remove {len(removed_data)}")
+        return process_df
+
+    def generate_data(self):
+        # Material
+        material_cost_matrix, material_amount_matrix = (
+            cmg.generate_material_usage_cost_matrix(
+                self.process_df, self.material_usage
+            )
+        )
+        material_cost_matrix = material_cost_matrix.values
+        material_amount_matrix = material_amount_matrix.values
+
+        row, col = material_cost_matrix.shape
+        material_cost_matrix = material_cost_matrix.reshape(row, 1, col)
+        material_amount_matrix = material_amount_matrix.reshape(row, 1, col)
+
+        # Employee
+        (
+            employee_cost_matrix,
+            employee_duration_matrix,
+            employee_day_amount_matrix,
+        ) = cmg.generate_employee_usage_cost_matrix(
+            self.process_df, self.employee_usage
+        )
+        employee_cost_matrix = employee_cost_matrix.values
+        employee_duration_matrix = employee_duration_matrix.values
+        employee_day_amount_matrix = employee_day_amount_matrix.values
+
+        # Reshape Matrix
+        #  Employee Cost
+        row, col = employee_cost_matrix.shape
+        employee_cost_matrix = employee_cost_matrix.reshape(
+            row, 1, col)
+
+        #  Employee Duration
+        row, col = employee_duration_matrix.shape
+        employee_duration_matrix = employee_duration_matrix.reshape(
+            row, 1, col
+        )
+
+        #  Employee Day Amount
+        row, col = employee_day_amount_matrix.shape
+        employee_day_amount_matrix = employee_day_amount_matrix.reshape(
+            row, 1, col
+        )
+
+        print(
+            f" Employee Cost matrix shape {employee_cost_matrix.shape}"
+        )
+
+        # Capital Cost
+        (
+            capital_cost_matrix,
+            day_amount_matrix,
+            capital_cost_duration_matrix,
+        ) = cmg.generate_capital_cost_matrix(
+            self.process_df, capital_cost_df=self.capital_cost_usage
+        )
+
+        # Get Values
+        capital_cost_matrix = capital_cost_matrix.values
+        day_amount_matrix = day_amount_matrix.values
+        capital_cost_duration_matrix = capital_cost_duration_matrix.values
+
+        # Reshape Matrix
+        row, col = capital_cost_matrix.shape
+        capital_cost_matrix = capital_cost_matrix.reshape(row, 1, col)
+
+        row, col = day_amount_matrix.shape
+        day_amount_matrix = day_amount_matrix.reshape(row, 1, col)
+
+        row, col = capital_cost_duration_matrix.shape
+        capital_cost_duration_matrix = capital_cost_duration_matrix.reshape(
+            row, 1, col)
+
+        result_matrix = cmg.generate_price_matrix(
+            process_df=self.process_df, use_3d=True
+        )
+
+        return (
+            material_cost_matrix,
+            material_amount_matrix,
+            employee_cost_matrix,
+            employee_duration_matrix,
+            employee_day_amount_matrix,
+            capital_cost_matrix,
+            day_amount_matrix,
+            capital_cost_duration_matrix,  # New On Finetuning
+            result_matrix,
+        )
+
+    def train_test_split(self, train_rate):
+        process_df_size = len(self.process_df)
+        trained_size = train_rate * process_df_size
+        train_process_df = self.process_df.sample(int(trained_size))
+        validate_process_df = self.process_df.drop(train_process_df.index)
+        # Ensure at least one record per original_material_name in train_process_df
+        unique_materials = self.process_df['original_material_name'].unique()
+        for material in unique_materials:
+            if material not in train_process_df['original_material_name'].values:
+                sample_record = self.process_df[self.process_df['original_material_name'] == material].sample(
+                    1)
+                train_process_df = pd.concat([train_process_df, sample_record])
+                validate_process_df = validate_process_df.drop(
+                    sample_record.index)
+
+        # Result Matrix
+        result_matrix = cmg.generate_price_matrix(
+            process_df=train_process_df, use_3d=True
+        )
+
+        validate_result_matrix = cmg.generate_price_matrix(
+            process_df=validate_process_df, use_3d=True
+        )
+
+        # Material
+        material_cost_matrix, material_amount_matrix = (
+            cmg.generate_material_usage_cost_matrix(
+                train_process_df, self.material_usage
+            )
+        )
+        material_cost_matrix = material_cost_matrix.values
+        material_amount_matrix = material_amount_matrix.values
+
+        # Material Validate
+        validate_material_cost_matrix, validate_material_amount_matrix = (
+            cmg.generate_material_usage_cost_matrix(
+                validate_process_df, self.material_usage
+            )
+        )
+
+        validate_material_cost_matrix = validate_material_cost_matrix.values
+        validate_material_amount_matrix = validate_material_amount_matrix.values
+
+        row, col = material_cost_matrix.shape
+        material_cost_matrix = material_cost_matrix.reshape(row, 1, col)
+        material_amount_matrix = material_amount_matrix.reshape(row, 1, col)
+
+        # Employee
+        (
+            employee_cost_matrix,
+            employee_duration_matrix,
+            employee_day_amount_matrix,
+        ) = cmg.generate_employee_usage_cost_matrix(
+            train_process_df, self.employee_usage
+        )
+        # Employee Extract Value
+        employee_cost_matrix = employee_cost_matrix.values
+        employee_duration_matrix = employee_duration_matrix.values
+        employee_day_amount_matrix = employee_day_amount_matrix.values
+
+        # Employee Reshape
+        row, col = employee_cost_matrix.shape
+        employee_cost_matrix = employee_cost_matrix.reshape(
+            row, 1, col)
+        row, col = employee_duration_matrix.shape
+        employee_duration_matrix = employee_duration_matrix.reshape(
+            row, 1, col)
+        row, col = employee_day_amount_matrix.shape
+        employee_day_amount_matrix = employee_day_amount_matrix.reshape(
+            row, 1, col)
+
+        print(
+            f" Employee Cost matrix shape {employee_duration_matrix.shape} "
+        )
+
+        # Employee validate
+        (
+            validate_emp_cost_matrix,
+            validate_emp_duration_matrix,
+            validate_emp_day_amount_matrix,
+        ) = cmg.generate_employee_usage_cost_matrix(
+            validate_process_df, self.employee_usage
+        )
+        # Employee Validate Extract Value
+        validate_emp_cost_matrix = validate_emp_cost_matrix.values
+        validate_emp_duration_matrix = validate_emp_duration_matrix.values
+        validate_emp_day_amount_matrix = validate_emp_day_amount_matrix.values
+
+        # Employee Validate Reshape
+        row, col = validate_emp_cost_matrix.shape
+        validate_emp_cost_matrix = validate_emp_cost_matrix.reshape(
+            row, 1, col
+        )
+        row, col = validate_emp_duration_matrix.shape
+        validate_emp_duration_matrix = validate_emp_duration_matrix.reshape(
+            row, 1, col
+        )
+        row, col = validate_emp_day_amount_matrix.shape
+        validate_emp_day_amount_matrix = validate_emp_day_amount_matrix.reshape(
+            row, 1, col
+        )
+
+        # Capital Cost
+        capital_cost_matrix, day_amount_matrix, capital_duration_matrix = (
+            cmg.generate_capital_cost_matrix(
+                train_process_df, capital_cost_df=self.capital_cost_usage
+            )
+        )
+
+        # Capital Cost Extract Value
+        capital_cost_matrix = capital_cost_matrix.values
+        day_amount_matrix = day_amount_matrix.values
+        capital_duration_matrix = capital_duration_matrix.values
+
+        # Capital Cost Reshape for 3D
+        row, col = capital_cost_matrix.shape
+        capital_cost_matrix = capital_cost_matrix.reshape(row, 1, col)
+        row, col = day_amount_matrix.shape
+        day_amount_matrix = day_amount_matrix.reshape(row, 1, col)
+        row, col = capital_duration_matrix.shape
+        capital_duration_matrix = capital_duration_matrix.reshape(row, 1, col)
+
+        # Capital Cost validate
+        (
+            valdiate_capital_cost_matrix,
+            validate_dayamount_matrix,
+            validate_capital_duration_matrix,
+        ) = cmg.generate_capital_cost_matrix(
+            validate_process_df, capital_cost_df=self.capital_cost_usage
+        )
+
+        # Capital Cost Validate Value Extraction
+        valdiate_capital_cost_matrix = valdiate_capital_cost_matrix.values
+        validate_dayamount_matrix = validate_dayamount_matrix.values
+        validate_capital_duration_matrix = validate_capital_duration_matrix.values
+
+        # Capital Cost Validate Reshape
+        row, col = valdiate_capital_cost_matrix.shape
+        valdiate_capital_cost_matrix = valdiate_capital_cost_matrix.reshape(
+            row, 1, col)
+
+        row, col = validate_dayamount_matrix.shape
+        validate_dayamount_matrix = validate_dayamount_matrix.reshape(
+            row, 1, col)
+
+        row, col = validate_capital_duration_matrix.shape
+        validate_capital_duration_matrix = validate_capital_duration_matrix.reshape(
+            row, 1, col
+        )
+
+        validate_payload = {
+            "validate_process_df": validate_process_df,
+            "validate_result_matrix": validate_result_matrix,
+            "validate_material_cost_matrix": validate_material_cost_matrix,
+            "validate_material_amount_matrix": validate_material_amount_matrix,
+            "validate_capital_cost_matrix": valdiate_capital_cost_matrix,
+            "validate_day_amount_matrix": validate_dayamount_matrix,
+            "validate_capital_duration_matrix": validate_capital_duration_matrix,
+            "validate_employee_cost_matrix": validate_emp_cost_matrix,
+            "validate_employee_duration_matrix": validate_emp_duration_matrix,
+            "validate_employee_day_amount_matrix": validate_emp_day_amount_matrix,
+        }
+
+        return (
+            material_cost_matrix,
+            material_amount_matrix,
+            employee_cost_matrix,
+            employee_duration_matrix,
+            employee_day_amount_matrix,
+            capital_cost_matrix,
+            day_amount_matrix,
+            capital_duration_matrix,
+            result_matrix,
+            validate_payload,
+        )
+
+    def train_test_split_without_matrix(self, train_rate):
+        process_df_size = len(self.process_df)
+        trained_size = train_rate * process_df_size
+        train_process_df = self.process_df.sample(int(trained_size))
+        validate_process_df = self.process_df.drop(train_process_df.index)
+
+        # Adjust to match new Process dataset
+        train_capital_cost = self.capital_cost_usage.copy()
+        train_capital_cost = train_capital_cost[
+            train_capital_cost["process_id"].isin(
+                train_process_df["process_id"])
+        ]
+
+        train_employee_usage = self.employee_usage.copy()
+        train_employee_usage = train_employee_usage[
+            train_employee_usage["process_id"].isin(
+                train_process_df["process_id"])
+        ]
+
+        train_material_usage = self.material_usage.copy()
+        train_material_usage = train_material_usage[
+            train_material_usage["process_id"].isin(
+                train_process_df["process_id"])
+        ]
+
+        # Adjust to match new Process dataset for validation set
+        validate_capital_cost = self.capital_cost_usage.copy()
+        validate_capital_cost = validate_capital_cost[
+            validate_capital_cost["process_id"].isin(
+                validate_process_df["process_id"])
+        ]
+
+        validate_employee_usage = self.employee_usage.copy()
+        validate_employee_usage = validate_employee_usage[
+            validate_employee_usage["process_id"].isin(
+                validate_process_df["process_id"]
+            )
+        ]
+
+        validate_material_usage = self.material_usage.copy()
+        validate_material_usage = validate_material_usage[
+            validate_material_usage["process_id"].isin(
+                validate_process_df["process_id"]
+            )
+        ]
+
+        return (
+            train_process_df,
+            train_employee_usage,
+            train_material_usage,
+            train_capital_cost,
+            validate_process_df,
+            validate_employee_usage,
+            validate_material_usage,
+            validate_capital_cost,
+        )
+
+    def generate_data_from_input(
+        self, process_df, material_usage, employee_usage, capital_cost_usage
+    ):
+        # Material
+        material_cost_matrix, material_amount_matrix = (
+            cmg.generate_material_usage_cost_matrix(process_df, material_usage)
+        )
+        material_cost_matrix = material_cost_matrix.values
+        material_amount_matrix = material_amount_matrix.values
+
+        row, col = material_cost_matrix.shape
+        material_cost_matrix = material_cost_matrix.reshape(row, 1, col)
+        material_amount_matrix = material_amount_matrix.reshape(row, 1, col)
+
+        # Employee
+        (employee_cost_matrix,
+         employee_duration_matrix,
+         employee_day_amount_matrix,
+         ) = cmg.generate_employee_usage_cost_matrix(process_df, employee_usage)
+        employee_cost_matrix = employee_cost_matrix.values
+        employee_duration_matrix = employee_duration_matrix.values
+        employee_day_amount_matrix = employee_day_amount_matrix.values
+
+        # Reshape Matrix
+        #  Employee Cost
+        row, col = employee_cost_matrix.shape
+        employee_cost_matrix = employee_cost_matrix.reshape(
+            row, 1, col)
+        #  Employee Duration
+        row, col = employee_duration_matrix.shape
+        employee_duration_matrix = employee_duration_matrix.reshape(
+            row, 1, col)
+        #  Employee Day Amount
+        row, col = employee_day_amount_matrix.shape
+        employee_day_amount_matrix = employee_day_amount_matrix.reshape(
+            row, 1, col
+        )
+
+        print(
+            f" Employee Cost matrix shape {employee_cost_matrix.shape} "
+        )
+
+        # Capital Cost
+        (
+            capital_cost_matrix,
+            day_amount_matrix,
+            capital_cost_duration_matrix,
+        ) = cmg.generate_capital_cost_matrix(
+            process_df, capital_cost_df=capital_cost_usage
+        )
+
+        # Get Values
+        capital_cost_matrix = capital_cost_matrix.values
+        day_amount_matrix = day_amount_matrix.values
+        capital_cost_duration_matrix = capital_cost_duration_matrix.values
+
+        # Reshape Matrix
+        row, col = capital_cost_matrix.shape
+        capital_cost_matrix = capital_cost_matrix.reshape(row, 1, col)
+
+        row, col = day_amount_matrix.shape
+        day_amount_matrix = day_amount_matrix.reshape(row, 1, col)
+
+        row, col = capital_cost_duration_matrix.shape
+        capital_cost_duration_matrix = capital_cost_duration_matrix.reshape(
+            row, 1, col)
+
+        result_matrix = cmg.generate_price_matrix(
+            process_df=process_df, use_3d=True)
+
+        return (
+            material_cost_matrix,
+            material_amount_matrix,
+            employee_cost_matrix,
+            employee_duration_matrix,
+            employee_day_amount_matrix,
+            capital_cost_matrix,
+            day_amount_matrix,
+            capital_cost_duration_matrix,  # New On Finetuning
+            result_matrix,
+        )
+
+    def get_validation_payload(self, validate_process_df):
+        validate_result_matrix = cmg.generate_price_matrix(
+            process_df=validate_process_df, use_3d=True
+        )
+
+        # Material Validate
+        validate_material_cost_matrix, validate_material_amount_matrix = (
+            cmg.generate_material_usage_cost_matrix(
+                validate_process_df, self.material_usage
+            )
+        )
+
+        validate_material_cost_matrix = validate_material_cost_matrix.values
+        validate_material_amount_matrix = validate_material_amount_matrix.values
+
+        # Employee validate
+        (
+            validate_employee_cost_matrix,
+            validate_employee_duration_matrix,
+            validate_employee_day_amount_matrix,
+        ) = cmg.generate_employee_usage_cost_matrix(
+            validate_process_df, self.employee_usage
+        )
+        # Employee Validate Extract Value
+        validate_employee_cost_matrix = validate_employee_cost_matrix.values
+        validate_employee_duration_matrix = validate_employee_duration_matrix.values
+        validate_employee_day_amount_matrix = validate_employee_day_amount_matrix.values
+
+        # Employee Validate Reshape
+        row, col = validate_employee_cost_matrix.shape
+        validate_employee_cost_matrix = validate_employee_cost_matrix.reshape(
+            row, 1, col
+        )
+        row, col = validate_employee_duration_matrix.shape
+        validate_employee_duration_matrix = validate_employee_duration_matrix.reshape(
+            row, 1, col
+        )
+        row, col = validate_employee_day_amount_matrix.shape
+        validate_employee_day_amount_matrix = validate_employee_day_amount_matrix.reshape(
+            row, 1, col
+        )
+
+        # Capital Cost validate
+        (
+            valdiate_capital_cost_matrix,
+            validate_dayamount_matrix,
+            validate_capital_duration_matrix,
+        ) = cmg.generate_capital_cost_matrix(
+            validate_process_df, capital_cost_df=self.capital_cost_usage
+        )
+
+        # Capital Cost Validate Value Extraction
+        valdiate_capital_cost_matrix = valdiate_capital_cost_matrix.values
+        validate_dayamount_matrix = validate_dayamount_matrix.values
+        validate_capital_duration_matrix = validate_capital_duration_matrix.values
+
+        # Capital Cost Validate Reshape
+        row, col = valdiate_capital_cost_matrix.shape
+        valdiate_capital_cost_matrix = valdiate_capital_cost_matrix.reshape(
+            row, 1, col)
+
+        row, col = validate_dayamount_matrix.shape
+        validate_dayamount_matrix = validate_dayamount_matrix.reshape(
+            row, 1, col)
+
+        row, col = validate_capital_duration_matrix.shape
+        validate_capital_duration_matrix = validate_capital_duration_matrix.reshape(
+            row, 1, col
+        )
+
+        validate_payload = {
+            "validate_process_df": validate_process_df,
+            "validate_result_matrix": validate_result_matrix,
+            "validate_material_cost_matrix": validate_material_cost_matrix,
+            "validate_material_amount_matrix": validate_material_amount_matrix,
+            "validate_capital_cost_matrix": valdiate_capital_cost_matrix,
+            "validate_day_amount_matrix": validate_dayamount_matrix,
+            "validate_capital_duration_matrix": validate_capital_duration_matrix,
+            "validate_employee_cost_matrix": validate_employee_cost_matrix,
+            "validate_employee_duration_matrix": validate_employee_duration_matrix,
+            "validate_employee_day_amount_matrix": validate_employee_day_amount_matrix,
+        }
+
+        return validate_payload
+
+    def get_data(self):
+        return (
+            self.process_df,
+            self.employee_usage,
+            self.material_usage,
+            self.capital_cost_usage,
+        )

model/matrix_generator/cost_matrix_generator.py

@@ -0,0 +1,297 @@
+import pandas as pd
+import numpy as np
+
+
+def generate_material_usage_cost_matrix(process_df, material_usage_df):
+    overall_cost_matrix = pd.DataFrame()
+    overall_amount_matrix = pd.DataFrame()
+    process_df = process_df.reset_index()
+
+    # Find Unique for fixed the column of dataframe and Matrix
+    unique_material_id = material_usage_df["_id"].unique()
+
+    for index in process_df.index:
+        selected_process = process_df.iloc[index]
+
+        # Find Unique Material
+        # Find All Material Usage
+        selected_process_material = material_usage_df[
+            material_usage_df["process_id"] == selected_process["process_id"]
+        ]
+        cost_dict = {}
+        amount_dict = {}
+
+        # Iteration Over Material
+        for idx in range(len(selected_process_material)):
+            selected_data = selected_process_material.iloc[idx]
+            material_id = selected_data["_id"]
+            cost = selected_data["unit_cost"]
+            amount = selected_data["amount"]
+            cost_dict[material_id] = cost
+            amount_dict[material_id] = amount
+
+        # Iteration Over Rest of Material
+        for material_id in unique_material_id:
+            if material_id not in cost_dict:
+                cost_dict[material_id] = 0
+                amount_dict[material_id] = 0
+
+        cost_df = pd.DataFrame(
+            cost_dict, index=[selected_process["process_id"]])
+        amount_df = pd.DataFrame(
+            amount_dict, index=[selected_process["process_id"]])
+
+        overall_cost_matrix = pd.concat([overall_cost_matrix, cost_df], axis=0)
+        overall_amount_matrix = pd.concat(
+            [overall_amount_matrix, amount_df], axis=0)
+
+    # Reorder Column to be same normal and validation
+    column_list = unique_material_id.tolist()
+    ordered_columns = sorted(column_list)
+    overall_cost_matrix = overall_cost_matrix[ordered_columns]
+    overall_amount_matrix = overall_amount_matrix[ordered_columns]
+
+    overall_cost_matrix.fillna(0, inplace=True)
+    overall_amount_matrix.fillna(0, inplace=True)
+
+    return (overall_cost_matrix, overall_amount_matrix)
+
+
+def generate_employee_usage_cost_matrix(process_df, employee_usage_df):
+    overall_cost_matrix = pd.DataFrame()
+    overall_duration_matrix = pd.DataFrame()
+    overall_day_amount_matrix = pd.DataFrame()
+
+    employee_usage_df["duration"] = (
+        employee_usage_df["duration"] * employee_usage_df["amount"]
+    )
+
+    unique_emp_id = employee_usage_df["employee_id"].unique()
+
+    process_df = process_df.reset_index()
+
+    # Iteration Over each process
+    for index in process_df.index:
+        selected_process = process_df.iloc[index]
+        selected_process_employee = employee_usage_df[
+            employee_usage_df["process_id"] == selected_process["process_id"]
+        ]
+
+        ec_cost_dict = {}
+        ec_duration_dict = {}
+        ec_day_amount_dict = {}
+
+        unique_process_employee = selected_process_employee["employee_id"].unique(
+        )
+        unique_pe_df = pd.DataFrame(
+            unique_process_employee, columns=["employee_id"])
+
+        # Adust Employee
+        # Converse many employee record to one record for each employee in one process
+        # Process will can contain many of employee but 1 employee only 1 record
+        for idx in range(len(unique_pe_df)):
+            selected_data = unique_pe_df.iloc[idx]
+            all_record = selected_process_employee[
+                selected_process_employee["employee_id"] == selected_data["employee_id"]
+            ]
+            first_record = all_record.iloc[0]
+            # Cost also the same pick from the first record
+            cost = first_record["cost"]
+            day_amount = first_record["day_amount"]
+            # Duration is the sum of all duration of employee in the process
+            duration = all_record["duration"].sum()
+            # Update the record of unique_pe_df add cost and duration
+            unique_pe_df.loc[idx, "cost"] = cost
+            unique_pe_df.loc[idx, "duration"] = duration
+            unique_pe_df.loc[idx, "day_amount"] = day_amount
+            unique_pe_df.loc[idx, "process_id"] = first_record["process_id"]
+
+        for idx in range(len(unique_pe_df)):
+            selected_data = unique_pe_df.iloc[idx]
+            cost = selected_data["cost"]
+            employee_id = selected_data["employee_id"]
+            duration = selected_data["duration"]
+            day_amount = selected_data["day_amount"]
+
+            ec_cost_dict[employee_id] = cost
+            ec_duration_dict[employee_id] = duration
+            ec_day_amount_dict[employee_id] = day_amount
+
+        # Iteration Over Rest of Employee
+
+        for employee_id in unique_emp_id:
+            if employee_id not in ec_cost_dict:
+                ec_cost_dict[employee_id] = 0
+                ec_duration_dict[employee_id] = 0
+                ec_day_amount_dict[employee_id] = 1
+
+        employee_cost_df = pd.DataFrame(
+            ec_cost_dict, index=[selected_process["process_id"]]
+        )
+
+        employee_duration_df = pd.DataFrame(
+            ec_duration_dict, index=[selected_process["process_id"]]
+        )
+
+        employee_dayamount_df = pd.DataFrame(
+            ec_day_amount_dict, index=[selected_process["process_id"]]
+        )
+
+        overall_cost_matrix = pd.concat(
+            [overall_cost_matrix, employee_cost_df], axis=0
+        )
+
+        overall_duration_matrix = pd.concat(
+            [overall_duration_matrix, employee_duration_df], axis=0
+        )
+
+        overall_day_amount_matrix = pd.concat(
+            [overall_day_amount_matrix, employee_dayamount_df], axis=0
+        )
+
+    # Reorder Column to be same normal and validation
+
+    # Reorder for Emploee
+    column_list = unique_emp_id.tolist()
+    ordered_columns = sorted(column_list)
+    overall_cost_matrix = overall_cost_matrix[ordered_columns]
+    overall_duration_matrix = overall_duration_matrix[ordered_columns]
+    overall_day_amount_matrix = overall_day_amount_matrix[ordered_columns]
+
+    overall_cost_matrix.fillna(0, inplace=True)
+    overall_duration_matrix.fillna(0, inplace=True)
+    overall_day_amount_matrix.fillna(1, inplace=True)
+
+    return (
+        overall_cost_matrix,
+        overall_duration_matrix,
+        overall_day_amount_matrix,
+    )
+
+
+def generate_capital_cost_matrix(process_df, capital_cost_df):
+    cost_df = pd.DataFrame()
+    day_amount_df = pd.DataFrame()
+    duration_df = pd.DataFrame()
+    process_df = process_df.reset_index()
+
+    # Find Unique id to fixed the column of dataframe and Matrix
+    unique_capital_cost_id = capital_cost_df["_id"].unique()
+
+    # Iteration Over each process
+    for index in process_df.index:
+        selected_process = process_df.iloc[index]
+        selected_process_capitalcost = capital_cost_df[
+            capital_cost_df["process_id"] == selected_process["process_id"]
+        ]
+
+        cost_dict = {}
+        day_amount_dict = {}
+        duration_dict = {}
+        uniq_process_cc = selected_process_capitalcost["_id"].unique()
+
+        uniq_pcc_df = pd.DataFrame(
+            uniq_process_cc, columns=["capital_cost_id"])
+
+        # Adust Capital Cost
+        # Converse many capital Cost record to one record for each capital Cost in one process
+        # Process will can contain many of capital cost but 1 capital cost only 1 record
+        for idx in range(len(uniq_pcc_df)):
+            selected_data = uniq_pcc_df.iloc[idx]
+            all_record = selected_process_capitalcost[
+                selected_process_capitalcost["_id"] == selected_data["capital_cost_id"]
+            ]
+            first_record = all_record.iloc[0]
+            # Cost also the same pick from the first record
+            cost = first_record["cost"]
+            # Duration is the sum of all duration of employee in the process
+            duration = all_record["duration"].sum()
+            # Update the record of unique_pe_df add cost and duration
+            uniq_pcc_df.loc[idx, "cost"] = cost
+            uniq_pcc_df.loc[idx, "duration"] = duration
+            uniq_pcc_df.loc[idx, "day_amount"] = first_record["day_amount"]
+            uniq_pcc_df.loc[idx, "process_id"] = first_record["process_id"]
+
+        # Iteration Only for 1 cc per record data
+        for idx in range(len(uniq_pcc_df)):
+            selected_data = uniq_pcc_df.iloc[idx]
+            cost = selected_data["cost"]
+            duration = selected_data["duration"]
+            captial_cost_id = selected_data["capital_cost_id"]
+            cost_dict[captial_cost_id] = cost
+            day_amount_dict[captial_cost_id] = selected_data["day_amount"]
+            duration_dict[captial_cost_id] = duration
+
+        # Do for the rest of capital cost object
+        for cc_id in unique_capital_cost_id:
+            if cc_id not in cost_dict:
+                cost_dict[cc_id] = 0
+                day_amount_dict[cc_id] = 1
+                duration_dict[cc_id] = 0
+
+        # Dataframe Generation
+        sub_cost_df = pd.DataFrame(
+            cost_dict, index=[selected_process["process_id"]])
+        sub_duration_df = pd.DataFrame(
+            duration_dict, index=[selected_process["process_id"]]
+        )
+        sub_dayamount_df = pd.DataFrame(
+            day_amount_dict, index=[selected_process["process_id"]]
+        )
+
+        # Generate Matrix
+        cost_df = pd.concat([cost_df, sub_cost_df], axis=0)
+        day_amount_df = pd.concat([day_amount_df, sub_dayamount_df], axis=0)
+        duration_df = pd.concat([duration_df, sub_duration_df], axis=0)
+
+    # Reorder the Column to be same on Training and validation
+
+    column_list = unique_capital_cost_id.tolist()
+    sorted_column = sorted(column_list)
+
+    day_amount_df = day_amount_df[sorted_column]
+    cost_df = cost_df[sorted_column]
+    duration_df = duration_df[sorted_column]
+
+    day_amount_df.fillna(1, inplace=True)
+    cost_df.fillna(0, inplace=True)
+    duration_df.fillna(1, inplace=True)
+
+    return (cost_df, day_amount_df, duration_df)
+
+
+def generate_price_matrix(process_df, use_3d=False, use_unit_cost=True):
+    price_arr = []
+    process_df = process_df.reset_index()
+    if use_unit_cost:
+        for index in process_df.index:
+            selected_data = process_df.iloc[index]
+            cost = selected_data["cost"]
+            if use_3d:
+                price_arr.append([[cost]])
+            else:
+                price_arr.append([cost])
+    else:
+        for index in process_df.index:
+            selected_data = process_df.iloc[index]
+            if use_3d:
+                price_arr.append([[selected_data["cost"]]])
+            else:
+                price_arr.append([selected_data["cost"]])
+    price_arr = np.array(price_arr)
+    return price_arr
+
+
+def generate_duration_matrix(process_df, use_3d=False):
+    duration_array = []
+    process_df = process_df.reset_index()
+    for index in process_df.index:
+        selected_data = process_df.iloc[index]
+        duration = selected_data["duration"]
+        if use_3d:
+            duration_array.append([[duration]])
+        else:
+            duration_array.append([duration])
+
+    duration_array = np.array(duration_array)
+    return duration_array

model/model/.gitignore

@@ -0,0 +1 @@
+__pycache__/

model/model/activation.py

@@ -0,0 +1,20 @@
+alpha = 0.1
+
+
+def leaky_relu(x):
+    shape = x.shape
+    x = x.flatten()
+    result = 0
+    if x > 0:
+        result = x
+    else:
+        result = alpha * x
+    return result.reshape(shape)
+
+
+def leaky_relu_prime(x):
+    x = x.flatten()
+    if x > 0:
+        return 1
+    else:
+        return alpha

model/model/captial_fc_layer.py

@@ -0,0 +1,111 @@
+from layer import Layer
+from tsensor import explain as exp
+import numpy as np
+import activation as act
+import importlib
+import weight_activation as wa
+
+importlib.reload(act)
+importlib.reload(wa)
+
+
+class CapitalCostFCLayer(Layer):
+    def __init__(self, input_size, output_size, hour_day):
+        self.weights = np.full(
+            (input_size, output_size), 1.0
+        )  # np.random.rand(input_size, output_size) - 0.5
+        self.bias = np.full(
+            (1, output_size), 0.0
+        )  # np.random.rand(1, output_size) - 0.5
+        print(f"weight shape {self.weights.shape}")
+        self.second_input = None
+        self.day_amount = None
+        self.hour_day = hour_day
+        self.cost = None
+        self.time_usage = None
+        self.input = None
+
+    def annotate(self, cost_rate, day_amount, time_usage):
+        with exp() as c:
+            # fmt:off
+            output = 1/60 * (1/self.hour_day) * cost_rate *  time_usage  *  (1/day_amount) @ self.weights + self.bias
+
+    # fmt:on
+
+    # Predict during use
+    def predict(self, cost_data, time_usage, day_amount):
+        element_input = np.multiply(cost_data, time_usage)
+        element_input = np.divide(element_input, day_amount)
+        output = (1 / 60) * (1 / self.hour_day) * np.dot(
+            element_input, self.weights
+        ) + self.bias
+        self.input = output
+        return act.leaky_relu(output)
+
+    # Predict During Train
+    def forward_propagation(self, cost_data, time_usage, day_amount):
+        self.cost = cost_data
+        self.time_usage = time_usage
+        self.day_amount = day_amount
+        if np.all(cost_data == 0) and np.all(time_usage == 0):
+            self.output = np.zeros((1, 1))
+            return self.output
+
+        element_input = np.multiply(self.cost, self.time_usage)
+        element_input = np.divide(element_input, self.day_amount)
+        self.output = (1 / 60) * (1 / self.hour_day) * np.dot(
+            element_input, self.weights
+        )  # + self.bias
+        self.output = np.nan_to_num(self.output)
+        return act.leaky_relu(self.output)
+
+    def predict(self, cost_data, time_usage, day_amount):
+        element_input = np.multiply(cost_data, time_usage)
+        element_input = np.divide(element_input, day_amount)
+        output = (1 / 60) * (1 / self.hour_day) * np.dot(
+            element_input, self.weights
+        )  # + self.bias
+        self.input = output
+        return act.leaky_relu(output)
+
+    # output error is dE/dY
+    def backward_propagation(self, output_error, learning_rate):
+        # dE/dX = dE/dY * df(x)/dx
+        # dE/dX = dE/dY * W^T
+        input_error = np.dot(output_error, self.weights.T)
+        # print(f'Output Error {output_error}')
+        # dE/dW = dE/dY * dY/dW
+        # dE/dwi = dE/dyi * xi
+        # dE/dW = dE/dY * X^T
+
+        activation_input = self.input
+        activation_prime = act.leaky_relu_prime(activation_input)
+        input = self.time_usage * (1 / 60) * (1 / self.hour_day)
+        input = np.multiply(input, self.cost)
+        input = np.divide(input, self.day_amount)
+
+        weight_error = np.dot(output_error, input)
+        weight_error = np.multiply(weight_error, activation_prime)
+
+        row, col = self.weights.shape
+        weight_error = weight_error.reshape(row, col)
+
+        # dE/dB = dE/dY
+        bias_error = output_error * activation_prime
+        # bias_error = output_error
+        # print(f"Capital Cost Acutal Input{activation_input}")
+        # print(f"Capital Cost Activation Prime {activation_prime}")
+        # print(f"Capital Cost Output Error {output_error}")
+
+        # Update Parameter
+        self.weights -= learning_rate * weight_error
+        self.weights = wa.un_zero_weight(self.weights)
+        self.bias -= learning_rate * bias_error
+        # print("Update weight to ", self.weights)
+        return input_error  # dE/dX
+
+    def get_weight(self):
+        return self.weights
+
+    def get_bias(self):
+        return self.bias

model/model/employee_fc_layer.py

@@ -0,0 +1,121 @@
+from layer import Layer
+import numpy as np
+from tsensor import explain as exp
+
+import activation as act
+import weight_activation as wa
+import importlib
+
+importlib.reload(act)
+importlib.reload(wa)
+
+
+class EmployeeFCLayer(Layer):
+    def __init__(self, input_size, output_size, hour_day):
+        self.weights = np.full(
+            (input_size, output_size), 1.0
+        )  # np.random.rand(input_size, output_size) - 0.5
+        self.bias = np.full(
+            (1, output_size), 0.0
+        )  # np.random.rand(1, output_size) - 0.5
+        print(f"weight shape {self.weights.shape}")
+        self.time_usage = None
+        self.hour_day = hour_day
+        self.cost = None
+        self.input = None
+
+    def annotate(self, cost_rate, time_usage, day_amount):
+        with exp() as c:
+            # fmt: off
+            output = 1/75 * 1/self.hour_day * time_usage *1/day_amount * cost_rate @ self.weights + self.bias
+
+    # fmt: on
+
+    # Predict the result during use
+    def predict(self, cost_data, time_usage, day_amount):
+        cost_time = np.multiply(cost_data, time_usage)
+        day_amount = np.divide(1, day_amount)
+        output = (1 / 75) * (1 / self.hour_day) * np.dot(
+            cost_time, self.weights
+        ) + self.bias
+        # print(f"Weight For Daily Employee: {self.weights}")
+        self.input = output
+        return act.leaky_relu(output)
+
+    # Predict During Train
+    def forward_propagation(self, cost_data, time_usage, day_amount):
+        self.cost = cost_data
+        self.time_usage = time_usage
+        self.day_amount = day_amount
+
+        if (
+            np.all(cost_data == 0)
+            and np.all(time_usage == 0)
+            and np.all(day_amount == 0)
+        ):
+            self.output = np.zeros((1, 1))
+            return self.output
+
+        cost_time = np.multiply(self.cost, self.time_usage)
+        cost_time = np.divide(cost_time, day_amount)
+        self.output = (
+            (1 / 75) * (1 / self.hour_day) * np.dot(cost_time, self.weights)
+        )  # + self.bias
+        return act.leaky_relu(self.output)
+
+    def predict(self, cost_data, time_usage, day_amount):
+        cost_time = np.multiply(cost_data, time_usage)
+        cost_time = np.divide(cost_time, day_amount)
+        output = (
+            (1 / 75) * (1 / self.hour_day) * np.dot(cost_time, self.weights)
+        )  # + self.bias
+        # print(f"Weight For Daily Employee: {self.weights}")
+        self.input = output
+        return act.leaky_relu(output)
+
+    # output error is dE/dY
+    def backward_propagation(self, output_error, learning_rate):
+        # print(f"DE: Weight {self.weights}")
+        input_error = np.dot(output_error, self.weights.T)
+        # print(f"DE: Weight.T {self.weights.T}")
+        # print(f"DE: Input Error {input_error}")
+        # print(f"DE: Output Error {output_error}")
+        # print(f"DE: Time Usage {self.time_usage}")
+        input = self.time_usage * (1 / 75) * (1 / self.hour_day)
+        # print(f"DE: input Before Multiply {input}")
+        # print(f"DE: Cost {self.cost} and Cost Transpose {self.cost.T}")
+        input = np.multiply(input, self.cost)
+        input = np.multiply(input, 1 / self.day_amount)
+        # print(f"DE: input After Multiply {gradient}")
+        # print(f"DE: Output Error {output_error}")
+        weight_error = np.dot(output_error, input)
+
+        activation_input = self.input
+        activation_prime = act.leaky_relu_prime(activation_input)
+
+        weight_error = np.multiply(weight_error, activation_prime)
+
+        row, col = self.weights.shape
+        # dE/dB = dE/dY
+        bias_error = output_error * activation_prime
+        # bias_error = output_error
+        # print(f"Daily Employee Acutal Input{activation_input}")
+        # print(f"Daily Employee Activation Prime {activation_prime}")
+        # print(f"Daily Employee Output Error {output_error}")
+
+        weight_error = weight_error.reshape(row, col)
+        # Update Parameter
+        # print(f"DE: Weight Error {weight_error}")
+        # print(f"DE: New Weight {self.weights}")
+        self.weights -= learning_rate * weight_error
+        self.weights = wa.un_zero_weight(self.weights)
+        # print('DE: New Bias', self.bias)
+        self.bias -= learning_rate * bias_error
+        # print("Update weight to ", self.weights)
+        return input_error  # dE/dX
+
+    def get_weight(self):
+        return self.weights
+
+    def get_bias(self):
+        return self.bias

model/model/generate_data_set.py

@@ -0,0 +1,78 @@
+import pandas as pd
+import numpy as np
+import importlib
+import sys
+
+# fmt:off
+sys.path.append('../matrix_generator')
+
+import cost_matrix_generator as cmg
+importlib.reload(cmg)
+# fmt:on
+
+# Import Data
+process_df = pd.read_csv('example/generated_process_data.csv')
+employee_usage = pd.read_csv("example/generated_employee_usage.csv")
+material_usage = pd.read_csv("example/generated_material_usage.csv")
+capital_cost_usage = pd.read_csv("example/generated_captial_cost.csv")
+
+# Data Extract and Shaping (Pre Processing)
+
+
+def generate_data():
+    # Material
+    material_cost_matrix, material_amount_matrix = cmg.generate_material_usage_cost_matrix(
+        process_df, material_usage)
+    material_cost_matrix = material_cost_matrix.values
+    material_amount_matrix = material_amount_matrix.values
+
+    row, col = material_cost_matrix.shape
+    material_cost_matrix = material_cost_matrix.reshape(row, 1, col)
+    material_amount_matrix = material_amount_matrix.reshape(row, 1, col)
+
+    # Employee
+    monthy_employee_cost_matrix, daily_employee_cost_matrix = cmg.generate_employee_usage_cost_matrix(
+        process_df, employee_usage)
+    monthy_employee_cost_matrix = monthy_employee_cost_matrix.values
+    daily_employee_cost_matrix = daily_employee_cost_matrix.values
+
+    row, col = monthy_employee_cost_matrix.shape
+    monthy_employee_cost_matrix = monthy_employee_cost_matrix.reshape(
+        row, 1, col)
+    row, col = daily_employee_cost_matrix.shape
+    daily_employee_cost_matrix = daily_employee_cost_matrix.reshape(
+        row, 1, col)
+    print(
+        f'Monthy Employee Cost matrix shape {monthy_employee_cost_matrix.shape} & Daily Employee Cost Matrix Shape {daily_employee_cost_matrix.shape}')
+
+    # Capital Cost
+    unit_cost_matrix, machine_hour_matrix, life_time_matrix = cmg.generate_capital_cost_matrix(
+        process_df, capital_cost_df=capital_cost_usage)
+
+    capital_cost_matrix = unit_cost_matrix.values
+
+    machine_hour_matrix = machine_hour_matrix.values
+
+    life_time_matrix = life_time_matrix.values
+
+    row, col = capital_cost_matrix.shape
+
+    capital_cost_matrix = capital_cost_matrix.reshape(row, 1, col)
+
+    row, col = machine_hour_matrix.shape
+
+    machine_hour_matrix = machine_hour_matrix.reshape(row, 1, col)
+
+    row, col = life_time_matrix.shape
+
+    life_time_matrix = life_time_matrix.reshape(row, 1, col)
+
+    # Time Usage
+    duration_matrix = cmg.generate_duration_matrix(
+        process_df=process_df, use_3d=True)
+
+    result_matrix = cmg.generate_price_matrix(
+        process_df=process_df, use_3d=True
+    )
+
+    return material_cost_matrix, material_amount_matrix, monthy_employee_cost_matrix, daily_employee_cost_matrix, capital_cost_matrix, machine_hour_matrix, life_time_matrix, duration_matrix, result_matrix

model/model/layer.py

@@ -0,0 +1,17 @@
+# Base Class Layer
+class Layer:
+    def __init__(self):
+        self.input = None
+        self.output = None
+        self.time_usage = None
+
+    # compute the output of a layer for a given input
+    def forward_propagation(self, input):
+        raise NotImplementedError
+
+    # conpute dE/dX for a given dE/dY (and update parameters if any)
+    def backward_propagation(self, output_error, learning_rate):
+        raise NotImplementedError
+
+    def predict(self):
+        raise NotImplementedError

model/model/loss.py

@@ -0,0 +1,21 @@
+import numpy as np
+
+# lost function and its derivatives
+
+
+def mse(y_true, y_pred):
+    # print(f'y-true = {y_true} & y-predict = {y_pred}')
+    return np.mean(np.power(y_true-y_pred, 2))
+
+
+def mse_prime(y_true, y_pred):
+    # dE/dY = d(ERROR ROOT MEAN SQUARE)/dY
+    # dE/dY = d/dy (y-y_predict)^2
+    # dE/dY = 2(y-y_predict)
+    # dE/dY = 2*error
+    return 2*(y_pred-y_true)/y_true.size
+
+
+def rmspe(y_true, y_pred):
+    rmspe = (np.sqrt(np.mean(np.square((y_true - y_pred) / y_true)))) * 100
+    return rmspe

model/model/material_fc_layer.py

@@ -0,0 +1,94 @@
+from layer import Layer
+from tsensor import explain as exp
+import numpy as np
+
+import activation as act
+import weight_activation as wa
+import importlib
+
+importlib.reload(act)
+importlib.reload(wa)
+
+
+class MaterialFCLayer(Layer):
+    def __init__(self, input_size, output_size):
+        self.weights = np.full((input_size, output_size), 1.0)
+        self.bias = np.full((1, output_size), 0.0)
+        print(f"weight shape {self.weights.shape}")
+        self.cost = None
+        self.amount = None
+        self.input = None
+
+    def annotate(self, cost_data, amount_data):
+        with exp() as c:
+            output = cost_data * amount_data @ self.weights + self.bias
+
+    # For Predict the result during use
+    def predict(self, cost_data, amount_data):
+        cost_amount = np.multiply(cost_data, amount_data)
+        output = np.dot(cost_amount, self.weights) + self.bias
+        self.input = output
+        return act.leaky_relu(output)
+
+    # For Predict the result during training
+    def forward_propagation(self, cost_data, amount_data):
+        self.cost = cost_data
+        self.amount = amount_data
+        if np.all(cost_data == 0) and np.all(amount_data == 0):
+            self.output = np.zeros((1, 1))
+            return self.output
+        cost_amount = np.multiply(self.cost, self.amount)
+        self.output = np.dot(cost_amount, self.weights)  # + self.bias
+        return act.leaky_relu(self.output)
+
+    def predict(self, cost_data, amount_data):
+        cost_amount = np.multiply(cost_data, amount_data)
+        output = np.dot(cost_amount, self.weights)  # + self.bias
+        # print(f"Weight For Material: {self.weights}")
+        self.input = output
+        # print(f"Material Acutal Input On Predict {self.input}")
+
+        return act.leaky_relu(output)
+
+    # output error is dE/dY
+    # dE/dX = dE/dY * df(x)/dx
+    # dE/dX = dE/dY * W^T
+    # dE/dW = dE/dY * dY/dW
+    # dE/dwi = dE/dyi * xi
+    # dE/dW = dE/dY * X^T
+    def backward_propagation(self, output_error, learning_rate):
+        row, col = self.weights.shape
+        input_error = np.dot(output_error, self.weights.T)
+        gradient = np.multiply(self.cost, self.amount)
+
+        weight_error = np.dot(output_error, gradient)
+
+        weight_error = weight_error.reshape(row, col)
+        activation_input = self.input
+        activation_prime = act.leaky_relu_prime(activation_input)
+        weight_error = np.multiply(weight_error, activation_prime)
+        bias_error = output_error * activation_prime
+
+        self.weights -= learning_rate * weight_error
+        self.weights = wa.un_zero_weight(self.weights)
+        self.bias -= learning_rate * bias_error
+        # dE/dB = dE/dY
+        # print(f"M: Input Error {input_error}")
+        # print(f"M: Gradient {gradient}")
+        # print(f"M: Output Error {output_error}")
+        # print(f"In Material, output error {output_error} gradient {gradient}")
+        # print(f"Material Acutal Input{activation_input}")
+        # print(f"Material Activation Prime {activation_prime}")
+        # print(f"Material Output Error {output_error}")
+
+        # Update Parameter
+        # print(f"M: Learning Rate  {learning_rate} Weight Error {weight_error}")
+        # print(f"M: New Weight  {self.weights} ")
+        # print("Update weight to ", self.weights)
+        return input_error  # dE/dX
+
+    def get_weight(self):
+        return self.weights
+
+    def get_bias(self):
+        return self.bias

model/model/material_network.py

@@ -0,0 +1,113 @@
+import network as nw
+import importlib
+import numpy as np
+
+importlib.reload(nw)
+
+
+class MaterialNetwork(nw.Network):
+    def __init__(self):
+        super().__init__()
+
+    def fit(self, cost_train, y_train, epochs, learning_rate, amount_train):
+        result = []
+        samples = len(cost_train)
+
+        # Train epoch times
+        for i in range(epochs):
+            err = 0
+
+            # train for all samples
+            for j in range(samples):
+                cost_input = cost_train[j]
+                amount_input = amount_train[j]
+                output = None
+
+                # predict data at all layer
+                for layer in self.layers:
+                    output = layer.forward_propagation(cost_input, amount_input)
+                    # output as input of next layer
+                    cost_input = output
+
+                # Find loss for display
+                err += self.loss(y_train[j], output)
+
+                # Find Error of output dE/dY using derivation of MSE
+                error = self.loss_prime(y_train[j], output)
+                # Update Weight for next data
+                # By find gradient of weight in each layer and update
+                weight = []
+
+                for layer in reversed(self.layers):
+                    error = layer.backward_propagation(error, learning_rate)
+                    weight.append(layer.get_weight())
+
+            # Find Average Error per sample
+            err /= samples
+            print("Epoch %d/%d calculate with error = %f" % (i + 1, epochs, err))
+            result.append({"epoch": i + 1, "error": err})
+            self.weight_list = np.append(self.weight_list, [weight])
+
+        return result
+
+    def fit_on_sample(self, cost_input, y_train, learning_rate, amount_input):
+        err = 0
+        output = None
+
+        # predict data at all layer
+        for layer in self.layers:
+            output = layer.forward_propagation(cost_input, amount_input)
+            # output as input of next layer
+            cost_input = output
+
+        # Find loss for display
+        err += self.loss(y_train, output)
+
+        # Find Error of output dE/dY using derivation of MSE
+        error = self.loss_prime(y_train, output)
+
+        # Update Weight for next data
+        # By find gradient of weight in each layer and update
+        weight = []
+        for layer in reversed(self.layers):
+            error = layer.backward_propagation(error, learning_rate)
+            weight.append(layer.get_weight())
+        # print(f'Epoch calculate with error = {err}')
+
+        self.weight_list = np.append(self.weight_list, [weight])
+        return (output, err)
+
+    def get_weights(self):
+        result = []
+        for layer in self.layers:
+            result.append(layer.get_weight())
+        return result
+
+    def predict_sample(self, cost_input, amount_input):
+        output = None
+
+        # predict data at all layer
+        for layer in self.layers:
+            output = layer.forward_propagation(cost_input, amount_input)
+            # output as input of next layer
+            first_input = output
+            weight = layer.get_weight()
+            self.weight_list = np.append(self.weight_list, [weight])
+
+        return output
+
+    def predict(self, cost_input, amount_input):
+        output = None
+
+        # predict data at all layer
+        for layer in self.layers:
+            output = layer.predict(cost_input, amount_input)
+            # output as input of next layer
+            first_input = output
+        return output
+
+    def check_type(self, input_name):
+        if input_name == "material":
+            return True
+        print(f"You go to wrong class this is Material not {input_name}")
+        return False

model/model/matrix_normalization.py

@@ -0,0 +1,153 @@
+import normalize as norm
+import importlib
+
+importlib.reload(norm)
+
+
+def normalize_payload(
+    material_cost_matrix,
+    material_amount_matrix,
+    employee_cost_matrix,
+    employee_duration_matrix,
+    employee_day_amount_matrix,
+    capital_cost_matrix,
+    day_amount_matrix,
+    capital_cost_duration_matrix,
+    validation_payload,
+    display_log=False,
+):
+    max_data = {}
+    min_data = {}
+    # Normalized Material Matrix
+    max_arr, min_arr = norm.find_max_min(material_cost_matrix)
+    normalized_material_cost = norm.normalized(
+        material_cost_matrix, max_arr, min_arr)
+    validate_material_cost_matrix = validation_payload["validate_material_cost_matrix"]
+
+    # Normalize Validate Material Cost Matrix
+    normalized_validate_material_cost = norm.normalized_2d(
+        validate_material_cost_matrix, material_cost_matrix, max_arr, min_arr
+    )
+    max_data["material_cost"] = max_arr
+    min_data["material_cost"] = min_arr
+
+    # Normalized Material Amount Matrix
+    max_arr, min_arr = norm.find_max_min(material_amount_matrix)
+    normalized_material_amount = norm.normalized(
+        material_amount_matrix, max_arr, min_arr
+    )
+    validate_material_amount_matrix = validation_payload[
+        "validate_material_amount_matrix"
+    ]
+
+    if display_log:
+        print("normalized_material_amount", normalized_material_amount)
+        print("------------")
+        print("normalized_material_cost", normalized_material_cost)
+        print("------------")
+
+    normalized_validate_material_amount = norm.normalized_2d(
+        validate_material_amount_matrix, material_amount_matrix, max_arr, min_arr
+    )
+    max_data["material_amount"] = max_arr
+    min_data["material_amount"] = min_arr
+
+    # Normalized  Employee Cost Matrix
+    max_arr, min_arr = norm.find_max_min(employee_cost_matrix)
+    normalized_employee_cost = norm.normalized(
+        employee_cost_matrix, max_arr, min_arr)
+    validate_employee_cost_matrix = validation_payload["validate_employee_cost_matrix"]
+    normalized_validate_employee_cost = norm.normalized(
+        validate_employee_cost_matrix, max_arr, min_arr
+    )
+    max_data["employee_cost"] = max_arr
+    min_data["employee_cost"] = min_arr
+
+    # Normalized  Employee Duration Matrix
+    max_arr, min_arr = norm.find_max_min(employee_duration_matrix)
+    normalized_employee_duration = norm.normalized(
+        employee_duration_matrix, max_arr, min_arr
+    )
+    validate_employee_duration_matrix = validation_payload[
+        "validate_employee_duration_matrix"
+    ]
+    normalized_validate_employee_duration = norm.normalized(
+        validate_employee_duration_matrix,
+        max_arr,
+        min_arr,
+    )
+    max_data["employee_duration"] = max_arr
+    min_data["employee_duration"] = min_arr
+
+    # Normalized Employee Day Amount
+    max_arr, min_arr = norm.find_max_min(employee_day_amount_matrix)
+    normalized_employee_day_amount = norm.normalized(
+        employee_day_amount_matrix, max_arr, min_arr
+    )
+    validate_employee_day_amount_matrix = validation_payload[
+        "validate_employee_day_amount_matrix"
+    ]
+    normalized_validate_employee_day_amount = norm.normalized(
+        validate_employee_day_amount_matrix,
+        max_arr,
+        min_arr,
+    )
+    max_data["employee_day_amount"] = max_arr
+    min_data["employee_day_amount"] = min_arr
+
+    # Normalized Capital Cost Matrix
+    max_arr, min_arr = norm.find_max_min(capital_cost_matrix)
+    normalized_capital_cost = norm.normalized(
+        capital_cost_matrix, max_arr, min_arr)
+    validate_capital_cost_matrix = validation_payload["validate_capital_cost_matrix"]
+    normalized_validate_capital_cost = norm.normalized(
+        validate_capital_cost_matrix, max_arr, min_arr
+    )
+    max_data["capital_cost"] = max_arr
+    min_data["capital_cost"] = min_arr
+
+    # Normalized Day Amount Matrix
+    max_arr, min_arr = norm.find_max_min(day_amount_matrix)
+    normalized_day_amount = norm.normalized(
+        day_amount_matrix, max_arr, min_arr)
+    validate_day_amount_matrix = validation_payload["validate_day_amount_matrix"]
+    normalized_validate_day_amount = norm.normalized(
+        validate_day_amount_matrix, max_arr, min_arr
+    )
+    max_data["day_amount"] = max_arr
+    min_data["day_amount"] = min_arr
+
+    # Normalized Capital Cost Duration Matrix
+    validate_capital_duration_matrix = validation_payload[
+        "validate_capital_duration_matrix"
+    ]
+    max_arr, min_arr = norm.find_max_min(capital_cost_duration_matrix)
+    normalized_capital_cost_duration = norm.normalized(
+        capital_cost_duration_matrix, max_arr, min_arr
+    )
+    normalized_validate_capital_duration = norm.normalized(
+        validate_capital_duration_matrix, max_arr, min_arr
+    )
+    max_data["capital_cost_duration"] = max_arr
+    min_data["capital_cost_duration"] = min_arr
+
+    return (
+        normalized_material_cost,
+        normalized_material_amount,
+        normalized_validate_material_cost,
+        normalized_validate_material_amount,
+        normalized_employee_cost,
+        normalized_employee_duration,
+        normalized_employee_day_amount,
+        normalized_validate_employee_cost,
+        normalized_validate_employee_duration,
+        normalized_validate_employee_day_amount,
+        normalized_capital_cost,
+        normalized_capital_cost_duration,
+        normalized_day_amount,
+        normalized_validate_capital_cost,
+        normalized_validate_capital_duration,
+        normalized_validate_day_amount,
+        max_data,
+        min_data,
+    )

model/model/network.py

@@ -0,0 +1,105 @@
+import numpy as np
+
+
+# https://medium.com/towards-data-science/math-neural-network-from-scratch-in-python-d6da9f29ce65
+class Network:
+    def __init__(self):
+        self.layers = []
+        self.loss = None
+        self.loss_prime = None
+        self.weight_list = []
+
+    def add(self, layer):
+        self.layers.append(layer)
+
+    def use(self, loss, loss_prime):
+        self.loss = loss
+        self.loss_prime = loss_prime
+
+    def fit(self, x_train, y_train, epochs, learning_rate):
+        samples = len(x_train)
+
+        # Train epoch times
+        for i in range(epochs):
+            err = 0
+
+            # train for all samples
+            for j in range(samples):
+                input = x_train[j]
+                output = None
+
+                # predict data at all layer
+                for layer in self.layers:
+                    output = layer.forward_propagation(input)
+                    # output as input of next layer
+                    input = output
+
+                # Find loss for display
+                err += self.loss(y_train[j], output)
+
+                # Find Error of output dE/dY using derivation of MSE
+                error = self.loss_prime(y_train[j], output)
+                # Update Weight for next data
+                # By find gradient of weight in each layer and update
+                for layer in reversed(self.layers):
+                    error = layer.backward_propagation(error, learning_rate)
+
+            # Find Average Error per sample
+            err /= samples
+            print("Epoch %d/%d calculate with error = %f" %
+                  (i + 1, epochs, err))
+            print(f"Update weight to {layer.get_weight()} ")
+            print(f"Update Bias to {layer.get_bias()}")
+            print("")
+
+    def fit_on_sample(self):
+        raise NotImplementedError
+
+    def get_weight_list(self):
+        return self.weight_list
+
+    def get_weights(self):
+        raise NotImplementedError
+
+    def get_biases(self):
+        result = []
+        for layer in self.layers:
+            result.append(layer.get_bias())
+        return result
+
+    def predict_sample(self, first_input, second_input):
+        output = None
+
+        # predict data at all layer
+        for layer in self.layers:
+            output = layer.forward_propagation(first_input, second_input)
+            # output as input of next layer
+            first_input = output
+
+        return output
+
+    def back_propagate(self, error, learning_rate):
+        # weight = []
+        for layer in reversed(self.layers):
+            error = layer.backward_propagation(error, learning_rate)
+            # weight.append(layer.get_weight())
+        # print(f'Epoch calculate with error = {err}')
+
+    # self.weight_list = np.append(self.weight_list, [weight])
+
+    def predict(self, first_input, second_input):
+        output = None
+
+        # predict data at all layer
+        for layer in self.layers:
+            output = layer.predict(first_input, second_input)
+            # output as input of next layer
+            first_input = output
+
+        return output
+
+    def check_type(self):
+        print(
+            "It is in the Initial Class Network Please call this function on the child class"
+        )
+        return False

model/model/normalize.py

@@ -0,0 +1,70 @@
+import numpy as np
+
+
+def find_max_min(input_array):
+    input_np_arr = np.array(input_array)
+    x, y, z = input_np_arr.shape
+    if z == 0:
+        return None, None
+    input_np_arr = input_np_arr.reshape(-y, z)
+    # Find Max
+    max_array = np.max(input_np_arr, axis=0)
+    min_array = np.min(input_np_arr, axis=0)
+    data_amount = max_array - min_array
+    data_margin = np.multiply(data_amount, 0.15)
+    max_with_added = np.add(max_array, data_margin)
+    # Find Min
+    min_with_added = np.subtract(min_array, data_margin)
+    min_with_added[min_with_added < 0] = 0
+
+    return max_with_added, min_with_added
+
+
+def normalized(input_array, max_arr, min_arr):
+    input_np_arr = np.array(input_array, dtype=np.float32)
+    x, y, z = input_np_arr.shape
+    if z == 0:
+        return input_np_arr
+    input_np_arr = input_np_arr.reshape(-y, z)
+    normalized_array = input_np_arr.copy()
+    for i in range(0, len(input_np_arr)):
+        for j in range(0, len(input_np_arr[i])):
+            max = max_arr[j]
+            min = min_arr[j]
+            if max == min:
+                new_data = 1
+            else:
+                new_data = (input_np_arr[i][j] - min) / (max - min)
+            normalized_array[i][j] = new_data
+
+    normalized_array = normalized_array.reshape(x, y, z)
+    return normalized_array
+
+
+def normalized_2d(validate_payload, train_payload, max_arr, min_arr):
+    x, y, z = train_payload.shape
+
+    if z == 0:
+        return validate_payload
+    print('----')
+    print("Validate Payload size", validate_payload.shape)
+    print("Train Payload size", train_payload.shape)
+    x, y = np.array(validate_payload).shape
+    validate_payload = validate_payload.reshape(x, 1, z)
+    result = normalized(validate_payload, max_arr, min_arr)
+    return result
+
+
+def denormalize(value, max, min):
+    data_amount = max - min
+    data_margin = np.multiply(data_amount, 0.15)
+    max_with_added = max + data_margin
+    # Find Min
+    min_with_added = min - data_margin
+    if min_with_added < 0:
+        min_with_added = 0
+
+    denormalized_vaule = (
+        value * (max_with_added - min_with_added)) + min_with_added
+
+    return denormalized_vaule

model/model/sample_payload_adjustment.py

@@ -0,0 +1,152 @@
+import numpy as np
+
+
+def get_sample_payload(
+    sample_payload,
+    material_element,
+    employee_element,
+    capital_cost_element,
+    material_cost_input,
+    material_amount_input,
+    employee_input,
+    emp_dur_input,
+    employee_dayamount_input,
+    capital_cost_input,
+    day_amount_input,
+    capital_cost_dur_input,
+    predicted_mc,
+    predicted_ec,
+    predicted_cc,
+    bias,
+    result_input,
+    result,
+    error,
+    percent_loss,
+    epoch_number,
+    sample_number,
+    model_weights,
+):
+    # Sample Payload for Debugging
+    # Reshape weight to 2D
+    # Material Weight
+    i = epoch_number
+    j = sample_number
+    model_bias = bias
+
+    material_element.check_type("material")
+    material_elem_weight = material_element.get_weights()
+    x, y, z = np.array(material_elem_weight).shape
+    material_elem_weight = np.array(material_elem_weight).reshape(x, y)
+    # Material Bias
+    material_elem_bias = material_element.get_biases()
+    x, y, z = np.array(material_elem_bias).shape
+    material_elem_bias = np.array(material_elem_bias).reshape(x, y)
+    employee_element.check_type("employee")
+    # Employee Weight
+    employee_elem_weight = employee_element.get_weights()
+    x, y, z = np.array(employee_elem_weight).shape
+    employee_elem_weight = np.array(employee_elem_weight).reshape(x, y)
+    # Employee Bias
+    employee_elem_bias = employee_element.get_biases()
+    x, y, z = np.array(employee_elem_bias).shape
+    employee_elem_bias = np.array(employee_elem_bias).reshape(x, y)
+    # Capital Cost Weight
+    capital_cost_element.check_type("capital")
+    capital_elem_weight = capital_cost_element.get_weights()
+    x, y, z = np.array(capital_elem_weight).shape
+    capital_elem_weight = np.array(capital_elem_weight).reshape(x, y)
+    # Capital Cost Bias
+    capital_elem_bias = capital_cost_element.get_biases()
+    x, y, z = np.array(capital_elem_bias).shape
+    capital_elem_bias = np.array(capital_elem_bias).reshape(x, y)
+    sample_payload.append(
+        {
+            "epoch": (i - 1),
+            "sample": j,
+            "material_cost": material_cost_input,
+            "material_amount": material_amount_input,
+            "material_weight": material_elem_weight,
+            "material_bias": material_elem_bias,
+            "employee_cost": employee_input,
+            "employee_duration": emp_dur_input,
+            "employee_dayamount": employee_dayamount_input,
+            "employee_weight": employee_elem_weight,
+            "employee_bias": employee_elem_bias,
+            "capital_cost": capital_cost_input,
+            "day_amount": day_amount_input,
+            "capital_cost_duration": capital_cost_dur_input,
+            "capital_cost_weight": capital_elem_weight,
+            "capital_cost_bias": capital_elem_bias,
+            "result": result_input,
+            "result_predict": result,
+        }
+    )
+    material_costs = material_cost_input.flatten()
+    for idx, cost in enumerate(material_costs):
+        sample_payload[-1][f"material_cost_{idx + 1}"] = cost
+    material_amounts = material_amount_input.flatten()
+    for idx, amount in enumerate(material_amounts):
+        sample_payload[-1][f"material_amount_{idx + 1}"] = amount
+    material_weights = material_elem_weight.flatten()
+    for idx, weight in enumerate(material_weights):
+        sample_payload[-1][f"material_weight_{idx + 1}"] = weight
+    material_biases = material_elem_bias.flatten()
+    for idx, bias in enumerate(material_biases):
+        sample_payload[-1][f"material_bias_{idx + 1}"] = bias
+    employee_costs = employee_input.flatten()
+    for idx, cost in enumerate(employee_costs):
+        sample_payload[-1][f"employee_cost_{idx + 1}"] = cost
+    employee_durations = emp_dur_input.flatten()
+    for idx, duration in enumerate(employee_durations):
+        sample_payload[-1][f"employee_duration_{idx + 1}"] = duration
+    employee_dayamounts = employee_dayamount_input.flatten()
+    for idx, amount in enumerate(employee_dayamounts):
+        sample_payload[-1][f"employee_dayamount_{idx + 1}"] = amount
+    employee_weights = employee_elem_weight.flatten()
+    for idx, weight in enumerate(employee_weights):
+        sample_payload[-1][f"employee_weight_{idx + 1}"] = weight
+    employee_biases = employee_elem_bias.flatten()
+    for idx, bias in enumerate(employee_biases):
+        sample_payload[-1][f"employee_bias_{idx + 1}"] = bias
+    capital_costs = capital_cost_input.flatten()
+    for idx, cost in enumerate(capital_costs):
+        sample_payload[-1][f"capital_cost_{idx + 1}"] = cost
+    day_amounts = day_amount_input.flatten()
+    for idx, amount in enumerate(day_amounts):
+        sample_payload[-1][f"day_amount_{idx + 1}"] = amount
+    capital_cost_durations = capital_cost_dur_input.flatten()
+    for idx, duration in enumerate(capital_cost_durations):
+        sample_payload[-1][f"capital_cost_duration_{idx + 1}"] = duration
+    capital_cost_weights = capital_elem_weight.flatten()
+    for idx, weight in enumerate(capital_cost_weights):
+        sample_payload[-1][f"capital_cost_weight_{idx + 1}"] = weight
+    capital_cost_bias = capital_elem_bias.flatten()
+    for idx, bias in enumerate(capital_cost_bias):
+        sample_payload[-1][f"capital_cost_bias_{idx + 1}"] = bias
+    predicted_mc_reshape = np.array(predicted_mc).flatten()
+    for idx, res in enumerate(predicted_mc_reshape):
+        sample_payload[-1]["total_material"] = res
+    predicted_ec_reshape = np.array(predicted_ec).flatten()
+    for idx, res in enumerate(predicted_ec_reshape):
+        sample_payload[-1]["total_daily_employee"] = res
+    predicted_cc_reshape = np.array(predicted_cc).flatten()
+    for idx, res in enumerate(predicted_cc_reshape):
+        sample_payload[-1]["total_capital_cost"] = res
+
+    model_bias_reshape = np.array(model_bias).flatten()
+    for idx, res in enumerate(model_bias_reshape):
+        sample_payload[-1]["model_bias"] = res
+
+    model_weights_reshape = np.array(model_weights).flatten()
+    for idx, res in enumerate(model_weights_reshape):
+        sample_payload[-1][f"model_weight_{idx + 1}"] = res
+    result_reshape = np.array(result_input).flatten()
+    for idx, res in enumerate(result_reshape):
+        sample_payload[-1]["result"] = res
+    result_predict_reshape = np.array(result).flatten()
+    for idx, res in enumerate(result_predict_reshape):
+        sample_payload[-1]["result_predict"] = res
+    sample_payload[-1]["error"] = error
+    sample_payload[-1]["error_percent"] = percent_loss
+
+    return sample_payload

model/model/tdce_model.py

@@ -0,0 +1,541 @@
+import numpy as np
+import random
+import pandas as pd
+import importlib
+import time
+
+import material_network as mn
+import time_driven_network as tdn
+import loss
+import normalize as norm
+import matrix_normalization as mnorm
+import sample_payload_adjustment as spa
+import weight_activation as wa
+
+importlib.reload(mn)
+importlib.reload(tdn)
+importlib.reload(loss)
+importlib.reload(norm)
+importlib.reload(mnorm)
+importlib.reload(spa)
+importlib.reload(wa)
+
+
+# Generated from Gemini
+def generate_random_numbers():
+    # Generate a random number between 0 and 1 (exclusive)
+    random_val = random.random()
+    number1 = random_val
+    # The second number is another random value between 0 and (1 - number1)
+    number2 = random.random() * (1 - number1)
+    # The third number is simply 1 minus the sum of the first two
+    number3 = 1 - number1 - number2
+
+    return np.array([number1, number2, number3]).reshape(3, 1)
+
+
+# Model Reference
+# Early Stopping https://medium.com/@juanc.olamendy/understanding-early-stopping-a-key-to-preventing-overfitting-in-machine-learning-17554fc321ff
+
+
+class TDCEModel:
+    def __init__(self):
+        self.material_element = mn.MaterialNetwork()
+        self.employee_element = tdn.TimeDrivenNetwork()
+        self.capital_cost_element = tdn.TimeDrivenNetwork()
+        random_weight = np.array([1.0, 1.0, 1.0]).reshape(
+            3, 1
+        )  # generate_random_numbers()
+        self.weights = random_weight
+        self.bias = np.full((1, 1), 0.0)
+        self.loss = loss.mse
+        self.loss_prime = loss.mse_prime
+        self.loss_percent = loss.rmspe
+        self.gradient = np.array([[0, 0, 0]])
+        self.prediction_error = np.array([[0, 0, 0]])
+        self.weight_list = np.array([[[0], [0], [0]]])
+        self.epoch_error = []
+        self.sample_errors = []
+        self.material_learning_rate = 0.001
+        self.employee_learning_rate = 0.001
+        self.capital_cost_learning_rate = 0.001
+        self.max_data = {}
+        self.min_data = {}
+        self.sample_payload = []
+        self.use_early_stopping = False
+        self.patience = 10
+        self.use_model_weight = False
+
+    def inital_inside_element(
+        self,
+        material_layer,
+        employee_layer,
+        capital_cost_layer,
+    ):
+        self.material_element.add(material_layer)
+        self.material_element.use(loss.mse, loss.mse_prime)
+        self.employee_element.add(employee_layer)
+        self.employee_element.use(loss.mse, loss.mse_prime)
+        self.capital_cost_element.add(capital_cost_layer)
+        self.capital_cost_element.use(loss.mse, loss.mse_prime)
+        print("Initial Successfully")
+
+    # For Setting New Network Element
+
+    def set_material_element(self, material_network):
+        self.material_element = material_network
+
+    def set_employee_element(self, employee_element):
+        self.employee_element = employee_element
+
+    def set_capital_cost_element(self, capital_cost_element):
+        self.capital_cost_element = capital_cost_element
+
+    def use(self, loss, loss_prime, loss_percent):
+        self.loss = loss
+        self.loss_prime = loss_prime
+        self.loss_percent = loss_percent
+
+    def set_learning_rate(self, material_lr, employee_lr, cc_lr):
+        self.material_learning_rate = material_lr
+        self.employee_learning_rate = employee_lr
+        self.capital_cost_learning_rate = cc_lr
+        print("Learning Rate Set Successfully")
+        print(
+            f"Material LL {material_lr},  Employee LL {employee_lr}, Capital Cost LL {cc_lr}"
+        )
+
+    def activate_early_stopping(self):
+        self.use_early_stopping = True
+        print("Activate Early Stopping Successfully")
+
+    def deactivate_early_stopping(self):
+        self.use_early_stopping = False
+        print("Deactivate Early Stopping Successfully")
+
+    def activete_model_weight(self):
+        self.use_model_weight = True
+        print("Activate Model Weight Successfully")
+
+    def deactivate_model_weight(self):
+        self.use_model_weight = False
+        print("Deactivate Model Weight Successfully")
+
+    # For Early Stopping
+    def edit_patience_round(self, patience_round):
+        self.patience = patience_round
+
+    def fit_with_validation(
+        self,
+        material_cost_matrix,
+        material_amount_matrix,
+        employee_cost_matrix,
+        employee_duration_matrix,
+        employee_day_amount_matrix,
+        capital_cost_matrix,
+        day_amount_matrix,
+        capital_cost_duration_matrix,
+        result_matrix,
+        epoch,
+        learning_rate,
+        validation_payload,
+        display_round_log=False,
+    ):
+        results = []
+        epoch_errors = []
+        sample_errors = []
+        sample_payload = []
+
+        # For Early Stopping
+        patience_counter = 0
+        best_validation_error = np.inf
+
+        # print('Material Cost Matrix')
+        # print(material_cost_matrix)
+        # print('-----------------------------------')
+        # print('Material Amount Matrix')
+        # print(material_amount_matrix)
+        # print('------------------------------')
+        # print('Daily Employee Matrix')
+        # print(daily_employee_cost_matrix)
+        # print('------------------------------')
+        # print('Monthly Employee Matrix')
+        # print(monthly_employee_cost_matrix)
+        # print('------------------------------')
+        print(f"W:  Initial Weight {self.weights}")
+
+        # Duration Represent the amount of process
+        samples = len(result_matrix)
+        validate_result_matrix = validation_payload["validate_result_matrix"]
+
+        # Some of validate payload use normalized_validate because size is not
+        # same as train payload if they are in 3D it will use only normalized function
+
+        (
+            normalized_material_cost,
+            normalized_material_amount,
+            normalized_validate_material_cost,
+            normalized_validate_material_amount,
+            normalized_employee_cost,
+            normalized_employee_duration,
+            normalized_employee_day_amount,
+            normalized_validate_employee_cost,
+            normalized_validate_employee_duration,
+            normalized_validate_employee_day_amount,
+            normalized_capital_cost,
+            normalized_capital_cost_duration,
+            normalized_day_amount,
+            normalized_validate_capital_cost,
+            normalized_validate_capital_duration,
+            normalized_validate_day_amount,
+            max_data,
+            min_data,
+        ) = mnorm.normalize_payload(
+            material_cost_matrix=material_cost_matrix,
+            material_amount_matrix=material_amount_matrix,
+            employee_cost_matrix=employee_cost_matrix,
+            employee_duration_matrix=employee_duration_matrix,
+            employee_day_amount_matrix=employee_day_amount_matrix,
+            capital_cost_matrix=capital_cost_matrix,
+            day_amount_matrix=day_amount_matrix,
+            capital_cost_duration_matrix=capital_cost_duration_matrix,
+            validation_payload=validation_payload,
+            display_log=False,
+        )
+
+        self.min_data = min_data
+        self.max_data = max_data
+
+        for i in range(epoch):
+            error = 0
+            sum_error = 0
+            sum_error_percent = 0
+            sum_validation_error = 0
+            sum_validation_error_percent = 0
+            start_time = time.time()
+            validate_sample_amount = 0
+
+            for j in range(samples):
+                # Result
+                result_input = result_matrix[j]
+                # Material
+                # material_cost_input = material_cost_matrix[j]
+                material_cost_input = normalized_material_cost[j]
+
+                # material_amount_input = material_amount_matrix[j]
+                material_amount_input = normalized_material_amount[j]
+
+                # Employee / Labor
+                employee_cost_input = normalized_employee_cost[j]
+                employee_duration_input = normalized_employee_duration[j]
+                employee_day_amount_input = normalized_employee_day_amount[j]
+                # Capital Cost
+                capital_cost_input = normalized_capital_cost[j]
+                day_amount_input = normalized_day_amount[j]
+                capital_cost_dur_input = normalized_capital_cost_duration[j]
+
+                if j < len(normalized_validate_material_cost):
+                    # VALIDATION INPUT
+                    validate_material_cost_input = normalized_validate_material_cost[j]
+                    validate_material_amount_input = (
+                        normalized_validate_material_amount[j]
+                    )
+                    validate_employee_input = (
+                        normalized_validate_employee_cost[j]
+                    )
+                    validate_emp_dur_input = (
+                        normalized_validate_employee_duration[j]
+                    )
+                    validate_emp_dayamount_input = (
+                        normalized_validate_employee_day_amount[j]
+                    )
+                    validate_capital_cost_input = normalized_validate_capital_cost[j]
+                    validate_dayamount_input = normalized_validate_day_amount[j]
+                    validate_capital_cost_dur_input = (
+                        normalized_validate_capital_duration[j]
+                    )
+                    validate_result_input = validate_result_matrix[j]
+
+                # Train Material ELE
+                predicted_mc = self.material_element.predict_sample(
+                    cost_input=material_cost_input, amount_input=material_amount_input
+                )
+
+                #  Employee Cost ELE
+                predicted_ec = self.employee_element.predict_sample(
+                    cost_input=employee_cost_input,
+                    time_input=employee_duration_input,
+                    day_amount=employee_day_amount_input
+                )
+
+                # Capital Cost ELE
+                predicted_cc = self.capital_cost_element.predict_sample(
+                    cost_input=capital_cost_input,
+                    time_input=capital_cost_dur_input,
+                    day_amount=day_amount_input,
+                )
+
+                # For Validation
+                # Predict will not update class vairable while predict_sample
+                # which will be update their variable for train
+
+                if j < len(normalized_validate_material_cost):
+                    # Test Material ELE
+                    validate_predicted_mc = self.material_element.predict(
+                        cost_input=validate_material_cost_input,
+                        amount_input=validate_material_amount_input,
+                    )
+
+                    # Test Monthly Employee Cost ELE
+                    validate_predicted_ec = self.employee_element.predict(
+                        cost_input=validate_employee_input,
+                        time_input=validate_emp_dur_input,
+                        day_amount=validate_emp_dayamount_input
+                    )
+
+                    # Test Capital Cost ELE
+                    validate_predicted_cc = self.capital_cost_element.predict(
+                        cost_input=validate_capital_cost_input,
+                        time_input=validate_capital_cost_dur_input,
+                        day_amount=validate_dayamount_input,
+                    )
+
+                    validate_result = (
+                        validate_predicted_mc * self.weights[0]
+                        + validate_predicted_ec * self.weights[1]
+                        + validate_predicted_cc * self.weights[2]
+                    ) + self.bias
+
+                # Result Combination and Find Error
+                result = (
+                    predicted_mc * self.weights[0]
+                    + predicted_ec * self.weights[1]
+                    + predicted_cc * self.weights[2]
+                ) + self.bias
+
+                # if result < 0:
+                #     result = [[0]]
+
+                # print(
+                #     f"predicted_mc {predicted_mc} predicted_dmc {predicted_dmc} predicted_mec{predicted_mec} predicted_cc{predicted_cc}")
+
+                # Find MSE both Result and validation
+                error = self.loss(result_input, result)
+
+                # Find RMSPE both Result and Validate
+                percent_loss = self.loss_percent(result_input, result)
+
+                # Find Derivative of Loss
+                loss_prime = self.loss_prime(result_input, result)
+                bias_error = loss_prime
+
+                if display_round_log:
+                    print(
+                        f"Epoch {i} Sample {j} : Model level weight {self.weights}")
+                    print(f"Epoch {i} Sample {j} : Bias {self.bias}")
+                    print(
+                        f"Epoch {i} Sample {j} : Result {result}, Validate Result {validate_result}"
+                    )
+                    print(
+                        f"Epoch {i} Sample {j} : Material Result {predicted_mc}  Employee {predicted_ec}  Capital Cost {predicted_cc}"
+                    )
+                    print(
+                        f"Epoch {i} Sample {j} : Actual Result {result_input}")
+                    print(
+                        f"Epoch {i} Sample {j} : Error (MSE) {error}, Error To Adjust(Loss Prime) {loss_prime}  "
+                    )
+                    print(
+                        f"Epoch {i} Sample {j} : Error Percent {percent_loss} ")
+                    print("-----------------")
+
+                # Find Gradient of each weight
+                # mse_prime dot Leaky_relu(input)
+                # For Adjust Grdient in Model Level
+                material_weight_error = np.dot(predicted_mc, loss_prime)
+                ec_weight_error = np.dot(predicted_ec, loss_prime)
+                cc_weight_error = np.dot(predicted_cc, loss_prime)
+
+                # Append For log keeping
+                sample_errors.append(
+                    {
+                        "epoch": (i - 1),
+                        "sample": j,
+                        "error": error,
+                        "error_percent": percent_loss,
+                    }
+                )
+
+                # Sample Payload for Debugging
+                sample_payload = spa.get_sample_payload(
+                    sample_payload=sample_payload,
+                    material_element=self.material_element,
+                    employee_element=self.employee_element,
+                    capital_cost_element=self.capital_cost_element,
+                    material_cost_input=material_cost_input,
+                    material_amount_input=material_amount_input,
+                    employee_input=employee_cost_input,
+                    emp_dur_input=employee_duration_input,
+                    employee_dayamount_input=employee_day_amount_input,
+                    capital_cost_input=capital_cost_input,
+                    day_amount_input=day_amount_input,
+                    capital_cost_dur_input=capital_cost_dur_input,
+                    predicted_mc=predicted_mc,
+                    predicted_ec=predicted_ec,
+                    predicted_cc=predicted_cc,
+                    bias=self.bias,
+                    result_input=result_input,
+                    result=result,
+                    error=error,
+                    percent_loss=percent_loss,
+                    epoch_number=i,
+                    sample_number=j,
+                    model_weights=self.weights,
+                )
+
+                # print(f'Result {result} & Loss {loss_prime}')
+                # print(
+                #     f'Material Gradient {material_weight_error}, DE Gradient {de_weight_error}, ME Gradient {me_weight_error}, CC Gradient {cc_weight_error}')
+
+                # Back Propagation of Inside Element
+                # mse_prime dot w
+                sum_material_error = np.dot(loss_prime, self.weights[0])
+                self.material_element.back_propagate(
+                    sum_material_error, self.material_learning_rate
+                )
+
+                sum_ec_error = np.dot(loss_prime, self.weights[1])
+                self.employee_element.back_propagate(
+                    sum_ec_error, self.employee_learning_rate
+                )
+
+                sum_capital_error = np.dot(loss_prime, self.weights[2])
+                self.capital_cost_element.back_propagate(
+                    sum_capital_error, self.capital_cost_learning_rate
+                )
+
+                if self.use_model_weight is True:
+                    # Update Weight
+                    overall_gradient = np.array(
+                        [
+                            material_weight_error[0],
+                            ec_weight_error[0],
+                            cc_weight_error[0],
+                        ]
+                    )
+                    self.weights -= learning_rate * overall_gradient
+                self.bias -= learning_rate * bias_error
+
+                result_input_value = result_input.reshape(1)
+                result_input_value = result_input_value[0]
+
+                if j < len(normalized_validate_material_cost):
+                    validation_error = self.loss(
+                        validate_result_input, validate_result)
+                    validation_error_percent = self.loss_percent(
+                        validate_result_input, validate_result
+                    )
+                    sum_validation_error += validation_error
+                    sum_validation_error_percent += validation_error_percent
+                    validate_sample_amount += 1
+
+                sum_error += error
+                sum_error_percent += percent_loss
+
+            end_time = time.time()
+            validation_error = sum_validation_error / validate_sample_amount
+            print(
+                f"{i + 1} /{epoch} Epoch Error = {sum_error / samples} ({sum_error_percent / samples} %), Validate Error = {validation_error} ({sum_validation_error_percent / validate_sample_amount}) estimate time {end_time - start_time}"
+            )
+
+            epoch_errors.append(
+                {
+                    "epoch": (i + 1),
+                    "error": sum_error / samples,
+                    "error_percent": sum_error_percent / samples,
+                    "validate_error": sum_validation_error / validate_sample_amount,
+                    "validate_error_percent": sum_validation_error_percent / validate_sample_amount,
+                }
+            )
+
+            if self.use_early_stopping:
+                if validation_error < best_validation_error:
+                    best_validation_error = validation_error
+                    patience_counter = 0
+                else:
+                    patience_counter += 1
+                    if patience_counter == self.patience:
+                        print(f"Early Stopping at Epoch {i + 1}")
+                        break
+
+            sum_error = 0
+            sum_error_percent = 0
+            sum_validation_error = 0
+            sum_validation_error_percent = 0
+
+        self.epoch_error = epoch_errors
+        self.sample_errors = sample_errors
+        self.sample_payload = sample_payload
+        epoch_error_df = pd.DataFrame(epoch_errors)
+        last_sample_payload = sample_payload[-1]
+
+        print("-------------------")
+        print(
+            f"Minimum Error =  {epoch_error_df['error'].min()} Minimum Error percent {round(epoch_error_df['error_percent'].min(), 4)} Accuracy {100 - epoch_error_df['error_percent'].min()}%"
+        )
+        print(
+            f"Average Error =  {epoch_error_df['error'].mean()} Average Error percent {round(epoch_error_df['error_percent'].mean(), 4)} Accuracy {100 - epoch_error_df['error_percent'].mean()}%"
+        )
+        print(
+            f"Maximum Error =  {epoch_error_df['error'].max()} Maximum Error percent {round(epoch_error_df['error_percent'].max(), 2)} Accuracy {100 - epoch_error_df['error_percent'].max()}%"
+        )
+        print(
+            f"Minimum Validation Error =  {epoch_error_df['validate_error'].min()} Minimum Error percent {round(epoch_error_df['validate_error_percent'].min(), 4)} Accuracy {100 - epoch_error_df['validate_error_percent'].min()}%"
+        )
+        print(
+            f"Average Validation Error =  {epoch_error_df['validate_error'].mean()} Average Error percent {round(epoch_error_df['validate_error_percent'].mean(), 4)} Accuracy {100 - epoch_error_df['validate_error_percent'].mean()}%"
+        )
+        print(
+            f"Maximum Validation Error =  {epoch_error_df['validate_error'].max()} Maximum Error percent {round(epoch_error_df['validate_error_percent'].max(), 4)} Accuracy {100 - epoch_error_df['validate_error_percent'].max()}%"
+        )
+        print(
+            f"Last Validation Error =  {epoch_error_df.iloc[-1]['validate_error']} Last Validate Error percent {round(epoch_error_df.iloc[-1]['validate_error_percent'], 4)} Accuracy {100 - epoch_error_df.iloc[-1]['validate_error_percent']}%"
+        )
+        print(
+            f"Final Model - Material Weight {last_sample_payload['material_weight']} Material Bias {last_sample_payload['material_bias']}"
+        )
+        print(
+            f" - Employee Weight {last_sample_payload['employee_weight']} Monthly Employee Bias {last_sample_payload['employee_bias']}"
+        )
+        print(
+            f" - Capital Cost Weight {last_sample_payload['capital_cost_weight']} Capital Cost Bias {last_sample_payload['capital_cost_bias']}"
+        )
+        print(f" - Model Bias {last_sample_payload['model_bias']}")
+        print("-------------------")
+
+        return results
+
+    def get_gradient(self):
+        return self.gradient
+
+    def get_prediction_error(self):
+        return self.prediction_error
+
+    def get_weight_list(self):
+        return self.weight_list
+
+    def get_epoch_error(self):
+        return self.epoch_error
+
+    def get_sample_error(self):
+        return self.sample_errors
+
+    def get_model_element_weights(self):
+        return (
+            self.material_element.get_weight_list(),
+            self.daily_employee_element.get_weight_list(),
+            self.monthly_employee_element.get_weight_list(),
+            self.capital_cost_element.get_weight_list(),
+        )
+
+    def get_sample_payload(self):
+        return self.sample_payload

model/model/time_driven_network.py

@@ -0,0 +1,109 @@
+import network as nw
+import importlib
+import numpy as np
+
+importlib.reload(nw)
+
+
+class TimeDrivenNetwork(nw.Network):
+    def __init__(self):
+        super().__init__()
+
+    def fit(self, cost_train, y_train, epochs, learning_rate, time_usage, day_amount):
+        result = []
+        samples = len(cost_train)
+
+        # Train epoch times
+        for i in range(epochs):
+            err = 0
+
+            # train for all samples
+            for j in range(samples):
+                cost_input = cost_train[j]
+                time_input = time_usage[j]
+                da_input = day_amount[j]
+                output = None
+
+                # predict data at all layer
+                for layer in self.layers:
+                    output = layer.forward_propagation(
+                        cost_input, time_input, da_input)
+                    # output as input of next layer
+                    cost_input = output
+
+                # Find loss for display
+                err += self.loss(y_train[j], output)
+
+                # Find Error of output dE/dY using derivation of MSE
+                error = self.loss_prime(y_train[j], output)
+                weight = []
+
+                # Update Weight for next data
+                # By find gradient of weight in each layer and update
+                for layer in reversed(self.layers):
+                    error = layer.backward_propagation(error, learning_rate)
+                    weight.append(layer.get_weight())
+
+            # Find Average Error per sample
+            err /= samples
+            print("Epoch %d/%d calculate with error = %f" %
+                  (i + 1, epochs, err))
+            result.append({"epoch": i + 1, "error": err})
+            self.weight_list = np.append(self.weight_list, [weight])
+
+        return result
+
+    def fit_on_sample(self, cost_input, y_train, learning_rate, time_input, day_amount):
+        err = 0
+        output = None
+
+        # predict data at all layer
+        for layer in self.layers:
+            output = layer.forward_propagation(
+                cost_input, time_input, day_amount)
+            # output as input of next layer
+            cost_input = output
+
+        # Find loss for display
+        err += self.loss(y_train, output)
+
+        # Find Error of output dE/dY using derivation of MSE
+        error = self.loss_prime(y_train, output)
+
+        # Update Weight for next data
+        # By find gradient of weight in each layer and update
+        for layer in reversed(self.layers):
+            error = layer.backward_propagation(error, learning_rate)
+        # print(f'Epoch calculate with error = {err}')
+        return (output, err)
+
+    def get_weights(self):
+        result = []
+        for layer in self.layers:
+            result.append(layer.get_weight())
+        return result
+
+    def predict_sample(self, cost_input, time_input, day_amount):
+        output = None
+        for layer in self.layers:
+            output = layer.forward_propagation(
+                cost_input, time_input, day_amount)
+            # output as input of next layer
+            cost_input = output
+            weight = layer.get_weight()
+            self.weight_list = np.append(self.weight_list, [weight])
+        return output
+
+    def predict(self, cost_input, time_input, day_amount):
+        output = None
+        for layer in self.layers:
+            output = layer.predict(cost_input, time_input, day_amount)
+            # output as input of next layer
+            cost_input = output
+        return output
+
+    def check_type(self, input_name):
+        if input_name == "capital" or input_name == "employee":
+            return True
+        print(f"You go to wrong class this is Time Driven not {input_name}")
+        return False

model/model/weight_activation.py

@@ -0,0 +1,10 @@
+import numpy as np
+
+alpha = 0
+
+
+def un_zero_weight(x):
+    shape = x.shape
+    x = x.flatten()
+    result = np.where(x < 0, 0, x)
+    return result.reshape(shape)

model/plot_input_variation.py

@@ -0,0 +1,12 @@
+import pandas as pd
+from scipy.stats import variation, iqr
+
+
+def get_data(folder_name):
+    process_df = pd.read_csv(f"{folder_name}/generated_process_data.csv")
+    material_usage_df = pd.read_csv(
+        f"{folder_name}/generated_material_usage.csv")
+    employee_usage_df = pd.read_csv(
+        f"{folder_name}/generated_employee_usage.csv")
+    capital_cost_df = pd.read_csv(f"{folder_name}/generated_captial_cost.csv")
+    return process_df, material_usage_df, employee_usage_df, capital_cost_df

model/result_display.py

@@ -0,0 +1,114 @@
+import os
+import pandas as pd
+
+
+def create_directory(primary_directory_name):
+    result_dir = f"{primary_directory_name}/results"
+    try:
+        os.mkdir(result_dir)
+    except FileExistsError:
+        print("Folder is Exist")
+
+    return result_dir
+
+
+def creating_error_csv(
+    primary_directory_name,
+    learning_rate,
+    iteration_number,
+    round_number,
+    breakpoint_number,
+):
+    result_dir = create_directory(primary_directory_name)
+    overall_learning_rate_err_ = []
+    for lr in learning_rate:
+        round_err_list = []
+        round_percent_list = []
+        round_validate_err_list = []
+        round_validate_err_percent_list = []
+        round_brakpoint_err_list = []
+        round_brakpoint_err_percent_list = []
+        round_brakpoint_val_err_list = []
+        round_brakpoint_val_err_percent_list = []
+        round_errors = []
+        learning_rate_err_dict = {"learning_rate": str(lr)}
+        for round_no in range(round_number):
+            round_err_dict = {"learning_rate": str(lr)}
+            directory_name = primary_directory_name + "/round" + str(round_no + 1)
+            df = pd.read_csv(f"{directory_name}/{iteration_number}-{lr}.csv")
+            round_err_list.append(df["error"].values[-1])
+            round_percent_list.append(df["error_percent"].values[-1])
+            round_validate_err_list.append(df["validate_error"].values[-1])
+            round_validate_err_percent_list.append(
+                df["validate_error_percent"].values[-1]
+            )
+            breakpoint_df = df[df["epoch"] <= breakpoint_number]
+            round_brakpoint_err_list.append(breakpoint_df["error"].values[-1])
+            round_brakpoint_err_percent_list.append(
+                breakpoint_df["error_percent"].values[-1]
+            )
+            round_brakpoint_val_err_list.append(
+                breakpoint_df["validate_error"].values[-1]
+            )
+            round_brakpoint_val_err_percent_list.append(
+                breakpoint_df["validate_error_percent"].values[-1]
+            )
+
+            # Added to the dictionary
+            round_err_dict[f"round"] = round_no
+            round_err_dict[f"error"] = df["error"].values[-1]
+            round_err_dict[f"error_percent"] = df["error_percent"].values[-1]
+            round_err_dict[f"validate_error"] = df["validate_error"].values[-1]
+            round_err_dict[f"validate_error_percent"] = df[
+                "validate_error_percent"
+            ].values[-1]
+            round_err_dict[f"brakpoint_error"] = breakpoint_df["error"].values[-1]
+            round_err_dict[f"brakpoint_error_percent"] = breakpoint_df[
+                "error_percent"
+            ].values[-1]
+            round_err_dict[f"brakpoint_validate_error"] = breakpoint_df[
+                "validate_error"
+            ].values[-1]
+            round_err_dict[f"brakpoint_validate_error_percent"] = breakpoint_df[
+                "validate_error_percent"
+            ].values[-1]
+            round_errors.append(round_err_dict)
+
+        round_err_df = pd.DataFrame(round_errors)
+        round_err_df.to_csv(f"{result_dir}/{lr}_round_error.csv", index=False)
+
+        average_error = round_err_df["error"].mean()
+        average_error_percent = round_err_df["error_percent"].mean()
+        average_validate_error = round_err_df["validate_error"].mean()
+        average_validate_error_percent = round_err_df["validate_error_percent"].mean()
+        average_brakpoint_error = round_err_df["brakpoint_error"].mean()
+        average_brakpoint_error_percent = round_err_df["brakpoint_error_percent"].mean()
+        average_brakpoint_validate_error = round_err_df[
+            "brakpoint_validate_error"
+        ].mean()
+        average_brakpoint_validate_error_percent = round_err_df[
+            "brakpoint_validate_error_percent"
+        ].mean()
+        learning_rate_err_dict["average_error"] = average_error
+        learning_rate_err_dict["average_error_percent"] = average_error_percent
+        learning_rate_err_dict["average_validate_error"] = average_validate_error
+        learning_rate_err_dict["average_validate_error_percent"] = (
+            average_validate_error_percent
+        )
+        learning_rate_err_dict["average_brakpoint_error"] = average_brakpoint_error
+        learning_rate_err_dict["average_brakpoint_error_percent"] = (
+            average_brakpoint_error_percent
+        )
+        learning_rate_err_dict["average_brakpoint_validate_error"] = (
+            average_brakpoint_validate_error
+        )
+        learning_rate_err_dict["average_brakpoint_validate_error_percent"] = (
+            average_brakpoint_validate_error_percent
+        )
+
+        overall_learning_rate_err_.append(learning_rate_err_dict)
+
+    overall_learning_rate_err_df = pd.DataFrame(overall_learning_rate_err_)
+    overall_learning_rate_err_df.to_csv(
+        f"{result_dir}/overall_learning_rate_err.csv", index=False
+    )

model/viyacrab_augmentation.py

@@ -0,0 +1,78 @@
+import pandas as pd
+from sklearn.utils import resample
+
+
+def vy_training_augmentation(process_df):
+    process_df = process_df.copy()
+    a_crab_df = process_df[process_df["original_material_name"]
+                           == "ปูทั้งตัว A"]
+    c_crab_df = process_df[process_df["original_material_name"]
+                           == "ปูทั้งตัว C"]
+    only_small_crab_df = process_df[process_df["original_material_name"]
+                                    == "ปูทั้งตัว จิ๋ว"]
+    only_loss_crab_df = process_df[process_df["original_material_name"]
+                                   == "ปูทั้งตัว โพรก"]
+    small_crab_df = process_df[process_df["original_material_name"]
+                               == "ปูจิ๋ว และโพรก"]
+
+    # Compare the amount of each crab type rows
+    a_crab_size = a_crab_df.shape[0]
+    c_crab_size = c_crab_df.shape[0]
+    small_crab_size = small_crab_df.shape[0]
+    only_small_size = only_small_crab_df.shape[0]
+    only_loss_size = only_loss_crab_df.shape[0]
+
+    # Find the maximum size of the crab type
+    max_size = max(a_crab_size, c_crab_size, small_crab_size,
+                   only_small_size, only_loss_size)
+
+    # Calculate the number of rows to add for each crab type
+    a_crab_add = max_size * 2 - a_crab_size
+    c_crab_add = max_size * 2 - c_crab_size
+    small_crab_add = max_size * 2 - small_crab_size
+    only_small_crab_add = max_size * 2 - only_small_size
+    only_loss_crab_add = max_size * 2 - only_loss_size
+
+    # Add rows to each crab type
+    if a_crab_size > 0:
+        a_crab_augmented = resample(a_crab_df, n_samples=a_crab_add)
+    else:
+        a_crab_augmented = pd.DataFrame()
+    if c_crab_size > 0:
+        c_crab_augmented = resample(c_crab_df, n_samples=c_crab_add)
+    else:
+        c_crab_augmented = pd.DataFrame()
+    if small_crab_size > 0:
+        small_crab_augmented = resample(
+            small_crab_df, n_samples=small_crab_add)
+    else:
+        small_crab_augmented = pd.DataFrame()
+    if only_small_size > 0:
+        only_small_crab_augmented = resample(
+            only_small_crab_df, n_samples=only_small_crab_add)
+    else:
+        only_small_crab_augmented = pd.DataFrame()
+    if only_loss_size > 0:
+        only_loss_crab_augmented = resample(
+            only_loss_crab_df, n_samples=only_loss_crab_add)
+    else:
+        only_loss_crab_augmented = pd.DataFrame()
+
+    # Concatenate the augmented dataframes
+    a_crab_df_combined = pd.concat([a_crab_df, a_crab_augmented])
+    c_crab_df_combined = pd.concat([c_crab_df, c_crab_augmented])
+    small_crab_df_combined = pd.concat([small_crab_df, small_crab_augmented])
+
+    only_small_crab_df_combined = pd.concat(
+        [only_small_crab_df, only_small_crab_augmented])
+    only_loss_crab_df_combined = pd.concat(
+        [only_loss_crab_df, only_loss_crab_augmented])
+
+    # New Process Dataframe
+    process_df = pd.concat(
+        [a_crab_df_combined, c_crab_df_combined,
+         small_crab_df_combined, only_small_crab_df_combined,
+         only_loss_crab_df_combined
+         ])
+
+    return process_df

requirement.txt

@@ -0,0 +1,11 @@
+numpy
+pandas
+matplotlib
+tensor-sensor
+array-to-latex
+scikit-learn
+scipy
+cowsay
+pyfiglet
+seaborn
+statsmodels