Create app.py

app.py

@@ -0,0 +1,611 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.metrics import mean_squared_error, r2_score
+import joblib
+import os
+
+# Generate synthetic dataset for beam behavior prediction
+def generate_beam_dataset(n_samples=1000):
+    np.random.seed(42)
+    
+    # Generate random beam configurations
+    lengths = np.random.uniform(1, 20, n_samples)
+    
+    # Generate 1-3 random point loads for each beam
+    point_loads_data = []
+    for i in range(n_samples):
+        n_loads = np.random.randint(1, 4)
+        loads = []
+        for _ in range(n_loads):
+            pos = np.random.uniform(0, lengths[i])
+            magnitude = np.random.uniform(-10000, 10000)
+            loads.append((pos, magnitude))
+        point_loads_data.append(loads)
+    
+    # Generate random UDL parameters
+    udl_starts = np.random.uniform(0, lengths * 0.4, n_samples)
+    udl_lengths = np.random.uniform(1, lengths * 0.6, n_samples)
+    udl_ends = np.minimum(udl_starts + udl_lengths, lengths)
+    udl_values = np.random.uniform(-5000, 5000, n_samples)
+    
+    # Calculate features for ML
+    features = []
+    max_sfd = []
+    max_bmd = []
+    
+    for i in range(n_samples):
+        # Calculate beam characteristics
+        length = lengths[i]
+        point_loads = point_loads_data[i]
+        udl_start = udl_starts[i]
+        udl_end = udl_ends[i]
+        udl_value = udl_values[i]
+        
+        # Calculate SFD and BMD
+        x = np.linspace(0, length, 100)
+        shear_force = np.zeros_like(x)
+        bending_moment = np.zeros_like(x)
+        
+        # Apply point loads
+        for pos, load in point_loads:
+            shear_force[x >= pos] += load
+            
+        # Apply UDL
+        for j, xi in enumerate(x):
+            if udl_start <= xi <= udl_end:
+                for k in range(j, len(x)):
+                    shear_force[k] += udl_value * (min(x[k], udl_end) - max(xi, udl_start))
+        
+        # Compute Bending Moment by integrating shear force
+        for j in range(1, len(x)):
+            bending_moment[j] = bending_moment[j-1] + shear_force[j-1] * (x[j] - x[j-1])
+        
+        # Extract features
+        num_loads = len(point_loads)
+        total_point_load = sum(load for _, load in point_loads)
+        avg_load_position = sum(pos*load for pos, load in point_loads) / max(1, abs(total_point_load)) if total_point_load != 0 else 0
+        udl_coverage = (udl_end - udl_start) / length if length > 0 else 0
+        total_udl_force = udl_value * (udl_end - udl_start)
+        
+        features.append([
+            length, 
+            num_loads,
+            total_point_load, 
+            avg_load_position,
+            udl_start,
+            udl_end,
+            udl_value,
+            udl_coverage,
+            total_udl_force
+        ])
+        
+        max_sfd.append(np.max(np.abs(shear_force)))
+        max_bmd.append(np.max(np.abs(bending_moment)))
+    
+    # Create dataframe
+    feature_cols = [
+        'beam_length',
+        'num_point_loads',
+        'total_point_load',
+        'avg_load_position',
+        'udl_start',
+        'udl_end',
+        'udl_value',
+        'udl_coverage',
+        'total_udl_force'
+    ]
+    
+    X_df = pd.DataFrame(features, columns=feature_cols)
+    y_df = pd.DataFrame({
+        'max_shear_force': max_sfd,
+        'max_bending_moment': max_bmd
+    })
+    
+    # Combine into a single dataset
+    dataset = pd.concat([X_df, y_df], axis=1)
+    
+    return dataset, X_df.columns, y_df.columns
+
+# ML Model Training Function
+def train_beam_ml_models(dataset):
+    # Split features and targets
+    X = dataset.iloc[:, :9]  # First 9 columns are features
+    y_sfd = dataset['max_shear_force']
+    y_bmd = dataset['max_bending_moment']
+    
+    # Split into training and testing sets
+    X_train, X_test, y_sfd_train, y_sfd_test = train_test_split(X, y_sfd, test_size=0.2, random_state=42)
+    _, _, y_bmd_train, y_bmd_test = train_test_split(X, y_bmd, test_size=0.2, random_state=42)
+    
+    # Train SFD model
+    sfd_model = RandomForestRegressor(n_estimators=100, random_state=42)
+    sfd_model.fit(X_train, y_sfd_train)
+    
+    # Train BMD model
+    bmd_model = RandomForestRegressor(n_estimators=100, random_state=42)
+    bmd_model.fit(X_train, y_bmd_train)
+    
+    # Evaluate models
+    sfd_preds = sfd_model.predict(X_test)
+    bmd_preds = bmd_model.predict(X_test)
+    
+    sfd_rmse = np.sqrt(mean_squared_error(y_sfd_test, sfd_preds))
+    bmd_rmse = np.sqrt(mean_squared_error(y_bmd_test, bmd_preds))
+    
+    sfd_r2 = r2_score(y_sfd_test, sfd_preds)
+    bmd_r2 = r2_score(y_bmd_test, bmd_preds)
+    
+    # Save models
+    joblib.dump(sfd_model, 'sfd_model.pkl')
+    joblib.dump(bmd_model, 'bmd_model.pkl')
+    
+    return {
+        'sfd_model': sfd_model,
+        'bmd_model': bmd_model,
+        'metrics': {
+            'sfd_rmse': sfd_rmse,
+            'bmd_rmse': bmd_rmse,
+            'sfd_r2': sfd_r2,
+            'bmd_r2': bmd_r2
+        }
+    }
+
+# Improved calculation function using exact integrals
+def calculate_sfd_bmd(length, point_loads, udl_start, udl_end, udl_value):
+    x = np.linspace(0, length, 200)
+    shear_force = np.zeros_like(x)
+    bending_moment = np.zeros_like(x)
+    
+    # Apply point loads (corrected)
+    for pos, load in point_loads:
+        shear_force[x >= pos] += load
+        
+        # Calculate bending moment directly for point loads
+        for i, xi in enumerate(x):
+            if xi >= pos:
+                bending_moment[i] += load * (xi - pos)
+    
+    # Apply UDL (corrected calculation)
+    udl_length = udl_end - udl_start
+    if udl_length > 0 and udl_value != 0:
+        for i, xi in enumerate(x):
+            # Shear force at point xi due to UDL
+            if xi <= udl_start:
+                # Before UDL: no contribution
+                pass
+            elif xi >= udl_end:
+                # After UDL: full contribution
+                shear_force[i] += udl_value * udl_length
+            else:
+                # Within UDL region: partial contribution
+                shear_force[i] += udl_value * (xi - udl_start)
+                
+            # Bending moment calculations for UDL
+            if xi <= udl_start:
+                # No contribution before UDL
+                pass
+            elif xi >= udl_end:
+                # Full contribution after UDL
+                centroid_distance = xi - (udl_start + udl_end)/2
+                bending_moment[i] += udl_value * udl_length * centroid_distance
+            else:
+                # Partial contribution within UDL
+                partial_length = xi - udl_start
+                centroid_distance = partial_length/2
+                bending_moment[i] += udl_value * partial_length * centroid_distance
+    
+    return x, shear_force, bending_moment
+
+# AI Agent for beam analysis and optimization
+class BeamAnalysisAgent:
+    def __init__(self):
+        # Initialize models
+        if os.path.exists('sfd_model.pkl') and os.path.exists('bmd_model.pkl'):
+            self.sfd_model = joblib.load('sfd_model.pkl')
+            self.bmd_model = joblib.load('bmd_model.pkl')
+            self.models_loaded = True
+        else:
+            print("Training new ML models...")
+            dataset, _, _ = generate_beam_dataset(1000)
+            model_data = train_beam_ml_models(dataset)
+            self.sfd_model = model_data['sfd_model']
+            self.bmd_model = model_data['bmd_model']
+            self.models_loaded = True
+            print(f"ML models trained. Metrics: {model_data['metrics']}")
+    
+    def analyze_beam(self, length, point_loads, udl_start, udl_end, udl_value):
+        # Calculate exact SFD and BMD
+        x, shear_force, bending_moment = calculate_sfd_bmd(length, point_loads, udl_start, udl_end, udl_value)
+        
+        # Extract feature vector for ML prediction
+        num_loads = len(point_loads)
+        total_point_load = sum(load for _, load in point_loads) if point_loads else 0
+        avg_load_position = sum(pos*load for pos, load in point_loads) / max(1, abs(total_point_load)) if point_loads and total_point_load != 0 else 0
+        udl_coverage = (udl_end - udl_start) / length if length > 0 else 0
+        total_udl_force = udl_value * (udl_end - udl_start)
+        
+        feature_vector = np.array([[
+            length, 
+            num_loads,
+            total_point_load, 
+            avg_load_position,
+            udl_start,
+            udl_end,
+            udl_value,
+            udl_coverage,
+            total_udl_force
+        ]])
+        
+        # Make predictions
+        if self.models_loaded:
+            predicted_max_sfd = self.sfd_model.predict(feature_vector)[0]
+            predicted_max_bmd = self.bmd_model.predict(feature_vector)[0]
+        else:
+            predicted_max_sfd = np.max(np.abs(shear_force))
+            predicted_max_bmd = np.max(np.abs(bending_moment))
+        
+        # Calculate actual maximum values
+        actual_max_sfd = np.max(np.abs(shear_force))
+        actual_max_bmd = np.max(np.abs(bending_moment))
+        
+        # Identify critical points
+        sfd_critical_idx = np.argmin(np.abs(shear_force))
+        sfd_critical_point = x[sfd_critical_idx]
+        bmd_max_idx = np.argmax(np.abs(bending_moment))
+        bmd_max_point = x[bmd_max_idx]
+        
+        # Generate visualizations
+        fig, axs = plt.subplots(2, 1, figsize=(10, 12))
+        
+        # Plot beam with loads
+        beam_ax = plt.subplot2grid((3, 1), (0, 0), fig=fig)
+        beam_ax.plot([0, length], [0, 0], 'k-', linewidth=3)  # Beam
+        beam_ax.set_ylim(-1, 1)
+        
+        # Draw point loads
+        for pos, load in point_loads:
+            if load > 0:
+                beam_ax.arrow(pos, 0.5, 0, -0.3, head_width=0.2, head_length=0.1, fc='r', ec='r')
+                beam_ax.text(pos, 0.6, f"{load}N", ha='center')
+            else:
+                beam_ax.arrow(pos, -0.5, 0, 0.3, head_width=0.2, head_length=0.1, fc='b', ec='b')
+                beam_ax.text(pos, -0.6, f"{abs(load)}N", ha='center')
+        
+        # Draw UDL
+        if udl_end > udl_start and udl_value != 0:
+            if udl_value > 0:
+                for u in np.linspace(udl_start, udl_end, 20):
+                    beam_ax.arrow(u, 0.3, 0, -0.2, head_width=0.05, head_length=0.05, fc='r', ec='r')
+                beam_ax.plot([udl_start, udl_end], [0.3, 0.3], 'r-', linewidth=2)
+                beam_ax.text((udl_start + udl_end)/2, 0.4, f"{udl_value}N/m", ha='center')
+            else:
+                for u in np.linspace(udl_start, udl_end, 20):
+                    beam_ax.arrow(u, -0.3, 0, 0.2, head_width=0.05, head_length=0.05, fc='b', ec='b')
+                beam_ax.plot([udl_start, udl_end], [-0.3, -0.3], 'b-', linewidth=2)
+                beam_ax.text((udl_start + udl_end)/2, -0.4, f"{abs(udl_value)}N/m", ha='center')
+        
+        beam_ax.set_title("Beam Configuration")
+        beam_ax.set_xlabel("Position (m)")
+        beam_ax.set_yticks([])
+        beam_ax.grid(True)
+        
+        # Plot SFD
+        axs[0].plot(x, shear_force, 'b-', linewidth=2)
+        axs[0].fill_between(x, 0, shear_force, alpha=0.3, color='blue')
+        axs[0].axhline(0, color='k', linestyle='-', alpha=0.5)
+        axs[0].set_title("Shear Force Diagram (SFD)")
+        axs[0].set_xlabel("Position (m)")
+        axs[0].set_ylabel("Shear Force (N)")
+        axs[0].grid(True)
+        
+        # Plot BMD
+        axs[1].plot(x, bending_moment, 'r-', linewidth=2)
+        axs[1].fill_between(x, 0, bending_moment, alpha=0.3, color='red')
+        axs[1].axhline(0, color='k', linestyle='-', alpha=0.5)
+        axs[1].set_title("Bending Moment Diagram (BMD)")
+        axs[1].set_xlabel("Position (m)")
+        axs[1].set_ylabel("Bending Moment (N⋅m)")
+        axs[1].grid(True)
+        
+        plt.tight_layout()
+        
+        # Prepare analysis report
+        report = {
+            "beam_configuration": {
+                "length": length,
+                "point_loads": point_loads,
+                "udl": {
+                    "start": udl_start,
+                    "end": udl_end,
+                    "value": udl_value
+                }
+            },
+            "analysis_results": {
+                "max_shear_force": {
+                    "actual": float(actual_max_sfd),
+                    "predicted": float(predicted_max_sfd),
+                    "prediction_error": float(abs(predicted_max_sfd - actual_max_sfd) / actual_max_sfd * 100) if actual_max_sfd != 0 else 0
+                },
+                "max_bending_moment": {
+                    "actual": float(actual_max_bmd),
+                    "predicted": float(predicted_max_bmd),
+                    "prediction_error": float(abs(predicted_max_bmd - actual_max_bmd) / actual_max_bmd * 100) if actual_max_bmd != 0 else 0
+                },
+                "critical_points": {
+                    "zero_shear_force": float(sfd_critical_point),
+                    "max_bending_moment": float(bmd_max_point)
+                }
+            }
+        }
+        
+        return fig, report
+    
+    def suggest_optimizations(self, length, point_loads, udl_start, udl_end, udl_value, target_criterion="minimize_bending"):
+        original_x, original_sf, original_bm = calculate_sfd_bmd(length, point_loads, udl_start, udl_end, udl_value)
+        original_max_bm = np.max(np.abs(original_bm))
+        original_max_sf = np.max(np.abs(original_sf))
+        
+        suggestions = []
+        
+        # Try repositioning point loads
+        if len(point_loads) > 0:
+            for i, (pos, load) in enumerate(point_loads):
+                # Try moving each load to 5 different positions
+                test_positions = np.linspace(0.1 * length, 0.9 * length, 5)
+                for new_pos in test_positions:
+                    if abs(new_pos - pos) < 0.05 * length:  # Skip if too close to original
+                        continue
+                    
+                    # Create new point loads list with moved load
+                    new_point_loads = point_loads.copy()
+                    new_point_loads[i] = (new_pos, load)
+                    
+                    # Calculate new diagrams
+                    _, new_sf, new_bm = calculate_sfd_bmd(length, new_point_loads, udl_start, udl_end, udl_value)
+                    new_max_bm = np.max(np.abs(new_bm))
+                    new_max_sf = np.max(np.abs(new_sf))
+                    
+                    # Check if this is an improvement
+                    if target_criterion == "minimize_bending" and new_max_bm < original_max_bm * 0.9:
+                        bm_reduction = (original_max_bm - new_max_bm) / original_max_bm * 100
+                        suggestions.append({
+                            "type": "reposition_load",
+                            "original": {"position": pos, "load": load},
+                            "suggestion": {"position": float(new_pos), "load": load},
+                            "improvement": f"{bm_reduction:.1f}% reduction in maximum bending moment"
+                        })
+                    elif target_criterion == "minimize_shear" and new_max_sf < original_max_sf * 0.9:
+                        sf_reduction = (original_max_sf - new_max_sf) / original_max_sf * 100
+                        suggestions.append({
+                            "type": "reposition_load",
+                            "original": {"position": pos, "load": load},
+                            "suggestion": {"position": float(new_pos), "load": load},
+                            "improvement": f"{sf_reduction:.1f}% reduction in maximum shear force"
+                        })
+        
+        # Try adjusting UDL
+        if udl_end > udl_start and udl_value != 0:
+            # Try different UDL positions
+            test_starts = np.linspace(0, 0.5 * length, 3)
+            test_lengths = np.linspace(0.2 * length, 0.5 * length, 3)
+            
+            for new_start in test_starts:
+                for new_length in test_lengths:
+                    new_end = new_start + new_length
+                    if new_end > length:
+                        continue
+                        
+                    # Too similar to original
+                    if abs(new_start - udl_start) < 0.1 * length and abs(new_end - udl_end) < 0.1 * length:
+                        continue
+                    
+                    # Calculate new diagrams
+                    _, new_sf, new_bm = calculate_sfd_bmd(length, point_loads, new_start, new_end, udl_value)
+                    new_max_bm = np.max(np.abs(new_bm))
+                    new_max_sf = np.max(np.abs(new_sf))
+                    
+                    # Check if this is an improvement
+                    if target_criterion == "minimize_bending" and new_max_bm < original_max_bm * 0.9:
+                        bm_reduction = (original_max_bm - new_max_bm) / original_max_bm * 100
+                        suggestions.append({
+                            "type": "adjust_udl",
+                            "original": {"start": udl_start, "end": udl_end},
+                            "suggestion": {"start": float(new_start), "end": float(new_end)},
+                            "improvement": f"{bm_reduction:.1f}% reduction in maximum bending moment"
+                        })
+                    elif target_criterion == "minimize_shear" and new_max_sf < original_max_sf * 0.9:
+                        sf_reduction = (original_max_sf - new_max_sf) / original_max_sf * 100
+                        suggestions.append({
+                            "type": "adjust_udl",
+                            "original": {"start": udl_start, "end": udl_end},
+                            "suggestion": {"start": float(new_start), "end": float(new_end)},
+                            "improvement": f"{sf_reduction:.1f}% reduction in maximum shear force"
+                        })
+        
+        # Sort suggestions by improvement
+        if suggestions:
+            suggestions.sort(key=lambda x: float(x["improvement"].split('%')[0]), reverse=True)
+            return suggestions[:3]  # Return top 3 suggestions
+        else:
+            return [{"type": "no_suggestions", "message": "No significant improvements found with the attempted modifications."}]
+
+# Gradio Interface Functions
+def format_report(report):
+    text = f"## Beam Analysis Report\n\n"
+    text += f"### Configuration\n"
+    text += f"- Beam Length: {report['beam_configuration']['length']}m\n"
+    text += f"- Point Loads: {report['beam_configuration']['point_loads']}\n"
+    text += f"- UDL: {report['beam_configuration']['udl']['value']} N/m from {report['beam_configuration']['udl']['start']}m to {report['beam_configuration']['udl']['end']}m\n\n"
+    
+    text += f"### Results\n"
+    text += f"- Maximum Shear Force: {report['analysis_results']['max_shear_force']['actual']:.2f} N\n"
+    text += f"- Maximum Bending Moment: {report['analysis_results']['max_bending_moment']['actual']:.2f} N⋅m\n"
+    text += f"- Critical Points:\n"
+    text += f"  - Zero Shear Force (likely max bending): {report['analysis_results']['critical_points']['zero_shear_force']:.2f}m\n"
+    text += f"  - Max Bending Moment: {report['analysis_results']['critical_points']['max_bending_moment']:.2f}m\n\n"
+    
+    text += f"### ML Predictions\n"
+    text += f"- Predicted Max Shear Force: {report['analysis_results']['max_shear_force']['predicted']:.2f} N (Error: {report['analysis_results']['max_shear_force']['prediction_error']:.2f}%)\n"
+    text += f"- Predicted Max Bending Moment: {report['analysis_results']['max_bending_moment']['predicted']:.2f} N⋅m (Error: {report['analysis_results']['max_bending_moment']['prediction_error']:.2f}%)\n"
+    
+    return text
+
+def format_optimization_suggestions(suggestions):
+    text = f"## Optimization Suggestions\n\n"
+    
+    if suggestions[0].get("type") == "no_suggestions":
+        text += "No significant improvements found with the attempted modifications.\n"
+        return text
+    
+    for i, suggestion in enumerate(suggestions, 1):
+        text += f"### Suggestion {i}\n"
+        
+        if suggestion["type"] == "reposition_load":
+            text += f"- Type: Reposition Point Load\n"
+            text += f"- Original Position: {suggestion['original']['position']:.2f}m with {suggestion['original']['load']}N\n"
+            text += f"- Suggested Position: {suggestion['suggestion']['position']:.2f}m\n"
+            text += f"- Improvement: {suggestion['improvement']}\n\n"
+        
+        elif suggestion["type"] == "adjust_udl":
+            text += f"- Type: Adjust UDL Position\n"
+            text += f"- Original: {suggestion['original']['start']:.2f}m to {suggestion['original']['end']:.2f}m\n"
+            text += f"- Suggested: {suggestion['suggestion']['start']:.2f}m to {suggestion['suggestion']['end']:.2f}m\n"
+            text += f"- Improvement: {suggestion['improvement']}\n\n"
+    
+    return text
+
+def parse_point_loads(point_loads_str):
+    if not point_loads_str or point_loads_str.strip() == "":
+        return []
+    
+    try:
+        # Handle different input formats
+        point_loads_str = point_loads_str.replace(';', ',')
+        if '[' not in point_loads_str:
+            # Try to parse as simple comma-separated numbers in pairs
+            values = [float(x.strip()) for x in point_loads_str.split(',') if x.strip()]
+            if len(values) % 2 != 0:
+                raise ValueError("Point loads must be specified as position,load pairs")
+            
+            return [(values[i], values[i+1]) for i in range(0, len(values), 2)]
+        else:
+            # Parse as literal Python expression
+            return eval(point_loads_str)
+    except Exception as e:
+        return [(0, 0)]  # Return a default value on error
+
+# Initialize the agent
+beam_agent = BeamAnalysisAgent()
+
+def analyze_beam_ui(length, point_loads_str, udl_start, udl_end, udl_value):
+    point_loads = parse_point_loads(point_loads_str)
+    fig, report = beam_agent.analyze_beam(length, point_loads, udl_start, udl_end, udl_value)
+    formatted_report = format_report(report)
+    return fig, formatted_report
+
+def optimize_beam_ui(length, point_loads_str, udl_start, udl_end, udl_value, target_criterion):
+    point_loads = parse_point_loads(point_loads_str)
+    suggestions = beam_agent.suggest_optimizations(length, point_loads, udl_start, udl_end, udl_value, target_criterion)
+    formatted_suggestions = format_optimization_suggestions(suggestions)
+    return formatted_suggestions
+
+def train_model_ui():
+    dataset, feature_names, target_names = generate_beam_dataset(2000)
+    model_data = train_beam_ml_models(dataset)
+    
+    # Update the agent's models
+    global beam_agent
+    beam_agent.sfd_model = model_data['sfd_model']
+    beam_agent.bmd_model = model_data['bmd_model']
+    
+    # Format training results
+    metrics = model_data['metrics']
+    report = f"## ML Model Training Results\n\n"
+    report += f"### Dataset\n"
+    report += f"- Generated {len(dataset)} sample beam configurations\n"
+    report += f"- Features: {', '.join(feature_names)}\n"
+    report += f"- Targets: {', '.join(target_names)}\n\n"
+    
+    report += f"### Model Performance\n"
+    report += f"- Shear Force Prediction:\n"
+    report += f"  - RMSE: {metrics['sfd_rmse']:.2f}\n"
+    report += f"  - R²: {metrics['sfd_r2']:.4f}\n"
+    report += f"- Bending Moment Prediction:\n"
+    report += f"  - RMSE: {metrics['bmd_rmse']:.2f}\n"
+    report += f"  - R²: {metrics['bmd_r2']:.4f}\n"
+    
+    return report
+
+# Create the Gradio interface
+with gr.Blocks(title="Beam Analysis with ML Agent") as iface:
+    gr.Markdown("# Structural Beam Analysis with ML Agent")
+    gr.Markdown("This application uses machine learning to analyze and optimize structural beams.")
+    
+    with gr.Tab("Beam Analysis"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                length_input = gr.Number(value=10.0, label="Beam Length (m)")
+                point_loads_input = gr.Textbox(value="[(2, -1000), (8, -2000)]", label="Point Loads [(position, magnitude)]")
+                udl_start_input = gr.Number(value=4.0, label="UDL Start Position (m)")
+                udl_end_input = gr.Number(value=7.0, label="UDL End Position (m)")
+                udl_value_input = gr.Number(value=-500, label="UDL Value (N/m)")
+                analyze_btn = gr.Button("Analyze Beam")
+            
+            with gr.Column(scale=2):
+                output_plot = gr.Plot(label="Beam Analysis Plot")
+                output_report = gr.Markdown(label="Analysis Report")
+        
+        analyze_btn.click(
+            analyze_beam_ui,
+            inputs=[length_input, point_loads_input, udl_start_input, udl_end_input, udl_value_input],
+            outputs=[output_plot, output_report]
+        )
+    
+    with gr.Tab("Beam Optimization"):
+        with gr.Row():
+            with gr.Column(scale=1):
+                opt_length_input = gr.Number(value=10.0, label="Beam Length (m)")
+                opt_point_loads_input = gr.Textbox(value="[(2, -1000), (8, -2000)]", label="Point Loads [(position, magnitude)]")
+                opt_udl_start_input = gr.Number(value=4.0, label="UDL Start Position (m)")
+                opt_udl_end_input = gr.Number(value=7.0, label="UDL End Position (m)")
+                opt_udl_value_input = gr.Number(value=-500, label="UDL Value (N/m)")
+                opt_criterion = gr.Radio(
+                    ["minimize_bending", "minimize_shear"], 
+                    label="Optimization Target", 
+                    value="minimize_bending"
+                )
+                optimize_btn = gr.Button("Suggest Optimizations")
+            
+            with gr.Column(scale=2):
+                optimization_suggestions = gr.Markdown(label="Optimization Suggestions")
+        
+        optimize_btn.click(
+            optimize_beam_ui,
+            inputs=[
+                opt_length_input, 
+                opt_point_loads_input, 
+                opt_udl_start_input, 
+                opt_udl_end_input, 
+                opt_udl_value_input, 
+                opt_criterion
+            ],
+            outputs=[optimization_suggestions]
+        )
+    
+    with gr.Tab("ML Model Training"):
+        train_btn = gr.Button("Train New ML Models")
+        training_results = gr.Markdown(label="Training Results")
+        
+        train_btn.click(
+            train_model_ui,
+            inputs=[],
+            outputs=[training_results]
+        )
+
+# Launch the app
+if __name__ == "__main__":
+    iface.launch()