Qwen-Turbo-BF16数据库课程设计：智能问答系统开发

想象一下，你正在上一门数据库课程。老师布置了一个课程设计：开发一个学生信息管理系统。你需要设计表结构，写SQL查询，还要做个简单的界面。你埋头苦干，终于写好了查询“找出所有选修了‘数据库原理’且成绩在90分以上的学生”。代码跑起来，结果……不对？你开始逐行检查SQL，是JOIN写错了，还是WHERE条件漏了？这种调试过程，相信每个学过数据库的同学都深有体会。

有没有一种方法，能让数据库“听懂人话”？比如，你直接问：“帮我查一下选了数据库课且成绩优秀的同学”，系统就能自动理解你的意图，生成正确的SQL语句，执行查询，甚至把结果用清晰的图表展示出来。这听起来像是科幻场景，但现在，借助像Qwen-Turbo-BF16这样的AI大模型，我们完全可以在课程设计的框架内，亲手搭建出这样一个“智能数据库问答系统”。

这不仅仅是完成一次作业，更是将前沿的AI能力与经典的数据库知识相结合，打造一个真正实用、能解决实际痛点的工具。接下来，我就带你一步步实现它。

1. 为什么需要智能数据库问答？

在传统的数据库应用开发和学习中，存在几个明显的痛点：

对非技术人员不友好：业务人员、产品经理甚至很多开发者自己，都不一定擅长编写复杂的SQL。他们知道想要什么数据（“上个月销售额最高的三个产品是什么？”），但不知道如何用SQL表达。

学习曲线陡峭：对于数据库课程的初学者，SQL的语法、多表连接、子查询、聚合函数等概念需要大量练习才能掌握。一个简单的逻辑错误就可能导致完全错误的结果，打击学习信心。

效率瓶颈：即使是熟练的开发者，面对复杂的业务逻辑，编写和调试SQL也需要时间。更不用说，当数据模型发生变化时，相关的所有查询都需要检查和修改。

结果理解门槛：查询返回的往往是一堆行列数据。如何快速从中洞察趋势、发现问题？还需要额外的数据分析或可视化步骤。

而一个智能问答系统，就像给你的数据库配了一个“专属数据分析师”。它能够：

1. 理解自然语言：你用日常说话的方式提问。
2. 自动生成SQL：将你的问题精准地翻译成数据库能执行的查询语句。
3. 执行与验证：自动运行查询，并处理可能出现的错误（比如表名写错、字段不存在）。
4. 解释与可视化：不仅给出原始数据，还能用文字总结关键发现，或用图表直观展示。

对于数据库课程设计而言，这个项目能让你同时深入理解数据库原理、自然语言处理（NLP） 和应用系统开发，价值远超一个简单的CRUD管理系统。

2. 核心组件与技术选型

要构建这样一个系统，我们需要几个核心部分，并为每个部分选择合适的技术。考虑到是课程设计，我们会优先选择开源、易用且学习资源丰富的工具。

2.1 大脑：大语言模型 (LLM)

这是系统的智能核心，负责理解问题并生成SQL。我们需要一个在代码和推理方面表现良好的模型。

• 模型选择：Qwen-Turbo-BF16 通义千问（Qwen）系列模型在代码生成和中文理解上表现突出。Qwen-Turbo是其高性能版本，而BF16精度能在保持模型能力的同时，显著降低部署所需的显存，这对于我们在个人电脑或学校服务器上运行非常友好。它完全有能力完成从自然语言到SQL的转换任务。

• 部署方式：我们可以使用Hugging Face的transformers库在本地加载模型，或者调用云端API（如果有资源）。为了课程设计的完整性和可控性，我们重点讲解本地部署。

2.2 翻译官：Text-to-SQL 模块

这不是一个独立的软件，而是我们利用LLM要实现的核心功能。其工作流程如下：

1. 模式理解：系统需要知道数据库里有那些表（students, courses, enrollments），每个表有哪些字段，以及字段的类型和含义（外键关系等）。这些信息构成数据库的“模式”（Schema）。
2. 问题解析：LLM分析用户问题，识别关键实体（如“学生”、“数据库课程”、“成绩”）和意图（查询、筛选、排序、聚合）。
3. SQL生成：结合数据库模式，将解析出的意图组装成语法正确的SQL语句。

