使用X-AnyLabeling+Ultralytics标注数据训练YOLOV11模型

2025-12-05

说明

此文章用于记录训练

安装X-Anylabeling

git clone https://github.com/CVHub520/X-AnyLabeling ,或者直接下载Releases版的EXE直接运行。

安装Ultralytics

pip install -U ultralytics

别忘了安装PyTorch

使用X-AnyLabeling标注图片

打开X-AnyLabeling并使用图形界面的标注工具，标注完毕后会针对每张图片生成对应的json数据。

接下来导出classes.txt ，步骤为点击工具-总览-导出，将导出后的压缩包解压可得classes.txt

使用代码将标注数据转换为yolov8 dataset数据集

X-AnyLabeling标注的数据为Json格式，无法直接用于训练，运行以下代码将数据转换成训练数据集：

# convert_xanylabeling_to_yolo_final.py
import json
import shutil
from pathlib import Path
from sklearn.model_selection import train_test_split
import yaml

# 支持的图片格式
IMG_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp'}

def convert_single_json(json_path, img_dir, label_dir, name2id):
    """转换单个JSON为YOLO txt格式"""
    with open(json_path, encoding='utf-8') as f:
        data = json.load(f)
    
    # 获取图片路径
    img_name = data.get("imagePath", json_path.stem + ".jpg")
    img_path = img_dir / img_name
    
    # 如果直接路径不存在，尝试查找同名不同扩展名的图片
    if not img_path.exists():
        # 查找所有可能的图片格式
        for ext in IMG_EXTENSIONS:
            alt_path = img_dir / f"{img_path.stem}{ext}"
            if alt_path.exists():
                img_path = alt_path
                break
    
    if not img_path.exists():
        print(f"⚠️ 图片不存在: {img_path}")
        return None
    
    # 转换标注
    lines = []
    for shape in data.get("shapes", []):
        if shape["shape_type"] == "rectangle":
            label = shape["label"]
            if label not in name2id:
                print(f"⚠️ 未知类别: {label}")
                continue
            class_id = name2id[label]
            
            # 坐标转换 - 支持2点和4点格式
            points = shape["points"]
            img_w, img_h = data["imageWidth"], data["imageHeight"]
            
            if len(points) == 2:
                # 标准2点格式：左上角和右下角
                x1, y1 = points[0]
                x2, y2 = points[1]
            elif len(points) == 4:
                # X-AnyLabeling的4点格式：4个角点
                # 提取所有x和y坐标
                xs = [p[0] for p in points]
                ys = [p[1] for p in points]
                # 找到边界框
                x1, x2 = min(xs), max(xs)
                y1, y2 = min(ys), max(ys)
            else:
                print(f"⚠️ 坐标点数量异常: {len(points)} (应该是2或4)")
                continue
            
            # 计算YOLO格式
            x_center = ((x1 + x2) / 2) / img_w
            y_center = ((y1 + y2) / 2) / img_h
            width = abs(x2 - x1) / img_w
            height = abs(y2 - y1) / img_h
            
            # 验证标注有效性
            if width == 0 or height == 0:
                print(f"⚠️ 跳过无效标注 (宽度或高度为0): {label}")
                continue
            
            lines.append(f"{class_id} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}")
    
    # 写入txt
    txt_path = label_dir / f"{img_path.stem}.txt"
    txt_path.parent.mkdir(parents=True, exist_ok=True)
    txt_path.write_text("\n".join(lines))
    return img_path, txt_path

