= max_rp: st.session_state["rp"]=0
st.session_state["rp_pl"] = not st.session_state["rp_pl"]; st.rerun()
# slider - use value= so auto-play can write to rp freely
new_rp = st.slider("Nodes explored", 0, max_rp,
value=st.session_state["rp"],
help="Drag to replay how the algorithm searches node by node")
if new_rp != st.session_state["rp"]:
st.session_state["rp"] = new_rp
st.session_state["rp_pl"] = False
rp = st.session_state["rp"]
done = (rp == max_rp)
explored = set(expl_r[:rp])
cur_node = expl_r[rp-1] if rp > 0 else None
path_set = set(path_r) if path_r else set()
st.progress(rp/max_rp,
text=f"{rp}/{max_rp} nodes explored"
+(" · Path found ✓" if done and path_r else ""))
# map
f2 = go.Figure()
# edges
for a,b,_ in EDGES:
f2.add_trace(go.Scatter(x=[NODES_R[a][0],NODES_R[b][0],None],
y=[NODES_R[a][1],NODES_R[b][1],None],mode="lines",
line=dict(color="#dde6f0",width=1.5),showlegend=False,hoverinfo="skip"))
# final path highlight (thick amber)
if path_r and done:
for i in range(len(path_r)-1):
pa,pb=path_r[i],path_r[i+1]
f2.add_trace(go.Scatter(
x=[NODES_R[pa][0],NODES_R[pb][0],None],
y=[NODES_R[pa][1],NODES_R[pb][1],None],mode="lines",
line=dict(color=AMBER,width=7),showlegend=False,hoverinfo="skip"))
# nodes
for zone, zcol in [("urban",RED),("rural",GREEN)]:
ns=[(n,d) for n,d in NODES_R.items() if d[2]==zone]
for n,d in ns:
if n==sn: nc,sz="white",26
elif n==en: nc,sz="#fde68a",26
elif n in path_set and done: nc,sz=AMBER,24
elif n in explored: nc,sz="#93c5fd",20
else: nc,sz=zcol,16
# ring around currently expanding node
if n==cur_node and not done:
f2.add_trace(go.Scatter(x=[d[0]],y=[d[1]],mode="markers",
marker=dict(size=34,color=_rgba(BLUE,0.2),
line=dict(color=BLUE,width=2)),
showlegend=False,hoverinfo="skip"))
state=("Final path" if n in path_set and done
else "Exploring now" if n==cur_node
else "Explored" if n in explored
else "Not explored")
f2.add_trace(go.Scatter(x=[d[0]],y=[d[1]],mode="markers+text",
marker=dict(size=sz,color=nc,line=dict(color=SLATE,width=1.5)),
text=[n],textposition="middle center",
textfont=dict(size=7.5,color="#fff" if n in explored and n not in (sn,en) else SLATE),
showlegend=False,
hovertemplate=f"{n}
{state}"))
f2.update_layout(**_layout(460))
f2.update_xaxes(showgrid=False,showticklabels=False,zeroline=False)
f2.update_yaxes(showgrid=False,showticklabels=False,zeroline=False)
st.plotly_chart(f2, use_container_width=True, key="rp_chart")
# legend
st.markdown(f"""
""", unsafe_allow_html=True)
if path_r and done:
m1,m2,m3=st.columns(3)
m1.metric("Path cost", f"{cost_r:.2f} km")
m2.metric("Nodes explored",len(expl_r))
m3.metric("Path", f"{len(path_r)} nodes")
st.markdown(f"""
Route: {" → ".join(path_r)}
{algo} explored {len(expl_r)} nodes to find a {cost_r:.2f} km route from {sn} to {en}.
""", unsafe_allow_html=True)
# auto-play replay
if st.session_state["rp_pl"] and rp < max_rp:
time.sleep(0.9 / rp_speed)
st.session_state["rp"] = rp + 1
st.rerun()
elif st.session_state["rp_pl"] and rp >= max_rp:
st.session_state["rp_pl"] = False
# ══════════════════════════════════════════════════════════════════════════════
# TASK 4 - A* vs IDA*
# ══════════════════════════════════════════════════════════════════════════════
with T4:
st.markdown("""
📊
Same shortest path, completely different strategies
A* remembers every node it visits - fast, but memory grows with the network.
IDA* forgets and re-searches from scratch each pass, tightening its cost bound each time - slower
but uses almost no memory. This benchmark runs 10 routes × 20 timing runs across urban
and rural pairs to find out which algorithm is right for EcoCart - and at what scale that answer changes.
""", unsafe_allow_html=True)
urban_data=[
["U1→U10","5.69","7","0.160","5.69","43","0.572"],
["U7→U6", "4.21","5","0.086","4.21","22","0.323"],
["U2→U9", "3.11","2","0.079","3.11","6", "0.131"],
["U1→U9", "4.40","4","0.084","4.40","15","0.220"],
["U3→U8", "4.21","5","0.107","4.21","19","0.282"],
]
rural_data=[
["R1→R9", "10.39","6","0.124","10.39","34","0.453"],
["R2→R8", "7.82", "4","0.097","7.82", "14","0.209"],
["R3→R10","6.77", "5","0.103","6.77", "21","0.326"],
["R1→R6", "7.51", "3","0.064","7.51", "10","0.153"],
["R4→R9", "7.82", "7","0.125","7.82", "50","0.673"],
]
hdr=["Route","A* km","A* nodes","A* ms","IDA* km","IDA* nodes","IDA* ms"]
cu,cr=st.columns(2)
with cu:
st.markdown("**Urban routes**")
st.dataframe(pd.DataFrame(urban_data,columns=hdr),use_container_width=True,hide_index=True)
with cr:
st.markdown("**Rural routes**")
st.dataframe(pd.DataFrame(rural_data,columns=hdr),use_container_width=True,hide_index=True)
all_rows=urban_data+rural_data
routes=[r[0] for r in all_rows]
a_n=[int(r[2]) for r in all_rows]; i_n=[int(r[5]) for r in all_rows]
a_m=[float(r[3]) for r in all_rows]; i_m=[float(r[6]) for r in all_rows]
fig4=make_subplots(rows=1,cols=2,
subplot_titles=["Nodes expanded (fewer = smarter)","Time ms (lower = faster)"])
for ci,(av,iv) in enumerate([(a_n,i_n),(a_m,i_m)],1):
fig4.add_trace(go.Bar(name="A*", x=routes,y=av,marker_color=BLUE, showlegend=(ci==1)),row=1,col=ci)
fig4.add_trace(go.Bar(name="IDA*",x=routes,y=iv,marker_color=AMBER,showlegend=(ci==1)),row=1,col=ci)
fig4.update_layout(paper_bgcolor=SURF,plot_bgcolor=BG,font_color=SLATE,
barmode="group",height=360,margin=dict(l=40,r=20,t=50,b=80),
legend=dict(bgcolor=SURF,bordercolor=BORDER))
fig4.update_xaxes(gridcolor=BORDER,tickangle=45)
fig4.update_yaxes(gridcolor=BORDER)
st.plotly_chart(fig4,use_container_width=True)
if os.path.exists("output/algo_comparison.png"):
st.image("output/algo_comparison.png",caption="From task3_4_routing.py",use_container_width=True)
st.markdown("""
Both algorithms found identical optimal paths on every single route - path costs match exactly.
But A* was faster and expanded fewer nodes every time. The starkest example: R4→R9, where
A* needed 7 node expansions in 0.125 ms while IDA* needed 50 in 0.673 ms.
For EcoCart's current network, A* is the clear winner. IDA*'s value shows up at national scale —
when the network has millions of nodes and storing A*'s visited set would exhaust memory.
""", unsafe_allow_html=True)
# ══════════════════════════════════════════════════════════════════════════════
# TASK 5 - FORECASTING
# ══════════════════════════════════════════════════════════════════════════════
with T5:
st.markdown("""
📈
Can a simple model beat 200 decision trees?
Linear Regression (fast, transparent) goes head-to-head against
Random Forest (200 trees, non-linear patterns). Both train on 730 days of EcoCart
sales history and are tested blind on 140 days they have never seen.
Press Run to see which model wins on MAE, RMSE, R², and MAPE - and why the result is surprising.
""", unsafe_allow_html=True)
run_t5 = st.button("▶ Run Task 5 - Demand Forecasting",
type="primary", use_container_width=True, key="run_t5")
if run_t5 or st.session_state.get("t5_done"):
st.session_state["t5_done"] = True
@st.cache_data
def _run_task5():
spec=importlib.util.spec_from_file_location("task5","task5_forecasting.py")
m=importlib.util.module_from_spec(spec); buf=io.StringIO()
with redirect_stdout(buf): spec.loader.exec_module(m); m.main()
return buf.getvalue()
with st.spinner("Running task5_forecasting.py …"):
t5_out = _run_task5()
st.session_state["t5_text"] = t5_out
with st.expander("Terminal output", expanded=False):
st.markdown(f"""""", unsafe_allow_html=True)
m1,m2,m3,m4=st.columns(4)
m1.metric("LR - MAE","9.62 units"); m2.metric("LR - R²","0.762")
m3.metric("RF - MAE","9.75 units"); m4.metric("RF - R²","0.716")
if os.path.exists("output/forecast.png"):
st.image("output/forecast.png",
caption="Actual vs predicted sales - 140 test days",
use_container_width=True)
c1,c2=st.columns(2)
with c1:
if os.path.exists("output/residuals.png"):
st.image("output/residuals.png",caption="Residuals",use_container_width=True)
with c2:
if os.path.exists("output/feature_importance.png"):
st.image("output/feature_importance.png",
caption="Feature importance",use_container_width=True)
st.markdown("""
Linear Regression won on both accuracy and speed - R²=0.762 vs Random Forest's 0.716,
and a fraction of the training time (LR is a single matrix solve; RF trains 200 trees on
bootstrap samples). The reason LR wins here: once lag_7 (same weekday last week) is in the
features, the demand signal becomes mostly linear. Random Forest's complexity adds noise, not signal.
Top predictors: lag_7, lag_14, is_promo - weekly rhythm and promotions
drive demand more than anything else.
""", unsafe_allow_html=True)
# ══════════════════════════════════════════════════════════════════════════════
# TASK 6 - BUSINESS CASE
# ══════════════════════════════════════════════════════════════════════════════
with T6:
st.markdown("""
💼
What does all of this actually save the business?
This tab turns the technical results into a live financial model —
savings from A* route optimisation, revenue unlocked by fixing the segmentation bias, and
CO₂ avoided. All numbers are estimates based on assumed fleet inputs.
Use the sliders on the left to model EcoCart's real fleet size, fuel costs, and wages —
the ROI and payback period update instantly.
""", unsafe_allow_html=True)
ctrl, main = st.columns([1, 3])
with ctrl:
fleet =st.slider("Fleet (vehicles)", 5,100,30,5)
daily =st.slider("Deliveries/vehicle/day",10, 80,40,5)
avg_km =st.slider("Avg km per delivery", 2, 30,12,1)
fuel =st.slider("Fuel €/km", 0.10,0.60,0.32,0.01,format="€%.2f")
wage =st.slider("Driver wage €/hr", 10, 35,18,1,format="€%d")
days_yr=st.slider("Working days/year", 200,365,300,10)
rt_save=st.slider("Route saving % (A*)", 5, 35,18,1,format="%d%%")
seg_rev=st.slider("Rural revenue uplift €k",10,200,65,5)
with main:
total_km =fleet*daily*days_yr*avg_km
km_saved =total_km*rt_save/100
fuel_saved=km_saved*fuel
time_saved=(km_saved/40)*wage
route_save=fuel_saved+time_saved
seg_save =seg_rev*1000
total_eur =route_save+seg_save
co2 =km_saved*0.24/1000
dev=45000; ops=8000
payback=round((dev+ops)/total_eur*12,1) if total_eur>0 else 0
roi3 =round((total_eur*3-(dev+ops*3))/(dev+ops*3)*100,1)
mc=st.columns(4)
mc[0].metric("Est. annual saving",f"€{round(total_eur/1000,1)}k")
mc[1].metric("Est. payback",f"{payback} months")
mc[2].metric("3-year ROI",f"{roi3}%")
mc[3].metric("CO₂ saved/yr",f"{co2:.1f} t")
cats=["Route Optimisation (A*)","Fairer Segmentation (rural)"]
vals=[round(route_save/1000,1),round(seg_save/1000,1)]
fb=go.Figure(go.Bar(x=cats,y=vals,marker_color=[BLUE,GREEN],
text=[f"€{v}k" for v in vals],textposition="outside",
textfont_color=SLATE,width=0.4))
fb.update_layout(**_layout(250)); fb.update_xaxes(gridcolor=BORDER)
fb.update_yaxes(gridcolor=BORDER,title="€ thousands")
st.plotly_chart(fb,use_container_width=True)
years=[0,1,2,3]
ben=[0,total_eur,total_eur*2,total_eur*3]
cost=[0,dev+ops,dev+ops*2,dev+ops*3]
fr=go.Figure()
fr.add_trace(go.Scatter(x=years,y=[v/1000 for v in ben],name="Benefit",
line=dict(color=GREEN,width=2.5),mode="lines+markers"))
fr.add_trace(go.Scatter(x=years,y=[v/1000 for v in cost],name="Cost",
line=dict(color=RED,width=2.5,dash="dash"),mode="lines+markers"))
fr.add_hline(y=0,line_color=MUTED,line_width=1,line_dash="dot")
fr.update_layout(**_layout(270))
fr.update_layout(showlegend=True,legend=dict(bgcolor=SURF,bordercolor=BORDER,x=0.01,y=0.99))
fr.update_xaxes(gridcolor=BORDER,tickvals=[0,1,2,3],
ticktext=["Now","Year 1","Year 2","Year 3"])
fr.update_yaxes(gridcolor=BORDER,title="€ thousands")
st.plotly_chart(fr,use_container_width=True)
st.markdown(f"""
Reminder: these are estimates for illustration only - not measured values.
Current inputs: {fleet} vehicles, {daily} deliveries/day, {avg_km} km avg route,
{rt_save}% saving from A* routing, €{seg_rev}k rural revenue uplift assumed.
Change the sliders to model your own scenario.
""", unsafe_allow_html=True)