2.3 执行器：数据库连接与查询

生成的SQL需要在一个真实的数据库上运行。

• 数据库选择：为了简单通用，我们选择SQLite。它是一个轻量级的文件数据库，无需安装复杂的数据库服务，一个.db文件就搞定了，非常适合教学和原型开发。
• 连接工具：Python的sqlite3库是标准库，简单易用。我们将使用它来连接数据库、执行生成的SQL并获取结果。

2.4 表达者：结果处理与可视化

原始数据结果不够友好，我们需要加工。

• 数据整理：使用pandas库将查询结果转换为DataFrame，便于后续处理和分析。
• 文本总结：再次调用LLM，让它对查询结果进行解读，生成一段人性化的总结文字。（例如：“找到了5位同学，其中张三同学成绩最高，为95分。”）
• 图表生成：使用matplotlib或plotly库，根据结果类型自动生成合适的图表（柱状图、折线图、饼图等）。

2.5 交互界面：让用户用起来

我们需要一个方式让用户输入问题并看到结果。

• 选择：Gradio 它是一个快速构建机器学习Web界面的Python库，几行代码就能生成一个包含输入框、按钮和显示区域的网页应用，完美契合我们的需求。

整个系统的架构如下图所示：

用户问题
    |
    v
[Gradio Web界面]
    |
    v
[核心处理引擎]
    |-----------------------|
    v                       v
[LLM: SQL生成]      [数据库Schema]
    |                       |
    v                       |
[SQL语句]-------------------|
    |
    v
[sqlite3执行查询]
    |
    v
[查询结果]
    |-----------------------|
    v                       v
[LLM: 结果总结]      [pandas/matplotlib可视化]
    |                       |
    v                       v
[文本总结 + 图表] ----------|
    |
    v
[Gradio界面展示结果]

3. 动手搭建：从零开始的实现步骤

理论说完了，我们开始敲代码。请确保你的Python环境在3.8以上，并安装好必要的库。

pip install transformers torch sqlite3 pandas matplotlib gradio
# 如果需要使用Qwen，可能需要安装额外的依赖，如 `accelerate`, `sentencepiece` 等，请参考Qwen官方文档。

3.1 第一步：准备示例数据库

我们先创建一个简单的教学数据库，模拟学生选课系统。

# create_database.py
import sqlite3

# 连接到数据库（如果不存在则会创建）
conn = sqlite3.connect('school.db')
cursor = conn.cursor()

# 删除旧表（如果存在）
cursor.execute("DROP TABLE IF EXISTS students;")
cursor.execute("DROP TABLE IF EXISTS courses;")
cursor.execute("DROP TABLE IF EXISTS enrollments;")

# 创建学生表
cursor.execute('''
CREATE TABLE students (
    student_id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    major TEXT,
    enrollment_year INTEGER
);
''')

# 创建课程表
cursor.execute('''
CREATE TABLE courses (
    course_id INTEGER PRIMARY KEY,
    course_name TEXT NOT NULL,
    instructor TEXT,
    credit INTEGER
);
''')

# 创建选课记录表
cursor.execute('''
CREATE TABLE enrollments (
    enrollment_id INTEGER PRIMARY KEY,
    student_id INTEGER,
    course_id INTEGER,
    score INTEGER,
    semester TEXT,
    FOREIGN KEY (student_id) REFERENCES students(student_id),
    FOREIGN KEY (course_id) REFERENCES courses(course_id)
);
''')

# 插入示例数据
students = [
    (1, '张三', '计算机科学', 2022),
    (2, '李四', '软件工程', 2023),
    (3, '王五', '数据科学', 2022),
    (4, '赵六', '计算机科学', 2023),
    (5, '钱七', '软件工程', 2022),
]
cursor.executemany("INSERT INTO students VALUES (?, ?, ?, ?)", students)