def main(json_dir, img_dir, output_dir, class_file, split=0.2):
    """主流程：转换+划分+生成data.yaml"""
    print("=" * 60)
    print("开始转换X-AnyLabeling标注")
    print("=" * 60)
    
    # 读取类别
    with open(class_file, encoding='utf-8') as f:
        lines = [line.strip() for line in f if line.strip()]
    
    id2name = {i: name for i, name in enumerate(lines)}
    name2id = {name: i for i, name in enumerate(lines)}
    print(f"✅ 加载类别: {name2id}")
    
    # 检查输入目录
    json_path = Path(json_dir)
    img_path = Path(img_dir)
    print(f"\nJSON目录: {json_path} | 存在: {json_path.exists()}")
    print(f"图片目录: {img_path} | 存在: {img_path.exists()}")
    
    json_files = list(json_path.glob("*.json"))
    print(f"\n找到JSON文件数: {len(json_files)}")
    
    if len(json_files) == 0:
        print("❌ 错误：未找到任何JSON文件！")
        return
    
    # 检查图片文件（支持多种格式）
    img_files = [f for f in img_path.glob("*.*") if f.suffix.lower() in IMG_EXTENSIONS]
    print(f"找到图片文件数: {len(img_files)} | 格式: {set(f.suffix for f in img_files)}")
    
    if len(img_files) == 0:
        print("❌ 错误：未找到任何图片文件！")
        return
    
    # 创建目录
    output = Path(output_dir)
    for d in ["images/train", "images/val", "labels/train", "labels/val"]:
        (output / d).mkdir(parents=True, exist_ok=True)
    print(f"\n✅ 输出目录创建完成: {output}")
    
    # 转换所有JSON到临时目录
    temp_label_dir = output / "labels_temp"
    temp_label_dir.mkdir(exist_ok=True)
    img_paths, label_paths = [], []
    for json_file in json_files:
        result = convert_single_json(json_file, img_path, temp_label_dir, name2id)
        if result:
            img_paths.append(result[0])
            label_paths.append(result[1])
    
    print(f"\n转换成功总数: {len(img_paths)}")
    if len(img_paths) == 0:
        print("❌ 致命错误：未成功转换任何数据！")
        return
    
    # 拷贝图片到临时目录（保留原始扩展名）
    temp_img_dir = output / "images_temp"
    temp_img_dir.mkdir(exist_ok=True)
    for img in img_paths:
        shutil.copy(img, temp_img_dir)
    print(f"✅ 图片已拷贝到临时目录: {len(list(temp_img_dir.glob('*')))}张")
    
    # 划分train/val
    all_imgs = [f for f in temp_img_dir.glob("*.*") if f.suffix.lower() in IMG_EXTENSIONS]
    print(f"待划分图片数: {len(all_imgs)}")
    
    if len(all_imgs) < 2:
        print("❌ 错误：至少需要2张图片才能划分train/val")
        return
    
    train_imgs, val_imgs = train_test_split(all_imgs, test_size=split, random_state=42)
    print(f"划分结果: 训练集{len(train_imgs)}张, 验证集{len(val_imgs)}张")
    
    # 移动文件到最终位置（同时移动对应的标签文件）
    for img in train_imgs:
        shutil.move(str(img), output / "images/train")
        # 移动对应的标签文件
        label_file = temp_label_dir / f"{img.stem}.txt"
        if label_file.exists():
            shutil.move(str(label_file), output / "labels/train")
    
    for img in val_imgs:
        shutil.move(str(img), output / "images/val")
        # 移动对应的标签文件
        label_file = temp_label_dir / f"{img.stem}.txt"
        if label_file.exists():
            shutil.move(str(label_file), output / "labels/val")
    
    # 清理临时目录
    temp_img_dir.rmdir()
    if temp_label_dir.exists():
        # 检查是否还有剩余文件
        remaining = list(temp_label_dir.glob("*"))
        if remaining:
            print(f"⚠️ 警告：临时标签目录中还有{len(remaining)}个文件未处理")
        else:
            temp_label_dir.rmdir()
    
    # 生成data.yaml（使用列表格式避免ASCII码问题）
    yaml_content = {
        "path": str(output.absolute()),
        "train": "images/train",
        "val": "images/val",
        "nc": len(id2name),
        "names": [id2name[i] for i in range(len(id2name))]
    }
    (output / "data.yaml").write_text(yaml.dump(yaml_content, sort_keys=False, allow_unicode=True), encoding='utf-8')
    
    print("\n" + "=" * 60)
    print("✅ 转换完成！")
    print(f"训练集: {len(train_imgs)}张")
    print(f"验证集: {len(val_imgs)}张")
    print(f"配置文件: {output / 'data.yaml'}")
    print("=" * 60)


# 使用示例（请替换成你的真实路径）
if __name__ == "__main__":
    main(
        json_dir="D:/Develop/yolo/tran_data",
        img_dir="D:/Develop/yolo/tran_data",
        output_dir="D:/Develop/yolo/tran_data/dataset_complete", #转换输出路径
        class_file="D:/Develop/yolo/tran_data/classes.txt"
    )

执行完会生成daya.yml 文件和images lables文件夹

使用Ultralytics训练yolov11模型

首先需要前往官网下载yolo11n或者其它版本的模型，也可以直接在X-AnyLabeling中下载，具体操作为点击左侧的’AI’按钮，再点击选择模型，点击yolov11模型会自动开始下载。

运行以下代码开始训练模型：


from ultralytics import YOLO

model = YOLO('yolo11n.pt')

model.train(
    data='D:\\Develop\\yolo\\tran_data\\dataset_complete\\data.yaml',
    epochs=300,  # 增加epochs
    patience=50,  # 增加耐心值
    batch=4)

训练完成后会在控制台打印训练完成后的新模型路径，将会生成best.pt和last.pt

测试新训练的模型

from ultralytics import YOLO


model = YOLO(r"D:\\Develop\\detect\\train3\weights\\best.pt")
# Run inference on an image
results = model(r"D://test.png")  # Replace with your image path

# Process results list
for result in results:
    boxes = result.boxes  # Boxes object for bbox outputs
    masks = result.masks  # Masks object for segmentation masks outputs
    keypoints = result.keypoints  # Keypoints object for pose outputs
    probs = result.probs  # Probs object for classification outputs
    
    # Show the results
    result.show()  # display to screen
    
    # Print detected classes
    for box in boxes:
        class_id = int(box.cls[0])
        class_name = result.names[class_id]
        conf = float(box.conf[0])
        print(f"Detected: {class_name} with confidence: {conf:.2f}")

    # Save results to disk
    result.save(filename='result.jpg')  # save to disk

运行以上代码来测试是否能正常识别训练的物体。

展开全文 >>

使用nginx+flask调用SSE流式输出接口报net::ERR_HTTP2_PROTOCOL_ERROR

2025-06-13

起因

当我使用flask开发了一个SSE流式输出大模型返回内容的接口，前端调用时返回到一半出现net::ERR_HTTP2_PROTOCOL_ERROR 200 (OK)，排查了一天，各种nginx配置都试过了，无论是强制HTTP1还是设置缓冲大小都不管用。

最终当我试试关掉gunicorn,直接使用python app.py 运行flask时一切正常了！

解决

nginx配置

首先是nginx要正确配置返回头：

