Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import numpy as np | |
| import matplotlib.pyplot as plt | |
| import pandas as pd | |
| import io | |
| from scipy.stats import norm # Using scipy.stats, but it's a common numpy-adjacent lib for stats. If not allowed, can be replaced. | |
| # Let's stick to numpy. We can use norm.ppf or just ask for Z-score. | |
| # User said NO new concepts. Z-score is simple. I will just ask for the Z-score directly. | |
| # --- Calculation Functions --- | |
| 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) | |
| # Calculate SMA | |
| df[f'SMA (Window={window_size})'] = df['Demand'].rolling(window=window_size).mean() | |
| # Forecast next period | |
| forecast_next_period = df['Demand'].tail(window_size).mean() | |
| # Create plot | |
| 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." | |
| # --- Plotting Function --- | |
| 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 | |
| # --- Combined Interface Function for Basic EOQ --- | |
| 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) | |
| # Simple Reorder Point (no safety stock) | |
| 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." | |
| # --- Combined Interface Function for POQ --- | |
| 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." | |
| # --- Helper for Discount Tiers --- | |
| 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 | |
| # --- Combined Interface Function for Discount Model --- | |
| 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 | |
| # --- Gradio Interface --- | |
| 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(): | |
| # --- Tab 1: Basic EOQ Model --- | |
| 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 | |
| ) | |
| # --- Tab 2: Reorder Point & Safety Stock --- | |
| 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) | |
| # --- Tab 3: Quantity Discount Model --- | |
| 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 | |
| ) | |
| # --- Tab 4: Production Order Quantity (POQ) Model --- | |
| 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 | |
| ) | |
| # --- Tab 5: Demand Forecasting (SMA) --- | |
| 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) |