courses = [
    (101, '数据库原理', '王老师', 3),
    (102, '数据结构', '李老师', 4),
    (103, '机器学习', '张老师', 3),
    (104, 'Web开发', '赵老师', 3),
]
cursor.executemany("INSERT INTO courses VALUES (?, ?, ?, ?)", courses)

enrollments = [
    (1, 1, 101, 88, '2023-秋季'),
    (2, 1, 102, 92, '2023-秋季'),
    (3, 2, 101, 95, '2024-春季'),
    (4, 2, 103, 85, '2024-春季'),
    (5, 3, 101, 90, '2023-秋季'),
    (6, 3, 104, 78, '2024-春季'),
    (7, 4, 102, 91, '2024-春季'),
    (8, 5, 103, 87, '2023-秋季'),
    (9, 5, 104, 93, '2024-春季'),
]
cursor.executemany("INSERT INTO enrollments VALUES (?, ?, ?, ?, ?)", enrollments)

# 提交更改并关闭连接
conn.commit()
conn.close()
print("数据库 school.db 已创建并填充示例数据。")

运行这个脚本，你会在当前目录得到 school.db 文件。

3.2 第二步：加载Qwen模型并构建Text-to-SQL提示

这里我们演示如何使用transformers库加载模型。请注意：Qwen-Turbo-BF16模型文件较大（可能数十GB），请确保你有足够的磁盘空间和GPU内存（或使用CPU）。如果资源有限，可以考虑使用更小的Qwen-Coder模型，或者使用通义千问的API服务作为替代，这对于课程设计来说也是完全合理且更简便的选择。

以下代码展示核心逻辑，实际部署时请根据你的模型路径和硬件调整。

# model_loader.py
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

def load_qwen_model(model_path="Qwen/Qwen-Turbo-BF16"): # 请替换为你的实际模型路径或名称
    """
    加载Qwen模型和分词器。
    注意：首次运行需要下载模型，请确保网络通畅和磁盘空间充足。
    """
    print(f"正在加载模型: {model_path}...")
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.bfloat16, # 使用BF16精度
        device_map="auto", # 自动分配GPU/CPU
        trust_remote_code=True
    ).eval()
    print("模型加载完毕。")
    return model, tokenizer

def get_database_schema():
    """获取我们数据库的结构描述，用于拼接到提示词中。"""
    schema = """
    数据库 `school.db` 包含以下表：
    1. 表 `students`:
        - student_id (INTEGER, 主键): 学生ID
        - name (TEXT): 学生姓名
        - major (TEXT): 专业
        - enrollment_year (INTEGER): 入学年份
    2. 表 `courses`:
        - course_id (INTEGER, 主键): 课程ID
        - course_name (TEXT): 课程名称
        - instructor (TEXT): 授课教师
        - credit (INTEGER): 学分
    3. 表 `enrollments`:
        - enrollment_id (INTEGER, 主键): 选课记录ID
        - student_id (INTEGER, 外键，关联students.student_id): 学生ID
        - course_id (INTEGER, 外键，关联courses.course_id): 课程ID
        - score (INTEGER): 成绩
        - semester (TEXT): 学期
    """
    return schema

def generate_sql_with_llm(question, model, tokenizer, schema):
    """利用LLM，根据自然语言问题和数据库模式生成SQL。"""
    prompt = f"""你是一个专业的SQL专家。请根据下面的数据库结构，将用户的自然语言问题转换为一条准确、可执行的SQLite SQL查询语句。只输出SQL语句，不要有任何额外的解释、标记或注释。

数据库结构：
{schema}

用户问题：{question}

SQL查询语句："""
    
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=150,
            do_sample=False, # 为了稳定性，关闭随机采样
            temperature=0.1,
            pad_token_id=tokenizer.eos_token_id
        )
    
    generated_sql = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 从生成的文本中提取SQL部分（假设SQL在提示词之后）
    sql = generated_sql.split("SQL查询语句：")[-1].strip()
    # 清理可能的额外换行和引号
    sql = sql.split('\n')[0].strip('`\'" ')
    return sql

