First Commit New REpo

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/Inventory-Simulations.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.9 (SafetyStockSimulations)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (SafetyStockSimulations)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Inventory-Simulations.iml" filepath="$PROJECT_DIR$/.idea/Inventory-Simulations.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

agent_environment.py

@@ -0,0 +1,58 @@
+from abc import abstractmethod, ABC
+import numpy as np
+from scipy.stats import norm
+from config import LEAD_TIME, DEFAULT_SERVICE_LEVEL, MC_SIMS, HISTO_DAYS
+
+
+class Agent(ABC):
+    def __init__(self, daily_demand_distribution):
+        self.daily_demand_distribution = daily_demand_distribution
+
+    @abstractmethod
+    def compute_reorder_point(self, time_period) -> float:
+        pass
+
+    def get_historical_demand(self, time_period):
+        start_time = time_period - HISTO_DAYS
+        demand_list = self.daily_demand_distribution.daily_demand_distribution
+        return [d.actual_demand for d in demand_list[start_time:time_period]]
+
+class BaseAgent(Agent):
+
+    def compute_reorder_point(self, time_period):
+        historical_demand = self.get_historical_demand(time_period)
+        demand_mean = np.mean(historical_demand)
+        return demand_mean * LEAD_TIME
+
+class SafetyStockAgent(Agent):
+
+    def compute_reorder_point(self, time_period) -> float:
+        historical_demand = self.get_historical_demand(time_period)
+
+        demand_mean = np.mean(historical_demand)
+        demand_std = np.std(historical_demand, ddof=1)  # sample standard deviation
+
+        safety_stock = norm.ppf(DEFAULT_SERVICE_LEVEL) * demand_std * np.sqrt(LEAD_TIME)
+        return demand_mean * LEAD_TIME + safety_stock
+
+class ForecastAgent(Agent):
+    def __init__(self, daily_demand_distribution, demand_mean, demand_std):
+        super().__init__(daily_demand_distribution)
+        self.demand_mean = demand_mean
+        self.demand_std = demand_std
+
+    def compute_reorder_point(self, time_period) -> float:
+        safety_stock = norm.ppf(DEFAULT_SERVICE_LEVEL) * self.demand_std[time_period] * np.sqrt(LEAD_TIME)
+        return self.demand_mean[time_period] * LEAD_TIME + safety_stock
+
+class MonteCarloAgent(Agent):
+    def __init__(self, daily_demand_distribution):
+        super().__init__(daily_demand_distribution)
+        self.q = DEFAULT_SERVICE_LEVEL
+
+    def compute_reorder_point(self, time_period) -> float:
+        samples = self.daily_demand_distribution.sample_lead_time_demand(
+            time_period=time_period,
+            mc_sims=MC_SIMS
+        )
+        return float(np.quantile(samples, self.q))

config.py

@@ -0,0 +1,22 @@
+# Simulation constraints
+import numpy as np
+np.random.seed(42)
+
+SIM_DAYS = 730
+HISTO_DAYS = 365
+N_SIMULATIONS = 100
+MC_SIMS = 1000
+
+# Replenishment constraints & constants
+WRITE_OFF_RATE = 0.01
+WRITE_OFF_FREQUENCY = 7
+
+# Stock constraints
+LEAD_TIME = 3
+BASE_STOCK = 0
+DEFAULT_SERVICE_LEVEL = 0.95
+
+# Demand constraints
+GAMMA_SHAPE = np.random.uniform(6, 8) # 7
+GAMMA_SCALE = np.random.uniform(14, 18) # 16
+POISSON_LAMBDA = np.random.uniform(75, 85) # 80

demand_generator.py

