srcrs

构建一个智能投顾AI助手

Sat, 13 Dec 2025 00:00:00 +0000

# 简述

今年的工作全部精力都投入到Agent相关内容了，惊叹于AI发展过于迅速，尤其是AI编程在今年实现了商业化，自己也买了一年GLM订阅。今年也是我的投资生涯元年，看了几本书就妄想能在股市中大展手脚，好在今年是牛市，收益也超出了自己的预期，我的原则是不追求短期利益，着眼于长期投资。投资也是一个技术活，要看懂周期，看懂行业，看懂技术指标，在繁忙的工作中，这些分析会占用很大的精力，我在想，能否自己来做一个投资Agent来帮我分析呢？

接下来便投入到了研究和探索。最早接触到的是TradingAgents，它是Github一个开源的股票分析项目，多个Agent根据获取的不同信息，左右互搏，帮助投资者实现分析目的。为了深入分析这套体系，我用trpc-Agent-go重新实现了改项目，获取资源的工具统一用mcp实现，这一套下来，看起来分析的是头头是道，但是内容太多普通人难以辨别，运行一次就需要10-20分钟，并且该项目没有一个好的前端用户体验，遂作废。

从TradingAgents学到的经验，我总结了要做好一个投资助手要满足以下条件： 1.架构上要够简单，能够泛化 2.数据源要稳定，市场上开源数据很难同时一次性满足A股、港股、美股 3.要有一个好的客户端用户体验，电脑、手机设备

为此以下，我设计了这套解决方案：使用开源客户端，接入大模型，接入MCP数据源，设计提示词，只需要输入股票代码便能够分析。下面将详细记录我的做法。

  graph TB
    A[用户] --> B[AI客户端<br/>Cherry Studio/Kelivo/RikkaHub]
    B --> C[AI Agent<br/>GLM4.6/OpenRouter]
    C --> D[MCP工具层]
    D --> E[LongPort MCP<br/>行情数据/交易执行]
    E --> F[长桥OpenAPI<br/>A股/港股/美股]

    B --> G[提示词引擎]
    C --> H[投资分析逻辑]
    D --> I[风险监控]

    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#e8f5e8
    style D fill:#fff3e0
    style E fill:#ffebee

# 数据源选型

开源仓库：https://github.com/longportapp/openapi

数据源选择的是长桥，长桥是一家位于香港的券商，他们有着阿里的背景，核心创始团队很多来自阿里，在2025年5月16日便开放了mcp，据说是券商行业首个mcp，一次性可以接入A股、港股、美股数据。

他们的mcp是使用的rust实现，很多mcp客户端可能是由于协议差异原因，无法接入，后面我会详细讲解。

# 大模型选型

这部分其实选择最好的模型即可，需要支持Function Call。我自己付费了Openrouter和GLM，目前用的是GLM4.6较多一些。

# 客户端选型

以下都是开源的客户端

电脑：cherry studio
安卓：rikkahub或者kelivo

# 构建MCP服务

这部分原本我觉得会很快完成的，没想到长桥的mcp在手机的客户端无法使用，付出了很大精力寻找手机客户端，在项目Issues中提问，寻找解决方案，退而求其次web版的lobe-chat总应该行吧？连接是正常的，但是调用异常。

后来我偶然间想到是否有mcp代理服务，比如将stdio协议转换成streamable http协议，将sse协议转换成stdio等，也就是协议的互转。也许能够解决协议不兼容的部分。fastmcp proxy可以完美实现我的想法。

接下来还要解决访问权限的问题，长桥mcp并没有该功能，我的解决方案是加一层nginx，使用http用户名/密码基本身份验证，作为个人使用足够了。最后完美方案是nginx + fastmcp-proxy + longport-mcp架构。

# 项目目录

.
├── docker-compose.yaml
├── longport
│   ├── Dockerfile
│   ├── mcp-servers.json
│   ├── proxy_server.py
│   └── requirements.txt
└── nginx
     ├── .htpasswd
     └── conf.d
          └──api.conf

# nginx

# api.conf

server {
    listen 80;

    location /mcp {
        auth_basic "please input password";
        auth_basic_user_file /etc/nginx/.htpasswd;
        proxy_pass http://longport:8000/mcp;
    }
}

# .htpasswd

安装工具

# Debian/Ubuntu
sudo apt-get install apache2-utils
# CentOS/RHEL
sudo yum install httpd-tools

生成密码文件

请特别注意 -c参数只在第一次创建文件时使用，后续添加用户时去掉 -c，以免覆盖现有文件

`1`	`sudo htpasswd -c /etc/nginx/.htpasswd myuser`

添加更多用户

`1`	`sudo htpasswd /etc/nginx/.htpasswd anotheruser`

# nginx + longport-mcp架构

