refactor(frontend): 优化模型管理页面的交互和显示

- 将状态输出从 Textbox 改为 Label 组件，提高用户体验
- 添加 get_model_name 函数以获取模型名称，提高代码复用性
- 更新模型加载、卸载和保存后的状态显示，使信息更加准确
- 优化模型列表刷新功能，确保模型列表实时更新

.gitignore

@@ -11,6 +11,7 @@ env/
 # IDE
 .vscode/
 .idea/
+.roo
 
 # Environment files
 .env
@@ -28,3 +29,7 @@ workdir/
 
 # cache
 unsloth_compiled_cache
+
+# 测试和参考代码
+test.ipynb
+refer/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 C-a-r-r-y
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,15 @@
+# 基于文档驱动的自适应编码大模型微调框架
+## 简介
+本人的毕业设计
+### 项目概述
+
+* 通过深度解析私有库的文档以及其他资源，生成指令型语料，据此对大语言模型进行针对私有库的微调。
+
+### 项目技术
+
+* 使用unsloth框架在GPU上实现大语言模型的qlora微调
+* 使用langchain框架编写工作流实现批量生成微调语料
+* 使用tinydb和sqlite实现数据的持久化
+* 使用gradio框架实现前端展示
+
+**施工中......**

db/__init__.py

@@ -0,0 +1,11 @@
+from .init_db import get_sqlite_engine, initialize_sqlite_db
+from .prompt_store import get_prompt_tinydb, initialize_prompt_store
+from .dataset_store import get_all_dataset
+
+__all__ = [
+    "get_sqlite_engine",
+    "initialize_sqlite_db",
+    "get_prompt_tinydb",
+    "initialize_prompt_store",
+    "get_all_dataset"
+]

db/dataset_store.py

