SPIRAN ART SUMMONER部署教程：监控面板集成（GPU温度/显存/延迟）

SPIRAN ART SUMMONER部署教程：监控面板集成（GPU温度/显存/延迟）

1. 引言：为什么需要监控面板？

当你沉浸在SPIRAN ART SUMMONER创造的“斯皮拉”幻光世界中，看着“幻光虫”粒子在屏幕上漂浮，等待AI将你的“祈祷词”凝结成永恒画面时，有没有遇到过这样的情况？

• 点击“唤醒祈之子”后，界面卡在“SYNCHRONIZING WITH THE FAYTH...”状态，不知道要等多久
• 生成几张高清大图后，突然提示显存不足，创作被迫中断
• 不确定是GPU温度过高导致降频，还是模型加载出了问题

这些问题其实都有一个共同的根源：你对AI创作引擎的运行状态“看不见”。

就像驾驶一辆高性能跑车，如果仪表盘全是黑的，你不知道转速、水温、油量，开起来心里肯定没底。SPIRAN ART SUMMONER的Flux.1-Dev引擎同样需要“仪表盘”——一个实时监控面板，让你随时了解GPU的温度、显存使用情况、生成延迟等关键指标。

本教程将手把手教你为SPIRAN ART SUMMONER集成一个美观实用的监控面板，让你从“盲人摸象”变成“心中有数”，真正掌控AI创作的全过程。

2. 监控面板能为你带来什么？

在开始部署之前，我们先看看这个监控面板能解决哪些实际问题。

2.1 实时掌握硬件状态

想象一下这个场景：你正在为游戏项目生成一批史诗级场景原画，每张图都需要5120×2880的超高分辨率。生成到第5张时，进度条突然卡住不动了。

没有监控面板时：

• 你只能干等着，不知道是程序崩溃了还是正常处理中
• 反复刷新页面，尝试重新生成，可能造成重复计算
• 最终发现是GPU温度超过85°C触发了保护机制，但为时已晚

有了监控面板后：

• 实时看到GPU温度从60°C逐渐上升到82°C
• 显存使用率显示已占用22GB/24GB（接近满载）
• 你知道这是正常的高负载运行，不是程序错误
• 可以主动暂停批量任务，让GPU降温后再继续

2.2 优化生成策略

不同的生成参数对硬件压力完全不同：

• 低步数（20步）+低分辨率（1024×768）：显存占用约8GB，生成时间15秒
• 高步数（50步）+高分辨率（5120×2880）：显存占用可能突破22GB，生成时间超过2分钟

通过监控面板的历史数据，你可以：

1. 找到显存使用和生成质量的平衡点
2. 避免因显存不足导致的生成失败
3. 根据实时负载动态调整批量生成的数量

2.3 预防硬件损伤

GPU长时间高温运行会缩短寿命。监控面板就像给你的4090D显卡装了个“健康手环”：

• 温度超过80°C时收到预警
• 显存使用持续超过90%时提醒优化
• 记录历史峰值，为散热改进提供数据支持

3. 环境准备与依赖安装

现在我们来实际部署监控面板。别担心，整个过程就像安装一个手机App一样简单。

3.1 检查现有环境

首先确认你的SPIRAN ART SUMMONER已经正常运行。打开终端，进入项目目录：

cd /path/to/spiran-art-summoner

检查Streamlit服务是否在运行：

# 查看进程 ps aux | grep streamlit # 或者直接访问Web界面 # 默认地址是 http://localhost:8501

如果能看到SPIRAN的幻光界面，说明基础环境没问题。

3.2 安装监控依赖

监控面板需要几个Python库来获取硬件信息。在项目目录下打开新的终端，执行：

# 安装核心监控库 pip install gpustat pynvml psutil # 安装Web界面增强库（可选，但推荐） pip install plotly dash

这些库是干什么的？

• gpustat：专门用于获取NVIDIA GPU信息（温度、显存、利用率）
• pynvml：NVIDIA官方的GPU管理库
• psutil：获取CPU、内存等系统信息
• plotly：创建漂亮的实时图表

3.3 验证安装是否成功