# 测试函数
if __name__ == "__main__":
    # 注意：实际运行前请确保模型已正确加载
    # model, tokenizer = load_qwen_model()
    # schema = get_database_schema()
    # test_question = "查询所有选修了‘数据库原理’这门课的学生姓名和成绩。"
    # sql = generate_sql_with_llm(test_question, model, tokenizer, schema)
    # print(f"问题：{test_question}")
    # print(f"生成的SQL：{sql}")
    print("此脚本为模块，请在主程序中调用。")

3.3 第三步：执行SQL并处理结果

# database_executor.py
import sqlite3
import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO
import base64

def execute_sql_and_fetch(sql_query, db_path='school.db'):
    """执行SQL查询并返回结果（DataFrame格式）和可能的错误信息。"""
    conn = None
    try:
        conn = sqlite3.connect(db_path)
        df = pd.read_sql_query(sql_query, conn)
        error = None
    except sqlite3.Error as e:
        df = pd.DataFrame()
        error = f"SQL执行错误: {e}"
    except pd.io.sql.DatabaseError as e:
        df = pd.DataFrame()
        error = f"数据读取错误: {e}"
    finally:
        if conn:
            conn.close()
    return df, error

def summarize_results_with_llm(question, sql, df, model, tokenizer):
    """利用LLM对查询结果进行文本总结。"""
    if df.empty:
        return "查询未返回任何数据。"
    
    # 将DataFrame转换为易读的文本格式
    result_str = df.to_string(index=False)
    
    prompt = f"""你是一个数据分析助手。用户提出了一个问题：“{question}”
系统执行了SQL查询：`{sql}`
查询结果如下（表格格式）：
{result_str}

请用一两句简洁、通顺的中文总结一下这个结果的核心发现。不要重复描述表格所有内容，而是指出关键信息，比如数量、趋势、极值等。"""
    
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=100,
            do_sample=False,
            temperature=0.3,
            pad_token_id=tokenizer.eos_token_id
        )
    summary = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 提取总结部分
    summary = summary.split(prompt)[-1].strip() if prompt in summary else summary
    return summary

def visualize_results(df):
    """根据DataFrame的内容，尝试生成一个简单的图表。"""
    if df.empty or len(df) <= 1:
        return None # 数据太少，不生成图表
    
    plt.figure(figsize=(8, 5))
    img_bytes = BytesIO()
    
    try:
        # 简单的启发式规则：如果结果包含‘score’和‘name’，画柱状图
        if 'score' in df.columns and ('name' in df.columns or 'student_id' in df.columns):
            # 取前10个，避免过多
            plot_df = df.head(10).sort_values('score', ascending=False)
            x_label = 'name' if 'name' in plot_df.columns else 'student_id'
            plt.bar(plot_df[x_label].astype(str), plot_df['score'])
            plt.xlabel(x_label)
            plt.ylabel('成绩')
            plt.title('学生成绩分布')
            plt.xticks(rotation=45, ha='right')
            plt.tight_layout()
        # 如果包含‘course_name’和平均成绩或选课人数，也可以画图
        # ... 可以在这里添加更多可视化规则
        
        plt.savefig(img_bytes, format='png', dpi=100)
        plt.close()
        img_bytes.seek(0)
        # 将图片转换为base64字符串，方便在HTML/Gradio中显示
        img_base64 = base64.b64encode(img_bytes.read()).decode('utf-8')
        return f"data:image/png;base64,{img_base64}"
    except Exception as e:
        print(f"生成图表时出错: {e}")
        return None

3.4 第四步：用Gradio整合所有功能

现在，我们把所有零件组装起来，做一个漂亮的界面。

# main_app.py
import gradio as gr
# 导入我们之前写的模块
# from model_loader import load_qwen_model, get_database_schema, generate_sql_with_llm
# from database_executor import execute_sql_and_fetch, summarize_results_with_llm, visualize_results
import torch

# 为了演示，我们在这里模拟这些函数。实际使用时请取消注释上面的import并实现它们。
# 模拟函数开始 (在实际项目中，请使用上面实现的具体函数)
def get_database_schema():
    return "模拟的数据库结构..."

