Upload 5 files

generate_eq.py

@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+
+DAMAGE_STATES = ['none', 'minor', 'severe', 'collapse']
+
+def generate_buildings(n_buildings, diameter_km, seed=42):
+
+    np.random.seed(seed)
+    buildings = []
+    
+    radius = diameter_km / 2
+    
+    for i in range(n_buildings):
+        angle = np.random.uniform(0, 2 * np.pi)
+        r = np.random.uniform(0.5, radius)
+        
+        x = r * np.cos(angle)
+        y = r * np.sin(angle)
+        distance = r
+        
+        building_type = np.random.choice(
+            ['wood', 'concrete', 'steel'], 
+            p=[0.5, 0.3, 0.2]
+        )
+        
+        if building_type == 'wood':
+            occupancy = int(np.random.uniform(10, 100))
+        elif building_type == 'concrete':
+            occupancy = int(np.random.uniform(50, 300))
+        else:
+            occupancy = int(np.random.uniform(100, 500))
+        
+        buildings.append({
+            'building_id': i,
+            'x': round(x, 2),
+            'y': round(y, 2),
+            'distance_km': round(distance, 2),
+            'building_type': building_type,
+            'occupancy': occupancy
+        })
+    
+    return pd.DataFrame(buildings)
+
+def compute_damage_probabilities(distance, building_type, magnitude, alpha_params):
+    magnitude_scale = (magnitude - 5.0) / 3.0
+    magnitude_scale = max(0.1, min(magnitude_scale, 2.0))
+    
+    base_damage = np.exp(-distance / (15.0 * magnitude_scale))
+    
+    alpha = alpha_params[building_type]
+    
+    p_collapse = alpha * base_damage * 0.30 * magnitude_scale
+    p_severe = alpha * base_damage * 0.25 * magnitude_scale
+    p_minor = alpha * base_damage * 0.20 * magnitude_scale
+    
+    total = p_collapse + p_severe + p_minor
+    if total > 0.95:
+        scale = 0.95 / total
+        p_collapse *= scale
+        p_severe *= scale
+        p_minor *= scale
+    
+    p_none = 1 - (p_collapse + p_severe + p_minor)
+    
+    return np.array([p_none, p_minor, p_severe, p_collapse])
+
+def simulate_damage(buildings_df, magnitude, alpha_params, seed=42):
+    np.random.seed(seed)
+    
+    buildings = buildings_df.copy()
+    
+    for idx, building in buildings.iterrows():
+        probs = compute_damage_probabilities(
+            building['distance_km'],
+            building['building_type'],
+            magnitude,
+            alpha_params
+        )
+        
+        damage_state = np.random.choice(DAMAGE_STATES, p=probs)
+        
+        buildings.at[idx, 'true_damage'] = damage_state
+        buildings.at[idx, 'p_none'] = round(probs[0], 4)
+        buildings.at[idx, 'p_minor'] = round(probs[1], 4)
+        buildings.at[idx, 'p_severe'] = round(probs[2], 4)
+        buildings.at[idx, 'p_collapse'] = round(probs[3], 4)
+    
+    return buildings
+
+def create_scenario(n_buildings=100, diameter_km=40, magnitude=6.5, 
+                   alpha_params=None, seed=42):
+    if alpha_params is None:
+        alpha_params = {'wood': 1.5, 'concrete': 1.0, 'steel': 0.7}
+    
+    buildings = generate_buildings(n_buildings, diameter_km, seed)
+    scenario = simulate_damage(buildings, magnitude, alpha_params, seed)
+    
+    return scenario