@@ -0,0 +1,50 @@
+import os
+import sys
+import json
+from pathlib import Path
+from typing import List
+from tinydb import TinyDB, Query
+from tinydb.storages import MemoryStorage
+
+# 将项目根目录添加到系统路径中，以便能够导入项目中的其他模块
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from schema.dataset import dataset, dataset_item, Q_A
+
+def get_all_dataset(workdir: str) -> TinyDB:
+    """
+    扫描workdir/dataset目录下的所有json文件并读取为dataset对象列表
+    
+    Args:
+        workdir (str): 工作目录路径
+        
+    Returns:
+        TinyDB: 包含所有数据集对象的TinyDB对象
+    """
+    dataset_dir = os.path.join(workdir, "dataset")
+    if not os.path.exists(dataset_dir):
+        return TinyDB(storage=MemoryStorage)
+        
+    db = TinyDB(storage=MemoryStorage)
+    for filename in os.listdir(dataset_dir):
+        if filename.endswith(".json"):
+            filepath = os.path.join(dataset_dir, filename)
+            try:
+                with open(filepath, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                    db.insert(data)
+            except (json.JSONDecodeError, Exception) as e:
+                print(f"Error loading dataset file {filename}: {str(e)}")
+                continue
+                
+    return db
+
+
+if __name__ == "__main__":
+    # 定义工作目录路径
+    workdir = os.path.join(os.path.dirname(__file__), "..", "workdir")
+    # 获取所有数据集
+    datasets = get_all_dataset(workdir)
+    # 打印结果
+    print(f"Found {len(datasets)} datasets:")
+    for ds in datasets.all():
+        print(f"- {ds['name']} (ID: {ds['id']})")

db/init_db.py

@@ -0,0 +1,79 @@
+import os
+import sys
+from sqlmodel import SQLModel, create_engine, Session
+from sqlmodel import select
+from typing import Optional
+from pathlib import Path
+from dotenv import load_dotenv
+from sqlalchemy.engine import Engine
+
+# 将项目根目录添加到系统路径中，以便能够导入项目中的其他模块
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from schema.dataset_generation import APIProvider
+
+# 全局变量，用于存储数据库引擎实例
+_engine: Optional[Engine] = None
+
+def get_sqlite_engine(workdir: str) -> Engine:
+    """
+    获取数据库引擎实例。如果引擎尚未创建，则创建一个新的引擎并返回。
+
+    Args:
+        workdir (str): 工作目录路径，用于确定数据库文件的存储位置。
+
+    Returns:
+        Engine: SQLAlchemy 数据库引擎实例。
+    """
+    global _engine
+    if not _engine:
+        # 创建数据库目录（如果不存在）
+        db_dir = os.path.join(workdir, "db")
+        os.makedirs(db_dir, exist_ok=True)
+        # 定义数据库文件路径
+        db_path = os.path.join(db_dir, "db.sqlite")
+        # 创建数据库URL
+        db_url = f"sqlite:///{db_path}"
+        # 创建数据库引擎
+        _engine = create_engine(db_url)
+    return _engine
+
+def initialize_sqlite_db(engine: Engine) -> None:
+    """
+    初始化数据库，创建所有表结构，并插入初始数据（如果不存在）。
+
+    Args:
+        engine (Engine): SQLAlchemy 数据库引擎实例。
+    """
+    # 创建所有表结构
+    SQLModel.metadata.create_all(engine)
+    # 加载环境变量
+    load_dotenv()
+    # 从环境变量中获取API相关配置
+    api_key = os.getenv("API_KEY")
+    base_url = os.getenv("BASE_URL")
+    model_id = os.getenv("MODEL_ID")
+    
+    # 如果所有必要的环境变量都存在，则插入初始数据
+    if api_key and base_url and model_id:
+        with Session(engine) as session:
+            # 查询是否已存在APIProvider记录
+            statement = select(APIProvider).limit(1)
+            existing_provider = session.exec(statement).first()
+            
+            # 如果不存在，则插入新的APIProvider记录
+            if not existing_provider:
+                provider = APIProvider(
+                    base_url=base_url,
+                    model_id=model_id,
+                    api_key=api_key
+                )
+                session.add(provider)
+                session.commit()
+
+if __name__ == "__main__":
+    # 定义工作目录路径
+    workdir = os.path.join(os.path.dirname(__file__), "..", "workdir")
+    # 获取数据库引擎
+    engine = get_sqlite_engine(workdir)
+    # 初始化数据库
+    initialize_sqlite_db(engine)

db/prompt_store.py

@@ -0,0 +1,62 @@
+import os
+import sys
+from typing import Optional
+from pathlib import Path
+from datetime import datetime, timezone
+from tinydb import TinyDB, Query
+from tinydb.storages import JSONStorage
+
+# 将项目根目录添加到系统路径中，以便能够导入项目中的其他模块
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from schema.prompt import promptTempleta
+
+# 全局变量，用于存储TinyDB实例
+_db_instance: Optional[TinyDB] = None
+# 自定义存储类，用于格式化JSON数据
+def get_prompt_tinydb(workdir: str) -> TinyDB:
+    """
+    获取TinyDB实例。如果实例尚未创建，则创建一个新的并返回。
+
+    Args:
+        workdir (str): 工作目录路径，用于确定数据库文件的存储位置。
+
+    Returns:
+        TinyDB: TinyDB数据库实例
+    """
+    global _db_instance
+    if not _db_instance:
+        # 创建数据库目录（如果不存在）
+        db_dir = os.path.join(workdir, "db")
+        os.makedirs(db_dir, exist_ok=True)
+        # 定义数据库文件路径
+        db_path = os.path.join(db_dir, "prompts.json")
+        # 创建TinyDB实例
+        _db_instance = TinyDB(db_path)
+    return _db_instance
+
+def initialize_prompt_store(db: TinyDB) -> None:
+    """
+    初始化prompt模板存储
+
+    Args:
+        db (TinyDB): TinyDB数据库实例
+    """
+    # 检查数据库是否为空
+    if not db.all():  # 如果数据库中没有数据
+        db.insert(promptTempleta(
+            id=0,
+            name="default",
+            description="默认提示词模板",
+            content="""项目名为:{ project_name }
+请依据以下该项目官方文档的部分内容，创造合适的对话数据集用于微调一个了解该项目的小模型的语料，要求兼顾文档中间尽可能多的信息点，使用中文
+文档节选：{ content }""").model_dump())
+    # 如果数据库中已有数据，则跳过插入
+
+
+if __name__ == "__main__":
+    # 定义工作目录路径
+    workdir = os.path.join(os.path.dirname(__file__), "..", "workdir")
+    # 获取数据库实例
+    db = get_prompt_tinydb(workdir)
+    # 初始化prompt存储
+    initialize_prompt_store(db)

frontend/__init__.py

@@ -0,0 +1,7 @@
+from .chat_page import *
+from .setting_page import *
+from .train_page import *
+from .model_manage_page import *
+from .dataset_manage_page import *
+from .dataset_generate_page import *
+from .prompt_manage_page import *

frontend/chat_page.py

@@ -0,0 +1,35 @@
+import gradio as gr
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from global_var import model,tokenizer
+
+def chat_page():
+    with gr.Blocks() as demo:
+        import random
+        import time
+        gr.Markdown("## 聊天")
+        chatbot = gr.Chatbot(type="messages")
+        msg = gr.Textbox()
+        clear = gr.Button("Clear")
+
+        def user(user_message, history: list):
+            return "", history + [{"role": "user", "content": user_message}]
+
+        def bot(history: list):
+            bot_message = random.choice(["How are you?", "I love you", "I'm very hungry"])
+            history.append({"role": "assistant", "content": ""})
+            for character in bot_message:
+                history[-1]['content'] += character
+                time.sleep(0.1)
+                yield history
+
+        msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+            bot, chatbot, chatbot
+
+        )
+        clear.click(lambda: None, None, chatbot, queue=False)
+    return demo
+
+if __name__ == "__main__":
+    chat_page().queue().launch()

frontend/dataset_generate_page.py