def generate_sql_with_llm(question, model, tokenizer, schema):
    # 这里模拟一个简单的规则，实际必须使用LLM
    if "数据库原理" in question and "成绩" in question:
        return "SELECT s.name, e.score FROM students s JOIN enrollments e ON s.student_id = e.student_id JOIN courses c ON e.course_id = c.course_id WHERE c.course_name = '数据库原理';"
    elif "平均成绩" in question:
        return "SELECT c.course_name, AVG(e.score) as avg_score FROM enrollments e JOIN courses c ON e.course_id = c.course_id GROUP BY c.course_name;"
    else:
        return "SELECT * FROM students LIMIT 5;" # 默认返回一个简单查询

def execute_sql_and_fetch(sql_query, db_path='school.db'):
    import pandas as pd
    # 模拟执行，返回一些硬编码数据
    if "数据库原理" in sql_query:
        data = {'name': ['张三', '李四', '王五'], 'score': [88, 95, 90]}
    elif "AVG" in sql_query:
        data = {'course_name': ['数据库原理', '数据结构', '机器学习', 'Web开发'], 'avg_score': [91.0, 91.5, 86.0, 85.5]}
    else:
        data = {'student_id': [1,2,3,4,5], 'name':['张三','李四','王五','赵六','钱七'], 'major':['CS','SE','DS','CS','SE'], 'enrollment_year':[2022,2023,2022,2023,2022]}
    return pd.DataFrame(data), None

def summarize_results_with_llm(question, sql, df, model, tokenizer):
    return f"模拟总结：查询找到了 {len(df)} 条记录。"

def visualize_results(df):
    # 模拟返回一个占位图
    return None
# 模拟函数结束

# 全局变量（在实际应用中，应考虑更优雅的状态管理）
# model, tokenizer = None, None
schema = get_database_schema()

def process_question(question):
    """处理用户问题的核心函数"""
    # 在实际应用中，这里需要加载模型
    # global model, tokenizer
    # if model is None:
    #     model, tokenizer = load_qwen_model()
    
    output_md = "## 处理过程\n" # 用Markdown格式输出过程
    
    # 1. 生成SQL
    sql = generate_sql_with_llm(question, None, None, schema) # 传入模拟的None
    output_md += f"**1. 生成的SQL语句：**\n```sql\n{sql}\n```\n\n"
    
    # 2. 执行SQL
    df, error = execute_sql_and_fetch(sql)
    if error:
        output_md += f"**2. 执行结果：**\n **错误**：{error}\n"
        return output_md, None, None
    else:
        output_md += f"**2. 执行成功，返回 {len(df)} 行数据。**\n\n"
    
    # 3. 显示数据（前20行）
    output_md += "**3. 查询结果（表格）：**\n"
    output_md += df.head(20).to_markdown(index=False) + "\n\n"
    
    # 4. 文本总结
    summary = summarize_results_with_llm(question, sql, df, None, None)
    output_md += f"**4. 结果解读：**\n{summary}\n\n"
    
    # 5. 可视化
    chart_img = visualize_results(df)
    
    return output_md, df, chart_img

# 创建Gradio界面
with gr.Blocks(title="智能数据库问答系统 - 课程设计") as demo:
    gr.Markdown("# 🧠 智能数据库问答系统")
    gr.Markdown("这是一个基于Qwen大模型的数据库课程设计项目。你可以用自然语言查询`school.db`学生选课数据库。")
    
    with gr.Row():
        with gr.Column(scale=4):
            question_input = gr.Textbox(
                label="请输入你的问题",
                placeholder="例如：查询所有选修了‘数据库原理’的学生姓名和成绩。或者：哪门课的平均成绩最高？",
                lines=3
            )
            submit_btn = gr.Button(" 执行查询", variant="primary")
        
        with gr.Column(scale=6):
            process_output = gr.Markdown(label="处理过程与结果")
    
    with gr.Row():
        data_table = gr.Dataframe(label="原始数据", interactive=False)
        image_output = gr.Image(label="可视化图表", interactive=False)
    
    # 绑定事件
    submit_btn.click(
        fn=process_question,
        inputs=[question_input],
        outputs=[process_output, data_table, image_output]
    )
    
    # 添加一些示例问题，方便用户快速尝试
    gr.Examples(
        examples=[
            ["显示所有学生的信息。"],
            ["查询选修了‘数据库原理’这门课的学生姓名和成绩。"],
            ["计算每门课程的平均成绩，并从高到低排序。"],
            ["找出专业是‘计算机科学’且入学年份是2022年的学生。"],
            ["统计每个专业有多少名学生？"],
        ],
        inputs=[question_input],
        label="点击试试示例问题"
    )

