ChatGLM-6B与MySQL数据库智能交互方案

ChatGLM-6B与MySQL数据库智能交互方案

想象一下这个场景：你是一家电商公司的数据分析师，每天都要面对销售部门同事的各种数据查询需求。

“帮我查一下上个月华东地区手机品类的销售额排名前五的城市。” “对比一下这个季度和上个季度服装类目的退货率变化。” “预测一下下个月家电产品的库存需求。”

这些需求听起来很合理，但问题来了——销售同事不懂SQL，你不可能每次都亲自写查询语句。传统的解决方案要么是开发固定的报表系统（不够灵活），要么是培训业务人员学SQL（成本太高）。有没有一种方法，能让业务人员用自然语言直接查询数据库，就像跟同事聊天一样简单？

这就是我们今天要聊的ChatGLM-6B与MySQL智能交互方案。它不是什么遥不可及的黑科技，而是一个实实在在能落地的企业级解决方案。接下来，我会带你一步步了解这个方案的核心思路、实现方法，以及在实际业务中能带来什么价值。

1. 为什么需要自然语言查询数据库？

在深入技术细节之前，我们先看看传统数据查询方式面临的几个痛点。

1.1 业务人员的困境

大部分业务人员没有编程背景，更别说写SQL了。当他们需要数据支持决策时，通常要走这样一个流程：

1. 向数据分析师或IT部门提需求
2. 等待需求排期（短则几小时，长则几天）
3. 沟通需求细节（经常出现理解偏差）
4. 收到结果后发现有新问题，又要重新走流程

这个过程中，时间成本高，沟通成本更高。更糟糕的是，当业务需要快速响应市场变化时，这种延迟往往是致命的。

1.2 技术人员的负担

从技术团队的角度看，情况也不乐观：

• 重复劳动：很多查询需求其实很相似，但每次都要重新写SQL
• 资源浪费：高级技术人员的时间被大量基础查询工作占用
• 安全风险：如果直接给业务人员数据库权限，可能因为误操作导致数据问题

1.3 自然语言查询的优势

自然语言查询数据库的方案，正好能解决这些问题：

• 零门槛：业务人员用日常语言提问，不需要学SQL
• 即时响应：问题提出后几秒钟就能得到答案
• 灵活自由：可以问任何想到的问题，不受固定报表限制
• 安全可控：查询经过模型解析和校验，避免直接操作数据库的风险

2. 方案整体架构设计

要实现自然语言查询数据库，我们需要一个完整的系统架构。这个架构的核心思想是：把自然语言问题转换成SQL语句，执行查询后，再把结果用自然语言解释给用户。

2.1 核心组件

整个系统由四个主要部分组成：

1. 自然语言理解模块：基于ChatGLM-6B，理解用户的问题意图
2. SQL生成模块：根据理解的结果，生成对应的SQL查询语句
3. 查询执行模块：连接MySQL数据库，执行SQL并获取结果
4. 结果解释模块：把查询结果转换成易于理解的文字描述

2.2 工作流程

当用户提出一个问题时，系统会这样处理：

用户问题 → ChatGLM理解 → SQL生成 → 数据库查询 → 结果解释 → 用户答案

举个例子，用户问：“上个月销售额最高的产品是什么？”

系统会这样处理：

1. ChatGLM理解到用户想查询“销售额最高”的产品，时间范围是“上个月”
2. 生成SQL：SELECT product_name, SUM(sales_amount) FROM sales WHERE sale_date >= '2024-01-01' AND sale_date <= '2024-01-31' GROUP BY product_name ORDER BY SUM(sales_amount) DESC LIMIT 1
3. 执行查询，假设得到结果：('智能手机X', 1500000)
4. 解释结果：“上个月销售额最高的产品是智能手机X，总销售额为150万元。”

3. 关键技术实现细节

理论说完了，我们来看看具体怎么实现。我会用实际的代码示例来说明每个关键环节。

3.1 ChatGLM-6B的部署与调用

首先，我们需要部署ChatGLM-6B模型。这里提供一个简单的API服务部署方案：