@@ -0,0 +1,77 @@
+import numpy as np
+import ciw.dists
+from dataclasses import dataclass
+from typing import List
+from config import POISSON_LAMBDA, GAMMA_SHAPE, GAMMA_SCALE, MC_SIMS, LEAD_TIME
+
+np.random.seed(42)
+
+@dataclass
+class DailyDemandDistribution:
+    day: int
+    actual_demand: int
+    demand_mean: float
+    demand_std: float
+    forecast_distribution: ciw.dists.Distribution
+
+class DemandGenerator:
+    def __init__(self, SIM_DAYS):
+        self.SIM_DAYS = SIM_DAYS
+        self.daily_demand_distribution: List[DailyDemandDistribution] = self.generate_distribution()
+
+    def generate_distribution(self) -> List[DailyDemandDistribution]:
+
+        daily_demand_distribution = []
+
+        for day in range(self.SIM_DAYS):
+            demand_distribution = ciw.dists.MixtureDistribution(
+                [
+                    ciw.dists.Gamma(shape=GAMMA_SHAPE, scale=GAMMA_SCALE),
+                    ciw.dists.Poisson(rate=POISSON_LAMBDA)
+                ],
+                [0.9, 0.1]
+            )
+            demand_mean, demand_std = self.get_demand_stats()
+            actual_demand = int(demand_distribution.sample())
+
+            daily_demand_distribution.append(
+                DailyDemandDistribution(
+                    day=day,
+                    actual_demand=actual_demand,
+                    demand_mean=demand_mean,
+                    demand_std=demand_std,
+                    forecast_distribution=demand_distribution
+                )
+            )
+        return daily_demand_distribution
+
+    def get_daily_demand(self, time_period: int) -> int: # CHECK UTILITY OF THIS FUNCTION
+        return self.daily_demand_distribution[time_period].actual_demand
+
+    def sample_lead_time_demand(self, time_period, mc_sims=MC_SIMS): # CHECK TO REDUCE TIME COMPLEXITY
+        samples = []
+        for i in range(mc_sims):
+            total_demand = 0
+            for j in range(1, LEAD_TIME + 1):
+                total_demand += self.daily_demand_distribution[time_period + j].forecast_distribution.sample()
+            samples.append(total_demand)
+        return samples
+
+    # ciw.dists doesn't have a method to get mean and std, so we calculate it manually
+    def get_demand_stats(self) -> (float, float):
+        weights = [0.9, 0.1]
+        mean_gamma = GAMMA_SHAPE * GAMMA_SCALE
+        mean_poisson = POISSON_LAMBDA
+
+        var_gamma = GAMMA_SHAPE * GAMMA_SCALE ** 2
+        var_poisson = POISSON_LAMBDA
+
+        mixture_mean = weights[0] * mean_gamma + weights[1] * mean_poisson
+
+        mixture_var = (
+                weights[0] * (var_gamma + (mean_gamma - mixture_mean) ** 2) +
+                weights[1] * (var_poisson + (mean_poisson - mixture_mean) ** 2)
+        )
+        mixture_std = np.sqrt(mixture_var)
+
+        return mixture_mean, mixture_std

inventory_manager.py

@@ -0,0 +1,30 @@
+from config import WRITE_OFF_RATE, BASE_STOCK, DEFAULT_SERVICE_LEVEL, MC_SIMS
+from demand_generator import DemandGenerator
+
+class InventoryManager:
+    def __init__(self, order_processor, agent):
+        self.inventory = BASE_STOCK
+        self.order_processor = order_processor
+        self.total_write_off_quantity = 0
+        self.agent = agent
+
+    def reorder(self, time_period):
+        reorder_point = self.agent.compute_reorder_point(time_period)
+        if self.inventory <= reorder_point:
+            self.order_processor.place_order(time_period, reorder_point)
+
+    def inventory_update(self, demand_quantity):
+        if self.inventory >= demand_quantity:
+            self.inventory -= demand_quantity
+        else:
+            self.inventory = 0
+
+    def apply_writeoff(self, time_period):
+            write_off_quantity = int(self.inventory * WRITE_OFF_RATE)
+            self.inventory -= write_off_quantity
+            self.total_write_off_quantity += write_off_quantity
+            return write_off_quantity
+
+    def process_deliveries(self, time_period):
+        processed_delivery = self.order_processor.manage_order(time_period)
+        self.inventory += processed_delivery

main.py

@@ -0,0 +1,36 @@
+import montecarlo_simulator
+from agent_environment import MonteCarloAgent, SafetyStockAgent, ForecastAgent, Agent, BaseAgent
+from demand_generator import DemandGenerator
+from config import SIM_DAYS, N_SIMULATIONS
+import ciw
+ciw.seed(11)
+
+simulation_version = input("Choose a simulation version (0-3):\n"
+                         "0: Historical Demand Agent\n"
+                         "1: Safety Stock Agent\n" 
+                         "2: Forecast Agent\n"
+                         "3: Monte Carlo Agent\n")
+
+print(f"Running simulation version: {simulation_version}")
+version = int(simulation_version)
+
+# THIS SHIT SUPPOSED TO BE HAPPENING DURING SIMULATION
+demand_generator = DemandGenerator(SIM_DAYS)
+daily_demand_distribution = demand_generator.daily_demand_distribution
+
+demand_mean = [d.demand_mean for d in daily_demand_distribution]
+demand_std = [d.demand_std for d in daily_demand_distribution]
+
+agent_versions = {
+    0: BaseAgent(daily_demand_distribution),
+    1: SafetyStockAgent(daily_demand_distribution),
+    2: ForecastAgent(daily_demand_distribution, demand_mean, demand_std),
+    3: MonteCarloAgent(daily_demand_distribution)
+}
+try:
+    selected_agent = agent_versions[version]
+except:
+    raise ValueError("Invalid simulation version")
+
+sim = montecarlo_simulator.MonteCarloSimulator(selected_agent)
+sim.run_simulation(N_SIMULATIONS, SIM_DAYS)

montecarlo_simulator.py