运行一个简单的测试脚本，确保能正确读取GPU信息：

# 创建测试文件 test_gpu.py import gpustat try: stats = gpustat.GPUStatCollection.new_query() for gpu in stats: print(f"GPU {gpu.index}: {gpu.name}") print(f" 温度: {gpu.temperature}°C") print(f" 显存: {gpu.memory_used}/{gpu.memory_total} MB") print(f" 利用率: {gpu.utilization}%") print("✅ GPU信息读取成功！") except Exception as e: print(f"❌ 读取失败: {e}")

运行测试：

python test_gpu.py

你应该能看到类似这样的输出：

GPU 0: NVIDIA GeForce RTX 4090D 温度: 42°C 显存: 1024/24564 MB 利用率: 5% ✅ GPU信息读取成功！

4. 集成监控面板到SPIRAN界面

接下来，我们要把监控功能“嵌入”到SPIRAN ART SUMMONER的幻光界面中。这里提供两种方案，你可以根据需求选择。

4.1 方案一：侧边栏监控（简单集成）

如果你希望监控面板不干扰主创作界面，可以把它放在侧边栏。

找到SPIRAN项目中的主Streamlit文件（通常是app.py或main.py），在合适的位置添加以下代码：

# 在导入部分添加 import streamlit as st import gpustat import psutil import time from datetime import datetime # 在侧边栏部分添加监控面板 with st.sidebar: st.markdown("---") st.markdown("### 🔮 幻光引擎监控") # 创建刷新按钮 if st.button("刷新监控数据", key="refresh_monitor"): st.rerun() # 获取GPU信息 try: gpu_stats = gpustat.GPUStatCollection.new_query() gpu = gpu_stats.gpus[0] # 假设只有一块GPU # 显示关键指标 col1, col2 = st.columns(2) with col1: # GPU温度（带颜色提示） temp = gpu.temperature if temp < 60: temp_color = "🟢" elif temp < 80: temp_color = "🟡" else: temp_color = "🔴" st.metric("GPU温度", f"{temp}°C", delta=None, help=f"{temp_color} 正常范围: 30-80°C") # GPU利用率 util = gpu.utilization st.metric("GPU利用率", f"{util}%") with col2: # 显存使用 mem_used = gpu.memory_used mem_total = gpu.memory_total mem_percent = (mem_used / mem_total) * 100 st.metric("显存使用", f"{mem_used}/{mem_total} MB") st.progress(mem_percent / 100, text=f"占用率: {mem_percent:.1f}%") # 系统信息 st.markdown("#### 系统状态") cpu_percent = psutil.cpu_percent() memory = psutil.virtual_memory() st.metric("CPU使用率", f"{cpu_percent}%") st.metric("内存使用", f"{memory.used//1024**3}/{memory.total//1024**3} GB") # 最后更新时间 st.caption(f"最后更新: {datetime.now().strftime('%H:%M:%S')}") except Exception as e: st.warning(f"监控数据获取失败: {e}") st.info("请确保已安装gpustat和psutil库")

这个方案的特点：

• 简单直接，10分钟就能搞定
• 不修改主界面布局
• 数据手动刷新，减少性能开销
• 适合轻度监控需求

4.2 方案二：独立监控页面（高级集成）

如果你需要更详细的监控和历史数据，可以创建一个独立的监控页面。

4.2.1 创建监控模块

在项目目录下新建一个文件monitor.py：