# api_service.py from fastapi import FastAPI, HTTPException from pydantic import BaseModel from transformers import AutoTokenizer, AutoModel import torch app = FastAPI() # 加载ChatGLM-6B模型 model_path = "./chatglm-6b" tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True) model = AutoModel.from_pretrained(model_path, trust_remote_code=True).half().cuda() model.eval() class QueryRequest(BaseModel): question: str history: list = [] @app.post("/chat") async def chat_with_glm(request: QueryRequest): try: response, history = model.chat( tokenizer, request.question, history=request.history, max_length=2048, top_p=0.7, temperature=0.95 ) return { "response": response, "history": history, "status": "success" } except Exception as e: raise HTTPException(status_code=500, detail=str(e)) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

这个API服务启动后，我们就可以通过HTTP请求与ChatGLM-6B交互了。

3.2 自然语言到SQL的转换

这是整个系统的核心难点。我们需要训练或微调模型，让它学会根据数据库结构和用户问题生成正确的SQL。

3.2.1 数据库结构理解

首先，模型需要知道数据库里有什么。我们可以提供一个数据库结构描述：

# database_schema.py database_schema = { "sales": { "columns": { "id": "INT, 主键", "product_id": "INT, 产品ID", "sale_date": "DATE, 销售日期", "quantity": "INT, 销售数量", "unit_price": "DECIMAL(10,2), 单价", "sales_amount": "DECIMAL(10,2), 销售额", "region": "VARCHAR(50), 销售区域" }, "description": "销售记录表，包含每笔销售的详细信息" }, "products": { "columns": { "id": "INT, 主键", "product_name": "VARCHAR(100), 产品名称", "category": "VARCHAR(50), 产品类别", "cost_price": "DECIMAL(10,2), 成本价" }, "description": "产品信息表" }, "customers": { "columns": { "id": "INT, 主键", "customer_name": "VARCHAR(100), 客户名称", "region": "VARCHAR(50), 所在区域", "customer_level": "VARCHAR(20), 客户等级" }, "description": "客户信息表" } }

3.2.2 SQL生成提示词设计

为了让ChatGLM生成正确的SQL，我们需要设计专门的提示词（prompt）：

def build_sql_prompt(question, schema_description): prompt = f"""你是一个专业的SQL生成助手。请根据用户的问题和数据库结构，生成正确的MySQL查询语句。 数据库结构： {schema_description} 用户问题：{question} 请按照以下步骤思考： 1. 理解用户问题的真实意图 2. 确定需要查询哪些表 3. 确定需要哪些字段 4. 确定过滤条件（WHERE子句） 5. 确定分组和排序方式（如果有的话） 6. 生成完整的SQL语句 只输出SQL语句，不要有其他解释。""" return prompt

3.2.3 完整的SQL生成流程

# sql_generator.py import re class SQLGenerator: def __init__(self, chatglm_api_url="http://localhost:8000/chat"): self.api_url = chatglm_api_url self.schema = self.load_schema() def load_schema(self): # 从文件或配置加载数据库结构 # 这里简化处理，直接返回描述 return """ 表名：sales（销售记录表） 字段：id, product_id, sale_date, quantity, unit_price, sales_amount, region 表名：products（产品表） 字段：id, product_name, category, cost_price 表名：customers（客户表） 字段：id, customer_name, region, customer_level """ def generate_sql(self, question): # 构建提示词 prompt = self.build_sql_prompt(question) # 调用ChatGLM API import requests response = requests.post( self.api_url, json={"prompt": prompt, "history": []} ) if response.status_code == 200: result = response.json() sql = self.extract_sql(result["response"]) return sql else: raise Exception(f"API调用失败: {response.text}") def build_sql_prompt(self, question): return f"""你是一个SQL专家。请根据以下数据库结构和用户问题，生成正确的MySQL查询语句。 数据库结构： {self.schema} 用户问题：{question} 请生成SQL语句，只输出SQL，不要有其他内容。""" def extract_sql(self, response_text): # 从模型回复中提取SQL语句 # 使用正则表达式匹配SELECT开头的语句 sql_pattern = r"SELECT.*?(?:;|$)" match = re.search(sql_pattern, response_text, re.IGNORECASE | re.DOTALL) if match: sql = match.group(0).strip() # 确保以分号结尾 if not sql.endswith(';'): sql += ';' return sql else: # 如果没有匹配到，尝试直接使用回复内容 lines = response_text.strip().split('\n') for line in lines: if line.strip().upper().startswith('SELECT'): sql = line.strip() if not sql.endswith(';'): sql += ';' return sql raise Exception("无法从回复中提取SQL语句")