generate_reports.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pandas as pd
+
+DAMAGE_STATES = ['none', 'minor', 'severe', 'collapse']
+
+REPORT_SOURCES = {
+    'automated_sensor': {'reliability': 0.85, 'weight': 0.25},
+    'phone_call': {'reliability': 0.60, 'weight': 0.50},
+    'social_media': {'reliability': 0.40, 'weight': 0.20},
+    'inspector': {'reliability': 0.95, 'weight': 0.05}
+}
+
+def generate_noisy_report(true_state, reliability):
+    if np.random.random() < reliability:
+        return true_state
+    
+    other_states = [s for s in DAMAGE_STATES if s != true_state]
+    true_idx = DAMAGE_STATES.index(true_state)
+    
+    weights = []
+    for state in other_states:
+        state_idx = DAMAGE_STATES.index(state)
+        distance = abs(state_idx - true_idx)
+        weight = 1.0 / (distance + 1)
+        weights.append(weight)
+    
+    weights = np.array(weights) / sum(weights)
+    return np.random.choice(other_states, p=weights)
+
+def generate_building_reports(building, lambda_rates, max_time_hours=3, seed=None):
+    if seed is not None:
+        np.random.seed(seed)
+    
+    true_damage = building['true_damage']
+    lambda_rate = lambda_rates[true_damage]
+    
+    reports = []
+    current_time = 0
+    max_time_minutes = max_time_hours * 60
+    
+    while current_time < max_time_minutes:
+        lambda_per_minute = lambda_rate / 60.0
+        time_to_next = np.random.exponential(1.0 / lambda_per_minute)
+        current_time += time_to_next
+        
+        if current_time >= max_time_minutes:
+            break
+        
+        source_types = list(REPORT_SOURCES.keys())
+        source_weights = [REPORT_SOURCES[s]['weight'] for s in source_types]
+        source = np.random.choice(source_types, p=source_weights)
+        
+        reliability = REPORT_SOURCES[source]['reliability']
+        reported_state = generate_noisy_report(true_damage, reliability)
+        
+        reports.append({
+            'time_minutes': round(current_time, 2),
+            'source': source,
+            'reported_state': reported_state,
+            'building_id': building['building_id'],
+            'building_type': building['building_type'],
+            'true_damage': building['true_damage']
+        })
+    
+    return reports
+
+def generate_all_reports(buildings_df, lambda_rates=None, max_time_hours=3, seed=42):
+    if lambda_rates is None:
+        lambda_rates = {
+            'collapse': 8.0,
+            'severe': 3.0,
+            'minor': 0.8,
+            'none': 0.2
+        }
+    
+    np.random.seed(seed)
+    all_reports = []
+    
+    for idx, building in buildings_df.iterrows():
+        building_seed = seed + idx if seed is not None else None
+        reports = generate_building_reports(
+            building.to_dict(), 
+            lambda_rates, 
+            max_time_hours,
+            building_seed
+        )
+        all_reports.extend(reports)
+    
+    reports_df = pd.DataFrame(all_reports)
+    if len(reports_df) > 0:
+        reports_df = reports_df.sort_values('time_minutes').reset_index(drop=True)
+    
+    return reports_df
+
+def get_report_reliability(source):
+    return REPORT_SOURCES[source]['reliability']

requirements.txt