这是直接使用长桥mcp服务，该方案存在大部分客户端兼容性问题

  flowchart LR
    A[AI客户端] --> B{HTTP请求<br/>:8080}
    B --> C[Nginx<br/>Basic Auth]
    C --> D[LongPort MCP<br/>HTTP服务]
    D --> E[长桥证券API]

    C --> F[认证失败]
    F --> G[401错误]

    D --> H[协议兼容性问题]
    H --> I[连接异常]

    style C fill:#fff3e0
    style D fill:#ffebee
    style H fill:#ffcdd2

# longport-mcp(Dockerfile)

FROM debian:bookworm-slim

# 安装必要的运行时依赖
RUN apt-get update && apt-get install -y \
    curl \
    ca-certificates \
    unzip \
    tar \
    sudo \
    && rm -rf /var/lib/apt/lists/*

# 创建目录和日志
RUN mkdir -p /app/logs

# 下载并安装 longport-mcp
RUN curl -sSL https://raw.githubusercontent.com/longportapp/openapi/refs/heads/main/mcp/install | bash

# 暴露端口
EXPOSE 8000

# 设置工作目录
WORKDIR /app

# 启动命令 (直接使用环境变量，程序自动读取)
CMD ["longport-mcp", "--http", "--readonly", "--bind", "0.0.0.0:8000", "--log-dir", "/app/logs"]

# docker-compose.yaml

version: '3.8'

services:
  longport-nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      # 挂载配置文件目录
      - ./nginx/conf.d:/etc/nginx/conf.d
      # 挂载Lua脚本和依赖库目录
      - ./nginx/.htpasswd:/etc/nginx/.htpasswd
    depends_on:
      - longport
    restart: unless-stopped
  longport:
    build: ./longport
    environment:
      # 中国地区配置
      - LONGPORT_REGION=CN
      # 认证信息 (请填入你的真实信息)
      - LONGPORT_APP_KEY=your-app-key
      - LONGPORT_APP_SECRET=your-app-secret
      - LONGPORT_ACCESS_TOKEN=your-access-token
      # 日志配置
      - RUST_LOG=info
    volumes:
      - ./logs:/app/logs
    restart: unless-stopped

# nginx + fastmcp-proxy + longport-mcp架构

完美兼容性方案

  flowchart TB
    A[用户设备] --> B[AI客户端]
    B --> C[HTTP请求]
    C --> D{Nginx反向代理<br/>端口8080}
    D --> E[Basic Auth认证]
    E --> F[FastMCP Proxy<br/>协议转换]
    F --> G[LongPort MCP<br/>Stdio协议]
    G --> H[长桥证券API]

    subgraph "安全边界"
        D --> E --> F
    end

    subgraph "协议转换层"
        F --> G
    end

    subgraph "数据服务层"
        G --> H
    end

    style D fill:#ffebee
    style F fill:#e8f5e8
    style G fill:#e1f5fe

# fastmcp-proxy + longport-mcp(Dockerfile)

FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Install system dependencies
RUN apt-get update && apt-get install -y \
    curl \
    ca-certificates \
    unzip \
    tar \
    sudo \
    && rm -rf /var/lib/apt/lists/*

# Copy requirements and install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

RUN mkdir -p /app/logs

# Download and Install longport-mcp
RUN curl -sSL https://raw.githubusercontent.com/longportapp/openapi/refs/heads/main/mcp/install | bash

# Copy the proxy server code
COPY . .

# Expose port
EXPOSE 8000

# Run the proxy server
CMD ["python", "proxy_server.py"]

# proxy_server.py

#!/usr/bin/env python3
import json
from fastmcp import FastMCP

# Load config from JSON file
config_path = "/app/mcp-servers.json"
with open(config_path, 'r') as f:
    config = json.load(f)

# Create and run proxy
proxy = FastMCP.as_proxy(config, name="MCP Proxy")

if __name__ == "__main__":
    proxy.run(
        stateless_http=True,
        transport="http",
        host="0.0.0.0",
        port=8000
    )

# mcp-servers.json

{
  "mcpServers": {
    "longport-mcp": {
      "command": "/usr/local/bin/longport-mcp",
      "env": {
        "LONGPORT_APP_KEY": "your-app-key",
        "LONGPORT_APP_SECRET": "your-app-secret",
        "LONGPORT_ACCESS_TOKEN": "your-access-token"
      }
    }
  }
}

# requirements.txt

`1`	`fastmcp==2.14.0`

# docker-compose.yaml

version: "3.8"

services:
  longport-nginx:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      # 挂载配置文件目录
      - ./nginx/conf.d:/etc/nginx/conf.d
      # 挂载Lua脚本和依赖库目录
      - ./nginx/.htpasswd:/etc/nginx/.htpasswd
    depends_on:
      - longport
    restart: unless-stopped
  longport:
    build: ./longport
    environment:
      # 日志配置
      - RUST_LOG=info
    volumes:
      - ./logs:/app/logs
      - ./longport/mcp-servers.json:/app/mcp-servers.json
    restart: unless-stopped

# 编写提示词

提示词可以根据自己的投资风格进行编写，千人千面，这里就不进行分享了。

# 结语

工具只是辅助，万不可全部都相信工具、大V，投资需谨慎。最后，祝大家在投资的道路上都能挣大钱！

# 参考

mcp大模型的通用工具调用协议

Sun, 30 Mar 2025 00:00:00 +0000

# MCP和Function Call对比

在本次文章开始写之前，要搞明白Function Call和MCP的区别。

  graph TD
    A[用户输入] --> B[大模型判断意图]
    B --> C{是否需要调用函数?}
    C -->|是| D[生成结构化函数调用请求<br>（如JSON参数）]
    C -->|否| E[直接生成回答]
    D --> F[开发者解析并执行函数]
    F --> G[获取函数执行结果]
    G --> H[将结果反馈给大模型]
    H --> I[生成最终回答]
    I --> J[输出给用户]

  graph LR
    A[用户请求] --> B[大模型]
    B --> C[MCP服务器]
    C --> D{路由判断}
    D -->|工具调用| E[执行外部工具]
    D -->|数据查询| F[访问数据库]
    E --> C{{MCP服务器}}
    F --> C
    C --> B[大模型]
    B --> G[生成回答]

对比维度	Function Call	MCP (Managed Context Protocol)
协议层级	特定厂商（如OpenAI）的功能实现	通用协议标准（类似USB-C接口规范）
标准化程度	依赖厂商定义，灵活性高但碎片化	强制遵循JSON-RPC 2.0标准，统一性强
核心功能	单次函数调用（如天气查询）	上下文管理+工具动态接入（如多工具协作）
控制权归属	大模型主导调用逻辑	应用层通过MCP服务器管理工具与数据源
典型场景	简单API调用（如发送邮件、查询数据库）	企业级复杂系统集成（如医疗数据中台）
扩展性	需手动注册函数	支持动态加载工具和知识库

对比下来，MCP是在大模型和工具之间定义了标准化的协议，只需要和MCP服务器交互即可。那么现在任何大模型都遵循该协议吗？

为此，查看了代码在执行中给大模型实际的数据，可以看到，这只是一段prompt，任何大模型只要能遵循指令，即可实现mcp的调用。

<|im_start|>system
You are Qwen, created by Alibaba Cloud. You are a helpful assistant.

# Tools

You may call one or more functions to assist with the user query.


You are provided with function signatures within <tools></tools> XML tags:

<tools>
{\"type\": \"function\", \"function\": {\"name\":\"calculate\",\"description\":\"Perform basic arithmetic operations\",\"parameters\":{\"type\":\"object\",\"required\":[\"operation\",\"x\",\"y\"],\"properties\":{\"operation\":{\"type\":\"string\",\"description\":\"The operation to perform (add, subtract, multiply, divide)\",\"enum\":[\"add\",\"subtract\",\"multiply\",\"divide\"]},\"x\":{\"type\":\"number\",\"description\":\"First number\"},\"y\":{\"type\":\"number\",\"description\":\"Second number\"}}}}}

</tools>


For each function call, return a json object with function name and arguments within <tool_call></tool_call> XML tags:

<tool_call>

{\"name\": <function-name>, \"arguments\": <args-json-object>}

</tool_call><|im_end|>

<|im_start|>user

我今天买了一斤苹果和一斤梨，苹果是5块一斤，梨是3块一斤，我一共花了多少钱？<|im_end|>

<|im_start|>assistant

# 测试代码

package main

import (
 "context"
 "fmt"
 "log"
 "time"

 "github.com/cloudwego/eino/components/tool"
 "github.com/cloudwego/eino/compose"
 "github.com/cloudwego/eino/flow/agent/react"
 "github.com/cloudwego/eino/schema"
 "github.com/mark3labs/mcp-go/client"
 "github.com/mark3labs/mcp-go/mcp"
 "github.com/mark3labs/mcp-go/server"

 "github.com/cloudwego/eino-ext/components/model/ollama"
 mcpp "github.com/cloudwego/eino-ext/components/tool/mcp"
)

func main() {

 startMCPServer()
 time.Sleep(1 * time.Second)
 ctx := context.Background()

 mcpTools := getMCPTool(ctx)

 chatModel, err := ollama.NewChatModel(ctx, &ollama.ChatModelConfig{
  BaseURL: "http://localhost:11434",
  Model:   "qwen2.5:7b",
 })
 if err != nil {
  log.Printf("NewChatModel failed, err=%v", err)
  return
 }

 agent, err := react.NewAgent(ctx, &react.AgentConfig{
  Model:       chatModel,
  ToolsConfig: compose.ToolsNodeConfig{Tools: mcpTools},
 })

 fmt.Println(err)

 rsp, err := agent.Generate(ctx, []*schema.Message{
  {
   Role:    schema.User,
   Content: "我今天买了一斤苹果和一斤梨，苹果是5块一斤，梨是3块一斤，我一共花了多少钱？",
  },
 })

 fmt.Println(rsp, err)
}

func getMCPTool(ctx context.Context) []tool.BaseTool {
 cli, err := client.NewSSEMCPClient("http://localhost:12345/sse")
 if err != nil {
  log.Fatal(err)
 }
 err = cli.Start(ctx)
 if err != nil {
  log.Fatal(err)
 }

 initRequest := mcp.InitializeRequest{}
 initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
 initRequest.Params.ClientInfo = mcp.Implementation{
  Name:    "example-client",
  Version: "1.0.0",
 }

 _, err = cli.Initialize(ctx, initRequest)
 if err != nil {
  log.Fatal(err)
 }

 tools, err := mcpp.GetTools(ctx, &mcpp.Config{Cli: cli})
 if err != nil {
  log.Fatal(err)
 }

 return tools
}

func startMCPServer() {
 svr := server.NewMCPServer("demo", mcp.LATEST_PROTOCOL_VERSION)
 svr.AddTool(mcp.NewTool("calculate",
  mcp.WithDescription("Perform basic arithmetic operations"),
  mcp.WithString("operation",
   mcp.Required(),
   mcp.Description("The operation to perform (add, subtract, multiply, divide)"),
   mcp.Enum("add", "subtract", "multiply", "divide"),
  ),
  mcp.WithNumber("x",
   mcp.Required(),
   mcp.Description("First number"),
  ),
  mcp.WithNumber("y",
   mcp.Required(),
   mcp.Description("Second number"),
  ),
 ), func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
  fmt.Println("Received request:", request)
  op := request.Params.Arguments["operation"].(string)
  x := request.Params.Arguments["x"].(float64)
  y := request.Params.Arguments["y"].(float64)

  var result float64
  switch op {
  case "add":
   result = x + y
  case "subtract":
   result = x - y
  case "multiply":
   result = x * y
  case "divide":
   if y == 0 {
    return mcp.NewToolResultText("Cannot divide by zero"), nil
   }
   result = x / y
  }
  log.Printf("Calculated result: %.2f", result)
  return mcp.NewToolResultText(fmt.Sprintf("%.2f", result)), nil
 })
 go func() {
  defer func() {
   e := recover()
   if e != nil {
    fmt.Println(e)
   }
  }()

  err := server.NewSSEServer(svr, server.WithBaseURL("http://localhost:12345")).Start("localhost:12345")

  if err != nil {
   log.Fatal(err)
  }
 }()
}

执行代码，可以看到是有工具调用的。依托于该基础代码，未来可以封装更多的工具。

<nil>
Received request: {{tools/call {<nil>}} {calculate map[operation:add x:5 y:3] <nil>}}
2025/03/30 19:07:20 Calculated result: 8.00
assistant: 苹果和梨的单价相加就是总价，所以您一共花了8元钱。
finish_reason: stop <nil>

结尾抛出一个问题，大模型的输入输出是有上限的，当工具达到几百个时，大模型会能正确找到函数吗，如何解决？

Linux部署Flux的GGUF量化版

Sat, 29 Mar 2025 00:00:00 +0000

# 前序

AI画图风靡一时，极客精神必须要自建。

# 机器配置

操作系统：Tlinux 3.2 CPU：32核 CPU：32 核内存：64G 硬盘：500G 显卡：L20 1/3卡，显存14G

# 基础环境配置

# 1.安装conda

conda初始化一个干净的python环境，创建install_conda.sh

# 创建指定目录
mkdir -p ~/miniconda3

# 下载安装脚本到目标目录
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh

# 执行静默安装（-b: 静默模式，-u: 更新现有安装，-p: 指定路径）
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3

# 删除安装脚本（可选）
rm ~/miniconda3/miniconda.sh

# 编辑用户配置文件（如.bashrc或.zshrc）
echo 'export PATH="$HOME/miniconda3/bin:$PATH"' >> ~/.bashrc

# 使配置生效
source ~/.bashrc

# 初始化conda
conda init

~/miniconda3指定了安装路径，可以按需更改。执行install_conda.sh完后，关掉命令行，重新打开。

# 2.创建环境

`1`	`conda create --name stable-diffusion-webui-forge python=3.12`

# 3.进入到新环境

`1`	`conda activate stable-diffusion-webui-forge`

# 基于源码部署

# 1.下载stable-diffusion-webui-forge源码

`1`	`git clone https://github.com/lllyasviel/stable-diffusion-webui-forge.git`

# 2.安装依赖包

进入到stable-diffusion-webui-forge文件夹下，执行webui.sh

`1`	`bash webui.sh`

注意： 1.如果是非root环境，请将webui.sh中can_run_as_root改成1。 2.将venv文件夹命名为_。

# 3.下载模型和vae

下载vae

vae下载可以从flux-dev或flux-schnell

1
2

# 保存到models\VAE
wget https://huggingface.co/black-forest-labs/FLUX.1-dev/blob/main/ae.safetensors -P ./models/VAE

会出现401下载失败，推荐下载到本地再上传到机器。

-下载clip-l和t5

# 保存到models/text_encoder
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors -P ./models/text_encoder

# 保存到models/text_encoder
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors -P ./models/text_encoder

下载flux-gguf模型

可以从这里下载flux-dev和fulx-schnell

`1`	`wget https://huggingface.co/lllyasviel/FLUX.1-dev-gguf/resolve/main/flux1-dev-Q4_0.gguf -P ./models/Stable-diffusion`

# 启动程序

`1`	`./webui.sh -f --listen --port 7860`

接下来便可以访问7860端口启动的服务了。

# 参考

flux gguf模型下载

ai大模型微调

Tue, 19 Nov 2024 00:00:00 +0000

深圳今天好冷，瞬间入冬了，被子比较薄，半夜冻醒了几次，早上早早起来穿上厚衣服才暖和点。还有两个多月又要过年了，真快呀，今年还未回过，倒也没有什么期待的。

# 前言

公司目前又一站式大模型精调平台，用起来很方便，准备好数据，只需要在平台上点击就可以完成基座模型的微调。所谓微调，就是让模型学习某个特定领域的知识，在特定的场景中能够发挥更大的作用。有时候我在想，如果脱离了这个平台，能否利用手头的资源自己搭建一个微调环境呢？本文便是摸索过程的记录下的，希望能给未来研究者一些帮助。

本次我将以Qwen2.5基座模型进行微调，显卡资源是白嫖公司的英伟达L20，在TLinux系统服务器上完成全部的操作。

# 环境

# 机器配置

操作系统：Tlinux 3.2
CPU：32核
内存：64G
硬盘：500G
显卡：L20 1/3卡，显存14G

# 环境构建

使用LLaMA-Factory进行微调，在安装包时遇到了包冲突问题，故使用conda初始化一个干净环境

# conda安装并初始化环境

下载并进行安装

mkdir -p ~/miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh

创建一个新的环境

#默认创建到安装目录下
conda create --name llama-factory python=3.11
#在指定目录下安装
conda create -p /data/anaconda3/envs/llama-factory python=3.11

激活环境（进入环境）

`1`	`conda activate llama-factory`

# LLaMA-Factory环境构建

进入llama-factory环境后，便可以着手构建LLaMa-Factory环境，通过conda的新环境是不会遇到冲突问题的。

1
2
3

git clone --depth 1 https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e ".[torch,metrics]"

# awq量化环境

`1`	`pip install autoawq`

# 设置torch版本

这是在Qwen2.5需要进行的，详情可以见这篇文章

`1`	`pip install torch==2.2`

# 核心依赖包版本

transformers==4.46.1
torch==2.2

# 开始微调步骤

# 选择并下载基座模型

速度和资源的要求，选择Qwen/Qwen2.5-3B-Instruct-AWQ较为平衡，然后进行下载

`1`	`pip install modelscope`

1
2
3

#模型下载
from modelscope import snapshot_download
model_dir = snapshot_download('/data/models/Qwen/Qwen2.5-3B-Instruct-AWQ')

# 检查环境

from transformers import AutoModelForCausalLM, AutoTokenizer
model_name = "Qwen/Qwen2.5-3B-Instruct-AWQ"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
prompt = "Give me a short introduction to large language model."
messages = [
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
    {"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=512
)
generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]
response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
print(response)

执行这段代码，如果能够正常输出说明环境没问题。

# 编辑LLaMA-Factory训练参数

examples下面有很多示例的训练参数，参考编写Qwen2.5的微调配置

examples/train_lora/qwen2.5_3b_lora_sft.yaml

### model
model_name_or_path: /data/models/Qwen/Qwen2.5-3B-Instruct-AWQ

### method
stage: sft
do_train: true
finetuning_type: lora
lora_target: all

### dataset
dataset: identity,alpaca_en_demo
template: qwen
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

### output
output_dir: /data/saves/qwen2.5-3b/lora/sft
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

### train
per_device_train_batch_size: 1
gradient_accumulation_steps: 2
learning_rate: 1.0e-4
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true
ddp_timeout: 180000000

### eval
val_size: 0.1
per_device_eval_batch_size: 1
eval_strategy: steps
eval_steps: 500

这个配置文件包括了模型、方法、数据集、输出、训练、评估等等配置，如无特别需要保持默认即可。

# 模型配置

1
2

#指定模型路径，可以填写绝对路径
model_name_or_path: /data/models/Qwen/Qwen2.5-3B-Instruct-AWQ

# 方法配置

stage: sft
do_train: true
finetuning_type: lora
lora_target: all

stage: sft：表示当前的训练阶段是 SFT（Supervised Fine-Tuning）阶段，意味着模型将在特定的标注数据集上进行监督学习。
do_train: true：表示进行训练。
finetuning_type: lora：指定了微调的类型是 LoRA（Low-Rank Adapter），意味着通过低秩适配器层来进行微调，而不是全量训练整个模型。
lora_target: all：表示在模型的所有层上应用 LoRA 微调。你也可以选择特定的层，如 attention 或 ffn，但这里设置为 all，意味着所有的层都会应用 LoRA。

# 数据集配置

dataset: identity,alpaca_en_demo
template: qwen
cutoff_len: 2048
max_samples: 1000
overwrite_cache: true
preprocessing_num_workers: 16

dataset: identity,alpaca_en_demo：指定了要使用的数据集，这里列出了两个数据集：identity 和 alpaca_en_demo。你需要确保这两个数据集已经准备好并且路径正确。identity 可能是一个自定义数据集，alpaca_en_demo 是一个英文数据集。
template: qwen：指定了数据集的模板，这个模板通常用于数据预处理过程，它可能包括对文本的格式化或特殊的标注。
cutoff_len: 2048：指定了最大输入长度（单位为token）。如果输入文本超过这个长度，它将会被截断。这个长度与模型的最大接受长度有关，通常需要根据具体模型的设置调整。
max_samples: 1000：指定了使用的数据集样本的最大数量，这里设置为1000，意味着将只使用最多1000个样本进行训练。
overwrite_cache: true：如果缓存目录存在，则覆盖缓存。这个选项通常用于确保每次训练时使用最新的数据。
preprocessing_num_workers: 16：指定了数据预处理时使用的工作线程数，16个线程可以加速数据加载和预处理过程。

# 输出配置

output_dir: /data/saves/qwen2-7b/lora/sft
logging_steps: 10
save_steps: 500
plot_loss: true
overwrite_output_dir: true

output_dir: /data/saves/qwen2-3b/lora/sft：指定了训练过程中保存模型和日志的输出目录。在此路径下，将保存微调后的模型、检查点等文件。
logging_steps: 10：每10步记录一次日志。
save_steps: 500：每500步保存一次模型检查点。这样你可以在训练过程中定期保存模型的状态，避免意外中断时丢失训练进度。
plot_loss: true：在训练过程中，启用损失值可视化（例如通过TensorBoard或其他工具）。这有助于监控训练过程中模型的表现。
overwrite_output_dir: true：如果输出目录已存在，则覆盖它。确保训练过程中不会因为目录存在而出现错误。

# 训练配置

per_device_train_batch_size: 1
gradient_accumulation_steps: 2
learning_rate: 1.0e-4
num_train_epochs: 3.0
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true
ddp_timeout: 180000000

per_device_train_batch_size: 1：每个设备的训练批次大小设置为1。这通常与GPU的显存大小相关，如果显存较小，批次大小可以设置为1。
gradient_accumulation_steps: 2：梯度累积的步数。如果批次大小设置为1，但需要更多的梯度累积，可以通过此设置实现。
learning_rate: 1.0e-4：设置学习率为 0.0001，这是训练时调整权重的步长。
num_train_epochs: 3.0：训练的总周期数，这里设置为3轮。通常需要根据训练集大小和收敛速度来调整这个值。
lr_scheduler_type: cosine：学习率调度器类型，使用 cosine 调度策略，通常能在训练后期逐渐减小学习率。
warmup_ratio: 0.1：学习率的预热比例，设置为 0.1 表示前10%的训练步骤中，学习率将逐步增加到初始值。
bf16: true：启用 bfloat16 精度进行训练，以减少显存消耗并加速训练。这通常需要支持 bfloat16 的硬件（如TPU）。
ddp_timeout: 180000000：设置 Distributed Data Parallel（DDP）模式下的超时。这个值通常是为了防止分布式训练过程中发生超时错误。

# 评估配置

val_size: 0.1
per_device_eval_batch_size: 1
eval_strategy: steps
eval_steps: 500

val_size: 0.1：指定验证集的大小为训练数据的 10%，即从训练数据集中划分出10%作为验证集。
per_device_eval_batch_size: 1：评估时每个设备的批次大小为1。
eval_strategy: steps：评估策略设置为按步数评估，即每训练一定步数后进行评估。
eval_steps: 500：每500步进行一次评估。

# 执行微调

`1`	`llamafactory-cli train examples/train_lora/qwen2.5_3b_lora_sft.yaml`

# 微调领域大模型

# 参考

2024年下半年软件设计师

Sun, 10 Nov 2024 00:00:00 +0000

# 上午选择题

# web端口号

# 路径覆盖和环形复杂度

4、4

# 十进制5844逻辑地址转换

数字最大的那个

# 补码11111111的真值是

-1

# 磁道序列

暂无

# python代码的输出结果为

1
2
3

arr = [a * a for a in range(5) if a % 2 != 0]

print(arr)

[1, 9]

# python程序以下哪个语句有误

`1`	`del dict[1]`

# 以下哪个算法是稳定排序

归并排序

# 非联通，28条弧，最少有多少个节点

# 1000个数取前10个用什么排序最快？

堆排序

# ip转换mac地址是什么协议

ARP

# 对于16位的数据，海明码最小校验位数

# 乙侵犯甲公司的

著作权

# 以下ER关系依赖哪个是错误的

# 在TCP/IP协议中，以下哪个是应用层协议

DNS

# 通过邮件附件中文档携带的病毒

宏病毒

# 开发没有人使用的项目可能存在什么风险

商业风险

# BC的松弛时间，FH最早开始时间

# 构建哈夫曼树，以下哪个说法是正确的

0.08和0.12在同一层

# 参数传入树组名实际传入的是树组的？

第一个元素的地址

# 对于一个有序序列A[1…20]，使用折半查找法，如果查找的元素是A[13]，查找序列为

A[10]、A[15]、A[12]、A[13]

# 数据库授权

Grant

# 数据库分组

Group By

# 对于链表描述错误的是

链表可以随机访问任意一个元素

# RISC和CISC对比， CISC不包括的是

指令长度固定

# 下面对于指令周期描述正确的是

指令存取以及执行的时间总和

# 以用户需求为动力的模型

喷泉模型

# 下午案例分析题

# 数据流图

# C语言二叉排序树

return flag或者break

# ER图

# 请补充a、b空以及完整性约束

（a）班列编号（b）班列编号

订单的主键是xxxx，外键是xxxx

# 选做题java

(1) String name

(2) abstract void draw()

(3) abstract xxxx()

(4)

(5) new CompositeGraphic(“任意字符”)

根据群友回忆，陆续在整理中…

复盘国密sm4踩坑

Fri, 11 Oct 2024 00:00:00 +0000

复盘最近工作遇到的国密sm4解密，花费了不少精力才解决。

打开ai搜索引擎，初步了解什么是国密sm4。输出了以下内容：

国密SM4算法概述

国密SM4算法是中国国家密码管理局发布的商用密码算法标准，是一种对称分组加密算法。SM4算法主要用于数据的加密和解密，其设计目的是为了替代国际上广泛使用的DES和AES算法，以提高国内信息安全系统的自主可控性。

算法特点

密钥长度和分组长度：

SM4算法的密钥长度为128位，与AES算法相同，这一长度的密钥足以提供较高的安全性。
分组长度也为128位，即16字节。
结构：

SM4算法采用32轮迭代的非平衡Feistel结构，每一轮需要一个轮密钥。
加密和解密过程使用相同的算法，唯一的不同在于解密密钥是由加密密钥生成的。
核心操作：

异或操作：将轮密钥与输入数据进行异或运算。
移位操作：循环左移。
S盒变换：将8位输入映射到8位输出的固定变换，用于实现非线性变换。
加密过程

初始向量：

明文数据首先与初始向量进行异或运算。
轮函数：

轮函数包括32次迭代运算。
每一轮运算包括一个轮密钥加运算和四个S盒查找运算。
轮密钥加运算是将轮密钥与输入数据进行异或运算。
S盒查找运算是将数据通过S盒进行非线性变换。
输出密文：

经过32轮迭代运算后，输出密文。
解密过程

初始向量：

密文数据首先与初始向量进行异或运算。
轮函数：

解密过程与加密过程程类似，只是轮密钥的使用顺序相反。
输出明文：

经过32轮迭代运算后，输出明文。
安全性

SM4算法的安全性主要体现在以下几个方面：

密钥长度：128位的密钥长度提供了较高的安全性。
非线性变换：S盒变换引入了非线性，增加了算法的复杂度，提高了抗攻击能力。
迭代次数：32轮迭代使得攻击者难以通过简单的线性或差分攻击破解算法。
应用场景

SM4算法广泛应用于各种信息安全领域，包括但不限于：

数据加密：保护敏感数据的传输和存储。
网络通信：确保网络通信的安全性。
安全协议：如SSL/TLS协议中的加密算法。
总结

国密SM4算法作为一种高效的对称分组加密算法，凭借其较高的安全性和灵活性，在国内信息安全领域得到了广泛的应用。随着国密算法的普及，SM4算法在保障国家网络安全和推动信息产业自主可控方面将发挥越来越重要的作用。

通过上面内容，对国密有了一个初步的了解，该算法主要在国内使用，对标国际AES和DES加密算法。

现在说下我目前的信息，base64形式加密串、IV、TAG、以及密钥，它是国密sm4，带着这些在搜哟引擎找到了https://github.com/tjfoc/gmsm/blob/master/sm4/sm4_gcm_test.go，随后和对接方确认是sm4-gcm加密的，测试发现并无法实现解密，执行还会报错，怀疑是否是姿势不对，将参数调整一番仍然不行。

接着再和需求方沟通，同步无法解密的情况，也将代码也发送了过去，我说了这里用的一个开源库来解密的，对方还很吃惊，此时还没意识到问题在哪，无果。内部同时沟通一番，以前做过类似的解密，但是用的cpp，golang并没有用过，并给了一个cpp解密方法，成功解密。

这令我很好奇，步骤几乎一样，在golang竟然无法解密，有了对比就看差异了，两边源码都是有的。下面是go的一个目录。

sm4
├── lib
│   ├── sm4.h
│   └── sm4.a
├── sm4.go
├── sm4_gcm.go
├── sm4_gcm_test.go
├── sm4_test.go
└── utils.go

在cpp目录下也找到了sm4和sm4.a，通过阅读两边源码发现代码并没有加解密处理的逻辑，都是调用了静态库，对比下md5值，果然发现是不一样的。替换成cpp的这个版本后，解密成功。

后面了解到公司内部自己编译了一个国密版本，外面的开源版本并不能实现解密，当时也在内部社区进行了查阅，都是在讲实现原理，加解密例子，并无法获得有效信息（也许当时仔细看看也能看出问题）。

总结：

版本是否一致
了解原理，公司内部是否有特殊性
让对接方提供对应语言的解密示例或者sdk
快速找到能解密和不能解密的例子，查看实现源码

macbook安装ollama和qwen2.5-7b

Tue, 01 Oct 2024 00:00:00 +0000

# 简述

随着大型语言模型（LLM）的快速发展，越来越多的开发者和爱好者希望在本地设备上运行这些模型。本文将详细介绍如何在MacBook上安装Ollama和Qwen2.5 7B模型，帮助你快速上手并体验这些强大的模型。

# 安装ollama

# 1.环境准备

在开始安装之前，请确保你的MacBook满足以下要求：

操作系统：macOS Monterey 12.0 或更高版本。
硬件配置：建议至少16GB内存，M1或更高版本的处理器。
存储空间：至少10GB的可用存储空间。

# 2.安装Ollama

Ollama 是一个用于在本地运行大型语言模型的工具。以下是安装Ollama的步骤：

安装 Homebrew（如果尚未安装）：打开终端，运行以下命令：

`1`	`/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"`

安装Ollama：使用 Homebrew 安装 Ollama：

`1`	`brew install ollama`

如果不想使用homebrew安装，可以使用访问官网下载软件包https://ollama.com/

验证安装：运行以下命令验证Ollama是否安装成功：

`1`	`ollama --version`

# 下载Qwen2.5 7B模型

# 1.下载和安装Qwen2.5 7B模型

Qwen2.5 7B 是阿里云开源的大型语言模型，适用于多种任务。以下是下载和安装Qwen2.5 7B模型的步骤：

下载模型：使用 Ollama 下载 Qwen2.5 7B 模型：

`1`	`ollama pull qwen2.5-7b`

验证下载：运行以下命令验证模型是否下载成功：

`1`	`ollama models`

# 2.配置和运行模型

启动模型：使用 Ollama 启动 Qwen2.5 7B 模型：

`1`	`ollama run qwen2.5-7b`

测试模型：你可以通过命令行与模型进行交互，测试其性能。例如：

`1`	`ollama run qwen2.5-7b -- "你好，Qwen2.5 7B！"`

# 3.调试和优化

在运行过程中，你可能会遇到一些问题。以下是一些常见的调试和优化建议：

内存不足：如果遇到内存不足的问题，可以尝试减少模型的参数量或优化内存使用。
性能优化：使用 llama.cpp 推理框架可以提高模型的推理速度。
多线程支持：确保你的系统配置支持多线程，以提高模型的运行效率。

# 常见问题解答

1
2

Q: 安装Ollama时遇到问题怎么办？
A: 请确保你的网络连接正常，并检查 Homebrew 是否安装成功。如果问题仍然存在，可以参考 Ollama 的官方文档或社区支持。

1
2

Q: 模型下载速度慢怎么办？
A: 你可以尝试使用更快的网络连接，或者选择其他镜像源下载模型。

1
2

Q: 模型运行过程中卡顿怎么办？
A: 检查你的系统资源使用情况，确保有足够的内存和 CPU 资源。如果问题仍然存在，可以尝试减少模型的参数量。

1
2

Q: 跨域问题怎么解决
A: 在命令行执行`launchctl setenv OLLAMA_HOST "0.0.0.0"`，然后重启ollama。

# 总结

通过本文的介绍，你应该能够在 MacBook 上成功安装和运行 Ollama 和 Qwen2.5 7B 模型。