3.3 数据库查询执行

生成SQL后，我们需要安全地执行查询。这里要特别注意安全性，避免SQL注入等问题。

# database_query.py import pymysql from pymysql.cursors import DictCursor import logging class DatabaseQuery: def __init__(self, host, port, user, password, database): self.db_config = { "host": host, "port": port, "user": user, "password": password, "database": database, "charset": "utf8mb4", "cursorclass": DictCursor } self.logger = logging.getLogger(__name__) def execute_query(self, sql, params=None): """ 执行SQL查询，返回结果 """ connection = None try: # 验证SQL语句的安全性 self.validate_sql(sql) connection = pymysql.connect(**self.db_config) with connection.cursor() as cursor: if params: cursor.execute(sql, params) else: cursor.execute(sql) # 获取查询结果 if sql.strip().upper().startswith("SELECT"): result = cursor.fetchall() # 获取列名 column_names = [desc[0] for desc in cursor.description] return { "columns": column_names, "data": result, "row_count": len(result) } else: # 对于非SELECT语句，返回影响的行数 connection.commit() return { "affected_rows": cursor.rowcount, "message": "执行成功" } except pymysql.Error as e: self.logger.error(f"数据库查询错误: {e}") raise Exception(f"数据库查询失败: {str(e)}") finally: if connection: connection.close() def validate_sql(self, sql): """ 简单的SQL验证，防止危险操作 """ sql_upper = sql.upper().strip() # 禁止的操作 dangerous_keywords = [ "DROP", "DELETE", "TRUNCATE", "UPDATE", "INSERT", "ALTER", "CREATE", "GRANT", "REVOKE" ] # 如果是SELECT语句，检查是否包含危险操作 if sql_upper.startswith("SELECT"): for keyword in dangerous_keywords: if keyword in sql_upper: # 检查是否在注释或字符串中 if not self.is_in_comment_or_string(sql_upper, keyword): raise Exception(f"SQL语句包含禁止的操作: {keyword}") else: # 非SELECT语句直接拒绝 raise Exception("只允许执行SELECT查询语句") def is_in_comment_or_string(self, sql, keyword): """ 检查关键字是否在注释或字符串中 这是一个简化的实现，实际应用中需要更复杂的解析 """ # 移除单行注释 lines = sql.split('\n') clean_lines = [] for line in lines: if '--' in line: line = line.split('--')[0] clean_lines.append(line) clean_sql = ' '.join(clean_lines) # 检查关键字是否在引号内（简化处理） import re # 匹配单引号或双引号内的内容 quoted_pattern = r"['\"].*?['\"]" clean_sql = re.sub(quoted_pattern, '', clean_sql) return keyword not in clean_sql

3.4 查询结果的自然语言解释

拿到查询结果后，我们需要用自然语言解释给用户听。这个环节也很重要，因为原始数据对业务人员可能不够直观。

# result_interpreter.py class ResultInterpreter: def __init__(self, chatglm_api_url="http://localhost:8000/chat"): self.api_url = chatglm_api_url def interpret_result(self, question, sql, query_result): """ 将查询结果解释成自然语言 """ # 构建解释提示词 prompt = self.build_interpret_prompt(question, sql, query_result) # 调用ChatGLM API import requests response = requests.post( self.api_url, json={"prompt": prompt, "history": []} ) if response.status_code == 200: result = response.json() return result["response"] else: # 如果API调用失败，返回简单的解释 return self.simple_interpret(query_result) def build_interpret_prompt(self, question, sql, query_result): """ 构建结果解释的提示词 """ # 将查询结果转换成文本格式 result_text = self.format_result(query_result) prompt = f"""用户提出了这个问题：{question} 我们执行了以下SQL查询： {sql} 查询结果如下： {result_text} 请用自然语言解释这个查询结果，回答用户的问题。解释要简洁明了，让不懂技术的人也能听懂。""" return prompt def format_result(self, query_result): """ 格式化查询结果，便于模型理解 """ if "columns" in query_result and "data" in query_result: # 格式化表格数据 columns = query_result["columns"] data = query_result["data"] # 构建表头 header = " | ".join(columns) separator = "-" * len(header) # 构建数据行 rows = [] for row in data[:10]: # 只显示前10行，避免太长 if isinstance(row, dict): row_values = [str(row.get(col, "")) for col in columns] else: row_values = [str(value) for value in row] rows.append(" | ".join(row_values)) result_text = f"{header}\n{separator}\n" + "\n".join(rows) if len(data) > 10: result_text += f"\n... 还有 {len(data) - 10} 行数据未显示" return result_text else: return str(query_result) def simple_interpret(self, query_result): """ 简单的结果解释（备用方案） """ if "row_count" in query_result: row_count = query_result["row_count"] if row_count == 0: return "查询没有找到匹配的数据。" elif row_count == 1: return f"查询找到了1条记录。" else: return f"查询找到了{row_count}条记录。" else: return "查询执行成功。"