# monitor.py - 高级监控模块 import streamlit as st import gpustat import psutil import time import pandas as pd import plotly.graph_objects as go from threading import Thread from queue import Queue import json from pathlib import Path class SpiranMonitor: def __init__(self, history_size=100): """初始化监控器""" self.history_size = history_size self.data_queue = Queue() self.history_file = Path("monitor_history.json") self.load_history() def load_history(self): """加载历史数据""" if self.history_file.exists(): with open(self.history_file, 'r') as f: self.history_data = json.load(f) else: self.history_data = { 'timestamps': [], 'gpu_temp': [], 'gpu_mem': [], 'gpu_util': [], 'cpu_util': [], 'sys_mem': [] } def save_history(self): """保存历史数据""" with open(self.history_file, 'w') as f: json.dump(self.history_data, f) def collect_data(self): """收集一次监控数据""" try: # GPU信息 gpu_stats = gpustat.GPUStatCollection.new_query() gpu = gpu_stats.gpus[0] # 系统信息 cpu_percent = psutil.cpu_percent() memory = psutil.virtual_memory() data = { 'timestamp': time.time(), 'gpu_temp': gpu.temperature, 'gpu_mem_used': gpu.memory_used, 'gpu_mem_total': gpu.memory_total, 'gpu_util': gpu.utilization, 'cpu_util': cpu_percent, 'sys_mem_used': memory.used, 'sys_mem_total': memory.total, 'sys_mem_percent': memory.percent } # 更新历史数据 self.history_data['timestamps'].append( time.strftime('%H:%M:%S', time.localtime(data['timestamp'])) ) self.history_data['gpu_temp'].append(data['gpu_temp']) self.history_data['gpu_mem'].append( data['gpu_mem_used'] / data['gpu_mem_total'] * 100 ) self.history_data['gpu_util'].append(data['gpu_util']) self.history_data['cpu_util'].append(data['cpu_util']) self.history_data['sys_mem'].append(data['sys_mem_percent']) # 保持历史数据大小 for key in self.history_data: if len(self.history_data[key]) > self.history_size: self.history_data[key] = self.history_data[key][-self.history_size:] self.data_queue.put(data) self.save_history() return data except Exception as e: print(f"数据收集错误: {e}") return None def get_realtime_chart(self): """生成实时监控图表""" if len(self.history_data['timestamps']) < 2: return None fig = go.Figure() # GPU温度曲线 fig.add_trace(go.Scatter( x=self.history_data['timestamps'], y=self.history_data['gpu_temp'], name='GPU温度 (°C)', line=dict(color='#FF6B6B', width=2), yaxis='y1' )) # GPU利用率曲线 fig.add_trace(go.Scatter( x=self.history_data['timestamps'], y=self.history_data['gpu_util'], name='GPU利用率 (%)', line=dict(color='#4ECDC4', width=2), yaxis='y2' )) # 显存使用曲线 fig.add_trace(go.Scatter( x=self.history_data['timestamps'], y=self.history_data['gpu_mem'], name='显存使用 (%)', line=dict(color='#45B7D1', width=2), yaxis='y3' )) # 设置图表样式 fig.update_layout( title='幻光引擎实时监控', xaxis_title='时间', yaxis_title='温度 (°C)', yaxis2=dict( title='GPU利用率 (%)', overlaying='y', side='right', range=[0, 100] ), yaxis3=dict( title='显存使用 (%)', overlaying='y', side='right', position=0.95, range=[0, 100] ), hovermode='x unified', template='plotly_dark', height=400 ) return fig # 创建全局监控实例 monitor = SpiranMonitor()

4.2.2 创建监控页面

新建一个Streamlit页面文件pages/monitor_dashboard.py：