@@ -0,0 +1,41 @@
+import gradio as gr
+from global_var import docs, scan_docs_directory, prompt_store
+
+def dataset_generate_page():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 数据集生成")
+        with gr.Row():
+            with gr.Column():
+                # 获取文档列表并设置初始值
+                docs_list = [str(doc.name) for doc in scan_docs_directory("workdir")]
+                initial_doc = docs_list[0] if docs_list else None
+                
+                doc_dropdown = gr.Dropdown(
+                    choices=docs_list,
+                    value=initial_doc,  # 设置初始选中项
+                    label="选择文档",
+                    allow_custom_value=True,
+                    interactive=True
+                )
+                doc_state = gr.State(value=initial_doc)  # 用文档初始值初始化状态
+
+            with gr.Column():
+                # 获取模板列表并设置初始值
+                prompts = prompt_store.all()
+                prompt_choices = [f"{p['id']} {p['name']}" for p in prompts]
+                initial_prompt = prompt_choices[0] if prompt_choices else None
+                
+                prompt_dropdown = gr.Dropdown(
+                    choices=prompt_choices,
+                    value=initial_prompt,  # 设置初始选中项
+                    label="选择模板",
+                    allow_custom_value=True,
+                    interactive=True
+                )
+                prompt_state = gr.State(value=initial_prompt)  # 用模板初始值初始化状态
+
+        # 绑定事件（保留原有逻辑，确保交互时更新）
+        doc_dropdown.change(lambda x: x, inputs=doc_dropdown, outputs=doc_state)
+        prompt_dropdown.change(lambda x: x, inputs=prompt_dropdown, outputs=prompt_state)
+
+    return demo

frontend/dataset_manage_page.py

@@ -0,0 +1,55 @@
+import gradio as gr
+from global_var import datasets
+from tinydb import Query
+
+def dataset_manage_page():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 数据集管理")
+        with gr.Row():
+            # 获取数据集列表并设置初始值
+            datasets_list = [str(ds["name"]) for ds in datasets.all()]
+            initial_dataset = datasets_list[0] if datasets_list else None
+            
+            dataset_dropdown = gr.Dropdown(
+                choices=datasets_list,
+                value=initial_dataset,  # 设置初始选中项
+                label="选择数据集",
+                allow_custom_value=True,
+                interactive=True
+            )
+
+        # 添加数据集展示组件
+        qa_dataset = gr.Dataset(
+            components=["text", "text"],
+            label="问答数据",
+            headers=["问题", "答案"],
+            samples=[["示例问题", "示例答案"]],
+            samples_per_page=20,
+        )
+
+        def update_qa_display(dataset_name):
+            if not dataset_name:
+                return {"samples": [], "__type__": "update"}
+            
+            # 从数据库获取数据集
+            Dataset = Query()
+            ds = datasets.get(Dataset.name == dataset_name)
+            if not ds:
+                return {"samples": [], "__type__": "update"}
+            
+            # 提取所有Q_A数据
+            qa_list = []
+            for item in ds["dataset_items"]:
+                for qa in item["message"]:
+                    qa_list.append([qa["question"], qa["answer"]])
+            
+            return {"samples": qa_list, "__type__": "update"}
+
+        # 绑定事件，更新QA数据显示
+        dataset_dropdown.change(
+            update_qa_display,
+            inputs=dataset_dropdown,
+            outputs=qa_dataset
+        )
+
+    return demo

frontend/model_manage_page.py