@@ -0,0 +1,124 @@
+altair==5.4.1
+annotated-types==0.7.0
+anyio==3.7.1
+asyncio==3.4.3
+attrs==24.2.0
+beautifulsoup4==4.13.4
+blinker==1.8.2
+cachetools==5.5.0
+certifi==2024.8.30
+charset-normalizer==3.3.2
+click==8.1.7
+contourpy==1.3.2
+cycler==0.12.1
+distlib==0.3.9
+distro==1.9.0
+dotenv==0.9.9
+exceptiongroup==1.2.2
+fastapi==0.104.1
+filelock==3.18.0
+fonttools==4.60.1
+fsspec==2025.5.1
+gitdb==4.0.11
+GitPython==3.1.43
+google==3.0.0
+google-ai-generativelanguage==0.6.10
+google-api-core==2.20.0
+google-api-python-client==2.148.0
+google-auth==2.35.0
+google-auth-httplib2==0.2.0
+google-auth-oauthlib==1.2.1
+google-generativeai==0.8.3
+google_search_results==2.4.2
+googleapis-common-protos==1.65.0
+greenlet==3.2.1
+grpcio==1.66.2
+grpcio-status==1.66.2
+gspread==6.1.4
+h11==0.14.0
+hf-xet==1.1.5
+httpcore==1.0.7
+httplib2==0.22.0
+httpx==0.28.1
+httpx-sse==0.4.1
+huggingface-hub==0.33.2
+idna==3.10
+Jinja2==3.1.2
+jiter==0.9.0
+joblib==1.5.1
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+kiwisolver==1.4.9
+mangum==0.19.0
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.7
+mcp==1.12.4
+mdurl==0.1.2
+mpmath==1.3.0
+narwhals==2.12.0
+networkx==3.4.2
+numpy==2.1.2
+oauth2client==4.1.3
+oauthlib==3.2.2
+openai==1.3.5
+packaging==24.1
+pandas==2.2.3
+pillow==10.4.0
+platformdirs==4.3.8
+playwright==1.52.0
+plotly==6.5.0
+proto-plus==1.24.0
+protobuf==5.28.2
+pyarrow==17.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pydantic==2.5.0
+pydantic-settings==2.10.1
+pydantic_core==2.14.1
+pydeck==0.9.1
+pyee==13.0.0
+Pygments==2.18.0
+pyparsing==3.1.4
+PyPDF2==3.0.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.0.0
+python-multipart==0.0.6
+pytz==2024.2
+PyYAML==6.0.2
+referencing==0.35.1
+regex==2024.11.6
+requests==2.32.3
+requests-oauthlib==2.0.0
+rich==13.9.2
+rpds-py==0.20.0
+rsa==4.9
+safetensors==0.5.3
+scikit-learn==1.7.0
+scipy==1.15.3
+seaborn==0.13.2
+sentence-transformers==5.0.0
+six==1.16.0
+smmap==5.0.1
+sniffio==1.3.1
+soupsieve==2.7
+sse-starlette==3.0.2
+starlette==0.27.0
+streamlit==1.39.0
+sympy==1.14.0
+tenacity==9.0.0
+threadpoolctl==3.6.0
+tiktoken==0.9.0
+tokenizers==0.21.2
+toml==0.10.2
+torch==2.7.1
+tornado==6.4.1
+tqdm==4.66.5
+transformers==4.53.1
+typing-inspection==0.4.1
+typing_extensions==4.12.2
+tzdata==2024.2
+uritemplate==4.1.1
+urllib3==2.2.3
+uvicorn==0.24.0
+virtualenv==20.31.2

streamlit_app.py