# pages/monitor_dashboard.py - 独立监控页面 import streamlit as st import time from monitor import monitor st.set_page_config( page_title="幻光监控面板", page_icon="🔮", layout="wide" ) # 自定义CSS样式，匹配SPIRAN的幻光主题 st.markdown(""" <style> .main-header { background: linear-gradient(135deg, #0066ff 0%, #00f2ff 100%); -webkit-background-clip: text; -webkit-text-fill-color: transparent; font-size: 2.5rem; font-weight: bold; margin-bottom: 1rem; } .metric-card { background: rgba(0, 102, 255, 0.1); border-radius: 10px; padding: 1rem; border-left: 4px solid #00f2ff; margin-bottom: 1rem; } .warning { color: #FF6B6B; font-weight: bold; } .normal { color: #4ECDC4; } </style> """, unsafe_allow_html=True) # 页面标题 st.markdown('<div class="main-header">🔮 斯皮拉幻光引擎监控面板</div>', unsafe_allow_html=True) st.caption("实时监控GPU状态，确保你的创作之旅畅通无阻") # 自动刷新设置 auto_refresh = st.checkbox("开启自动刷新（每5秒）", value=True) refresh_interval = 5 if auto_refresh else 0 # 创建布局 col1, col2, col3 = st.columns([2, 1, 1]) with col1: st.markdown("### 📈 实时趋势") # 获取最新数据并更新图表 latest_data = monitor.collect_data() chart = monitor.get_realtime_chart() if chart: st.plotly_chart(chart, use_container_width=True) else: st.info("正在收集监控数据，请稍候...") # 显示数据表格 if len(monitor.history_data['timestamps']) > 0: df = pd.DataFrame({ '时间': monitor.history_data['timestamps'][-10:], # 最近10条 'GPU温度 (°C)': monitor.history_data['gpu_temp'][-10:], 'GPU利用率 (%)': monitor.history_data['gpu_util'][-10:], '显存使用 (%)': monitor.history_data['gpu_mem'][-10:], 'CPU使用 (%)': monitor.history_data['cpu_util'][-10:], '内存使用 (%)': monitor.history_data['sys_mem'][-10:] }) st.dataframe(df.style.format({ 'GPU温度 (°C)': '{:.1f}', 'GPU利用率 (%)': '{:.1f}', '显存使用 (%)': '{:.1f}', 'CPU使用 (%)': '{:.1f}', '内存使用 (%)': '{:.1f}' }), use_container_width=True) with col2: st.markdown("### 🔥 GPU状态") if latest_data: # GPU温度 temp = latest_data['gpu_temp'] temp_status = "正常" if temp < 75 else "注意" if temp < 85 else "警告" temp_color = "normal" if temp < 75 else "warning" st.markdown(f""" <div class="metric-card"> <h4>GPU温度</h4> <h2 class="{temp_color}">{temp}°C</h2> <p>状态: <span class="{temp_color}">{temp_status}</span></p> <p>正常范围: 30-75°C</p> </div> """, unsafe_allow_html=True) # GPU利用率 util = latest_data['gpu_util'] st.markdown(f""" <div class="metric-card"> <h4>GPU利用率</h4> <h2>{util}%</h2> <p>当前负载</p> </div> """, unsafe_allow_html=True) # 显存使用 mem_percent = (latest_data['gpu_mem_used'] / latest_data['gpu_mem_total'] * 100) st.progress(mem_percent / 100, text=f"显存使用: {mem_percent:.1f}%") st.caption(f"{latest_data['gpu_mem_used']//1024}/" f"{latest_data['gpu_mem_total']//1024} GB") with col3: st.markdown("### 💻 系统状态") if latest_data: # CPU使用率 cpu_util = latest_data['cpu_util'] st.markdown(f""" <div class="metric-card"> <h4>CPU使用率</h4> <h2>{cpu_util}%</h2> <p>处理器负载</p> </div> """, unsafe_allow_html=True) # 内存使用 sys_mem_percent = latest_data['sys_mem_percent'] st.markdown(f""" <div class="metric-card"> <h4>系统内存</h4> <h2>{sys_mem_percent}%</h2> <p>已用/总计</p> </div> """, unsafe_allow_html=True) st.caption(f"{latest_data['sys_mem_used']//1024**3}/" f"{latest_data['sys_mem_total']//1024**3} GB") # 生成延迟估算（基于历史数据） if len(monitor.history_data['gpu_util']) > 1: avg_util = sum(monitor.history_data['gpu_util'][-5:]) / 5 if avg_util > 80: delay_status = "较高" delay_color = "warning" elif avg_util > 50: delay_status = "正常" delay_color = "normal" else: delay_status = "较低" delay_color = "normal" st.markdown(f""" <div class="metric-card"> <h4>预估生成延迟</h4> <h2 class="{delay_color}">{delay_status}</h2> <p>基于GPU负载估算</p> </div> """, unsafe_allow_html=True) # 状态提示 st.markdown("---") col_info1, col_info2, col_info3 = st.columns(3) with col_info1: st.info(""" **💡 使用建议** - GPU温度 > 80°C：考虑暂停任务降温 - 显存 > 90%：降低分辨率或批量大小 - 高负载时生成延迟会增加 """) with col_info2: st.warning(""" **⚠️ 警告提示** - 持续高温可能损伤硬件 - 显存不足会导致生成失败 - 建议定期清理显存缓存 """) with col_info3: st.success(""" **✅ 最佳实践** - 生成前检查显存余量 - 长时间任务监控温度 - 合理设置生成参数 """) # 手动刷新按钮 if st.button("🔄 手动刷新数据", type="primary"): st.rerun() # 自动刷新逻辑 if auto_refresh: time.sleep(refresh_interval) st.rerun() # 底部信息 st.markdown("---") st.caption(f"最后更新: {time.strftime('%Y-%m-%d %H:%M:%S')}") st.caption("监控数据仅用于参考，实际性能可能因环境而异")

