import streamlit as st import plotly.express as px import plotly.graph_objects as go import pandas as pd import numpy as np import joblib import os from datetime import datetime from sklearn.preprocessing import MinMaxScaler # 页面函数定义 def show_optimized_parameter_adjustment(): # 页面标题 st.title("优化版挤出机参数调节建议") # 添加操作指引 with st.expander("📖 操作指引", expanded=True): st.markdown(""" 欢迎使用优化版挤出机参数调节建议功能！本功能基于多目标优化算法，根据您输入的米重数据和当前参数，为您提供科学合理的参数调整建议。 **操作步骤：** 1. 选择一个已训练好的模型 2. 输入米重标准值、上下限和当前挤出机参数 3. 输入当前实际米重测量值 4. 调整优化参数（可选） 5. 点击"计算优化调节建议"按钮 6. 查看系统生成的参数调整建议 **注意事项：** - 请确保输入的参数值在设备允许的范围内 - 优化算法会平衡米重偏差和调整幅度 - 历史调节记录可在页面底部查看 """) # 初始化会话状态 if 'optimized_adjustment_history' not in st.session_state: st.session_state['optimized_adjustment_history'] = [] # 1. 模型选择区域 with st.expander("🔍 模型选择", expanded=True): # 创建模型目录（如果不存在） model_dir = "saved_models" os.makedirs(model_dir, exist_ok=True) # 获取所有已保存的模型文件 model_files = [f for f in os.listdir(model_dir) if f.endswith('.joblib')] model_files.sort(reverse=True) # 最新的模型排在前面 if not model_files: st.warning("尚未保存任何模型，请先训练模型并保存。") return # 模型选择下拉框 selected_model_file = st.selectbox( "选择已保存的模型", options=model_files, help="选择要用于预测的模型文件" ) # 加载并显示模型信息 if selected_model_file: model_path = os.path.join(model_dir, selected_model_file) model_info = joblib.load(model_path) # 显示模型基本信息 st.subheader("📊 模型信息") info_cols = st.columns(2) with info_cols[0]: st.metric("模型类型", model_info['model_type']) st.metric("创建时间", model_info['created_at'].strftime('%Y-%m-%d %H:%M:%S')) st.metric("使用稳态数据", "是" if model_info.get('use_steady_data', False) else "否") with info_cols[1]: st.metric("R² 得分", f"{model_info['r2_score']:.4f}") st.metric("均方误差 (MSE)", f"{model_info['mse']:.6f}") st.metric("均方根误差 (RMSE)", f"{model_info['rmse']:.6f}") # 显示模型特征 st.write("🔑 模型使用的特征:") st.code(", ".join(model_info['features'])) # 如果是深度学习模型，显示序列长度 if 'sequence_length' in model_info: st.metric("序列长度", model_info['sequence_length']) # 保存模型信息到会话状态 st.session_state['selected_model'] = model_info st.session_state['selected_model_file'] = selected_model_file # 2. 参数输入区域 st.subheader("📝 参数输入") # 2.1 米重标准值、上下限输入 with st.expander("⚖️ 米重标准与上下限", expanded=True): weight_cols = st.columns(3) with weight_cols[0]: standard_weight = st.number_input( "标准米重", key="standard_weight", value=5.20, min_value=0.01, max_value=10.0, step=0.0001, format="%.4f", help="输入目标米重标准值" ) st.caption("单位: Kg/m") with weight_cols[1]: upper_limit = st.number_input( "米重上限", key="upper_limit", value=5.46, min_value=standard_weight, max_value=10.0, step=0.0001, format="%.4f", help="输入米重允许的上限值" ) st.caption("单位: Kg/m") with weight_cols[2]: lower_limit = st.number_input( "米重下限", key="lower_limit", value=5.02, min_value=0.01, max_value=standard_weight, step=0.0001, format="%.4f", help="输入米重允许的下限值" ) st.caption("单位: Kg/m") # 2.2 挤出机当前参数输入 with st.expander("🔧 挤出机当前参数", expanded=True): param_cols = st.columns(3) with param_cols[0]: current_screw_speed = st.number_input( "螺杆转速", key="current_screw_speed", value=230.0, min_value=0.0, max_value=500.0, step=0.1, help="输入当前螺杆转速" ) st.caption("单位: rpm") current_head_pressure = st.number_input( "机头压力", key="current_head_pressure", value=0.26, min_value=0.0, max_value=500.0, format="%.4f", step=1.0, help="输入当前机头压力" ) st.caption("单位: bar") current_process_speed = st.number_input( "流程主速", key="current_process_speed", value=6.6, min_value=0.0, max_value=300.0, step=0.1, help="输入当前流程主速" ) st.caption("单位: m/min") with param_cols[1]: current_screw_temperature = st.number_input( "螺杆温度", key="current_screw_temperature", value=79.9, min_value=0.0, max_value=300.0, step=1.0, help="输入当前螺杆温度" ) st.caption("单位: °C") current_rear_barrel_temperature = st.number_input( "后机筒温度", key="current_rear_barrel_temperature", value=79.9, min_value=0.0, max_value=300.0, step=1.0, help="输入当前后机筒温度" ) st.caption("单位: °C") with param_cols[2]: current_front_barrel_temperature = st.number_input( "前机筒温度", key="current_front_barrel_temperature", value=80.1, min_value=0.0, max_value=300.0, step=1.0, help="输入当前前机筒温度" ) st.caption("单位: °C") current_head_temperature = st.number_input( "机头温度", key="current_head_temperature", value=95.1, min_value=0.0, max_value=300.0, step=1.0, help="输入当前机头温度" ) st.caption("单位: °C") # 2.3 当前实际米重测量值输入 with st.expander("📏 当前实际米重", expanded=True): actual_weight = st.number_input( "当前实际米重", key="actual_weight", value=5.115, min_value=0.01, max_value=10.0, step=0.0001, format="%.4f", help="输入当前实际测量的米重值" ) st.caption("单位: Kg/m") # 3. 优化参数设置 st.subheader("⚙️ 优化参数设置") with st.expander("🎯 多目标优化参数", expanded=True): # 目标权重设置 st.write("### 目标权重") st.markdown("调整以下权重来平衡米重偏差和调整幅度的重要性：") weight_cols = st.columns(2) with weight_cols[0]: weight_deviation = st.slider( "米重偏差权重", min_value=0.1, max_value=1.0, value=0.8, step=0.1, help="权重越高，越优先考虑减少米重偏差" ) with weight_cols[1]: weight_adjustment = st.slider( "调整幅度权重", min_value=0.1, max_value=1.0, value=0.2, step=0.1, help="权重越高，越优先考虑减少调整幅度" ) # 调整权重，确保总和为1 total_weight = weight_deviation + weight_adjustment weight_deviation = weight_deviation / total_weight weight_adjustment = weight_adjustment / total_weight st.write(f"### 调整后权重（总和为1）") st.write(f"- 米重偏差权重: {weight_deviation:.2f}") st.write(f"- 调整幅度权重: {weight_adjustment:.2f}") # 参数调整约束 st.write("### 参数调整约束") constraint_cols = st.columns(2) with constraint_cols[0]: max_screw_speed_adjust = st.slider( "螺杆转速最大调整幅度(%)", min_value=5.0, max_value=20.0, value=15.0, step=1.0, help="单次调整的最大百分比" ) with constraint_cols[1]: max_process_speed_adjust = st.slider( "流程主速最大调整幅度(%)", min_value=3.0, max_value=15.0, value=10.0, step=1.0, help="单次调整的最大百分比" ) # 4. 计算优化调节建议 st.subheader("🚀 计算优化调节建议") if st.button("📊 计算优化调节建议", key="calculate_optimized_adjustment"): # 参数验证 validation_errors = [] if standard_weight <= 0: validation_errors.append("标准米重必须大于0") if upper_limit <= standard_weight: validation_errors.append("米重上限必须大于标准米重") if lower_limit >= standard_weight: validation_errors.append("米重下限必须小于标准米重") if current_screw_speed <= 0: validation_errors.append("螺杆转速必须大于0") if current_process_speed <= 0: validation_errors.append("流程主速必须大于0") if actual_weight <= 0: validation_errors.append("实际米重必须大于0") if validation_errors: st.error("参数输入错误：") for error in validation_errors: st.error(f"- {error}") else: with st.spinner("正在计算优化调节建议..."): # 获取选中的模型 if 'selected_model' not in st.session_state: st.error("请先选择一个模型") return model_info = st.session_state['selected_model'] model = model_info['model'] # 检查是否有缩放器 has_scalers = ('scaler_X' in model_info and model_info['scaler_X'] is not None and 'scaler_y' in model_info and model_info['scaler_y'] is not None) if has_scalers: scaler_X = model_info['scaler_X'] scaler_y = model_info['scaler_y'] features = model_info['features'] # 多目标优化算法 - 粒子群优化 def predict_weight(screw_speed, process_speed): """使用模型预测米重""" # 准备输入数据 input_data = { '螺杆转速': screw_speed, '机头压力': current_head_pressure, '流程主速': process_speed, '螺杆温度': current_screw_temperature, '后机筒温度': current_rear_barrel_temperature, '前机筒温度': current_front_barrel_temperature, '机头温度': current_head_temperature } # 根据模型特征创建输入DataFrame input_df = pd.DataFrame([input_data])[features] if model_info['model_type'] in ['LSTM', 'GRU', 'BiLSTM']: # 深度学习模型处理逻辑 import torch # 检查是否有缩放器 if has_scalers: scaled_input = scaler_X.transform(input_df) else: scaled_input = input_df.values # 获取序列长度 sequence_length = model_info.get('sequence_length', 10) # 创建序列数据 input_seq = np.tile(scaled_input, (sequence_length, 1)).reshape(1, sequence_length, -1) # 转换为PyTorch张量 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') input_tensor = torch.tensor(input_seq, dtype=torch.float32).to(device) # 预测 model.eval() with torch.no_grad(): y_pred_scaled_tensor = model(input_tensor) y_pred_scaled = y_pred_scaled_tensor.cpu().numpy().ravel()[0] if has_scalers: # 反缩放预测结果 predicted_weight = scaler_y.inverse_transform(np.array([[y_pred_scaled]]))[0][0] else: predicted_weight = y_pred_scaled elif has_scalers: # 特征缩放 scaled_input = scaler_X.transform(input_df) # 模型预测 scaled_prediction = model.predict(scaled_input)[0] # 反缩放预测结果 predicted_weight = scaler_y.inverse_transform(np.array([[scaled_prediction]]))[0][0] else: # 直接预测，不使用缩放器 predicted_weight = model.predict(input_df)[0] return predicted_weight def objective_function(params): """多目标目标函数""" screw_speed_val, process_speed_val = params # 预测米重 predicted_weight_val = predict_weight(screw_speed_val, process_speed_val) # 计算目标1：米重偏差 deviation_val = abs(predicted_weight_val - standard_weight) deviation_percent_val = abs((predicted_weight_val - standard_weight) / standard_weight * 100) # 计算目标2：调整幅度 screw_speed_adjustment_val = abs(screw_speed_val - current_screw_speed) process_speed_adjustment_val = abs(process_speed_val - current_process_speed) screw_speed_adjustment_percent_val = abs((screw_speed_val - current_screw_speed) / current_screw_speed * 100) process_speed_adjustment_percent_val = abs((process_speed_val - current_process_speed) / current_process_speed * 100) # 加权目标函数 objective_val = (weight_deviation * deviation_percent_val + weight_adjustment * (screw_speed_adjustment_percent_val + process_speed_adjustment_percent_val) / 2) return objective_val, predicted_weight_val, deviation_percent_val, \ screw_speed_adjustment_percent_val, process_speed_adjustment_percent_val # 参数约束 def is_within_constraints(params): """检查参数是否在约束范围内""" screw_speed, process_speed = params # 螺杆转速约束 if not (30 <= screw_speed <= 500): return False # 流程主速约束 if not (0 <= process_speed <= 200): return False # 单次调整幅度约束 screw_speed_adjustment_percent = abs((screw_speed - current_screw_speed) / current_screw_speed * 100) if screw_speed_adjustment_percent > max_screw_speed_adjust: return False process_speed_adjustment_percent = abs((process_speed - current_process_speed) / current_process_speed * 100) if process_speed_adjustment_percent > max_process_speed_adjust: return False return True # 粒子群优化算法 def particle_swarm_optimization(objective, constraints, bounds, n_particles=30, n_iterations=50): """粒子群优化算法""" # 初始化粒子 particles = [] velocities = [] best_positions = [] best_scores = [] # 边界 (screw_speed_min, screw_speed_max), (process_speed_min, process_speed_max) = bounds for _ in range(n_particles): # 随机初始化位置 while True: screw_speed = np.random.uniform(screw_speed_min, screw_speed_max) process_speed = np.random.uniform(process_speed_min, process_speed_max) pos = [screw_speed, process_speed] if constraints(pos): break particles.append(pos) velocities.append([0.0, 0.0]) best_positions.append(pos.copy()) # 计算初始得分 score, _, _, _, _ = objective(pos) best_scores.append(score) # 全局最优 global_best_idx = np.argmin(best_scores) global_best_position = best_positions[global_best_idx].copy() global_best_score = best_scores[global_best_idx] # PSO参数 w = 0.5 # 惯性权重 c1 = 1.5 # 认知系数 c2 = 1.5 # 社会系数 # 迭代优化 for _ in range(n_iterations): for i in range(n_particles): # 更新速度 r1, r2 = np.random.rand(), np.random.rand() velocities[i][0] = (w * velocities[i][0] + c1 * r1 * (best_positions[i][0] - particles[i][0]) + c2 * r2 * (global_best_position[0] - particles[i][0])) velocities[i][1] = (w * velocities[i][1] + c1 * r1 * (best_positions[i][1] - particles[i][1]) + c2 * r2 * (global_best_position[1] - particles[i][1])) # 更新位置 new_pos = [ particles[i][0] + velocities[i][0], particles[i][1] + velocities[i][1] ] # 检查约束 if constraints(new_pos): particles[i] = new_pos # 更新个体最优 current_score, _, _, _, _ = objective(new_pos) if current_score < best_scores[i]: best_scores[i] = current_score best_positions[i] = new_pos.copy() # 更新全局最优 if current_score < global_best_score: global_best_score = current_score global_best_position = new_pos.copy() return global_best_position, global_best_score # 设置参数边界 screw_speed_bounds = [ current_screw_speed * (1 - max_screw_speed_adjust / 100), current_screw_speed * (1 + max_screw_speed_adjust / 100) ] process_speed_bounds = [ current_process_speed * (1 - max_process_speed_adjust / 100), current_process_speed * (1 + max_process_speed_adjust / 100) ] # 执行优化 best_params, best_score = particle_swarm_optimization( objective_function, is_within_constraints, [(screw_speed_bounds[0], screw_speed_bounds[1]), (process_speed_bounds[0], process_speed_bounds[1])] ) # 获取最优参数的详细信息 best_screw_speed, best_process_speed = best_params best_objective, best_predicted_weight, best_deviation_percent, \ best_screw_adjust_percent, best_process_adjust_percent = objective_function(best_params) # 计算当前参数的预测结果 current_predicted_weight = predict_weight(current_screw_speed, current_process_speed) current_deviation_percent = abs((current_predicted_weight - standard_weight) / standard_weight * 100) # 生成调整建议文本 def generate_recommendation(): """生成调整建议文本""" screw_speed_change = "提高" if best_screw_speed > current_screw_speed else "降低" process_speed_change = "提高" if best_process_speed > current_process_speed else "降低" recommendation = f"米重偏差 {current_deviation_percent:.2f}%，建议调整：\n" recommendation += f"1. 将螺杆转速从 {current_screw_speed:.1f} rpm {screw_speed_change} 至 {best_screw_speed:.1f} rpm " recommendation += f"( {screw_speed_change} {abs(best_screw_adjust_percent):.2f}% )\n" recommendation += f"2. 将流程主速从 {current_process_speed:.1f} m/min {process_speed_change} 至 {best_process_speed:.1f} m/min " recommendation += f"( {process_speed_change} {abs(best_process_adjust_percent):.2f}% )\n" recommendation += f"\n预期效果：米重偏差将降至 {best_deviation_percent:.2f}%" return recommendation recommendation = generate_recommendation() # 构建调整结果 adjustment_result = { 'status': '正常范围' if best_predicted_weight >= lower_limit and best_predicted_weight <= upper_limit else \ '超上限' if best_predicted_weight > upper_limit else '超下限', 'real_time_weight': actual_weight, 'standard_weight': standard_weight, 'upper_limit': upper_limit, 'lower_limit': lower_limit, 'current_screw_speed': current_screw_speed, 'current_process_speed': current_process_speed, 'new_screw_speed': best_screw_speed, 'new_process_speed': best_process_speed, 'predicted_weight': best_predicted_weight, 'current_predicted_weight': current_predicted_weight, 'deviation_percentage': (actual_weight - standard_weight) / standard_weight * 100, 'current_predicted_deviation_percent': current_deviation_percent, 'predicted_deviation_percent': best_deviation_percent, 'screw_speed_adjustment': best_screw_speed - current_screw_speed, 'process_speed_adjustment': best_process_speed - current_process_speed, 'screw_speed_adjust_percent': best_screw_adjust_percent, 'process_speed_adjust_percent': best_process_adjust_percent, 'recommendation': recommendation, 'weight_deviation': weight_deviation, 'weight_adjustment': weight_adjustment, 'best_objective_score': best_score } # 保存到历史记录 history_record = { 'timestamp': datetime.now(), 'model_file': st.session_state.get('selected_model_file', '未知模型'), 'standard_weight': standard_weight, 'upper_limit': upper_limit, 'lower_limit': lower_limit, 'actual_weight': actual_weight, 'current_screw_speed': current_screw_speed, 'current_process_speed': current_process_speed, 'adjustment_result': adjustment_result } # 添加到会话状态的历史记录 st.session_state['optimized_adjustment_history'].append(history_record) # 限制历史记录数量 if len(st.session_state['optimized_adjustment_history']) > 100: st.session_state['optimized_adjustment_history'] = st.session_state['optimized_adjustment_history'][-100:] # 5. 结果展示 st.success("优化调节建议计算完成！") st.subheader("📋 优化调节建议结果") # 5.1 米重状态 if adjustment_result['status'] == "正常范围": st.success(f"米重状态: {adjustment_result['status']}") else: st.warning(f"米重状态: {adjustment_result['status']}") # 5.2 偏差信息 st.markdown("### 📊 偏差信息") info_cols = st.columns(3) info_cols[0].metric("实时米重", f"{adjustment_result['real_time_weight']:.4f} Kg/m") info_cols[1].metric("标准米重", f"{adjustment_result['standard_weight']:.4f} Kg/m") info_cols[2].metric("偏差百分比", f"{adjustment_result['deviation_percentage']:.2f}%") # 5.3 预测结果对比 st.markdown("### 📈 预测结果对比") pred_cols = st.columns(3) pred_cols[0].metric("当前参数预测米重", f"{adjustment_result['current_predicted_weight']:.4f} Kg/m") pred_cols[1].metric("优化后预测米重", f"{adjustment_result['predicted_weight']:.4f} Kg/m") pred_cols[2].metric("预测偏差改善", f"{adjustment_result['current_predicted_deviation_percent'] - adjustment_result['predicted_deviation_percent']:.2f}%") # 5.4 关键调整建议 st.markdown("### 🔑 关键调整建议") st.info(adjustment_result['recommendation']) # 5.5 参数调整对比 st.markdown("### 📊 参数调整对比") param_compare_df = pd.DataFrame({ '参数名称': ['螺杆转速', '流程主速'], '当前值': [adjustment_result['current_screw_speed'], adjustment_result['current_process_speed']], '优化建议值': [adjustment_result['new_screw_speed'], adjustment_result['new_process_speed']], '调整幅度': [f"{adjustment_result['screw_speed_adjust_percent']:.2f}%", f"{adjustment_result['process_speed_adjust_percent']:.2f}%"] }) # 高亮显示调整幅度 def highlight_adjustment(val): if isinstance(val, str) and '%' in val: try: percent = float(val.strip('%')) if percent > 0: return 'background-color: #90EE90' # 绿色表示增加 elif percent < 0: return 'background-color: #FFB6C1' # 红色表示减少 except: pass return '' styled_df = param_compare_df.style.applymap(highlight_adjustment, subset=['调整幅度']) st.dataframe(styled_df, use_container_width=True, hide_index=True) # 5.6 可视化对比 fig = go.Figure() fig.add_trace(go.Bar( x=param_compare_df['参数名称'], y=param_compare_df['当前值'], name='当前值', marker_color='blue' )) fig.add_trace(go.Bar( x=param_compare_df['参数名称'], y=param_compare_df['优化建议值'], name='优化建议值', marker_color='green' )) fig.update_layout( barmode='group', title='参数调整对比', yaxis_title='数值', height=400 ) st.plotly_chart(fig, use_container_width=True) # 5.7 优化效果可视化 st.markdown("### 📉 优化效果") # 目标函数值对比 fig_objective = go.Figure() fig_objective.add_trace(go.Bar( x=['当前参数', '优化后参数'], y=[ weight_deviation * current_deviation_percent + weight_adjustment * 0, weight_deviation * best_deviation_percent + weight_adjustment * \ (abs(best_screw_adjust_percent) + abs(best_process_adjust_percent)) / 2 ], marker_color=['red', 'green'] )) fig_objective.update_layout( title='多目标优化函数值对比', yaxis_title='目标函数值（越小越好）', height=300 ) st.plotly_chart(fig_objective, use_container_width=True) # 6. 历史记录展示 st.subheader("📚 历史调节记录") if 'optimized_adjustment_history' in st.session_state and st.session_state['optimized_adjustment_history']: # 显示历史记录数量 st.write(f"共 {len(st.session_state['optimized_adjustment_history'])} 条历史记录") # 分页显示 page_size = 10 total_pages = (len(st.session_state['optimized_adjustment_history']) + page_size - 1) // page_size page = st.selectbox( "选择页码", options=range(1, total_pages + 1), key="history_page" ) start_idx = (page - 1) * page_size end_idx = start_idx + page_size paginated_history = st.session_state['optimized_adjustment_history'][start_idx:end_idx] # 反向显示，最新记录在前面 for record in reversed(paginated_history): with st.expander(f"记录时间: {record['timestamp'].strftime('%Y-%m-%d %H:%M:%S')} | 模型: {record['model_file']}"): history_cols = st.columns(3) with history_cols[0]: st.write("**米重参数**") st.write(f"- 标准米重: {record['standard_weight']:.4f} Kg/m") st.write(f"- 米重上限: {record['upper_limit']:.4f} Kg/m") st.write(f"- 米重下限: {record['lower_limit']:.4f} Kg/m") st.write(f"- 实际米重: {record['actual_weight']:.4f} Kg/m") with history_cols[1]: st.write("**速度参数**") st.write(f"- 当前螺杆转速: {record['current_screw_speed']:.1f} rpm") st.write(f"- 当前流程主速: {record['current_process_speed']:.1f} m/min") st.write(f"- 建议螺杆转速: {record['adjustment_result']['new_screw_speed']:.1f} rpm") st.write(f"- 建议流程主速: {record['adjustment_result']['new_process_speed']:.1f} m/min") with history_cols[2]: st.write("**预测结果**") st.write(f"- 当前预测米重: {record['adjustment_result']['current_predicted_weight']:.4f} Kg/m") st.write(f"- 优化后预测米重: {record['adjustment_result']['predicted_weight']:.4f} Kg/m") st.write(f"- 当前预测偏差: {record['adjustment_result']['current_predicted_deviation_percent']:.2f}%") st.write(f"- 优化后预测偏差: {record['adjustment_result']['predicted_deviation_percent']:.2f}%") st.write("**调整建议**") st.write(record['adjustment_result']['recommendation']) else: st.info("暂无历史调节记录") # 7. 帮助说明 with st.expander("❓ 帮助说明"): st.markdown(""" ### 功能说明 本功能模块基于多目标优化算法，根据当前米重测量值和挤出机参数，为用户提供科学合理的参数调整建议。 ### 优化算法 - **算法类型**: 粒子群优化算法（PSO） - **优化目标**: 1. 最小化米重偏差 2. 最小化参数调整幅度 - **约束条件**: - 螺杆转速和流程主速上下限 - 单次最大调整幅度 ### 结果解读 - **米重状态**: 显示优化后预测米重是否在允许范围内 - **偏差信息**: 当前米重与标准米重的偏差 - **预测结果对比**: 当前参数和优化后参数的预测米重对比 - **调整建议**: 详细的参数调整建议 - **参数对比**: 直观展示参数调整幅度 - **优化效果**: 多目标优化函数值对比 ### 注意事项 1. 请确保输入的参数值准确反映设备当前状态 2. 优化建议仅供参考，实际操作时请结合现场经验 3. 建议在调整参数后密切观察米重变化 4. 定期更新模型以提高建议的准确性 """) # 页面入口 if __name__ == "__main__": show_optimized_parameter_adjustment()