@@ -0,0 +1,412 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from generate_eq import create_scenario
+from generate_reports import generate_all_reports
+from update_bayesian import run_inference, compute_decision_metrics
+
+st.set_page_config(layout="wide", page_title="Earthquake Response Simulator", page_icon="🌍")
+
+st.title("Bayesian Earthquake Response Simulator")
+st.markdown("Design your own earthquake scenario and watch Bayesian inference optimize rescue decisions")
+
+with st.sidebar:
+    st.header("Scenario Configuration")
+    
+    st.subheader("Earthquake Parameters")
+    magnitude = st.slider("Magnitude (Richter)", 5.0, 8.0, 6.5, 0.1,
+                         help="Higher magnitude = more energy, wider damage radius")
+    diameter = st.slider("Affected Area Diameter (km)", 10, 100, 40, 5)
+    n_buildings = st.slider("Number of Buildings", 20, 2000, 100, 10,
+                           help="More buildings = more realistic but slower computation")
+    n_teams = st.slider("Rescue Teams Available", 1, 50, 5, 1)
+    
+    st.subheader("Building Vulnerability")
+    with st.expander("Advanced: Vulnerability Parameters"):
+        alpha_wood = st.slider("Wood Buildings (α)", 0.5, 2.5, 1.5, 0.1)
+        alpha_concrete = st.slider("Concrete Buildings (α)", 0.5, 2.5, 1.0, 0.1)
+        alpha_steel = st.slider("Steel Buildings (α)", 0.5, 2.5, 0.7, 0.1)
+    
+    st.subheader("Report Arrival Rates")
+    with st.expander("Advanced: Poisson Rates (per hour)"):
+        lambda_collapse = st.slider("Collapsed Buildings", 1.0, 15.0, 8.0, 0.5)
+        lambda_severe = st.slider("Severe Damage", 0.5, 8.0, 3.0, 0.5)
+        lambda_minor = st.slider("Minor Damage", 0.1, 3.0, 0.8, 0.1)
+        lambda_none = st.slider("No Damage", 0.05, 1.0, 0.2, 0.05)
+    
+    st.divider()
+    
+    sim_seed = st.number_input("Random Seed", 0, 9999, 42, 1)
+    
+    if st.button("Generate New Scenario", type="primary"):
+        st.session_state.clear()
+        st.rerun()
+
+alpha_params = {'wood': alpha_wood, 'concrete': alpha_concrete, 'steel': alpha_steel}
+lambda_rates = {'collapse': lambda_collapse, 'severe': lambda_severe, 'minor': lambda_minor, 'none': lambda_none}
+
+if 'scenario' not in st.session_state:
+    with st.spinner("Generating earthquake scenario..."):
+        st.session_state.scenario = create_scenario(
+            n_buildings=n_buildings,
+            diameter_km=diameter,
+            magnitude=magnitude,
+            alpha_params=alpha_params,
+            seed=sim_seed
+        )
+        st.session_state.reports = generate_all_reports(
+            st.session_state.scenario,
+            lambda_rates=lambda_rates,
+            max_time_hours=3,
+            seed=sim_seed
+        )
+        st.session_state.beliefs = run_inference(
+            st.session_state.scenario,
+            st.session_state.reports
+        )
+        st.session_state.metrics = compute_decision_metrics(
+            st.session_state.scenario,
+            st.session_state.beliefs,
+            n_teams
+        )
+
+scenario = st.session_state.scenario
+reports = st.session_state.reports
+beliefs = st.session_state.beliefs
+metrics = st.session_state.metrics
+
+tab1, tab2, tab3 = st.tabs(["Live Simulation", "Building Analysis", "Results & Impact"])
+
+with tab1:
+
+    # --- Create placeholders so we control layout order ---
+    metrics_placeholder = st.empty()
+    st.divider()
+    slider_placeholder = st.empty()
+
+    # --- SLIDER RENDERED BELOW METRICS ---
+    with slider_placeholder:
+        current_time = st.slider(
+            "Simulation Time (minutes)",
+            min_value=0.0,
+            max_value=180.0,
+            value=0.0,
+            step=1.0,
+            help="Slide to watch how beliefs update as reports arrive over time"
+        )
+
+    # --- Now compute everything based on current_time ---
+    current_reports = reports[reports['time_minutes'] <= current_time]
+    num_current_reports = len(current_reports)
+
+    buildings_reported = current_reports['building_id'].nunique()
+
+    if num_current_reports > 0:
+        buildings_with_reports = current_reports['building_id'].unique()
+        current_beliefs_subset = beliefs[beliefs['building_id'].isin(buildings_with_reports)]
+        avg_entropy = current_beliefs_subset['entropy'].mean()
+    else:
+        avg_entropy = None
+
+    # --- RENDER METRICS ABOVE SLIDER ---
+    with metrics_placeholder.container():
+        col2, col3, col4 = st.columns(3)
+
+        with col2:
+            st.metric("Reports Received", num_current_reports)
+
+        with col3:
+            st.metric("Buildings Reported", buildings_reported)
+
+        with col4:
+            if avg_entropy is not None:
+                st.metric("Avg Uncertainty", f"{avg_entropy:.2f}",
+                          help="0 = certain, 2 = maximum uncertainty")
+            else:
+                st.metric("Avg Uncertainty", "—")
+
+    
+    from update_bayesian import bayesian_update
+    from generate_reports import get_report_reliability
+    
+    beliefs_at_time = []
+    for _, building in scenario.iterrows():
+        prior = np.array([
+            building['p_none'],
+            building['p_minor'],
+            building['p_severe'],
+            building['p_collapse']
+        ])
+        
+        building_reports = current_reports[current_reports['building_id'] == building['building_id']]
+        current_belief = prior.copy()
+        
+        for _, report in building_reports.iterrows():
+            reliability = get_report_reliability(report['source'])
+            current_belief = bayesian_update(current_belief, report['reported_state'], reliability)
+        
+        beliefs_at_time.append({
+            'building_id': building['building_id'],
+            'p_collapse_current': current_belief[3],
+            'has_reports': len(building_reports) > 0
+        })
+    
+    beliefs_current_df = pd.DataFrame(beliefs_at_time)
+    
+    map_data = scenario[['building_id', 'x', 'y', 'distance_km', 'building_type', 'occupancy', 'true_damage']].merge(
+        beliefs_current_df,
+        on='building_id'
+    )
+    
+    fig_map = px.scatter(
+        map_data,
+        x='x',
+        y='y',
+        size='occupancy',
+        color='p_collapse_current',
+        color_continuous_scale='RdYlGn_r',
+        range_color=[0, 1],
+        hover_data={
+            'building_id': True,
+            'building_type': True,
+            'distance_km': ':.1f',
+            'occupancy': True,
+            'p_collapse_current': ':.3f',
+            'true_damage': True,
+            'has_reports': True,
+            'x': False,
+            'y': False
+        },
+        labels={'p_collapse_current': 'P(Collapse)', 'has_reports': 'Received Reports'},
+        title=f"Building Risk Assessment at t={int(current_time)} minutes"
+    )
+    
+    fig_map.add_trace(go.Scatter(
+        x=[0], y=[0],
+        mode='markers+text',
+        marker=dict(size=20, color='red', symbol='star'),
+        text=['Epicenter'],
+        textposition='top center',
+        showlegend=False,
+        hoverinfo='skip'
+    ))
+    
+    for radius in [5, 10, 15, 20]:
+        if radius < diameter / 2:
+            theta = np.linspace(0, 2*np.pi, 100)
+            x_circle = radius * np.cos(theta)
+            y_circle = radius * np.sin(theta)
+            fig_map.add_trace(go.Scatter(
+                x=x_circle, y=y_circle,
+                mode='lines',
+                line=dict(color='gray', width=1, dash='dash'),
+                showlegend=False,
+                hoverinfo='skip'
+            ))
+    
+    fig_map.update_layout(
+        height=600,
+        xaxis_title="Distance East-West (km)",
+        yaxis_title="Distance North-South (km)",
+        xaxis=dict(scaleanchor="y", scaleratio=1),
+        yaxis=dict(scaleanchor="x", scaleratio=1)
+    )
+    
+    st.plotly_chart(fig_map, use_container_width=True)
+    
+    if num_current_reports > 0:
+        with st.expander("Recent Reports", expanded=False):
+            recent = current_reports.nsmallest(10, 'time_minutes', keep='last')
+            recent = recent.sort_values('time_minutes', ascending=False)
+            
+            for _, report in recent.iterrows():
+                st.text(
+                    f"t={report['time_minutes']:6.1f}m | "
+                    f"Building {report['building_id']:3.0f} | "
+                    f"{report['source']:20s} | "
+                    f"Reports: {report['reported_state']:8s} | "
+                    f"True: {report['true_damage']}"
+                )
+    else:
+        st.info("Move the time slider forward to see reports arrive...")
+
+with tab2:
+    buildings_with_reports = reports['building_id'].unique()
+    
+    if len(buildings_with_reports) > 0:
+        selected_building = st.selectbox(
+            "Select Building",
+            buildings_with_reports,
+            format_func=lambda x: f"Building {x}"
+        )
+        
+        building_info = scenario[scenario['building_id'] == selected_building].iloc[0]
+        building_beliefs = beliefs[beliefs['building_id'] == selected_building].iloc[0]
+        building_reports = reports[reports['building_id'] == selected_building]
+        
+        col1, col2 = st.columns([1, 2])
+        
+        with col1:
+            st.subheader("Building Information")
+            st.metric("Type", building_info['building_type'].title())
+            st.metric("Distance", f"{building_info['distance_km']:.1f} km")
+            st.metric("Occupancy", f"{building_info['occupancy']} people")
+            st.metric("True Damage", building_info['true_damage'].title())
+            
+            st.divider()
+            
+            st.subheader("Inference Results")
+            st.metric(
+                "P(Collapse)", 
+                f"{building_beliefs['p_collapse']:.3f}",
+                help=f"95% CI: [{building_beliefs['p_collapse_ci_lower']:.3f}, {building_beliefs['p_collapse_ci_upper']:.3f}]"
+            )
+            ci_width = building_beliefs['p_collapse_ci_upper'] - building_beliefs['p_collapse_ci_lower']
+            st.metric("Std Dev", f"{building_beliefs['p_collapse_std']:.3f}")
+        
+            st.metric("Entropy", f"{building_beliefs['entropy']:.2f}")
+            st.metric("Reports Received", int(building_beliefs['num_reports']))
+        
+        with col2:
+            st.subheader("Belief Evolution")
+            
+            prior = np.array([
+                building_info['p_none'],
+                building_info['p_minor'],
+                building_info['p_severe'],
+                building_info['p_collapse']
+            ])
+            
+            evolution = [{'time': 0, 'p_collapse': prior[3], 'event': 'Prior'}]
+            current = prior.copy()
+            
+            from update_bayesian import bayesian_update
+            from generate_reports import get_report_reliability
+            
+            for _, report in building_reports.iterrows():
+                reliability = get_report_reliability(report['source'])
+                current = bayesian_update(current, report['reported_state'], reliability)
+                evolution.append({
+                    'time': report['time_minutes'],
+                    'p_collapse': current[3],
+                    'event': f"{report['source']}: {report['reported_state']}"
+                })
+            
+            evolution_df = pd.DataFrame(evolution)
+            
+            fig_evolution = go.Figure()
+            
+            fig_evolution.add_trace(go.Scatter(
+                x=evolution_df['time'],
+                y=evolution_df['p_collapse'],
+                mode='lines+markers',
+                name='P(Collapse)',
+                line=dict(color='red', width=3),
+                hovertemplate='%{text}<br>P(Collapse): %{y:.3f}<extra></extra>',
+                text=evolution_df['event']
+            ))
+            
+            fig_evolution.add_hline(
+                y=building_beliefs['p_collapse_ci_lower'],
+                line_dash="dash",
+                line_color="gray",
+                annotation_text="95% CI Lower"
+            )
+            
+            fig_evolution.add_hline(
+                y=building_beliefs['p_collapse_ci_upper'],
+                line_dash="dash",
+                line_color="gray",
+                annotation_text="95% CI Upper"
+            )
+            
+            fig_evolution.update_layout(
+                title=f"Building {selected_building} - Belief Updates Over Time",
+                xaxis_title="Time (minutes)",
+                yaxis_title="P(Collapse)",
+                yaxis=dict(range=[0, 1]),
+                height=400
+            )
+            
+            st.plotly_chart(fig_evolution, use_container_width=True)
+            
+            st.subheader("Report Timeline")
+            for _, report in building_reports.iterrows():
+                reliability = get_report_reliability(report['source'])
+                st.text(
+                    f"t={report['time_minutes']:6.1f}m | "
+                    f"{report['source']:20s} ({reliability:.0%}) | "
+                    f"Reports: {report['reported_state']:8s} | "
+                    f"True: {report['true_damage']}"
+                )
+    else:
+        st.info("No buildings received reports in this simulation. Try increasing Poisson rates.")
+
+with tab3:
+    st.header("Decision Quality Comparison")
+    
+    improvement = metrics['improvement']
+    improvement_pct = metrics['improvement_pct']
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric(
+            "Naive Approach",
+            f"{metrics['naive_lives_saved']} people",
+            help="Using only distance-based priors"
+        )
+    
+    with col2:
+        st.metric(
+            "Bayesian Approach",
+            f"{metrics['bayesian_lives_saved']} people",
+            delta=f"+{improvement}",
+            help="Using updated posterior beliefs"
+        )
+    
+    with col3:
+        st.metric(
+            "Improvement",
+            f"{improvement_pct:.1f}%",
+            delta=f"+{improvement} lives"
+        )
+    
+    st.divider()
+    
+    if improvement > 0:
+        st.success(
+            f"By incorporating uncertain information via Bayesian inference, "
+            f"we can reach {improvement} more people ({improvement_pct:.1f}% improvement) "
+            f"with the same {n_teams} rescue teams."
+        )
+    elif improvement < 0:
+        st.warning(
+            f"In this scenario, the naive approach performed slightly better. "
+            f"This can happen when reports are very noisy or when the prior is already well-calibrated."
+        )
+    else:
+        st.info("Both approaches performed equally in this scenario.")
+    
+    st.subheader("Performance Metrics")
+    
+    map_data_full = scenario.merge(beliefs, on='building_id', suffixes=('_prior', '_posterior'))
+    
+    buildings_with_reports = reports['building_id'].unique()
+    comparison = map_data_full[map_data_full['building_id'].isin(buildings_with_reports)].copy()
+    
+    if len(comparison) > 0:
+        comparison['true_collapsed'] = (comparison['true_damage'] == 'collapse').astype(int)
+        comparison['naive_pred'] = (comparison['p_collapse_prior'] > 0.5).astype(int)
+        comparison['bayesian_pred'] = (comparison['p_collapse_posterior'] > 0.5).astype(int)
+        
+        naive_acc = (comparison['true_collapsed'] == comparison['naive_pred']).mean()
+        bayesian_acc = (comparison['true_collapsed'] == comparison['bayesian_pred']).mean()
+    
+        
+        st.metric("Naive Accuracy", f"{naive_acc:.1%}")
+        st.metric("Bayesian Accuracy", f"{bayesian_acc:.1%}", delta=f"{bayesian_acc - naive_acc:+.1%}")
+
+st.divider()