4.2.3 修改主程序添加导航

在SPIRAN的主程序文件中，添加监控页面的导航链接：

# 在SPIRAN主界面的侧边栏添加 with st.sidebar: # ... 原有的SPIRAN侧边栏代码 ... st.markdown("---") st.markdown("#### 🛠️ 系统工具") # 添加监控面板链接 if st.button("📊 打开监控面板", use_container_width=True): # 这里需要根据你的实际路由设置 # 如果是多页面应用，可以直接跳转 st.switch_page("pages/monitor_dashboard.py") # 或者使用markdown链接 st.markdown("[📊 在新标签页打开监控面板](http://localhost:8501/monitor_dashboard)")

这个方案的特点：

• 功能完整，有历史数据和趋势图表
• 自动刷新，实时监控
• 独立页面，不干扰创作
• 美观的UI，匹配SPIRAN主题
• 需要更多代码，但效果更好

5. 监控面板的使用技巧

部署好监控面板后，这里有一些实用技巧帮你更好地使用它。

5.1 理解关键指标的含义

GPU温度：

• < 60°C：凉爽状态，可以全力运行
• 60-75°C：正常负载，持续监控
• 75-85°C：较高负载，考虑优化或暂停
• > 85°C：危险温度，立即停止任务

显存使用率：

• < 70%：充足，可以处理复杂任务
• 70-90%：需要注意，避免同时运行多个任务
• > 90%：接近极限，可能发生显存溢出

GPU利用率：

• < 30%：轻负载，可能有性能瓶颈在其他地方
• 30-70%：正常负载
• > 70%：高负载，生成速度较快但温度上升

5.2 根据监控数据优化生成策略

通过监控数据，你可以建立自己的“最佳实践”：

# 基于监控数据的智能生成策略 def smart_generation_strategy(monitor_data): """ 根据监控数据动态调整生成参数 """ gpu_temp = monitor_data['gpu_temp'] gpu_mem_percent = monitor_data['gpu_mem_percent'] # 基础参数 base_params = { 'steps': 30, 'cfg_scale': 7.5, 'width': 1024, 'height': 1024, 'batch_size': 1 } # 根据温度调整 if gpu_temp > 80: # 高温时降低负载 base_params['steps'] = 20 base_params['width'] = 768 base_params['height'] = 768 print("⚠️ GPU温度较高，已自动降低生成质量") # 根据显存调整 if gpu_mem_percent > 85: # 显存紧张时减少批量大小 base_params['batch_size'] = 1 print("⚠️ 显存使用率高，已禁用批量生成") elif gpu_mem_percent < 50: # 显存充足时增加批量 base_params['batch_size'] = 2 print("✅ 显存充足，已启用批量生成") return base_params # 在生成前调用 current_monitor_data = monitor.collect_data() optimal_params = smart_generation_strategy(current_monitor_data)

5.3 常见问题排查

问题1：监控面板显示“No GPU detected”

解决方案： 1. 确认已安装NVIDIA驱动：nvidia-smi 2. 确认CUDA可用：python -c "import torch; print(torch.cuda.is_available())" 3. 重新安装gpustat：pip install --upgrade gpustat

问题2：数据刷新导致界面卡顿