location /system/ {
    proxy_pass http://127.0.0.1:8008/;
    # 配置支持sse
    proxy_set_header Connection 'Keep-Alive';  
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Connection '';
    proxy_http_version 1.1;  # 重要：确保使用HTTP/1.1协议
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection 'upgrade';
    # 添加以下配置以处理SSE
    proxy_buffering off;
    proxy_cache off;
}

其次是gunicorn启动命令

Gunicorn 的默认 sync 工作进程不适合长连接，因此使用异步工作进程如 gevent。

首先：
pip install gevent

再执行启动命令：
gunicorn --worker-class gevent --workers 4 --bind 0.0.0.0:8008 your_app:app

展开全文 >>

AI应用工程知识点整理

2025-04-21

什么是大语言模型？

大语言模型（LLM）是一种人工智能模型，它被设计用来理解和生成人类语言。关键在于 “大” 和 “语言模型” 这两个词：

“大” (Large): 指的是模型具有庞大的规模，主要体现在两个方面：
- 大规模的训练数据： LLM 是在海量的文本数据上训练出来的，这些数据通常包括互联网上的文本、书籍、文章、代码等等，数量级可以达到 TB 甚至 PB 级别。
- 大规模的参数量：模型的内部结构（通常是基于 Transformer 架构的神经网络）拥有数亿、数十亿甚至数千亿的参数。参数越多，模型理论上可以学习和存储的信息就越多，能力也更强。
“语言模型” (Language Model): 指的是模型的核心任务是预测文本序列的概率分布。简单来说，给定一段文本（例如，句子的一部分），语言模型的目标是预测接下来最有可能出现的词语。虽然目标看似简单，但为了做好这个预测，模型必须学习到语言的各种规律，包括：
- 语法规则：词语的正确排列顺序，句子的结构。
- 语义信息：词语和句子的含义，上下文的理解。
- 世界知识：模型通过学习大量文本，间接地学习到了关于世界的知识。
- 语用信息：语言在不同情境下的使用方式，风格，语气等等。

总的来说，LLM 就是通过学习海量文本数据，拥有了理解和生成人类语言能力的超大规模神经网络模型。

人工智能常见领域

计算机视觉 (CV)：
- 图像分类、目标检测、图像分割、图像生成
- 常用模型：ResNet、YOLO、Mask R-CNN、GANs
自然语言处理 (NLP)：
- 文本分类、情感分析、机器翻译、文本生成、问答系统
- 常用模型：Word2Vec、GloVe、BERT、Transformer、GPT
语音识别 (ASR)：
- 语音转文本、语音合成
- 常用模型：DeepSpeech、Wav2Vec
推荐系统：
- 协同过滤、基于内容的推荐、混合推荐
强化学习 (RL)：
- 马尔可夫决策过程 (MDP)
- Q-learning、Deep Q-Network (DQN)
- 策略梯度
- 应用场景：推荐系统、金融交易、游戏等
时间序列分析
- 应用场景：预测股票价格、汇率走势和市场趋势、预测天气变化和气候变化预测交通流量和路况等

主流AI大模型

一、文本生成与理解类模型 (以自然语言处理为主)

1. OpenAI GPT 系列 (GPT-3, GPT-3.5, GPT-4, GPT-4 Turbo等)
- 开发者: OpenAI
- 架构: Decoder-only Transformer (自回归模型)
- 训练数据: 海量的文本和代码数据，包括互联网文本、书籍、代码库等，规模庞大且质量高。
- 关键特点:
  - 强大的文本生成能力: 在文本生成、代码生成、创意写作、对话等方面表现卓越，生成文本流畅自然，逻辑连贯。
  - 上下文学习 (In-context Learning): 能够根据Prompt (提示词) 中的少量示例快速适应新任务，无需针对特定任务进行微调。
  - 指令遵循能力 (Instruction Following): 经过指令微调 (Instruction Tuning) 后，能更好地理解和执行用户指令，并生成符合指令的输出。
  - 多模态能力 (GPT-4): GPT-4 具备处理图像输入的能力，可以进行图像描述、视觉问答等任务，是真正的多模态大模型。
  - 持续进化: OpenAI 不断迭代和更新 GPT 系列模型，性能持续提升，例如 GPT-4 Turbo 拥有更长的上下文窗口，更低的API价格。
- 优点:
  - 顶尖的文本生成质量和理解能力。
  - 强大的通用性和泛化能力，适用范围广泛。
  - 成熟的 API 服务和生态系统，易于集成和使用。
  - 持续创新和迭代，性能不断提升。
- 缺点:
  - API 访问成本相对较高 (特别是 GPT-4)。
  - 模型细节和训练数据相对封闭 (特别是 GPT-4)。
  - 有时会产生幻觉 (Hallucination)，即生成不真实或与事实不符的内容。
  - 在某些特定领域或专业任务上，可能不如领域特定模型。
  - 对 Prompt 工程依赖性较高，需要精心设计 Prompt 才能发挥最佳性能。
2. Google PaLM 系列 (PaLM 2, Gemini 等)
- 开发者: Google
- 架构: Decoder-only Transformer (PaLM 2)，Transformer-based (Gemini)
- 训练数据: 海量的文本和代码数据，规模庞大，并侧重于高质量、多语言和多领域数据。
- 关键特点:
  - 强大的多语言能力: PaLM 2 在多语言理解和生成方面表现突出，支持超过100种语言。
  - 强大的推理能力: Gemini 系列模型 (特别是 Gemini Ultra) 在多项基准测试中表现出色，展现了强大的推理和理解能力，尤其在数学、逻辑推理等方面。
  - 多模态原生支持 (Gemini): Gemini 从设计之初就考虑了多模态，能够原生处理文本、图像、音频、视频等多种模态的数据，实现真正的多模态理解和生成。
  - Google 生态集成: 与 Google 搜索、Android 系统、Google Cloud 等生态系统深度集成，应用潜力巨大。