@@ -0,0 +1,109 @@
+import gradio as gr
+import os  # 导入os模块以便扫描文件夹
+import sys
+from pathlib import Path
+from unsloth import FastLanguageModel
+import torch
+
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from global_var import model,tokenizer
+from tools.model import get_model_name
+
+def model_manage_page():
+    workdir = "workdir"  # 假设workdir是当前工作目录下的一个文件夹
+    models_dir = os.path.join(workdir, "models")
+    model_folders = [name for name in os.listdir(models_dir) if os.path.isdir(os.path.join(models_dir, name))]  # 扫描models文件夹下的所有子文件夹
+
+    with gr.Blocks() as demo:
+        gr.Markdown("## 模型管理")
+        state_output = gr.Label(label="当前状态",value="当前未加载模型")  # 将 Textbox 改为 Label
+        with gr.Row():
+            with gr.Column(scale=3):
+                model_select_dropdown = gr.Dropdown(choices=model_folders, label="选择模型", interactive=True)  # 将子文件夹列表添加到Dropdown组件中，并设置为可选
+                max_seq_length_input = gr.Number(label="最大序列长度", value=4096, precision=0)
+                load_in_4bit_input = gr.Checkbox(label="使用4位量化", value=True)
+            with gr.Column(scale=1):
+                load_button = gr.Button("加载模型", variant="primary")
+                unload_button = gr.Button("卸载模型", variant="stop")
+                refresh_button = gr.Button("刷新模型列表", variant="secondary")  # 新增刷新按钮
+
+        with gr.Row():
+            with gr.Column(scale=3):
+                save_model_name_input = gr.Textbox(label="保存模型名称", placeholder="输入模型保存名称")
+            with gr.Column(scale=1):
+                save_button = gr.Button("保存模型", variant="secondary")
+
+        def load_model(selected_model, max_seq_length, load_in_4bit):
+            try:
+                global model, tokenizer
+                # 判空操作，如果模型已加载，则先卸载
+                if model is not None:
+                    unload_model()
+                
+                model_path = os.path.join(models_dir, selected_model)
+                model, tokenizer = FastLanguageModel.from_pretrained(
+                    model_name=model_path,
+                    max_seq_length=max_seq_length,
+                    load_in_4bit=load_in_4bit,
+                )
+                return f"模型 {get_model_name(model)} 已加载"
+            except Exception as e:
+                return f"加载模型时出错: {str(e)}"
+
+        load_button.click(fn=load_model, inputs=[model_select_dropdown, max_seq_length_input, load_in_4bit_input], outputs=state_output)
+
+        def unload_model():
+            try:
+                global model, tokenizer
+                # 将模型移动到 CPU
+                if model is not None:
+                    model.cpu()
+                
+                # 如果提供了 tokenizer，也将其设置为 None
+                if tokenizer is not None:
+                    tokenizer = None
+                
+                # 清空 CUDA 缓存
+                torch.cuda.empty_cache()
+                
+                # 将模型设置为 None
+                model = None
+
+                return "当前未加载模型"
+            except Exception as e:
+                return f"卸载模型时出错: {str(e)}"
+        
+        unload_button.click(fn=unload_model, inputs=None, outputs=state_output)
+
+        def save_model(save_model_name):
+            try:
+                global model, tokenizer
+                if model is None:
+                    return "没有加载的模型可保存"
+                
+                save_path = os.path.join(models_dir, save_model_name)
+                os.makedirs(save_path, exist_ok=True)
+                model.save_pretrained(save_path)
+                tokenizer.save_pretrained(save_path)
+                return f"模型已保存到 {save_path}"
+            except Exception as e:
+                return f"保存模型时出错: {str(e)}"
+        
+        save_button.click(fn=save_model, inputs=save_model_name_input, outputs=state_output)
+
+        def refresh_model_list():
+            try:
+                nonlocal model_folders
+                model_folders = [name for name in os.listdir(models_dir) if os.path.isdir(os.path.join(models_dir, name))]
+                return gr.Dropdown(choices=model_folders)
+            except Exception as e:
+                return f"刷新模型列表时出错: {str(e)}"
+        
+        refresh_button.click(fn=refresh_model_list, inputs=None, outputs=model_select_dropdown)
+
+    return demo
+
+if __name__ == "__main__":
+    demo = model_manage_page()
+    demo.queue()
+    demo.launch()

frontend/prompt_manage_page.py

@@ -0,0 +1,125 @@
+import gradio as gr
+import sys
+from pathlib import Path
+from typing import List
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from global_var import prompt_store
+from schema.prompt import promptTempleta
+def prompt_manage_page():
+    def get_prompts() -> List[List[str]]:
+        selected_row = None
+        try:
+            db = prompt_store
+            prompts = db.all()
+            return [
+                [p["id"], p["name"], p["description"], p["content"]]
+                for p in prompts
+            ]
+        except Exception as e:
+            raise gr.Error(f"获取提示词失败: {str(e)}")
+
+    def add_prompt(name, description, content):
+        try:
+            db = prompt_store
+            new_prompt = promptTempleta(
+                name=name if name else "",
+                description=description if description else "",
+                content=content if content else ""
+            )
+            prompt_id = db.insert(new_prompt.model_dump())
+            # 更新ID
+            db.update({"id": prompt_id}, doc_ids=[prompt_id])
+            return get_prompts(), "", "", ""  # 返回清空后的输入框值
+        except Exception as e:
+            raise gr.Error(f"添加失败: {str(e)}")
+
+    def edit_prompt():
+        global selected_row
+        if not selected_row:
+            raise gr.Error("请先选择要编辑的行")
+        try:
+            db = prompt_store
+            db.update({
+                "name": selected_row[1] if selected_row[1] else "",
+                "description": selected_row[2] if selected_row[2] else "",
+                "content": selected_row[3] if selected_row[3] else ""
+            }, doc_ids=[selected_row[0]])
+            return get_prompts()
+        except Exception as e:
+            raise gr.Error(f"编辑失败: {str(e)}")
+
+    def delete_prompt():
+        global selected_row
+        if not selected_row:
+            raise gr.Error("请先选择要删除的行")
+        try:
+            db = prompt_store
+            db.remove(doc_ids=[selected_row[0]])
+            return get_prompts()
+        except Exception as e:
+            raise gr.Error(f"删除失败: {str(e)}")
+        
+    selected_row = None  # 保存当前选中行的全局变量
+    
+    def select_record(evt: gr.SelectData):
+        global selected_row
+        selected_row = evt.row_value
+
+    with gr.Blocks() as demo:
+        gr.Markdown("## 提示词模板管理")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                name_input = gr.Textbox(label="模板名称")
+                description_input = gr.Textbox(label="模板描述")
+                content_input = gr.Textbox(label="模板内容", lines=10)
+                add_button = gr.Button("添加新模板", variant="primary")
+
+            with gr.Column(scale=3):
+                prompt_table = gr.DataFrame(
+                    headers=["id", "名称", "描述", "内容"],
+                    datatype=["number", "str", "str", "str"],
+                    interactive=True,
+                    value=get_prompts(),
+                    wrap=True,
+                    col_count=(4, "auto")
+                )
+
+                with gr.Row():
+                    refresh_button = gr.Button("刷新数据", variant="secondary")
+                    edit_button = gr.Button("编辑选中行", variant="primary")
+                    delete_button = gr.Button("删除选中行", variant="stop")
+
+        refresh_button.click(
+            fn=get_prompts,
+            outputs=[prompt_table],
+            queue=False
+        )
+
+        add_button.click(
+            fn=add_prompt,
+            inputs=[name_input, description_input, content_input],
+            outputs=[prompt_table, name_input, description_input, content_input]
+        )
+
+        prompt_table.select(select_record, [], [], show_progress="hidden")
+
+        edit_button.click(
+            fn=edit_prompt,
+            inputs=[],
+            outputs=[prompt_table]
+        )
+
+        delete_button.click(
+            fn=delete_prompt,
+            inputs=[],
+            outputs=[prompt_table]
+        )
+
+        return demo
+    
+
+if __name__ == "__main__":
+    demo = prompt_manage_page()
+    demo.queue()
+    demo.launch()