解决方案： 1. 增加刷新间隔：从5秒改为10秒 2. 使用轻量级模式：只监控关键指标 3. 在独立页面运行监控，不影响主界面

问题3：历史数据不保存

解决方案： 1. 检查monitor_history.json文件权限 2. 确认磁盘空间充足 3. 减少历史数据大小：history_size=50

6. 高级功能扩展

如果你对监控有更高要求，这里还有一些可以扩展的功能。

6.1 邮件/钉钉告警

当GPU温度或显存使用超过阈值时，自动发送告警：

# 告警功能扩展 import smtplib from email.mime.text import MIMEText class MonitorAlert: def __init__(self, config): self.config = config self.last_alert_time = {} def check_and_alert(self, monitor_data): """检查阈值并发送告警""" alerts = [] # GPU温度告警 if monitor_data['gpu_temp'] > self.config['temp_threshold']: if self._should_alert('gpu_temp'): alerts.append(f"GPU温度过高: {monitor_data['gpu_temp']}°C") # 显存使用告警 mem_percent = (monitor_data['gpu_mem_used'] / monitor_data['gpu_mem_total'] * 100) if mem_percent > self.config['mem_threshold']: if self._should_alert('gpu_mem'): alerts.append(f"显存使用过高: {mem_percent:.1f}%") # 发送告警 if alerts: self.send_alert("\n".join(alerts)) def _should_alert(self, alert_type): """防止告警轰炸，最小间隔5分钟""" current_time = time.time() last_time = self.last_alert_time.get(alert_type, 0) if current_time - last_time > 300: # 5分钟 self.last_alert_time[alert_type] = current_time return True return False def send_alert(self, message): """发送邮件告警""" # 这里需要配置你的邮件服务器 msg = MIMEText(f"SPIRAN监控告警:\n\n{message}") msg['Subject'] = 'SPIRAN GPU监控告警' msg['From'] = self.config['email_from'] msg['To'] = self.config['email_to'] try: with smtplib.SMTP(self.config['smtp_server'], self.config['smtp_port']) as server: server.starttls() server.login(self.config['email_user'], self.config['email_password']) server.send_message(msg) print(f"告警已发送: {message}") except Exception as e: print(f"告警发送失败: {e}") # 配置和使用 alert_config = { 'temp_threshold': 80, 'mem_threshold': 90, 'smtp_server': 'smtp.example.com', 'smtp_port': 587, 'email_from': 'monitor@example.com', 'email_to': 'admin@example.com', 'email_user': 'your_username', 'email_password': 'your_password' } alert_system = MonitorAlert(alert_config) # 在监控循环中调用 # alert_system.check_and_alert(latest_data)

6.2 生成性能分析

记录每次生成的性能数据，帮助优化参数：

# 性能分析扩展 import json from datetime import datetime class GenerationAnalyzer: def __init__(self): self.performance_log = [] self.log_file = "generation_performance.json" def log_generation(self, params, monitor_before, monitor_after, generation_time, image_size): """记录生成性能数据""" record = { 'timestamp': datetime.now().isoformat(), 'params': params, 'monitor_before': monitor_before, 'monitor_after': monitor_after, 'generation_time': generation_time, 'image_size': image_size, 'performance_score': self._calculate_score( generation_time, image_size, monitor_after ) } self.performance_log.append(record) # 保存到文件 with open(self.log_file, 'w') as f: json.dump(self.performance_log[-100:], f, indent=2) # 只保留最近100条 def _calculate_score(self, time, size, monitor_data): """计算性能评分""" # 简单的评分逻辑：时间越短、尺寸越大、温度越低，分数越高 time_score = max(0, 100 - time) # 每秒钟减1分 size_score = (size[0] * size[1]) / 10000 # 每万像素加1分 temp_penalty = max(0, monitor_data['gpu_temp'] - 60) * 2 # 超过60°C每度减2分 return time_score + size_score - temp_penalty def get_optimal_params(self): """基于历史数据推荐最优参数""" if not self.performance_log: return None # 找出评分最高的记录 best_record = max(self.performance_log, key=lambda x: x['performance_score']) return { 'recommended_params': best_record['params'], 'expected_time': best_record['generation_time'], 'score': best_record['performance_score'], 'sample_count': len(self.performance_log) } # 使用示例 analyzer = GenerationAnalyzer() # 在生成开始和结束时记录 start_time = time.time() monitor_before = monitor.collect_data() # ... 执行生成 ... end_time = time.time() monitor_after = monitor.collect_data() analyzer.log_generation( params=generation_params, monitor_before=monitor_before, monitor_after=monitor_after, generation_time=end_time - start_time, image_size=(width, height) ) # 获取优化建议 advice = analyzer.get_optimal_params() if advice: print(f"💡 基于{advice['sample_count']}次生成记录，推荐参数：") print(f" 步数: {advice['recommended_params']['steps']}") print(f" 分辨率: {advice['recommended_params']['width']}x" f"{advice['recommended_params']['height']}") print(f" 预计时间: {advice['expected_time']:.1f}秒")