4. 完整系统集成

现在我们把各个模块组合起来，形成一个完整的系统。

# natural_language_query_system.py import json from sql_generator import SQLGenerator from database_query import DatabaseQuery from result_interpreter import ResultInterpreter class NaturalLanguageQuerySystem: def __init__(self, config_file="config.json"): # 加载配置 with open(config_file, 'r', encoding='utf-8') as f: config = json.load(f) # 初始化各个组件 self.sql_generator = SQLGenerator(config["chatglm_api_url"]) self.db_query = DatabaseQuery( host=config["database"]["host"], port=config["database"]["port"], user=config["database"]["user"], password=config["database"]["password"], database=config["database"]["database"] ) self.interpreter = ResultInterpreter(config["chatglm_api_url"]) # 查询历史记录 self.query_history = [] def process_query(self, question): """ 处理用户查询的完整流程 """ try: print(f"处理问题: {question}") # 步骤1：生成SQL print("正在生成SQL语句...") sql = self.sql_generator.generate_sql(question) print(f"生成的SQL: {sql}") # 步骤2：执行查询 print("正在执行数据库查询...") query_result = self.db_query.execute_query(sql) print(f"查询结果行数: {query_result.get('row_count', 'N/A')}") # 步骤3：解释结果 print("正在解释查询结果...") explanation = self.interpreter.interpret_result(question, sql, query_result) # 保存到历史记录 self.query_history.append({ "question": question, "sql": sql, "result_summary": f"返回{query_result.get('row_count', 0)}行数据", "explanation": explanation }) return { "success": True, "explanation": explanation, "sql": sql, "raw_result": query_result } except Exception as e: error_msg = f"查询处理失败: {str(e)}" print(error_msg) return { "success": False, "error": error_msg, "explanation": f"抱歉，处理您的查询时出现了问题：{str(e)}" } def get_history(self): """ 获取查询历史 """ return self.query_history # 配置文件示例 config.json """ { "chatglm_api_url": "http://localhost:8000/chat", "database": { "host": "localhost", "port": 3306, "user": "readonly_user", "password": "your_password", "database": "business_data" } } """

5. 实际应用案例

理论和技术说完了，我们看看这个系统在实际业务中能怎么用。

5.1 电商销售分析场景

假设我们有一个电商公司的销售数据库，业务人员可以这样查询：

问题1：“帮我看看上个月哪个地区的手机销量最好？”

系统处理过程：

1. 理解问题：查询手机品类、上个月、按地区分组、按销量排序
2. 生成SQL：

SELECT region, SUM(quantity) as total_quantity FROM sales JOIN products ON sales.product_id = products.id WHERE products.category = '手机' AND sale_date >= '2024-01-01' AND sale_date <= '2024-01-31' GROUP BY region ORDER BY total_quantity DESC LIMIT 5;

3. 执行查询，得到结果
4. 解释结果：“上个月手机销量最好的地区是华东地区，总共销售了15,234台。其次是华南地区（12,567台）和华北地区（9,876台）。”

问题2：“对比一下第一季度和第二季度的服装类目销售额”

系统处理：

1. 理解问题：需要按季度分组统计服装类目的销售额
2. 生成SQL：

SELECT CASE WHEN sale_date BETWEEN '2024-01-01' AND '2024-03-31' THEN '第一季度' WHEN sale_date BETWEEN '2024-04-01' AND '2024-06-30' THEN '第二季度' END as quarter, SUM(sales_amount) as total_sales FROM sales JOIN products ON sales.product_id = products.id WHERE products.category = '服装' AND sale_date BETWEEN '2024-01-01' AND '2024-06-30' GROUP BY quarter ORDER BY quarter;