frontend/setting_page.py

@@ -0,0 +1,126 @@
+import gradio as gr
+from typing import List
+from sqlmodel import Session, select
+from schema import APIProvider
+from global_var import sql_engine
+
+def setting_page():
+    def get_providers() -> List[List[str]]:
+        selected_row = None
+        try:  # 添加异常处理
+            with Session(sql_engine) as session:
+                providers = session.exec(select(APIProvider)).all()
+                return [
+                    [p.id, p.model_id, p.base_url, p.api_key or ""]
+                    for p in providers
+                ]
+        except Exception as e:
+            raise gr.Error(f"获取数据失败: {str(e)}")
+
+    def add_provider(model_id, base_url, api_key):
+        try:
+            with Session(sql_engine) as session:
+                new_provider = APIProvider(
+                    model_id=model_id if model_id else None,
+                    base_url=base_url if base_url else None,
+                    api_key=api_key if api_key else None
+                )
+                session.add(new_provider)
+                session.commit()
+                session.refresh(new_provider)
+                return get_providers(), "", "", ""  # 返回清空后的输入框值
+        except Exception as e:
+            raise gr.Error(f"添加失败: {str(e)}")
+
+    def edit_provider():
+        global selected_row
+        if not selected_row:
+            raise gr.Error("请先选择要编辑的行")
+        try:
+            with Session(sql_engine) as session:
+                provider = session.get(APIProvider, selected_row[0])
+                if not provider:
+                    raise gr.Error("找不到选中的记录")
+                provider.model_id = selected_row[1] if selected_row[1] else None
+                provider.base_url = selected_row[2] if selected_row[2] else None
+                provider.api_key = selected_row[3] if selected_row[3] else None
+                session.add(provider)
+                session.commit()
+                session.refresh(provider)
+                return get_providers()
+        except Exception as e:
+            raise gr.Error(f"编辑失败: {str(e)}")
+
+    def delete_provider():
+        global selected_row
+        if not selected_row:
+            raise gr.Error("请先选择要删除的行")
+        try:
+            with Session(sql_engine) as session:
+                provider = session.get(APIProvider, selected_row[0])
+                if not provider:
+                    raise gr.Error("找不到选中的记录")
+                session.delete(provider)
+                session.commit()
+                return get_providers()
+        except Exception as e:
+            raise gr.Error(f"删除失败: {str(e)}")
+        
+    selected_row = None  # 保存当前选中行的全局变量
+    
+    def select_record(evt: gr.SelectData):
+        global selected_row
+        selected_row = evt.row_value
+
+    with gr.Blocks() as demo:
+        gr.Markdown("## API Provider 管理")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                model_id_input = gr.Textbox(label="Model ID")
+                base_url_input = gr.Textbox(label="Base URL")
+                api_key_input = gr.Textbox(label="API Key")
+                add_button = gr.Button("添加新API", variant="primary")
+
+            with gr.Column(scale=3):
+                provider_table = gr.DataFrame(
+                    headers=["id", "model id", "base URL", "API Key"],
+                    datatype=["number", "str", "str", "str"],
+                    interactive=True,
+                    value=get_providers(),
+                    wrap=True,
+                    col_count=(4, "auto")
+                )
+
+                with gr.Row():
+                    refresh_button = gr.Button("刷新数据", variant="secondary")
+                    edit_button = gr.Button("编辑选中行", variant="primary")
+                    delete_button = gr.Button("删除选中行", variant="stop")
+
+        refresh_button.click(
+            fn=get_providers,
+            outputs=[provider_table],
+            queue=False  # 立即刷新不需要排队
+        )
+
+        add_button.click(
+            fn=add_provider,
+            inputs=[model_id_input, base_url_input, api_key_input],
+            outputs=[provider_table, model_id_input, base_url_input, api_key_input]  # 添加清空输入框的输出
+        )
+
+        provider_table.select(select_record, [], [], show_progress="hidden")
+
+        edit_button.click(
+            fn=edit_provider,
+            inputs=[],
+            outputs=[provider_table]
+        )
+
+        delete_button.click(
+            fn=delete_provider,
+            inputs=[],
+            outputs=[provider_table]
+        )
+
+        return demo