@@ -0,0 +1,71 @@
+import pandas as pd
+from config import LEAD_TIME, HISTO_DAYS
+from demand_generator import DemandGenerator
+from order_processor import OrderProcessor
+from inventory_manager import InventoryManager
+from performance_tracker import PerformanceTracker
+
+class MonteCarloSimulator():
+    def __init__(self, agent):
+        self.agent = agent
+
+    def run_simulation(self, N_SIMULATIONS, SIM_DAYS):
+
+        all_simulation_results = []
+
+        for sim in range(N_SIMULATIONS):
+            time_period = 0
+            order_processor = OrderProcessor()
+            performance_tracker = PerformanceTracker()
+            demand_generator = DemandGenerator(SIM_DAYS)
+            self.agent.daily_demand_distribution = demand_generator
+
+            inventory_manager = InventoryManager(
+                order_processor=order_processor,
+                agent=self.agent
+            )
+
+            # Generate historical demand data -> consistency with algo 1 & 2
+            for day in range(HISTO_DAYS):
+                _ = demand_generator.get_daily_demand(day)
+
+            for day in range(HISTO_DAYS, SIM_DAYS):
+                demand_quantity = demand_generator.get_daily_demand(day)
+                base_inventory = inventory_manager.inventory
+
+                inventory_manager.inventory_update(demand_quantity)
+
+                if day < SIM_DAYS - LEAD_TIME: # no more orders after the last lead time
+                    inventory_manager.reorder(day)
+
+                inventory_manager.process_deliveries(day)
+
+                fulfilled_demand = min(demand_quantity, base_inventory)
+                daily_writeoff = inventory_manager.apply_writeoff(day)
+
+                performance_tracker.daily_performance(
+                    demand_quantity=demand_quantity,
+                    fulfilled_demand=fulfilled_demand,
+                    daily_writeoff=daily_writeoff
+                )
+
+                time_period += 1
+
+            print(f"\n Simulation {sim + 1}")
+            print("-" * 30)
+            sim_summary = performance_tracker.performance_summary()
+
+            for key, value in sim_summary.items():
+                    print(f"{key.title()}: {value}")
+
+            all_simulation_results.append(performance_tracker.performance_summary())
+
+        self.generate_overall_report(all_simulation_results)
+
+    def generate_overall_report(self, results):
+        df = pd.DataFrame(results)
+        summary_stats = df.agg(['mean', 'std']).transpose()
+        summary_stats.columns = ['Mean', 'Standard Deviation']
+        print("Cummulatige Simulation Results")
+        print("---------------------------------------------")
+        print(summary_stats.to_string(float_format="%.6f"))

order_processor.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from typing import List
+from config import LEAD_TIME
+
+@dataclass
+class Order:
+    arrival_day: int
+    quantity: int
+
+class OrderProcessor:
+    def __init__(self):
+        self.order_queue: List[Order] = [] # self.order_queue stores Order objects
+
+    def place_order(self, time_period: int, quantity: int):
+        arrival_day = time_period + LEAD_TIME # time_period = current_day
+        self.order_queue.append(Order(arrival_day=arrival_day, quantity=quantity))
+
+    def manage_order(self, time_period: int) -> int:
+        arrived_orders = [order for order in self.order_queue if order.arrival_day == time_period]
+        # if order.arrival_day < current_day order excluded after each call of process_order
+        self.order_queue = [order for order in self.order_queue if order.arrival_day > time_period]
+        return sum(order.quantity for order in arrived_orders)
+
+
+

performance_tracker.py

@@ -0,0 +1,33 @@
+class PerformanceTracker:
+
+    def __init__(self):
+        self.total_demand = 0
+        self.total_fulfilled_demand = 0
+        self.fill_rate = 0
+        self.write_offs = 0
+        self.stock_out_count = 0
+        self.total_lost_sales = 0
+
+    def daily_performance(self, demand_quantity, fulfilled_demand, daily_writeoff):
+        self.total_demand += demand_quantity
+        self.total_fulfilled_demand += fulfilled_demand
+        self.fill_rate = 1 - (self.total_demand - self.total_fulfilled_demand ) / self.total_demand if self.total_demand > 0 else 0
+        self.write_offs += daily_writeoff
+        self.total_lost_sales += (demand_quantity - fulfilled_demand) if demand_quantity > fulfilled_demand else 0
+
+        if fulfilled_demand < demand_quantity:
+            self.stock_out_counter()
+
+    def stock_out_counter(self) -> int:
+        self.stock_out_count += 1
+        return self.stock_out_count
+
+    def performance_summary(self):
+        return {
+            "total_demand": self.total_demand,
+            "fulfilled_demand": self.total_fulfilled_demand,
+            "fill_rate": self.fill_rate,
+            "write_offs": self.write_offs,
+            "stock_out_count": self.stock_out_count,
+            "total_lost_sales": self.total_lost_sales
+        }