| import gradio as gr |
| import numpy as np |
| import matplotlib.pyplot as plt |
| import pandas as pd |
| import io |
| from scipy.stats import norm |
| |
| |
|
|
| |
|
|
| def calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit): |
| """Calculates EOQ and related metrics for the basic model.""" |
| if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0: |
| return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan |
|
|
| eoq = np.sqrt((2 * annual_demand * order_cost) / holding_cost_per_unit) |
| num_orders_per_year = annual_demand / eoq if eoq > 0 else np.inf |
| avg_inventory = eoq / 2 |
| annual_ordering_cost = num_orders_per_year * order_cost |
| annual_holding_cost = avg_inventory * holding_cost_per_unit |
| total_annual_cost = annual_ordering_cost + annual_holding_cost |
| |
| demand_per_day = annual_demand / 365 |
| |
| return eoq, num_orders_per_year, avg_inventory, annual_ordering_cost, annual_holding_cost, total_annual_cost, demand_per_day |
|
|
| def calculate_eoq_with_discount(annual_demand, order_cost, holding_cost_rate, unit_cost, discount_tiers): |
| """Calculates EOQ with quantity discounts.""" |
| if annual_demand <= 0 or order_cost <= 0 or holding_cost_rate <= 0 or unit_cost <= 0: |
| return pd.DataFrame(), np.nan, np.nan, np.nan, np.nan, "Invalid inputs for discount model." |
|
|
| results = [] |
| best_total_cost = np.inf |
| best_eoq = np.nan |
| best_unit_cost = np.nan |
| best_tier = "" |
|
|
| discount_tiers = sorted(discount_tiers, key=lambda x: x[0]) |
|
|
| for i, (min_qty, max_qty, tier_unit_cost) in enumerate(discount_tiers): |
| holding_cost_per_unit = holding_cost_rate * tier_unit_cost |
| |
| tier_eoq, _, _, _, _, _, _ = calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit) |
| |
| if tier_eoq < min_qty: |
| relevant_qty = min_qty |
| elif tier_eoq > max_qty and max_qty != np.inf: |
| relevant_qty = max_qty |
| else: |
| relevant_qty = tier_eoq |
| |
| if relevant_qty <= 0: |
| num_orders = np.inf |
| ordering_cost = np.inf |
| holding_cost = 0 |
| purchase_cost = annual_demand * tier_unit_cost |
| total_cost = np.inf |
| else: |
| num_orders = annual_demand / relevant_qty |
| ordering_cost = num_orders * order_cost |
| holding_cost = (relevant_qty / 2) * holding_cost_per_unit |
| purchase_cost = annual_demand * tier_unit_cost |
| total_cost = ordering_cost + holding_cost + purchase_cost |
| |
| results.append({ |
| "Tier": f"Tier {i+1} ({min_qty}-{max_qty if max_qty != np.inf else '∞'})", |
| "Unit Cost ($)": tier_unit_cost, |
| "Holding Cost/Unit/Year ($)": f"{holding_cost_per_unit:.2f}", |
| "Theoretical EOQ (Units)": f"{tier_eoq:.0f}", |
| "Relevant Q (Units)": f"{relevant_qty:.0f}", |
| "Annual Ordering Cost ($)": f"{ordering_cost:.2f}", |
| "Annual Holding Cost ($)": f"{holding_cost:.2f}", |
| "Annual Purchase Cost ($)": f"{purchase_cost:.2f}", |
| "Total Annual Cost ($)": f"{total_cost:.2f}" |
| }) |
|
|
| if total_cost < best_total_cost: |
| best_total_cost = total_cost |
| best_eoq = relevant_qty |
| best_unit_cost = tier_unit_cost |
| best_tier = f"Tier {i+1}" |
|
|
| df = pd.DataFrame(results) |
| |
| return df, best_eoq, best_total_cost, best_unit_cost, best_tier, "Analysis complete." |
|
|
|
|
| def calculate_poq(annual_demand, order_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate): |
| """Calculates Production Order Quantity (POQ) and related metrics.""" |
| if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0 or \ |
| daily_production_rate <= 0 or daily_demand_rate <= 0: |
| return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan |
| |
| if daily_production_rate <= daily_demand_rate: |
| return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, "Production rate must be greater than demand rate." |
|
|
| poq = np.sqrt((2 * annual_demand * order_cost) / (holding_cost_per_unit * (1 - (daily_demand_rate / daily_production_rate)))) |
| |
| num_setups_per_year = annual_demand / poq if poq > 0 else np.inf |
| max_inventory_level = poq * (1 - (daily_demand_rate / daily_production_rate)) |
| avg_inventory = max_inventory_level / 2 |
| |
| annual_setup_cost = num_setups_per_year * order_cost |
| annual_holding_cost = avg_inventory * holding_cost_per_unit |
| total_annual_cost = annual_setup_cost + annual_holding_cost |
| |
| production_run_days = poq / daily_production_rate |
| inventory_cycle_days = poq / daily_demand_rate |
| |
| return poq, num_setups_per_year, max_inventory_level, avg_inventory, annual_setup_cost, \ |
| annual_holding_cost, total_annual_cost, production_run_days, inventory_cycle_days |
|
|
| def calculate_rop_and_ss(avg_daily_demand, lead_time_days, std_dev_daily_demand, service_level_z): |
| """Calculates Reorder Point and Safety Stock.""" |
| if avg_daily_demand < 0 or lead_time_days < 0 or std_dev_daily_demand < 0 or service_level_z < 0: |
| return 0, 0, 0, "Inputs must be non-negative." |
| |
| std_dev_lead_time = std_dev_daily_demand * np.sqrt(lead_time_days) |
| safety_stock = std_dev_lead_time * service_level_z |
| demand_during_lead_time = avg_daily_demand * lead_time_days |
| reorder_point = demand_during_lead_time + safety_stock |
| |
| return safety_stock, demand_during_lead_time, reorder_point, "Calculation successful." |
|
|
| def calculate_sma_forecast(demand_data_str, window_size): |
| """Calculates Simple Moving Average (SMA) forecast.""" |
| if not demand_data_str: |
| return pd.DataFrame(), None, "Please enter demand data." |
| |
| try: |
| demand_values = [float(d.strip()) for d in demand_data_str.split(',') if d.strip()] |
| if len(demand_values) < window_size: |
| return pd.DataFrame(), None, f"Not enough data for window size {window_size}. Need at least {window_size} data points." |
| |
| df = pd.DataFrame({'Demand': demand_values}) |
| df['Period'] = range(1, len(df) + 1) |
| |
| |
| df[f'SMA (Window={window_size})'] = df['Demand'].rolling(window=window_size).mean() |
| |
| |
| forecast_next_period = df['Demand'].tail(window_size).mean() |
| |
| |
| fig, ax = plt.subplots(figsize=(8, 4)) |
| ax.plot(df['Period'], df['Demand'], label='Actual Demand', marker='o', linestyle='-') |
| ax.plot(df['Period'], df[f'SMA (Window={window_size})'], label='SMA', marker='x', linestyle='--') |
| |
| ax.set_title('Simple Moving Average (SMA) Forecast', fontsize=14) |
| ax.set_xlabel('Period', fontsize=10) |
| ax.set_ylabel('Demand', fontsize=10) |
| ax.legend() |
| ax.grid(True, linestyle=':', alpha=0.7) |
| plt.tight_layout() |
| plt.close(fig) |
| |
| return df, fig, f"Forecast for next period: {forecast_next_period:.2f}" |
|
|
| except Exception as e: |
| return pd.DataFrame(), None, f"Error: {e}. Ensure data is comma-separated numbers." |
|
|
| |
|
|
| def create_eoq_plot(annual_demand, order_cost, holding_cost_per_unit, min_q=1, max_q_multiplier=2.5, current_eoq=None): |
| """Generates the EOQ cost curves plot.""" |
| if annual_demand <= 0 or order_cost <= 0 or holding_cost_per_unit <= 0: |
| fig, ax = plt.subplots(figsize=(6, 4)) |
| ax.text(0.5, 0.5, "Invalid input for plot.", horizontalalignment='center', verticalalignment='center', transform=ax.transAxes) |
| ax.axis('off') |
| plt.close(fig) |
| return fig |
|
|
| if current_eoq is None or np.isnan(current_eoq) or current_eoq <= 0: |
| current_eoq = np.sqrt((2 * annual_demand * order_cost) / holding_cost_per_unit) |
| if np.isnan(current_eoq) or current_eoq <= 0: |
| current_eoq = 100 |
|
|
| quantity_range = np.linspace(min_q, current_eoq * max_q_multiplier, 300) |
| |
| quantity_range = quantity_range[quantity_range > 0] |
| |
| ordering_costs = (annual_demand / quantity_range) * order_cost |
| holding_costs = (quantity_range / 2) * holding_cost_per_unit |
| total_costs = ordering_costs + holding_costs |
|
|
| fig, ax = plt.subplots(figsize=(6, 4)) |
|
|
| ax.plot(quantity_range, holding_costs, label='Annual Holding Cost', color='orange') |
| ax.plot(quantity_range, ordering_costs, label='Annual Ordering Cost', color='blue') |
| ax.plot(quantity_range, total_costs, label='Total Cost', color='green', linewidth=2.5) |
| |
| if not np.isnan(current_eoq) and current_eoq > 0: |
| ax.axvline(x=current_eoq, color='red', linestyle='--', label=f'EOQ: {current_eoq:.0f} units') |
| total_cost_at_eoq_idx = np.argmin(np.abs(quantity_range - current_eoq)) |
| total_cost_at_eoq = total_costs[total_cost_at_eoq_idx] |
| ax.plot(current_eoq, total_cost_at_eoq, 'ro') |
| |
| ax.set_title('EOQ Cost Analysis', fontsize=12) |
| ax.set_xlabel('Order Quantity (Units)', fontsize=10) |
| ax.set_ylabel('Annual Cost ($)', fontsize=10) |
| ax.legend(fontsize=8, loc='upper right') |
| ax.grid(True, linestyle=':', alpha=0.7) |
| ax.set_ylim(bottom=0) |
| ax.set_xlim(left=0) |
| ax.tick_params(axis='both', which='major', labelsize=8) |
| |
| plt.tight_layout() |
| plt.close(fig) |
| return fig |
|
|
| |
|
|
| def update_basic_eoq(annual_demand, order_cost, holding_cost_per_unit, lead_time_days): |
| """Updates all outputs for the Basic EOQ tab.""" |
| if any(x <= 0 for x in [annual_demand, order_cost, holding_cost_per_unit]): |
| return None, 0, 0, 0, 0, 0, 0, 0, "Please enter positive values for all basic EOQ parameters." |
|
|
| eoq, num_orders, avg_inventory, annual_ordering_cost, annual_holding_cost, total_annual_cost, demand_per_day = \ |
| calculate_basic_eoq(annual_demand, order_cost, holding_cost_per_unit) |
|
|
| |
| reorder_point = demand_per_day * lead_time_days |
| |
| plot_fig = create_eoq_plot(annual_demand, order_cost, holding_cost_per_unit, current_eoq=eoq) |
|
|
| return plot_fig, eoq, num_orders, avg_inventory, annual_ordering_cost, annual_holding_cost, \ |
| total_annual_cost, reorder_point, "Calculation successful." |
|
|
| |
| def update_poq_model(annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate): |
| """Updates all outputs for the POQ tab.""" |
| if any(x <= 0 for x in [annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate]): |
| return None, 0, 0, 0, 0, 0, 0, 0, 0, "Please enter positive values for all POQ parameters." |
| |
| if daily_production_rate <= daily_demand_rate: |
| return None, 0, 0, 0, 0, 0, 0, 0, 0, "Production rate must be greater than demand rate." |
|
|
| poq, num_setups, max_inv, avg_inv, annual_setup_cost, annual_holding_cost, total_cost, prod_days, cycle_days = \ |
| calculate_poq(annual_demand, setup_cost, holding_cost_per_unit, daily_production_rate, daily_demand_rate) |
| |
| plot_fig = create_eoq_plot(annual_demand, setup_cost, holding_cost_per_unit, current_eoq=poq, max_q_multiplier=2.0) |
|
|
| return plot_fig, poq, num_setups, max_inv, avg_inv, annual_setup_cost, annual_holding_cost, total_cost, \ |
| prod_days, cycle_days, "Calculation successful." |
|
|
| |
| def create_discount_tiers_df(tier1_min, tier1_max, tier1_uc, |
| tier2_min, tier2_max, tier2_uc, |
| tier3_min, tier3_max, tier3_uc): |
| """Helper to create the discount_tiers list from Gradio inputs.""" |
| tiers = [] |
| if tier1_min is not None and tier1_uc is not None and tier1_min >= 0 and tier1_uc >= 0: |
| tiers.append((tier1_min, tier1_max if tier1_max is not None else np.inf, tier1_uc)) |
| if tier2_min is not None and tier2_uc is not None and tier2_min >= 0 and tier2_uc >= 0: |
| tiers.append((tier2_min, tier2_max if tier2_max is not None else np.inf, tier2_uc)) |
| if tier3_min is not None and tier3_uc is not None and tier3_min >= 0 and tier3_uc >= 0: |
| tiers.append((tier3_min, tier3_max if tier3_max is not None else np.inf, tier3_uc)) |
| |
| valid_tiers = [] |
| for t in tiers: |
| if t[1] != np.inf and t[0] >= t[1]: |
| print(f"Warning: Invalid tier range {t}. Skipping.") |
| else: |
| valid_tiers.append(t) |
|
|
| valid_tiers = sorted(valid_tiers, key=lambda x: x[0]) |
| |
| return valid_tiers |
|
|
| |
| def update_discount_model(annual_demand, order_cost, holding_cost_rate_percent, |
| tier1_min, tier1_max, tier1_uc, |
| tier2_min, tier2_max, tier2_uc, |
| tier3_min, tier3_max, tier3_uc): |
| """Updates all outputs for the Quantity Discount tab.""" |
| holding_cost_rate = holding_cost_rate_percent / 100.0 |
|
|
| if any(x <= 0 for x in [annual_demand, order_cost, holding_cost_rate_percent]): |
| return pd.DataFrame(), 0, 0, 0, "", "Please enter positive values for core discount parameters." |
| |
| discount_tiers = create_discount_tiers_df( |
| tier1_min, tier1_max, tier1_uc, |
| tier2_min, tier2_max, tier2_uc, |
| tier3_min, tier3_max, tier3_uc |
| ) |
| |
| if not discount_tiers: |
| return pd.DataFrame(), 0, 0, 0, "", "No valid discount tiers defined. Please define at least one tier with positive min quantity and unit cost." |
|
|
| for i in range(len(discount_tiers) - 1): |
| if discount_tiers[i][2] < discount_tiers[i+1][2]: |
| return pd.DataFrame(), 0, 0, 0, "", "Error: Unit costs must be non-increasing with quantity." |
| |
| df_results, best_eoq, best_total_cost, best_unit_cost, best_tier, message = \ |
| calculate_eoq_with_discount(annual_demand, order_cost, holding_cost_rate, discount_tiers[0][2], discount_tiers) |
|
|
| return df_results, best_eoq, best_total_cost, best_unit_cost, best_tier, message |
|
|
| |
|
|
| with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Operations Management Dashboard") as demo: |
| gr.Markdown( |
| """ |
| # 📊 Advanced Operations Management Dashboard (Xyphor Advisors) |
| Welcome to your comprehensive tool for optimizing operations and inventory decisions. |
| """ |
| ) |
| |
| with gr.Tabs(): |
| |
| with gr.TabItem("Basic EOQ Model"): |
| gr.Markdown("## Economic Order Quantity (EOQ) Calculation") |
| gr.Markdown("Find the optimal order quantity that minimizes the sum of ordering and holding costs.") |
| with gr.Row(): |
| with gr.Column(): |
| gr.Markdown("### 🛠️ Input Parameters") |
| basic_demand = gr.Slider(100, 50000, value=12000, step=100, label="Annual Demand (D) [units/year]") |
| basic_order_cost = gr.Slider(5, 500, value=100, step=5, label="Ordering Cost (S) [$/order]") |
| basic_holding_cost = gr.Slider(0.1, 50, value=5, step=0.1, label="Holding Cost (H) [$/unit/year]") |
| basic_lead_time = gr.Slider(0, 30, value=7, step=1, label="Lead Time [days]", info="Time from order placement to receipt.") |
| |
| basic_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.") |
|
|
| with gr.Column(): |
| gr.Markdown("### 📈 Cost Analysis & Optimal Q") |
| basic_plot_output = gr.Plot(label="EOQ Cost Curves", scale=2) |
|
|
| with gr.Accordion("Detailed Results", open=True): |
| gr.Markdown("#### Key Metrics") |
| with gr.Row(): |
| basic_eoq_out = gr.Number(label="Optimal Order Quantity (EOQ) [units]", precision=0) |
| basic_num_orders_out = gr.Number(label="Annual Orders [count]", precision=2) |
| basic_avg_inventory_out = gr.Number(label="Average Inventory [units]", precision=2) |
| gr.Markdown("#### Annual Costs") |
| with gr.Row(): |
| basic_ordering_cost_out = gr.Number(label="Annual Ordering Cost [$]", precision=2) |
| basic_holding_cost_out = gr.Number(label="Annual Holding Cost [$]", precision=2) |
| basic_total_cost_out = gr.Number(label="Total Annual Cost [$]", precision=2) |
| gr.Markdown("#### Reorder Point (Simple)") |
| with gr.Row(): |
| basic_reorder_point_out = gr.Number(label="Reorder Point (without Safety Stock) [units]", precision=0) |
|
|
| basic_inputs = [basic_demand, basic_order_cost, basic_holding_cost, basic_lead_time] |
| basic_outputs = [basic_plot_output, basic_eoq_out, basic_num_orders_out, basic_avg_inventory_out, |
| basic_ordering_cost_out, basic_holding_cost_out, basic_total_cost_out, |
| basic_reorder_point_out, basic_status_message] |
| |
| for inp in basic_inputs: |
| inp.change( |
| fn=update_basic_eoq, |
| inputs=basic_inputs, |
| outputs=basic_outputs |
| ) |
| |
| demo.load( |
| fn=update_basic_eoq, |
| inputs=basic_inputs, |
| outputs=basic_outputs |
| ) |
|
|
| |
| with gr.TabItem("Reorder Point (ROP) & Safety Stock"): |
| gr.Markdown("## Reorder Point & Safety Stock Calculator") |
| gr.Markdown("Determine the precise inventory level at which to place a new order to avoid stockouts.") |
| with gr.Row(): |
| with gr.Column(): |
| gr.Markdown("### 🛠️ Input Parameters") |
| rop_avg_demand = gr.Number(label="Average Daily Demand [units/day]", value=50) |
| rop_lead_time = gr.Number(label="Lead Time [days]", value=10) |
| rop_std_dev = gr.Number(label="Standard Deviation of Daily Demand", value=5) |
| rop_z_score = gr.Slider(minimum=0.0, maximum=3.0, value=1.65, step=0.01, |
| label="Z-Score (for Service Level)", |
| info="e.g., 1.65 for 95% service level, 2.33 for 99%") |
| rop_status = gr.Textbox(label="Status", interactive=False) |
| |
| with gr.Column(): |
| gr.Markdown("### 🔑 Calculated Metrics") |
| rop_ss_out = gr.Number(label="Safety Stock (SS) [units]", precision=0, |
| info="The buffer stock held to prevent stockouts.") |
| rop_dlt_out = gr.Number(label="Demand During Lead Time [units]", precision=0, |
| info="Total expected demand while waiting for the order.") |
| rop_out = gr.Number(label="Reorder Point (ROP) [units]", precision=0, |
| info="Place an order when inventory hits this level. (ROP = SS + Demand During Lead Time)") |
|
|
| rop_inputs = [rop_avg_demand, rop_lead_time, rop_std_dev, rop_z_score] |
| rop_outputs = [rop_ss_out, rop_dlt_out, rop_out, rop_status] |
|
|
| for inp in rop_inputs: |
| inp.change(fn=calculate_rop_and_ss, inputs=rop_inputs, outputs=rop_outputs) |
| demo.load(fn=calculate_rop_and_ss, inputs=rop_inputs, outputs=rop_outputs) |
|
|
| |
| with gr.TabItem("Quantity Discount Model"): |
| gr.Markdown("## EOQ with Quantity Discounts") |
| gr.Markdown("Evaluate the impact of price breaks on the optimal order quantity and total cost.") |
| with gr.Row(): |
| with gr.Column(): |
| gr.Markdown("### 🛠️ Core Parameters") |
| discount_demand = gr.Slider(100, 50000, value=15000, step=100, label="Annual Demand (D) [units/year]") |
| discount_order_cost = gr.Slider(5, 500, value=75, step=5, label="Ordering Cost (S) [$/order]") |
| discount_holding_rate = gr.Slider(0.01, 0.5, value=0.2, step=0.01, label="Holding Cost Rate [% of Unit Cost]", info="e.g., 20% = 0.2") |
|
|
| gr.Markdown("### 🏷️ Discount Tiers") |
| gr.Markdown("Define up to three discount tiers. Unit costs must be non-increasing.") |
| with gr.Accordion("Tier 1", open=True): |
| with gr.Row(): |
| tier1_min_qty = gr.Number(label="Min Qty", value=0, precision=0) |
| tier1_max_qty = gr.Number(label="Max Qty", value=999, precision=0) |
| tier1_unit_cost = gr.Number(label="Unit Cost ($)", value=10.00, precision=2) |
| with gr.Accordion("Tier 2"): |
| with gr.Row(): |
| tier2_min_qty = gr.Number(label="Min Qty", value=1000, precision=0) |
| tier2_max_qty = gr.Number(label="Max Qty", value=4999, precision=0) |
| tier2_unit_cost = gr.Number(label="Unit Cost ($)", value=9.50, precision=2) |
| with gr.Accordion("Tier 3"): |
| with gr.Row(): |
| tier3_min_qty = gr.Number(label="Min Qty", value=5000, precision=0) |
| tier3_max_qty = gr.Number(label="Max Qty", value=None, precision=0, info="Leave blank for infinity") |
| tier3_unit_cost = gr.Number(label="Unit Cost ($)", value=9.00, precision=2) |
| |
| discount_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.") |
|
|
| with gr.Column(): |
| gr.Markdown("### 📊 Tier Analysis & Optimal Selection") |
| discount_output_df = gr.DataFrame(label="Discount Tier Analysis", interactive=False) |
| gr.Markdown("#### Optimal Discount Solution") |
| with gr.Row(): |
| best_discount_eoq_out = gr.Number(label="Optimal Order Quantity [units]", precision=0) |
| best_discount_cost_out = gr.Number(label="Minimum Total Annual Cost [$]", precision=2) |
| with gr.Row(): |
| best_discount_unit_cost_out = gr.Number(label="Unit Cost at Optimal Q [$]", precision=2) |
| best_discount_tier_out = gr.Textbox(label="Optimal Tier", interactive=False) |
| |
| discount_inputs = [discount_demand, discount_order_cost, discount_holding_rate, |
| tier1_min_qty, tier1_max_qty, tier1_unit_cost, |
| tier2_min_qty, tier2_max_qty, tier2_unit_cost, |
| tier3_min_qty, tier3_max_qty, tier3_unit_cost] |
| discount_outputs = [discount_output_df, best_discount_eoq_out, best_discount_cost_out, |
| best_discount_unit_cost_out, best_discount_tier_out, discount_status_message] |
|
|
| for inp in discount_inputs: |
| inp.change( |
| fn=update_discount_model, |
| inputs=discount_inputs, |
| outputs=discount_outputs |
| ) |
| |
| demo.load( |
| fn=update_discount_model, |
| inputs=discount_inputs, |
| outputs=discount_outputs |
| ) |
|
|
| |
| with gr.TabItem("Production Order Quantity (POQ) Model"): |
| gr.Markdown("## Production Order Quantity (POQ) Calculation") |
| gr.Markdown("Determine the optimal batch size when production is internal and gradual.") |
| with gr.Row(): |
| with gr.Column(): |
| gr.Markdown("### 🛠️ Input Parameters") |
| poq_demand = gr.Slider(100, 50000, value=20000, step=100, label="Annual Demand (D) [units/year]") |
| poq_setup_cost = gr.Slider(5, 500, value=200, step=5, label="Setup Cost (S) [$/setup]") |
| poq_holding_cost = gr.Slider(0.1, 50, value=8, step=0.1, label="Holding Cost (H) [$/unit/year]") |
| gr.Markdown("### 🏭 Production Specifics") |
| poq_prod_rate = gr.Slider(10, 2000, value=500, step=10, label="Daily Production Rate (P) [units/day]") |
| poq_demand_rate = gr.Slider(1, 1000, value=80, step=1, label="Daily Demand Rate (d) [units/day]", info="Must be less than Daily Production Rate.") |
| |
| poq_status_message = gr.Textbox(label="Status", interactive=False, value="Enter parameters and run.") |
|
|
| with gr.Column(): |
| gr.Markdown("### 📈 Cost Analysis & Optimal Batch Size") |
| poq_plot_output = gr.Plot(label="POQ Cost Curves", scale=2) |
|
|
| with gr.Accordion("Detailed Results", open=True): |
| gr.Markdown("#### Key Metrics") |
| with gr.Row(): |
| poq_out = gr.Number(label="Optimal Production Quantity (POQ) [units]", precision=0) |
| poq_num_setups_out = gr.Number(label="Annual Setups [count]", precision=2) |
| poq_max_inv_out = gr.Number(label="Maximum Inventory Level [units]", precision=2) |
| poq_avg_inv_out = gr.Number(label="Average Inventory [units]", precision=2) |
| gr.Markdown("#### Annual Costs") |
| with gr.Row(): |
| poq_setup_cost_out = gr.Number(label="Annual Setup Cost [$]", precision=2) |
| poq_holding_cost_out = gr.Number(label="Annual Holding Cost [$]", precision=2) |
| poq_total_cost_out = gr.Number(label="Total Annual Cost [$]", precision=2) |
| gr.Markdown("#### Production Cycle Details") |
| with gr.Row(): |
| poq_prod_days_out = gr.Number(label="Production Run Duration [days]", precision=2) |
| poq_cycle_days_out = gr.Number(label="Inventory Cycle Duration [days]", precision=2) |
|
|
| poq_inputs = [poq_demand, poq_setup_cost, poq_holding_cost, poq_prod_rate, poq_demand_rate] |
| poq_outputs = [poq_plot_output, poq_out, poq_num_setups_out, poq_max_inv_out, poq_avg_inv_out, |
| poq_setup_cost_out, poq_holding_cost_out, poq_total_cost_out, |
| poq_prod_days_out, poq_cycle_days_out, poq_status_message] |
|
|
| for inp in poq_inputs: |
| inp.change( |
| fn=update_poq_model, |
| inputs=poq_inputs, |
| outputs=poq_outputs |
| ) |
| |
| demo.load( |
| fn=update_poq_model, |
| inputs=poq_inputs, |
| outputs=poq_outputs |
| ) |
|
|
| |
| with gr.TabItem("Demand Forecasting (SMA)"): |
| gr.Markdown("## Simple Moving Average (SMA) Forecasting") |
| gr.Markdown("Forecast future demand based on the average of past demand data.") |
| with gr.Row(): |
| with gr.Column(scale=1): |
| gr.Markdown("### 🛠️ Input Parameters") |
| sma_data = gr.Textbox(label="Past Demand Data (comma-separated)", |
| value="100, 110, 105, 120, 115, 125, 130, 122, 135, 140") |
| sma_window = gr.Slider(minimum=2, maximum=10, value=3, step=1, |
| label="SMA Window Size (Periods)") |
| sma_status = gr.Textbox(label="Status & Forecast", interactive=False) |
| |
| with gr.Column(scale=2): |
| gr.Markdown("### 📈 Forecast Plot") |
| sma_plot = gr.Plot() |
| sma_df = gr.DataFrame(label="Data and SMA") |
|
|
| sma_inputs = [sma_data, sma_window] |
| sma_outputs = [sma_df, sma_plot, sma_status] |
|
|
| for inp in sma_inputs: |
| inp.change(fn=calculate_sma_forecast, inputs=sma_inputs, outputs=sma_outputs) |
| demo.load(fn=calculate_sma_forecast, inputs=sma_inputs, outputs=sma_outputs) |
|
|
| if __name__ == "__main__": |
| demo.launch(share=True, inbrowser=True, debug=True) |