frontend/train_page.py

@@ -0,0 +1,9 @@
+import gradio as gr
+
+def train_page():
+    with gr.Blocks() as demo:
+        gr.Markdown("## 微调")
+        with gr.Row():
+            with gr.Column():
+                pass
+    return demo

global_var.py

@@ -0,0 +1,10 @@
+from db import get_sqlite_engine, get_prompt_tinydb, get_all_dataset
+from tools import scan_docs_directory
+
+prompt_store = get_prompt_tinydb("workdir")
+sql_engine = get_sqlite_engine("workdir")
+docs = scan_docs_directory("workdir")
+datasets = get_all_dataset("workdir")
+
+model = None
+tokenizer = None

main.py

@@ -0,0 +1,28 @@
+import gradio as gr
+from frontend.setting_page import setting_page
+from frontend import *
+from db import initialize_sqlite_db,initialize_prompt_store
+from global_var import sql_engine,prompt_store
+
+if __name__ == "__main__":
+    initialize_sqlite_db(sql_engine)
+    initialize_prompt_store(prompt_store)
+    with gr.Blocks() as app:
+        gr.Markdown("# 基于文档驱动的自适应编码大模型微调框架")
+        with gr.Tabs():
+            with gr.TabItem("模型管理"):
+                model_manage_page()
+            with gr.TabItem("模型推理"):
+                chat_page()
+            with gr.TabItem("模型微调"):
+                train_page()
+            with gr.TabItem("数据集生成"):
+                dataset_generate_page()
+            with gr.TabItem("数据集管理"):
+                dataset_manage_page()
+            with gr.TabItem("提示词模板管理"):
+                prompt_manage_page()
+            with gr.TabItem("设置"):
+                setting_page()
+    
+    app.launch()

requirements.txt

@@ -1,2 +1,7 @@
 openai>=1.0.0
 python-dotenv>=1.0.0
+pydantic>=2.0.0
+gradio>=5.0.0
+langchain>=0.3
+tinydb>=4.0.0
+unsloth>=2025.3.9

schema/__init__.py

@@ -0,0 +1,4 @@
+from .dataset import *
+from .dataset_generation import APIProvider, LLMResponse, LLMRequest
+from .md_doc import MarkdownNode
+from .prompt import promptTempleta

schema/dataset.py

@@ -0,0 +1,30 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+from datetime import datetime, timezone
+
+class doc(BaseModel):
+    id: Optional[int] = Field(default=None, description="文档ID")
+    name: str = Field(default="", description="文档名称")
+    path: str = Field(default="", description="文档路径")
+    markdown_files: list[str] = Field(default_factory=list, description="文档路径列表")
+    version: Optional[str] = Field(default="", description="文档版本")
+
+class Q_A(BaseModel):
+    question: str = Field(default="", min_length=1,description="问题")
+    answer: str = Field(default="", min_length=1, description="答案")
+
+class dataset_item(BaseModel):
+    id: Optional[int] = Field(default=None, description="数据集项ID")
+    message: list[Q_A] = Field(description="数据集项内容")
+
+class dataset(BaseModel):
+    id: Optional[int] = Field(default=None, description="数据集ID")
+    name: str = Field(default="", description="数据集名称")
+    model_id: Optional[list[str]] = Field(default=None, description="数据集使用的模型ID")
+    source_doc: Optional[doc] = Field(default=None, description="数据集来源文档")
+    description: Optional[str] = Field(default="", description="数据集描述")
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="记录创建时间"
+    )
+    dataset_items: list[dataset_item] = Field(default_factory=list, description="数据集项列表")

schema/dataset_generation.py