3. 执行并解释：“第一季度服装类目销售额为285万元，第二季度为320万元，环比增长12.3%。”

5.2 客户服务场景

在客户服务部门，客服人员可能需要快速查询客户信息：

问题：“查一下客户张三最近的订单情况”

系统处理：

1. 理解问题：需要查询客户张三的订单记录，按时间倒序排列
2. 生成SQL：

SELECT orders.order_id, orders.order_date, orders.total_amount, orders.status, GROUP_CONCAT(products.product_name) as products FROM orders JOIN order_items ON orders.order_id = order_items.order_id JOIN products ON order_items.product_id = products.id JOIN customers ON orders.customer_id = customers.id WHERE customers.customer_name = '张三' GROUP BY orders.order_id ORDER BY orders.order_date DESC LIMIT 10;

3. 解释结果：“张三最近有3笔订单。最近一笔是昨天下的，购买了智能手机X和无线耳机，总金额2,499元，状态是已发货。另外两笔分别是上周和上个月的订单...”

6. 系统优化与进阶功能

基础功能实现后，我们可以考虑一些优化和进阶功能，让系统更智能、更好用。

6.1 SQL生成准确性提升

初始的SQL生成可能不够准确，我们可以通过以下方式改进：

# 添加SQL验证和修正机制 class EnhancedSQLGenerator(SQLGenerator): def generate_and_validate_sql(self, question, max_retries=3): """ 生成SQL并验证，如果不正确则重试 """ for attempt in range(max_retries): sql = self.generate_sql(question) # 简单验证SQL语法 if self.validate_sql_syntax(sql): # 尝试执行解释计划，验证SQL是否可执行 if self.explain_sql(sql): return sql else: print(f"第{attempt+1}次生成的SQL执行计划失败，重试...") # 在提示词中添加更多上下文信息 self.add_feedback_to_prompt(f"上次生成的SQL执行失败: {sql}") else: print(f"第{attempt+1}次生成的SQL语法错误，重试...") raise Exception("无法生成有效的SQL语句") def validate_sql_syntax(self, sql): """ 简单的SQL语法验证 """ # 这里可以集成SQL解析器进行更准确的验证 required_keywords = ["SELECT", "FROM"] sql_upper = sql.upper() for keyword in required_keywords: if keyword not in sql_upper: return False return True def explain_sql(self, sql): """ 执行EXPLAIN语句，验证SQL是否可执行 """ try: explain_sql = f"EXPLAIN {sql}" # 这里调用数据库查询，但只执行EXPLAIN，不实际查询数据 # 如果EXPLAIN成功，说明SQL语法正确且能正常执行 return True except: return False

6.2 多轮对话支持

实际使用中，用户可能需要进行多轮对话来细化查询：

class ConversationalQuerySystem(NaturalLanguageQuerySystem): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.conversation_context = {} def process_conversational_query(self, user_id, question): """ 处理带上下文的对话式查询 """ # 获取用户的对话历史 if user_id not in self.conversation_context: self.conversation_context[user_id] = { "history": [], "last_query": None, "last_result": None } context = self.conversation_context[user_id] # 分析问题是否与上下文相关 is_follow_up = self.is_follow_up_question(question, context) if is_follow_up and context["last_query"]: # 如果是跟进问题，结合上下文处理 enhanced_question = f"{context['last_query']}。现在我想进一步了解：{question}" result = self.process_query(enhanced_question) else: # 新问题，正常处理 result = self.process_query(question) # 更新上下文 context["last_query"] = question context["last_result"] = result # 保存到历史 context["history"].append({ "question": question, "result": result.get("explanation", ""), "timestamp": datetime.now().isoformat() }) # 限制历史记录长度 if len(context["history"]) > 10: context["history"] = context["history"][-10:] return result def is_follow_up_question(self, question, context): """ 判断是否是跟进问题 """ follow_up_keywords = ["另外", "还有", "详细", "具体", "然后", "接着", "再说", "进一步"] question_lower = question.lower() for keyword in follow_up_keywords: if keyword in question_lower: return True # 如果问题很短，且上下文中有最近查询，也可能是跟进问题 if len(question) < 20 and context["last_query"]: return True return False