- 优点:
  - 顶尖的多语言能力和强大的推理能力 (特别是 Gemini)。
  - 原生多模态支持 (Gemini)，具有广阔的应用前景。
  - 背靠 Google 强大的技术实力和生态系统。
  - 持续发展和迭代，Gemini 系列模型有望成为 GPT 系列的强有力竞争者。
- 缺点:
  - API 访问和生态系统相对 GPT 系列稍逊 (但正在快速发展)。
  - Gemini Ultra 的访问权限目前较为受限。
  - 模型细节和训练数据相对封闭。
  - 在某些特定任务上，可能需要进一步优化和微调。
3. Meta Llama 系列 (Llama 2, Llama 3 等)
- 开发者: Meta (原 Facebook)
- 架构: Decoder-only Transformer (Llama 2)，Transformer-based (Llama 3)
- 训练数据: 大规模的公开可用的文本数据，侧重于透明度和可复现性。
- 关键特点:
  - 开源和可商用: Llama 2 系列模型开源且允许商业用途，降低了使用门槛，促进了社区发展。 Llama 3 延续开源策略。
  - 性能接近甚至在某些方面超越 GPT-3.5: Llama 2 在某些基准测试中表现出色，性能接近甚至在某些方面超越了 GPT-3.5。 Llama 3 更进一步，性能更强大。
  - 多种尺寸版本: 提供多种参数规模的版本 (7B, 13B, 70B 等)，满足不同资源和应用场景的需求。
  - 社区支持和生态快速发展: 开源特性吸引了大量开发者和研究者参与，社区活跃，生态系统快速发展，涌现出各种基于 Llama 的应用和工具。
- 优点:
  - 开源和可商用，极大降低了使用门槛。
  - 高性能，在某些方面可媲美甚至超越闭源模型 (如 GPT-3.5)。
  - 多种尺寸版本，灵活性高。
  - 强大的社区支持和活跃的生态系统。
- 缺点:
  - 性能上整体相比 GPT-4 和 Gemini 仍有差距 (但 Llama 3 正在缩小差距)。
  - 在某些复杂任务或多模态任务上，能力相对较弱。
  - 开源模型需要一定的技术能力进行部署和维护。
4. Anthropic Claude 系列 (Claude 2, Claude 3 等)
- 开发者: Anthropic
- 架构: Transformer-based (Claude 2, Claude 3)
- 训练数据: 大规模的文本和代码数据，侧重于安全性和负责任的AI开发。
- 关键特点:
  - 强调安全和负责任的AI: Anthropic 致力于开发安全、可靠、对人类有益的AI模型，Claude 系列模型在安全性方面进行了特别设计和优化。
  - 长上下文窗口: Claude 2 拥有超长的上下文窗口 (100K tokens, Claude 3 Opus 达到 200K tokens)，能够处理更长的文本输入，例如整本书籍或长篇文档。 Claude 3 Sonnet 和 Haiku 的上下文窗口也达到 200K tokens。
  - 强大的理解和推理能力: Claude 3 Opus 在复杂推理、数学、代码生成等方面表现出色，在某些基准测试中甚至超越了 GPT-4 和 Gemini Ultra。
  - 多种版本 (Claude 3): Claude 3 系列提供 Opus (最强性能)、Sonnet (性能和速度平衡)、Haiku (最快速度和低成本) 三个版本，满足不同需求。
- 优点:
  - 强调安全和负责任的AI开发理念。
  - 超长的上下文窗口，擅长处理长文本输入。
  - 强大的理解和推理能力 (特别是 Claude 3 Opus)。
  - Claude 3 系列提供多种版本，选择更灵活。
- 缺点:
  - API 访问和生态系统相对 GPT 系列和 Google 稍弱。
  - 模型细节和训练数据相对封闭。
  - 在某些任务上，例如代码生成，可能不如专门的代码生成模型。
5. Baidu ERNIE 系列 (ERNIE 3.0 Titan, ERNIE Bot 4.0 等)
- 开发者: 百度
- 架构: Transformer-based (ERNIE 3.0 Titan, ERNIE Bot 4.0)
- 训练数据: 大规模中文和英文文本数据，侧重于中文理解和生成能力。
- 关键特点:
  - 强大的中文理解和生成能力: ERNIE 系列模型在中文 NLP 任务上表现出色，尤其在中文文本生成、中文问答、中文信息检索等方面。
  - 知识增强 (Knowledge Enhanced): ERNIE 模型融入了知识图谱等知识信息，增强了模型的知识理解和推理能力。
  - 多任务学习: ERNIE 模型采用多任务学习框架进行训练，提升了模型的通用性和泛化能力。
  - 百度生态集成: 与百度搜索、百度智能云等生态系统深度集成，应用场景广泛。
- 优点:
  - 顶尖的中文理解和生成能力，在中文 NLP 领域具有优势。
  - 知识增强，提升了知识理解和推理能力。
  - 百度生态集成，应用场景广泛。
  - 针对中文市场和用户进行了优化。
- 缺点:
  - 英文能力相对 GPT 系列和 Google 等模型稍弱。
  - 模型细节和训练数据相对封闭。
  - 国际化程度相对较低，主要服务于中文市场。