@@ -0,0 +1,51 @@
+from datetime import datetime, timezone
+from typing import Optional
+from sqlmodel import SQLModel, Relationship, Field
+
+class APIProvider(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True,allow_mutation=False)
+    base_url: str = Field(...,min_length=1,description="API的基础URL，不能为空")
+    model_id: str = Field(...,min_length=1,description="API使用的模型ID，不能为空")
+    api_key: Optional[str] = Field(default=None, description="用于身份验证的API密钥")
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="记录创建时间"
+    )
+
+class LLMResponse(SQLModel):
+    timestamp: datetime  = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="响应的时间戳"
+    )
+    response_id: str = Field(..., description="响应的唯一ID")
+    tokens_usage: dict = Field(default_factory=lambda: {
+        "prompt_tokens": 0,
+        "completion_tokens": 0,
+        "prompt_cache_hit_tokens": None,
+        "prompt_cache_miss_tokens": None
+    }, description="token使用信息")
+    response_content: dict = Field(default_factory=dict, description="API响应的内容")
+    total_duration: float = Field(default=0.0, description="请求的总时长，单位为秒")
+    llm_parameters: dict = Field(default_factory=lambda: {
+        "temperature": None,
+        "max_tokens": None,
+        "top_p": None,
+        "frequency_penalty": None,
+        "presence_penalty": None,
+        "seed": None
+    }, description="API的生成参数")
+
+class LLMRequest(SQLModel):
+    prompt: str = Field(..., description="发送给API的提示词") 
+    provider_id: int = Field(foreign_key="apiprovider.id")
+    provider: APIProvider = Relationship()
+    format: Optional[str] = Field(default=None, description="API响应的格式")
+    response: list[LLMResponse] = Field(default_factory=list, description="API响应列表")
+    error: Optional[list[str]] = Field(default=None, description="API请求过程中发生的错误信息")
+    total_duration: float = Field(default=0.0, description="请求的总时长，单位为秒")
+    total_tokens_usage: dict = Field(default_factory=lambda: {
+        "prompt_tokens": 0,
+        "completion_tokens": 0,
+        "prompt_cache_hit_tokens": None,
+        "prompt_cache_miss_tokens": None
+    }, description="token使用信息")

schema/md_doc.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class MarkdownNode(BaseModel):
+    level: int = Field(default=0, description="节点层级")
+    title: str = Field(default="Root", description="节点标题")
+    content: Optional[str] = Field(default=None, description="节点内容")
+    children: List['MarkdownNode'] = Field(default_factory=list, description="子节点列表")
+
+    class Config:
+        arbitrary_types_allowed = True
+
+MarkdownNode.model_rebuild()

schema/prompt.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from datetime import datetime, timezone
+
+class promptTempleta(BaseModel):
+    id: Optional[int] = Field(default=None, description="模板ID")
+    name: Optional[str] = Field(default="", description="模板名称")
+    description: Optional[str] = Field(default="", description="模板描述")
+    content: str = Field(default="", min_length=1, description="模板内容")
+    created_at: str = Field(
+        default_factory=lambda: datetime.now(timezone.utc).isoformat(),
+        description="记录创建时间"
+    )

tools/__init__.py

@@ -0,0 +1,4 @@
+from .parse_markdown import parse_markdown
+from .scan_doc_dir import *
+from .json_example import generate_example_json
+from .model import get_model_name

tools/convert_json_to_dataset.py

@@ -0,0 +1,35 @@
+from typing import List
+from schema.dataset import dataset, dataset_item, Q_A
+import json
+
+def convert_json_to_dataset(json_data: List[dict]) -> dataset:
+    # 将JSON数据转换为dataset格式
+    dataset_items = []
+    item_id = 1  # 自增ID计数器
+    for item in json_data:
+        qa = Q_A(question=item["question"], answer=item["answer"])
+        dataset_item_obj = dataset_item(id=item_id, message=[qa])
+        dataset_items.append(dataset_item_obj)
+        item_id += 1  # ID自增
+    
+    # 创建dataset对象
+    result_dataset = dataset(
+        name="Converted Dataset",
+        model_id=None,
+        description="Dataset converted from JSON",
+        dataset_items=dataset_items
+    )
+    return result_dataset
+
+# 示例：从文件读取JSON并转换
+if __name__ == "__main__":
+    # 假设JSON数据存储在文件中
+    with open(r"workdir\dataset_old\llamafactory.json", "r", encoding="utf-8") as file:
+        json_data = json.load(file)
+    
+    # 转换为dataset格式
+    converted_dataset = convert_json_to_dataset(json_data)
+    
+    # 输出结果到文件
+    with open("output.json", "w", encoding="utf-8") as file:
+        file.write(converted_dataset.model_dump_json(indent=4))

tools/json_example.py

@@ -0,0 +1,63 @@
+from pydantic import BaseModel, create_model
+from typing import Any, Dict, List, Optional, get_args, get_origin
+import json
+from datetime import datetime, date
+
+def generate_example_json(model: type[BaseModel]) -> str:
+    """
+    根据 Pydantic V2 模型生成示例 JSON 数据结构。
+    """
+
+    def _generate_example(field_type: Any) -> Any:
+        origin = get_origin(field_type)
+        args = get_args(field_type)
+
+        if origin is list or origin is List:
+            if args:
+                return [_generate_example(args[0])]
+            else:
+                return []
+        elif origin is dict or origin is Dict:
+            if len(args) == 2 and args[0] is str:
+                return {"key": _generate_example(args[1])}
+            else:
+                return {}
+        elif origin is Optional or origin is type(None):
+            if args:
+                return _generate_example(args[0])
+            else:
+                return None
+        elif field_type is str:
+            return "string"
+        elif field_type is int:
+            return 0
+        elif field_type is float:
+            return 0.0
+        elif field_type is bool:
+            return True
+        elif field_type is datetime:
+            return datetime.now().isoformat()
+        elif field_type is date:
+            return date.today().isoformat()
+        elif issubclass(field_type, BaseModel):
+            return generate_example_json(field_type)
+        else:
+            return "unknown"  # 对于未知类型返回 "unknown"
+
+    example_data = {}
+    for field_name, field in model.model_fields.items():
+        example_data[field_name] = _generate_example(field.annotation)
+
+    return json.dumps(example_data, indent=2, default=str)
+
+if __name__ == "__main__":
+    import sys
+    from pathlib import Path
+    # 添加项目根目录到sys.path
+    sys.path.append(str(Path(__file__).resolve().parent.parent))
+    from schema import Q_A
+    class Q_A_list(BaseModel):
+        Q_As: List[Q_A]
+
+    print("示例 JSON:")
+    print(generate_example_json(Q_A_list))