6.3 移动端监控

如果你希望在外出时也能查看GPU状态，可以添加简单的Web API：

# 简单的监控API from flask import Flask, jsonify import threading app = Flask(__name__) @app.route('/api/monitor') def get_monitor_data(): """获取当前监控数据的API接口""" data = monitor.collect_data() if data: return jsonify({ 'status': 'success', 'data': { 'gpu_temp': data['gpu_temp'], 'gpu_memory_percent': (data['gpu_mem_used'] / data['gpu_mem_total'] * 100), 'gpu_utilization': data['gpu_util'], 'cpu_utilization': data['cpu_util'], 'system_memory_percent': data['sys_mem_percent'], 'timestamp': data['timestamp'] } }) else: return jsonify({'status': 'error', 'message': '无法获取监控数据'}) def start_monitor_api(port=5000): """启动监控API服务""" threading.Thread( target=lambda: app.run(host='0.0.0.0', port=port, debug=False), daemon=True ).start() print(f"📱 监控API已启动: http://localhost:{port}/api/monitor") # 在SPIRAN启动时同时启动API # start_monitor_api()

这样你就可以通过手机浏览器访问http://你的服务器IP:5000/api/monitor查看实时状态了。

7. 总结

通过本教程，你已经成功为SPIRAN ART SUMMONER集成了一个功能完整的监控面板。让我们回顾一下关键收获：

7.1 监控面板的核心价值

1. 从盲目到可视：不再猜测GPU状态，所有关键指标一目了然
2. 预防性维护：在问题发生前预警，避免生成中断和硬件损伤
3. 性能优化：基于数据调整参数，找到质量与效率的最佳平衡点
4. 安心创作：专注于艺术创作，技术细节交给监控系统

7.2 不同方案的适用场景

• 侧边栏监控（方案一）：适合轻度用户，快速部署，基本功能
• 独立监控页面（方案二）：适合深度用户，完整功能，历史数据分析
• 高级扩展功能：适合专业用户，告警、分析、远程监控

7.3 最佳实践建议

1. 日常使用：开启侧边栏监控，每隔几分钟看一眼关键指标
2. 批量生成时：打开独立监控页面，观察趋势变化
3. 长时间运行：设置温度告警，避免硬件过热
4. 参数调优：利用性能分析功能，找到最适合你硬件的参数组合

7.4 下一步探索方向

如果你对这个监控系统感兴趣，还可以进一步扩展：

1. 集成到SPIRAN主题：让监控面板的UI完全匹配幻光风格
2. 添加更多指标：磁盘IO、网络延迟、模型加载时间等
3. 自动化优化：基于监控数据自动调整生成队列
4. 多GPU支持：如果你有多个GPU，可以分别监控

记住，好的工具应该让你更专注于创作本身，而不是技术细节。SPIRAN ART SUMMONER的幻光引擎很强大，配上这个监控面板，就像给赛车装上了专业的仪表盘——让你既能享受速度与激情，又能确保旅程安全顺畅。

现在，打开你的监控面板，开始无忧无虑的AI艺术创作吧！当幻光虫在屏幕上飞舞时，你知道背后的引擎正在健康高效地运行，这种感觉，很安心。

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。