6.3 数据可视化建议

除了文字解释，我们还可以建议合适的数据可视化方式：

class VisualizationAdvisor: def suggest_visualization(self, query_result, question): """ 根据查询结果和问题类型，建议合适的可视化方式 """ columns = query_result.get("columns", []) data = query_result.get("data", []) row_count = query_result.get("row_count", 0) if row_count == 0: return "没有数据可可视化" # 分析数据特征 numeric_columns = [] category_columns = [] time_columns = [] for col in columns: # 简单判断列类型（实际应用中需要更准确的判断） col_lower = col.lower() if any(keyword in col_lower for keyword in ["date", "time", "year", "month", "day"]): time_columns.append(col) elif any(keyword in col_lower for keyword in ["id", "name", "type", "category", "status"]): category_columns.append(col) elif any(keyword in col_lower for keyword in ["amount", "price", "quantity", "count", "total", "sum", "avg"]): numeric_columns.append(col) # 根据问题类型和数据特征建议可视化 question_lower = question.lower() if "趋势" in question_lower or "变化" in question_lower: if time_columns and numeric_columns: return "建议使用折线图展示趋势变化" if "占比" in question_lower or "比例" in question_lower: if category_columns and numeric_columns: return "建议使用饼图或环形图展示占比" if "排名" in question_lower or "最高" in question_lower or "最低" in question_lower: if category_columns and numeric_columns: return "建议使用柱状图展示排名" if "分布" in question_lower: if numeric_columns: return "建议使用直方图或箱线图展示分布" # 默认建议 if len(numeric_columns) >= 2: return "可以考虑使用散点图分析变量关系" elif time_columns and numeric_columns: return "建议使用时序图展示数据变化" elif category_columns and numeric_columns: return "建议使用柱状图对比不同类别" else: return "表格形式可能更适合展示这些数据"

7. 企业级部署考虑

在实际企业环境中部署这个系统，还需要考虑一些工程化问题。

7.1 性能优化

• 查询缓存：对常见查询结果进行缓存，减少重复计算
• 异步处理：对于复杂查询，使用异步处理避免阻塞
• 连接池：数据库连接使用连接池管理
• 模型量化：对ChatGLM-6B进行量化，减少内存占用

7.2 安全性保障

• 权限控制：不同用户只能访问授权的数据
• 查询限制：限制查询的数据量和复杂度
• 审计日志：记录所有查询操作，便于追溯
• 输入验证：严格验证用户输入，防止注入攻击

7.3 监控与维护

• 性能监控：监控查询响应时间、成功率等指标
• 错误处理：完善的错误处理和用户提示
• 模型更新：定期更新和优化模型
• 用户反馈：收集用户反馈，持续改进系统

8. 总结与展望

ChatGLM-6B与MySQL的智能交互方案，本质上是在自然语言处理和传统数据库之间架起了一座桥梁。这座桥梁让不懂技术的业务人员也能自如地查询和分析数据，大大降低了数据使用的门槛。

从实际应用效果来看，这种方案有几个明显的优势：

首先是效率提升。以前需要几个小时甚至几天才能得到的数据洞察，现在几分钟就能完成。业务人员可以快速验证想法，及时调整策略。

其次是资源优化。技术人员从重复性的查询工作中解放出来，可以专注于更有价值的模型优化和系统开发工作。

再者是决策质量改善。当数据获取变得如此简单时，业务决策自然会更多地依赖数据，而不是凭感觉或经验。

当然，这个方案也不是完美的。目前的版本在处理特别复杂的问题时，可能还需要人工干预。SQL生成的准确性也有提升空间。但这些都可以通过持续优化来解决。

未来，这个方向还有很多可以探索的空间。比如加入更多的数据源支持，不仅限于MySQL；比如实现更智能的查询理解，能处理更模糊的自然语言描述；再比如与BI工具深度集成，实现从查询到可视化的一站式服务。

技术最终要服务于业务。ChatGLM-6B与MySQL的智能交互，只是一个开始。随着大模型技术的不断成熟，相信会有更多这样“让技术更懂业务”的创新应用出现。

---

获取更多AI镜像

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