6. 清华大学 ChatGLM 系列 (ChatGLM3 等)
- 开发者: 清华大学 KEG 实验室
- 架构: Transformer-based (ChatGLM3)
- 训练数据: 大规模中英文文本数据，侧重于开源和研究。
- 关键特点:
  - 开源和免费可商用 (部分版本): ChatGLM3 部分版本开源且免费可商用，降低了使用门槛，促进了学术研究和商业应用。
  - 强大的中文能力: ChatGLM 系列模型在中文 NLP 任务上表现出色，尤其在中文对话、中文问答等方面。
  - 轻量化版本 (ChatGLM3-6B): 提供轻量化版本 (ChatGLM3-6B)，资源需求较低，可以在消费级硬件上部署和运行。
  - 插件机制 (Tool API): ChatGLM3 提供了 Tool API，允许模型调用外部工具，扩展了模型的功能。
- 优点:
  - 开源和免费可商用 (部分版本)，便于研究和应用。
  - 强大的中文能力，尤其在中文对话领域。
  - 轻量化版本，资源需求低，易于部署。
  - 插件机制，扩展了模型的功能。
- 缺点:
  - 英文能力相对 GPT 系列和 Google 等模型稍弱。
  - 模型规模相对较小，整体性能相比顶尖闭源模型仍有差距 (但轻量化和开源是其优势)。
  - 生态系统和社区规模相对较小 (但正在快速发展)。
7. 智谱 AI ChatYuan 系列 (ChatYuan-Large 等)
- 开发者: 智谱 AI
- 架构: Transformer-based (ChatYuan-Large)
- 训练数据: 大规模中英文文本数据，侧重于中文通用能力。
- 关键特点:
  - 强大的中文通用能力: ChatYuan 系列模型在中文通用能力方面表现出色，适用于多种中文 NLP 任务。
  - 指令遵循和对话能力: 经过指令微调，具备较好的指令遵循能力和对话能力。
  - 多领域应用: ChatYuan 模型应用于金融、法律、教育等多个领域。
- 优点:
  - 强大的中文通用能力。
  - 指令遵循和对话能力较好。
  - 多领域应用场景。
- 缺点:
  - 英文能力相对 GPT 系列和 Google 等模型稍弱。
  - 模型细节和训练数据相对封闭。
  - 社区和生态系统规模相对较小。

二、代码生成类模型

1. OpenAI Codex (基于 GPT 系列)
- 开发者: OpenAI
- 架构: Decoder-only Transformer (基于 GPT 系列)
- 训练数据: 海量的代码数据，包括 GitHub 代码库、公开代码数据集等。
- 关键特点:
  - 强大的代码生成能力: 能够根据自然语言描述或代码注释生成代码片段或完整程序。
  - 支持多种编程语言: 支持 Python, JavaScript, C++, Java, Go 等多种主流编程语言。
  - 代码补全和代码修复: 可以进行代码自动补全、代码错误检测和修复等任务。
  - 集成于 GitHub Copilot 等工具: Codex 模型是 GitHub Copilot 等代码生成工具的核心引擎。
- 优点:
  - 顶尖的代码生成质量和能力。
  - 支持多种编程语言。
  - 集成于流行的开发工具，易于使用。
- 缺点:
  - API 访问成本相对较高。
  - 模型细节和训练数据相对封闭。
  - 在某些复杂或特定领域的代码生成任务上，可能需要人工辅助。
2. Google Codey (基于 PaLM 2)
- 开发者: Google
- 架构: Decoder-only Transformer (基于 PaLM 2)
- 训练数据: 海量的代码数据，包括公开代码库、Google 内部代码数据等。
- 关键特点:
  - 强大的代码生成和代码理解能力: Codey 模型在代码生成、代码补全、代码解释等方面表现出色。
  - 多语言支持: 支持 Python, JavaScript, Java, Go, C++ 等多种编程语言，并侧重于多语言代码生成能力。
  - 与 Google Cloud 集成: Codey 模型与 Google Cloud Codey API 和 Google Cloud Workbench 等工具集成，方便开发者使用。
- 优点:
  - 强大的代码生成和代码理解能力。
  - 多语言支持，尤其在多语言代码生成方面具有优势。
  - 与 Google Cloud 生态集成，方便云端开发。
- 缺点:
  - API 访问和生态系统相对 OpenAI 稍逊 (但正在快速发展)。
  - 模型细节和训练数据相对封闭。
  - 在某些复杂或特定领域的代码生成任务上，可能需要人工辅助。
3. Meta Code Llama 系列 (Code Llama, Code Llama - Instruct 等)
- 开发者: Meta
- 架构: Decoder-only Transformer (基于 Llama 2)
- 训练数据: 海量的代码数据，包括公开代码库、Stack Overflow 等。
- 关键特点:
  - 开源和免费可商用: Code Llama 系列模型开源且允许商业用途，降低了使用门槛。
  - 多种尺寸版本: 提供多种参数规模的版本 (7B, 13B, 34B 等)，满足不同资源和应用场景的需求。
  - 指令微调版本 (Code Llama - Instruct): 提供指令微调版本，针对代码生成指令进行了优化，更易于使用。
  - 支持多种编程语言: 支持 Python, C++, Java, PHP, TypeScript, C#, Bash, SQL 等多种编程语言。
- 优点:
  - 开源和免费可商用，极大降低了使用门槛。
  - 高性能的代码生成能力，可媲美闭源模型。
  - 多种尺寸版本和指令微调版本，灵活性高。
  - 基于 Llama 2 开源生态，社区支持良好。