update_bayesian.py

@@ -0,0 +1,163 @@
+import numpy as np
+import pandas as pd
+from generate_reports import get_report_reliability
+
+DAMAGE_STATES = ['none', 'minor', 'severe', 'collapse']
+
+def compute_likelihood(reported_state, true_state, reliability):
+    if reported_state == true_state:
+        return reliability
+    
+    reported_idx = DAMAGE_STATES.index(reported_state)
+    true_idx = DAMAGE_STATES.index(true_state)
+    distance = abs(reported_idx - true_idx)
+    
+    base_error_prob = (1 - reliability) / 3.0
+    
+    if distance == 1:
+        return base_error_prob * 2.0
+    elif distance == 2:
+        return base_error_prob * 1.0
+    else:
+        return base_error_prob * 0.5
+
+def bayesian_update(prior, reported_state, reliability):
+    likelihood = np.array([
+        compute_likelihood(reported_state, state, reliability)
+        for state in DAMAGE_STATES
+    ])
+    
+    numerator = likelihood * prior
+    denominator = np.sum(numerator)
+    
+    if denominator < 1e-10:
+        return prior
+    
+    posterior = numerator / denominator
+    return posterior
+
+def entropy(probs):
+    probs = np.array(probs)
+    probs = probs[probs > 0]
+    return -np.sum(probs * np.log2(probs))
+
+def bootstrap_beliefs(reports, prior, n_bootstrap=100):
+    if len(reports) == 0:
+        return {
+            'mean': prior,
+            'std_dev': np.zeros_like(prior)
+        }
+    
+    bootstrap_posteriors = []
+    
+    for _ in range(n_bootstrap):
+        resampled_reports = [reports[i] for i in np.random.choice(
+            len(reports), size=len(reports), replace=True
+        )]
+        
+        belief = prior.copy()
+        for report in resampled_reports:
+            reliability = get_report_reliability(report['source'])
+            belief = bayesian_update(belief, report['reported_state'], reliability)
+        
+        bootstrap_posteriors.append(belief)
+    
+    bootstrap_posteriors = np.array(bootstrap_posteriors)
+    
+    return {
+        'mean': np.mean(bootstrap_posteriors, axis=0),
+        'std_dev': np.std(bootstrap_posteriors, axis=0) 
+    }
+
+def process_building(building, all_reports, prior):
+    building_id = building['building_id']
+    building_reports = all_reports[all_reports['building_id'] == building_id]
+    building_reports = building_reports.sort_values('time_minutes')
+    
+    current_belief = prior.copy()
+    report_list = []
+    
+    for _, report in building_reports.iterrows():
+        reliability = get_report_reliability(report['source'])
+        current_belief = bayesian_update(
+            current_belief, 
+            report['reported_state'], 
+            reliability
+        )
+        report_list.append(report.to_dict())
+    
+    bootstrap_result = bootstrap_beliefs(report_list, prior, n_bootstrap=50)
+    
+    return {
+        'building_id': building_id,
+        'p_none': current_belief[0],
+        'p_minor': current_belief[1],
+        'p_severe': current_belief[2],
+        'p_collapse': current_belief[3],
+        'entropy': entropy(current_belief),
+        'num_reports': len(building_reports)
+    }
+
+def run_inference(buildings_df, reports_df, n_samples=5000):
+    results = []
+
+    for _, building in buildings_df.iterrows():
+        prior = np.array([
+            building['p_none'],
+            building['p_minor'],
+            building['p_severe'],
+            building['p_collapse']
+        ])
+
+        result = process_building(building, reports_df, prior)
+
+        # Normalize posterior before sampling
+        posterior = np.array([
+            result['p_none'],
+            result['p_minor'],
+            result['p_severe'],
+            result['p_collapse']
+        ])
+        posterior = posterior / posterior.sum()  
+
+        samples = np.random.choice([0,1,2,3], size=n_samples, p=posterior)
+        collapse_samples = (samples == 3).astype(float)
+        result['p_collapse_std'] = collapse_samples.std()
+
+        results.append(result)
+
+    return pd.DataFrame(results)
+
+
+def compute_decision_metrics(buildings_df, beliefs_df, n_teams):
+    merged = buildings_df[['building_id', 'true_damage', 'occupancy', 'p_none', 'p_minor', 'p_severe', 'p_collapse']].merge(
+        beliefs_df[['building_id', 'p_none', 'p_minor', 'p_severe', 'p_collapse']],
+        on='building_id',
+        suffixes=('_prior', '_posterior')
+    )
+    
+    merged['at_risk_true'] = merged.apply(lambda row: {
+        'collapse': 0.9 * row['occupancy'],
+        'severe': 0.4 * row['occupancy'],
+        'minor': 0.05 * row['occupancy'],
+        'none': 0
+    }[row['true_damage']], axis=1)
+    
+    merged['expected_at_risk'] = (
+        merged['p_collapse_posterior'] * 0.9 * merged['occupancy'] +
+        merged['p_severe_posterior'] * 0.4 * merged['occupancy'] +
+        merged['p_minor_posterior'] * 0.05 * merged['occupancy']
+    )
+    
+    bayesian_top = merged.nlargest(n_teams, 'expected_at_risk')
+    bayesian_saved = bayesian_top['at_risk_true'].sum()
+    
+    naive_top = merged.nlargest(n_teams, 'p_collapse_prior')
+    naive_saved = naive_top['at_risk_true'].sum()
+    
+    return {
+        'bayesian_lives_saved': int(bayesian_saved),
+        'naive_lives_saved': int(naive_saved),
+        'improvement': int(bayesian_saved - naive_saved),
+        'improvement_pct': (bayesian_saved - naive_saved) / naive_saved * 100 if naive_saved > 0 else 0
+    }