tools/model.py

@@ -0,0 +1,4 @@
+import os
+
+def get_model_name(model):
+    return os.path.basename(model.name_or_path)

tools/parse_markdown.py

@@ -1,28 +1,45 @@
 import re
+import sys
+from pathlib import Path
 
-class MarkdownNode:
-    def __init__(self, level=0, title="Root"):
-        self.level = level
-        self.title = title
-        self.content = ""  # 使用字符串存储合并后的内容
-        self.children = []
+# 添加项目根目录到sys.path
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from schema import MarkdownNode
 
-    def __repr__(self):
-        return f"({self.level}) {self.title}"
+def process_markdown_file(file_path):
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
     
-    def add_child(self, child):
-        self.children.append(child)
+    root = parse_markdown(content)
+    results = []
     
-    def print_tree(self, indent=0):
+    def traverse(node, parent_titles):
+        current_titles = parent_titles.copy()
+        current_titles.append(node.title)
+        
+        if not node.children:  # 叶子节点
+            if node.content:
+                full_text = ' -> '.join(current_titles) + '\n' + node.content
+                results.append(full_text)
+        else:
+            for child in node.children:
+                traverse(child, current_titles)
+    
+    traverse(root, [])
+    return results
+def add_child(parent, child):
+    parent.children.append(child)
+
+def print_tree(node, indent=0):
     prefix = "│  " * (indent - 1) + "└─ " if indent > 0 else ""
-        print(f"{prefix}{self.title}")
-        if self.content:
+    print(f"{prefix}{node.title}")
+    if node.content:
         content_prefix = "│  " * indent + "├─ [内容]"
         print(content_prefix)
-            for line in self.content.split('\n'):
+        for line in node.content.split('\n'):
             print("│  " * indent + "│  " + line)
-        for child in self.children:
-            child.print_tree(indent + 1)
+    for child in node.children:
+        print_tree(child, indent + 1)
 
 def parse_markdown(markdown):
     lines = markdown.split('\n')
@@ -51,10 +68,10 @@ def parse_markdown(markdown):
         if match:
             level = len(match.group(1))
             title = match.group(2)
-            node = MarkdownNode(level, title)
+            node = MarkdownNode(level=level, title=title, content="", children=[])
             while stack[-1].level >= level:
                 stack.pop()
-            stack[-1].add_child(node)
+            add_child(stack[-1], node)
             stack.append(node)
         else:
             if stack[-1].content:
@@ -64,10 +81,13 @@ def parse_markdown(markdown):
     return root
 
 if __name__=="__main__":
-    # 从文件读取 Markdown 内容
-    with open("example.md", "r", encoding="utf-8") as f:
-        markdown = f.read()
+    # # 从文件读取 Markdown 内容
+    # with open("workdir/example.md", "r", encoding="utf-8") as f:
+    #     markdown = f.read()
 
-    # 解析 Markdown 并打印树结构
-    root = parse_markdown(markdown)
-    root.print_tree()
+    # # 解析 Markdown 并打印树结构
+    # root = parse_markdown(markdown)
+    # print_tree(root)
+    for i in process_markdown_file("workdir/example.md"):
+        print("~"*20)
+        print(i)

tools/scan_doc_dir.py

@@ -0,0 +1,32 @@
+import sys
+import os
+from pathlib import Path
+
+# 添加项目根目录到sys.path
+sys.path.append(str(Path(__file__).resolve().parent.parent))
+from schema import doc
+
+def scan_docs_directory(workdir: str):
+    docs_dir = os.path.join(workdir, "docs")
+
+    doc_list = os.listdir(docs_dir)
+
+    to_return = []
+
+    for doc_name in doc_list:
+        doc_path = os.path.join(docs_dir, doc_name)
+        if os.path.isdir(doc_path):
+            markdown_files = []
+            for root, dirs, files in os.walk(doc_path):
+                for file in files:
+                    if file.endswith(".md"):
+                        markdown_files.append(os.path.join(root, file))
+            to_return.append(doc(name=doc_name, path=doc_path, markdown_files=markdown_files))
+                    
+    return to_return
+
+# 添加测试代码
+if __name__ == "__main__":
+    workdir = os.path.join(os.path.dirname(__file__), "..", "workdir")
+    docs = scan_docs_directory(workdir)
+    print(docs)