- 缺点:
  - 在某些极端复杂的代码生成任务上，可能不如顶尖闭源模型。
  - 开源模型需要一定的技术能力进行部署和维护。
  - 生态系统相对 OpenAI 和 Google 稍逊 (但正在快速发展)。

三、多模态模型

1. OpenAI GPT-4 (多模态版本)
- 开发者: OpenAI
- 架构: Transformer-based (多模态 Transformer)
- 训练数据: 文本、图像、音频、视频等多种模态的数据。
- 关键特点:
  - 原生多模态支持: 能够处理文本、图像输入，并生成文本输出，实现图像描述、视觉问答等多模态任务。
  - 强大的多模态理解和生成能力: 在多模态任务上表现出色，例如图像描述准确生动，视觉问答逻辑清晰。
  - 与 GPT 系列文本能力无缝衔接: 多模态能力与 GPT 系列强大的文本能力无缝衔接，可以实现更复杂的多模态应用。
- 优点:
  - 顶尖的多模态理解和生成能力。
  - 与 GPT 系列文本能力融合，应用潜力巨大。
  - 成熟的 API 服务和生态系统。
- 缺点:
  - API 访问成本更高 (相比纯文本模型)。
  - 模型细节和多模态训练数据相对封闭。
  - 多模态能力仍处于发展初期，可能存在一些局限性。
2. Google Gemini 系列 (Gemini Ultra, Gemini Pro, Gemini Nano)
- 开发者: Google
- 架构: Transformer-based (原生多模态 Transformer)
- 训练数据: 文本、图像、音频、视频等多种模态的大规模数据。
- 关键特点:
  - 原生多模态架构: Gemini 从设计之初就考虑了多模态，采用原生多模态 Transformer 架构，能够更有效地融合和处理多种模态的数据。
  - 顶尖的多模态性能: Gemini Ultra 在多项多模态基准测试中表现出色，超越了 GPT-4 等模型。
  - 多种尺寸版本: Gemini 系列提供 Ultra (最强性能), Pro (性能和效率平衡), Nano (移动端部署) 三个版本，满足不同需求。
  - Google 生态集成: 与 Google 搜索、Android 系统、Google Cloud 等生态系统深度集成，多模态应用场景广阔。
- 优点:
  - 顶尖的多模态性能，在多模态领域具有领先优势。
  - 原生多模态架构，更有效地融合和处理多模态数据。
  - 多种尺寸版本，灵活性高。
  - 背靠 Google 强大的技术实力和生态系统，应用前景广阔。
- 缺点:
  - Gemini Ultra 的访问权限目前较为受限。
  - API 访问和生态系统相对 GPT 系列稍逊 (但正在快速发展)。
  - 模型细节和多模态训练数据相对封闭。
  - 多模态能力仍处于发展初期，仍有提升空间。

总结与选择建议:

选择合适的AI大模型需要根据具体的应用场景、需求和资源情况进行权衡：

文本生成与理解任务:
- 追求顶尖性能和通用性: GPT-4 或 Gemini Ultra 是首选，但成本较高。
- 追求高性能和相对较低成本: GPT-3.5 Turbo, PaLM 2, Claude 3 Sonnet/Opus 是不错的选择。
- 追求开源和可商用: Llama 3 或 Code Llama 系列是最佳选择。
- 中文 NLP 任务: ERNIE Bot 4.0 或 ChatGLM3 系列在中文领域具有优势。
代码生成任务:
- 追求顶尖代码生成能力: Codex (GitHub Copilot) 或 Codey 是首选。
- 追求开源和可商用: Code Llama 系列是最佳选择。
多模态任务:
- 追求顶尖多模态性能: Gemini Ultra 或 GPT-4 (多模态版本) 是首选，但成本较高。
- 需要考虑成本和易用性: Gemini Pro 或 GPT-4 (多模态版本) 的API 也是可行的选择。

more >>

展开全文 >>

浅谈一下精神内耗

2025-04-08

起因

最近家里人因为我一句无心的话而生气了好几天，因此我想聊一聊背后深层原因。

基于这个事我就一直在想，为什么她明知道我是无心的但还是生气了？为什么生气了这么久？

more >>

展开全文 >>

使用ollama + streamlit快速构建本地大模型应用

2024-12-17

说明

使用ollama可以很方便的运行本地大模型(包括官方模型和gguf量化模型)，使用streamlit快速构建对话界面。

安装ollama

以linux系统为例

在线安装

在线安装直接按官方命令执行：curl -fsSL https://ollama.com/install.sh | sh ，但鉴于国内网络下不动，可以考虑手动安装

手动安装

下载安装包： curl -L https://ollama.com/download/ollama-linux-amd64.tgz -o ollama-linux-amd64.tgz
解压： sudo tar -C /usr -xzf ollama-linux-amd64.tgz
运行服务： ollama serve

下载模型文件

此处使用modelscope下载qwen的gguf量化模型

安装modelscope下载工具:pip install -U modelscope

下载模型文件： modelscope download --model=Qwen/Qwen2.5-Coder-32B-Instruct-GGUF --include "qwen2.5-coder-32b-instruct-q5_k_m*.gguf" --local_dir .

创建ModelFile

ModelFile用于ollama构建本地模型，示例如下：

FROM ./QwQ-32B-Preview-GGUF/qwen2.5-coder-32b-instruct-q5_k_m.gguf
# sets the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1
# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token
PARAMETER num_ctx 4096

