|
|
| import gradio as gr |
| import pandas as pd |
| import plotly.express as px |
| import plotly.graph_objects as go |
| import random |
|
|
| |
| regions = ["Riyadh", "Makkah", "Eastern", "Madinah", "Qassim", "Asir", "Tabuk", "Hail", "Northern", |
| "Jazan", "Najran", "Bahah", "Jawf"] |
| income_bands = ["Low", "Mid", "High"] |
| property_types = ["Land", "Off-plan", "Ready", "Self-build"] |
|
|
| def default_subsidy_values(): |
| base = 300_000 |
| factor = 0.5 |
| return {(r, i, p): int((base - 100_000 * income_bands.index(i)) * factor) |
| for r in regions for i in income_bands for p in property_types} |
|
|
| def default_supply_cost_values(): |
| return {(p, r): {"Supply": random.randint(1000, 10000), "Discount (SAR)": random.randint(50_000, 300_000)} |
| for p in ["Land", "Off-plan"] for r in regions} |
|
|
| def monte_carlo_optimization(subsidies, budget_limit, target_contracts, supply_dict, interest_rate, demand_increase, n_trials=10000): |
| keys = list(subsidies.keys()) |
| best_result = None |
| best_score = float('-inf') |
| fairness_penalty_weight = 10_000_000 |
|
|
| demand_multiplier = 1 + (demand_increase / 100) |
| cost_multiplier = 1 + (interest_rate / 100) |
|
|
| for _ in range(n_trials): |
| contracts = {} |
| total_budget = 0 |
| total_contracts = 0 |
| shuffled_subs = {k: int(random.randint(150000, 400000) * cost_multiplier) for k in keys} |
| available_supply = {(r, p): supply_dict.get((p, r), 0) for (p, r) in supply_dict} |
|
|
| for k in keys: |
| r, i, p = k |
| max_supply = available_supply.get((r, p), 10000) |
| max_demand = int(max_supply * demand_multiplier) |
| max_possible_contracts = int(min((budget_limit - total_budget) // shuffled_subs[k], max_demand)) if shuffled_subs[k] > 0 else 0 |
| c = random.randint(0, max_possible_contracts) if max_possible_contracts > 0 else 0 |
| contracts[k] = c |
| total_budget += shuffled_subs[k] * c |
| total_contracts += c |
|
|
| if total_budget > budget_limit: |
| continue |
|
|
| achieved_regions = set(r for (r, i, p) in contracts if contracts[(r, i, p)] > 0) |
| achieved_income = set(i for (r, i, p) in contracts if contracts[(r, i, p)] > 0) |
| achieved_props = set(p for (r, i, p) in contracts if contracts[(r, i, p)] > 0) |
| fairness_penalty = ( |
| len(regions) - len(achieved_regions) + |
| len(income_bands) - len(achieved_income) + |
| len(property_types) - len(achieved_props) |
| ) * fairness_penalty_weight |
|
|
| score = total_contracts - fairness_penalty |
|
|
| if score > best_score: |
| best_score = score |
| best_result = (contracts, total_budget, total_contracts, shuffled_subs) |
|
|
| return best_result if best_result else ({}, 0, 0, subsidies) |
|
|
| def create_gauge_chart(value, title, max_value=100): |
| fig = go.Figure(go.Indicator( |
| mode="gauge+number", |
| value=value, |
| gauge={ |
| 'axis': {'range': [0, max_value]}, |
| 'bar': {'color': "darkblue"}, |
| 'steps': [ |
| {'range': [0, max_value * 0.5], 'color': "lightgray"}, |
| {'range': [max_value * 0.5, max_value], 'color': "lightgreen"} |
| ] |
| }, |
| title={'text': title} |
| )) |
| fig.update_layout(height=350, width=450, margin=dict(t=40, b=40, l=40, r=40)) |
| return fig |
|
|
| def build_app(): |
| supply_costs = default_supply_cost_values() |
|
|
| with gr.Blocks() as app: |
| gr.Markdown("# 🏨 Strategic Gears Housing Simulator – Auto Optimization") |
|
|
| with gr.Tab("Inputs"): |
| with gr.Row(): |
| with gr.Column(): |
| ir = gr.Slider(0, 10, 5, label="Interest Rate (%)") |
| dp = gr.Slider(0, 100, 10, label="Demand Increase (%)") |
| n = gr.Slider(100, 10000, 1000, step=100, label="Number of Simulations") |
| budget_limit = gr.Slider(10_000_000, 1_000_000_000, 500_000_000, step=10_000_000, label="Budget Limit (SAR)") |
| target_contracts = gr.Slider(1000, 20000, 5000, step=100, label="Target Contracts") |
| supply_inputs = {} |
|
|
| with gr.Accordion("Supply Inputs by Region and Property Type", open=False): |
| for p in ["Land", "Off-plan"]: |
| with gr.Accordion(p, open=False): |
| for r in regions: |
| supply_inputs[(p, r)] = gr.Slider(minimum=1, maximum=10000, |
| value=supply_costs[(p, r)]["Supply"], |
| step=1, |
| label=f"{r} {p} Supply") |
| run = gr.Button("Run Simulation") |
|
|
| with gr.Tab("Outputs"): |
| summary = gr.Markdown("Optimization summary will appear here.") |
|
|
| with gr.Row(): |
| with gr.Column(): |
| df_subsidy_policy = gr.Dataframe(label="1️⃣ Recommended Subsidy Support (SAR)") |
| subsidy_by_income_bar = gr.Plot(label="Average Subsidy by Income Band") |
| with gr.Column(): |
| df_contract_summary = gr.Dataframe(label="2️⃣ Contract Distribution") |
| contracts_by_region_bar = gr.Plot(label="Contracts by Region") |
|
|
| with gr.Row(): |
| with gr.Column(): |
| df_budget_summary = gr.Dataframe(label="3️⃣ Budget Distribution") |
| budget_util_gauge = gr.Plot(label="Budget Utilization (%)") |
| with gr.Column(): |
| df_discount_table = gr.Dataframe(label="4️⃣ Discount Table") |
| contracts_by_property_pie = gr.Plot(label="Contract Distribution by Property Type") |
| target_achievement_gauge = gr.Plot(label="Target Achievement (%)") |
| total_contracts_gauge = gr.Plot(label="Total Contracts (Scaled to Target)") |
|
|
| def run_sim(interest, demand, sims, budget, target, *supplies): |
| supply_dict = {(p, r): supplies[i] for i, (p, r) in enumerate(supply_inputs)} |
| result, total_bgt, total_con, final_subs = monte_carlo_optimization( |
| default_subsidy_values(), budget, target, supply_dict, interest, demand, sims |
| ) |
|
|
| df = pd.DataFrame([{ |
| "Region": r, "Income Band": i, "Property Type": p, |
| "Contracts": result.get((r, i, p), 0), |
| "Subsidy (SAR)": final_subs[(r, i, p)], |
| "Budget (SAR)": result.get((r, i, p), 0) * final_subs[(r, i, p)] |
| } for (r, i, p) in final_subs]) |
|
|
| subsidy_df = df[["Region", "Income Band", "Property Type", "Subsidy (SAR)"]].sort_values(by="Subsidy (SAR)", ascending=False) |
| contract_df = df[["Region", "Income Band", "Property Type", "Contracts"]].sort_values(by="Contracts", ascending=False) |
| budget_df = df[["Region", "Income Band", "Property Type", "Budget (SAR)"]].sort_values(by="Budget (SAR)", ascending=False) |
|
|
| df_discount = pd.DataFrame([{ |
| "Region": r, "Property Type": p, |
| "Discount (SAR)": random.randint(50_000, 300_000) |
| } for p in ["Land", "Off-plan"] for r in regions]) |
|
|
| summary_text = f""" |
| **Optimization Summary:** |
| - Total Budget Used: {total_bgt:,.0f} SAR |
| - Budget Utilization: {(total_bgt / budget) * 100:.1f}% |
| - Total Contracts: {total_con:,} |
| - Target Achievement: {(total_con / target) * 100:.1f}% |
| """ |
|
|
| |
| budget_util_pct = (total_bgt / budget) * 100 |
| target_achieved_pct = (total_con / target) * 100 |
| total_contracts_scaled = min(100, (total_con / target) * 100) |
|
|
| gauge_budget = create_gauge_chart(budget_util_pct, "Budget Utilization (%)") |
| gauge_target = create_gauge_chart(target_achieved_pct, "Target Achievement (%)") |
| gauge_contracts = create_gauge_chart(total_contracts_scaled, "Contracts (Scaled to Target %)") |
|
|
| |
| contracts_region = df.groupby("Region")["Contracts"].sum().reset_index() |
| bar_contract_region = px.bar(contracts_region, x="Region", y="Contracts", title="Contracts by Region") |
| min_y = 10 |
| max_y = contracts_region["Contracts"].max() * 1.1 |
| bar_contract_region.update_layout( |
| height=350, width=450, |
| yaxis=dict(title="Contracts", tickformat=",d", range=[min_y, max_y]), |
| margin=dict(t=50, b=40, l=60, r=40) |
| ) |
|
|
| |
| subsidy_income = df.groupby("Income Band")["Subsidy (SAR)"].mean().reset_index() |
| bar_subsidy_income = px.bar(subsidy_income, x="Income Band", y="Subsidy (SAR)", title="Average Subsidy by Income Band") |
| bar_subsidy_income.update_layout( |
| height=350, width=450, |
| yaxis=dict(tickprefix="SAR ", tickformat="~s"), |
| margin=dict(t=50, b=40, l=60, r=40) |
| ) |
|
|
| |
| contracts_property = df.groupby("Property Type")["Contracts"].sum().reset_index() |
| pie_property = px.pie(contracts_property, names="Property Type", values="Contracts", title="Contract Distribution by Property Type") |
| pie_property.update_layout(height=350, width=450, margin=dict(t=50, b=40, l=40, r=40)) |
|
|
| return summary_text, subsidy_df, contract_df, budget_df, df_discount, gauge_budget, gauge_target, gauge_contracts, bar_contract_region, bar_subsidy_income, pie_property |
|
|
| run.click( |
| fn=run_sim, |
| inputs=[ir, dp, n, budget_limit, target_contracts] + list(supply_inputs.values()), |
| outputs=[ |
| summary, df_subsidy_policy, df_contract_summary, df_budget_summary, df_discount_table, |
| budget_util_gauge, target_achievement_gauge, total_contracts_gauge, |
| contracts_by_region_bar, subsidy_by_income_bar, contracts_by_property_pie |
| ] |
| ) |
|
|
| return app |
|
|
| app = build_app() |
| app.launch() |
|
|