# 启动应用
if __name__ == "__main__":
    # 在实际项目中，先加载模型（比较耗时）
    # print("正在加载AI模型，这可能需要几分钟...")
    # model, tokenizer = load_qwen_model()
    # print("模型加载完成，启动界面...")
    demo.launch(server_name="0.0.0.0", server_port=7860, share=False) # share=True可以生成临时公网链接

运行 python main_app.py，然后在浏览器中打开 http://localhost:7860，你就能看到自己打造的智能数据库问答系统了！

4. 课程设计的延伸与思考

一个基本的系统已经完成，但这只是起点。你可以从这个原型出发，进行多方面的深化和扩展，让你的课程设计脱颖而出：

功能深化：

• 多轮对话与上下文：让系统能记住之前的对话。例如，用户问“计算机专业的学生有哪些？”，接着问“他们的平均成绩呢？”，系统应该知道“他们”指代上一问的结果。
• SQL纠错与验证：在执行生成的SQL前，可以先进行简单的语法检查，或者让LLM解释一下它生成的SQL打算做什么，让用户确认。
• 复杂查询支持：让系统支持嵌套查询、窗口函数等更复杂的SQL特性。
• 数据库操作：不仅支持查询（SELECT），还可以支持简单的插入、更新、删除（需谨慎，做好权限控制）。

性能与工程优化：

• Schema向量化检索：当数据库表非常多时，将所有表结构都塞进提示词会超出模型上下文长度。可以将Schema存入向量数据库，先检索出相关表，再生成SQL。
• Few-shot Prompting：在提示词中提供几个“问题-SQL”的配对示例，能显著提升模型生成准确率。
• 缓存机制：对相同或类似的问题，缓存其SQL和结果，提升响应速度。
• 使用专用Text-to-SQL模型：除了通用LLM，可以尝试微调或使用专门为Text-to-SQL任务训练的模型，如SQLCoder、ChatSQL等。

应用场景拓展：

• 对接真实业务数据库：将系统应用于一个真实的、结构更复杂的数据库（如电商、图书管理）。
• 生成数据报告：结合更强大的可视化库（如Plotly Dash），让系统能根据复杂问题生成包含多图表的分析报告。
• 集成到现有平台：将问答能力以API形式提供，集成到公司的内部数据平台或聊天工具（如钉钉、飞书）中。

5. 总结

通过这个“基于Qwen-Turbo-BF16的智能数据库问答系统”课程设计，我们完成了一次从理论到实践的完整旅程。你不仅巩固了数据库SQL知识，还亲身实践了如何利用大语言模型解决一个具体的、有价值的应用问题——降低数据查询的门槛。

从创建一个简单的SQLite数据库，到加载和调用大模型理解自然语言，再到执行查询、处理结果并可视化，最后用一个美观的Web界面将所有功能串联起来。这个过程涵盖了AI应用开发的多个关键环节：模型选型与部署、提示工程、前后端集成、数据处理与展示。

更重要的是，这个项目具有很强的可扩展性和实用性。它不仅仅是一个作业，更是一个可以继续迭代、应用到真实场景中的原型。你可以在此基础上，探索更先进的模型、更复杂的查询、更友好的交互，甚至将其作为你未来研究或工作的一个亮点项目。

技术的学习在于解决实际问题。希望这个项目能给你带来启发，让你看到AI与数据库结合所产生的奇妙化学反应。动手去完善它，让它变得更聪明、更强大吧。

---

获取更多AI镜像

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