# sets a custom system message to specify the behavior of the chat assistant
SYSTEM You are Mario from super mario bros, acting as an assistant.

其中FROM为本地大模型的路径

构建ollama本地大模型

执行:ollama create mymodel -f ./Modelfile 名字可以随便起，Modelfile为刚才创建的Modelfile文件路径。

创建完成后运行： ollama run mymodel

编写streamlit页面并与ollama对接

依赖

需要安装的依赖如下：

pip install transformers
pip install ctransformers
pip install streamlit
pip install torch

如无法运行可能需要安装torch cuda环境，具体安装此处省略。

编写python代码

创建main.py编写如下代码：


from transformers import AutoTokenizer
from ctransformers import AutoModelForCausalLM
from transformers import TextStreamer
import logging
import torch
import json
import requests

logger = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler(),  # 输出到控制台
        logging.FileHandler('qwen-chat-gguf.log')  # 输出到文件
    ]
)

import streamlit as st
st.set_page_config(
    page_title="MY AI",
    page_icon="🤖"  
)
"""
AI对话模块，支持流式输出 
"""

class QwenChat:
    def __init__(self):
        self.api_base = "http://localhost:11434"  # Ollama默认地址
        self.model = "mymodel"  # 使用的模型名称
    
    
    def stream_chat(self, prompt,history=None):

        # 构建API请求
        url = f"{self.api_base}/api/generate"
        headers = {
            "Content-Type": "application/json"
        }
        data = {
            "model": self.model,
            "prompt": prompt,
            "stream": True,
            "system": "你是AI助手",
            "messages": history
        }
        

        try:
            # 发送流式请求
            response = requests.post(url, headers=headers, json=data, stream=True)
            response.raise_for_status()
            return response
                        
        except Exception as e:
            logger.error(f"调用Ollama API时发生错误: {str(e)}")
            raise e
        
        
@st.cache_resource
def get_qwen_chat_instance():
    return QwenChat()


if __name__ == "__main__":
    
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
     # 创建 QwenChat 实例
    # 使用共享的 QwenChat 实例
    qwen_chat = get_qwen_chat_instance()
    
    st.title("AI助手")
    st.write("请问有什么可以帮您的？")
    
    
    # 初始化对话历史
    if "messages" not in st.session_state:
        st.session_state.messages = []
    
    # 显示历史对话
    for message in st.session_state.messages:
        with st.chat_message(message["role"]):
            st.markdown(message["content"])
    
    # 用户输入
    if prompt := st.chat_input("请输入您的问题"):
        # 显示用户问题
        with st.chat_message("user"):
            st.markdown(prompt)
        st.session_state.messages.append({"role": "user", "content": prompt})
        
        # 显示AI回答
        with st.chat_message("assistant"):
            message_placeholder = st.empty()
            full_response = ""
            
            full_text = ""
            # 获取历史消息（不包括最新的用户消息）
            history = st.session_state.messages[:-1] if len(st.session_state.messages) > 0 else None
            response = qwen_chat.stream_chat(prompt, history)
            
            for line in response.iter_lines():
                if line:
                    # 解析JSON响应
                    chunk = json.loads(line)
                    if "response" in chunk:
                        text_chunk = chunk["response"]
                        # print(text_chunk)
                        full_text += text_chunk
                        # 更新ui
                        message_placeholder.markdown(full_text + "▌")
                    
                    # 如果生成结束,退出循环    
                    if chunk.get("done", False):
                        break
            
            # 更新最终响应
            message_placeholder.markdown(full_text)
            
            st.session_state.messages.append({"role": "assistant", "content": full_text})

最终运行启动命令： streamlit run main.py

展开全文 >>

记caddy2报:no cipher suite supported by both client and server

2024-07-22

描述

配置好域名转发后发现依旧无法访问，使用service caddy status 发现报错： no cipher suite supported by both client and server

解决

改成如下配置:


site.com {
        reverse_proxy localhost:8080
        tls {
                protocols tls1.2 tls1.2
        }
}

增加 tls协议配置即可

展开全文 >>

Enable AI to have internet access - Google search integrated langchain

2024-04-20

Basic dependency

python 3.1.12 +
langchain 0.1.12 +
SERPAPI_API_KEY
OPEN_AI_API_KEY

SERPAPI_API_KEY get from https://serpapi.com/

Install the following dependencies:

pip install langchain
pip install pymupdf
pip install openai
pip install --upgrade --quiet  langchain langchain-community langchainhub langchain-openai chromadb bs4
pip install --upgrade langchain-openai tiktoken chromadb langchain
pip install fake_useragent

Get start

# set the api key
os.environ["SERPAPI_API_KEY"] = '003dc0d2d9e0dc818aa2b497342346dfgdf799af1849c5d1249d34dd7'
openai.api_key="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"

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ChatMessageHistory
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# build tool agent

from langchain_community.utilities import SerpAPIWrapper
from langchain.agents import create_openai_tools_agent
from langchain.agents import AgentExecutor,Tool
from langchain.memory import ConversationBufferWindowMemory

chat = ChatOpenAI(model="gpt-3.5-turbo-1106",streaming=True,max_tokens=4090,max_retries=2)
# 加载 serpapi 工具
search = SerpAPIWrapper()

tools = [Tool(
    name="google_search",
    description="Search Google for recent results.",
    func=search.run,
    max_results=1,
    max_iterations=2,
    max_retries=2,
    max_consecutive_errors=2,
    max_tokens=2000, #must
    return_direct=False
)]

prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful assistant. You may not need to use tools for every query - the user may just want to chat!",
        ),
         ("user", "{input}"),
         MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
)

memory = ConversationBufferWindowMemory(k=2, return_messages=True)
agent = create_openai_tools_agent(tools = tools,llm = chat,prompt=prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True,max_iterations=2,memory=memory)
response = agent_executor.invoke({"input": 'Who is the current President of the United States?'})
print(response)

Now AI can first use Google search and then answer your questions.

展开全文 >>

分布式常见面试笔记

2024-03-12

JAVA分布式服务常见面试题

分布式事务

Seata

seata是阿里开源的分布式事务调度框架，支持TCC、AT、SAGA、XA四种模式

AT
SEATA默认是AT模式，通过@GlobalTrancation 动态代理生成全局事务ID，并通过RM来管理全局事务，如中间出错需要回滚事务时则通过数据库中的undo-log回写，undolog记录了数据提交前的状态
XA
二阶段提交，需要数据库本身支持XA协议
TCC
即尝试(Try)-确认(Confirm)-取消(Cancel)，每个事务都分成这三个阶段，在提交事务前向另一个系统发送确认消息，两边系统都确认OK了才执行提交操作，有一方出现异常则执行Cancel（补偿方法），缺点在于三个方法都需要自已手动完成
SAGA
与TCC类似，不同点在于一阶段直接提交事务，失败则执行补偿操作，无锁，因此性能相对较好，但同时由于没有事务隔离性会带来赃写

more >>

展开全文 >>

SpringBoot定时任务Scheduled动态修改Cron执行时间

2024-03-12

场景

当某些简单的定时任务需要通过后台修改执行时间时，通过spring boot自带的定时任务来实现是个不错的选择。

代码实现

创建定时任务类

需要实现SchedulingConfigurer接口


@Slf4j
@Component
@Configuration
public class Scheduled implements SchedulingConfigurer{

    private String cron;
    TaskScheduler taskScheduler;
	@Autowired
	CronMapper cronMapper;

    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(30);
        scheduler.setThreadNamePrefix("TaskScheduler-");
        scheduler.initialize();
        return scheduler;
    }

	@Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		this.taskRegistrar=taskRegistrar;
		this.taskScheduler=taskScheduler();
		scheduleTask();
    }

	 public void scheduleTask() {
		 taskScheduler.schedule(this.task, triggerContext -> {
             //从数据库获取执行周期
             if(!StringUtils.hasText(this.cron)) {
             	Cron c = cronMapper.selectById("1");
             	//如果为空设置默认
             	if(c==null) {
             		c=new Cron();
                 	c.setCronId("1");
                 	c.setCron("0 0 0/6 * * ? ");
                 	cronMapper.insert(c);
             	}
             	this.cron = c.getCron();
             }
             //返回执行周期
             return new CronTrigger(this.cron).nextExecutionTime(triggerContext);
         });
	 }

    public void setCron(String cron) {
		this.cron = cron;
	}
}

通过接口触发修改执行时间


@PostMapping
public String updateCron(String cron){
	 //此处省略修改数据库中的cron 值 
     ...

     //修改为新的执行时间
     scheduled.setCron(cron);
     scheduled.scheduleTask();
     return "修改成功";
}

展开全文 >>

使用Caddy作为HTTP服务器并配置反向代理到本地端口

2023-07-02

用途

由于服务器上部署了caddy torjan 作为代理服务器，想要配置域名时发现80端口已经被caddy占用，无法使用nginx，干掉80端口代理又无法使用，于是打算直接使用caddy反向代理域名。

配置caddy时走了一些弯路，按照官方文档配置怎么都访问不了，在此记录一下最终解决方案

弯路

按照官方文档我找到了caddyFile的位置：/etc/caddy/Caddyfile

接着vi 编辑，如下配置：

1
2
3

reiner.host {
    reverse_proxy localhost:8000
}

保存后重启caddy: systemctl restart caddy.service

访问配置的域名，结果发现域名访问不进来，官方的说法是，不配置前缀只配置域名，默认转发http://reiner.host 以及 https://reiner.host 的80和443端口，理论上这么配置应该没错。

这里我的版本是caddy 2.6.x

最终解决

最终我打算不再相信官方文档，手动配置每个需要转发的端口，如下：

www.reiner.host:80 www.reiner.host:443 reiner.host:80 reiner.host:443 {
        tls [email protected]
        root * /data/pages
        file_server
}

gateway.reiner.host:80 gateway.reiner.host:443 {
        tls [email protected]
        reverse_proxy localhost:8000
}

其中第一段配置是将/data/pages文件夹下所有文件作为HTTP服务器，通过访问如 reiner.host 或者 www.reiner.host 转发到 /data/pages/index.html

第二段是配置后台接口的地址，通过访问gateway.reiner.host 转发到本地的8000端口服务

tls 的作用是帮你申请ssl证书，这一点比nginx方便很多，当配置完重启后已经可以直接通过https访问了

2023-8-26 update
针对同一个域名，根据不同的路径转换到不同的服务，配置示例如下：

www.reiner.host:80 www.reiner.host:443 reiner.host:80 reiner.host:443 {
        tls [email protected]
        reverse_proxy localhost:8080
        handle_path /api/user/* {
            reverse_proxy localhost:8081
        }
}

例如访问reiner.host/api/user/xxx 就会转发到服务器的8081端口

展开全文 >>