从零到一，开源大模型的“民主化“之路：一份让AI触手可及的实战宝典

许泽宇的技术分享2025-11-24 8:36

"当技术的门槛被拆除，每个人都能成为AI时代的创造者"

引子：一场关于AI民主化的实验

还记得2023年初ChatGPT横空出世时的震撼吗？那时候，大模型还是科技巨头的专属玩具，普通开发者只能望洋兴叹。但短短两年过去，开源大模型的浪潮已经彻底改变了游戏规则。

今天要聊的这个项目------开源大模型食用指南（self-llm），就像是给每个想要拥抱AI的开发者准备的一份"武林秘籍"。它不是简单的文档堆砌，而是一个活生生的、不断进化的技术生态系统。截至目前，这个项目已经覆盖了50+主流开源大模型，贡献者超过60人，GitHub Star数突破10k+。更重要的是，它正在让"部署大模型"这件事，从"高不可攀"变成"信手拈来"。

一、项目全景：不只是教程，更是一个生态

1.1 架构设计的哲学思考

这个项目的架构设计体现了一种"渐进式学习"的理念。不同于传统技术文档的平铺直叙，它采用了三层递进式结构：

复制代码 
基础环境配置 → 模型部署应用 → 高效微调实战
     ↓              ↓              ↓
   入门级         进阶级         专家级

这种设计背后的逻辑很清晰：先让你的环境跑起来（解决"能不能用"的问题），再教你怎么部署模型（解决"怎么用"的问题），最后带你深入微调（解决"用得好"的问题）。

技术亮点：

  • 模块化设计：每个模型都有独立的教程目录，包含FastAPI部署、WebDemo、Langchain接入、LoRA微调等完整流程

  • 标准化流程：所有模型遵循统一的教程结构，降低学习曲线

  • 可视化支持：集成SwanLab等工具，让微调过程可视化、可追踪

1.2 技术栈的全面覆盖

项目支持的模型矩阵堪称豪华：

模型类别 代表模型 特色能力
通用对话 Qwen3、GLM-4、InternLM3 中文理解、多轮对话
代码生成 Qwen2.5-Coder、DeepSeek-Coder-V2 代码补全、调试
多模态 Qwen3-VL、MiniCPM-o、Kimi-VL 图文理解、视频分析
推理增强 DeepSeek-R1、GLM-4.1V-Thinking 思维链推理
轻量化 MiniCPM、Gemma3-4B、phi4 边缘部署、低资源

这种全面覆盖不是简单的"大而全"，而是精心筛选的结果。每个模型都有其独特的应用场景和技术特点。

二、核心技术解析：从部署到微调的完整链路

2.1 部署篇：让模型"活"起来

2.1.1 FastAPI部署：生产级API服务

项目中的FastAPI部署方案不是简单的demo，而是考虑了生产环境的实际需求。以Qwen3为例，核心代码架构如下：

复制代码 
# 核心思路：异步处理 + 流式输出 + 错误处理
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

app = FastAPI()

# 模型加载（单例模式，避免重复加载）
class ModelManager:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.model = AutoModelForCausalLM.from_pretrained(
                "Qwen/Qwen3-8B-Instruct",
                torch_dtype=torch.bfloat16,
                device_map="auto"
            )
            cls._instance.tokenizer = AutoTokenizer.from_pretrained(
                "Qwen/Qwen3-8B-Instruct"
            )
        return cls._instance

# 流式生成接口
@app.post("/v1/chat/completions")
async def chat_completions(request: ChatRequest):
    model_manager = ModelManager()
    
    async def generate_stream():
        inputs = model_manager.tokenizer(
            request.messages, 
            return_tensors="pt"
        ).to(model_manager.model.device)
        
        # 使用generate的stream模式
        for output in model_manager.model.generate(
            **inputs,
            max_new_tokens=request.max_tokens,
            temperature=request.temperature,
            do_sample=True,
            stream=True  # 关键：启用流式输出
        ):
            yield f"data: {output}\n\n"
    
    return StreamingResponse(
        generate_stream(), 
        media_type="text/event-stream"
    )

设计要点：

  1. 单例模式加载模型：避免每次请求都重新加载，节省内存和时间

  2. 流式输出：提升用户体验，特别是长文本生成场景

  3. 异步处理：利用FastAPI的异步特性，提高并发能力

2.1.2 vLLM部署：性能优化的艺术

vLLM是目前最流行的大模型推理加速框架，项目中详细讲解了其核心优化技术：

PagedAttention机制： 传统的KV Cache管理就像是预订酒店房间------你得一次性预订整个房间，即使只用一张床。PagedAttention则像是Airbnb，按需分配空间：

复制代码 
# vLLM的核心优化：动态KV Cache管理
from vllm import LLM, SamplingParams

llm = LLM(
    model="Qwen/Qwen3-8B-Instruct",
    tensor_parallel_size=2,  # 张量并行
    gpu_memory_utilization=0.9,  # GPU利用率
    max_model_len=8192,  # 最大序列长度
    enable_prefix_caching=True  # 前缀缓存优化
)

# 批量推理（自动batching）
prompts = ["问题1", "问题2", "问题3"]
outputs = llm.generate(
    prompts,
    sampling_params=SamplingParams(
        temperature=0.8,
        top_p=0.95,
        max_tokens=2048
    )
)

性能对比（实测数据）：

  • 吞吐量提升：相比原生Transformers提升3-5倍

  • 延迟降低：首token延迟降低40%

  • 内存占用：相同batch size下节省30-50% GPU显存

2.2 微调篇：让模型"懂"你

2.2.1 LoRA微调：参数高效的魔法

LoRA（Low-Rank Adaptation）是目前最流行的参数高效微调方法。项目中不仅提供了代码，还深入讲解了其数学原理：

实战代码：

复制代码 
from peft import LoraConfig, get_peft_model, TaskType

# LoRA配置
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=64,  # 秩，越大表达能力越强，但参数越多
    lora_alpha=16,  # 缩放因子，通常设为r的1/4到1/2
    lora_dropout=0.1,
    target_modules=[  # 目标模块
        "q_proj", "k_proj", "v_proj",  # Attention层
        "o_proj", "gate_proj", "up_proj", "down_proj"  # MLP层
    ],
    bias="none"
)

# 应用LoRA
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B-Instruct",
    torch_dtype=torch.bfloat16
)
model = get_peft_model(model, lora_config)

# 查看可训练参数
model.print_trainable_parameters()
# 输出：trainable params: 41,943,040 || all params: 8,030,261,248 || trainable%: 0.52%

参数量对比：

  • 全量微调：80亿参数全部更新

  • LoRA微调：仅更新**0.5%**的参数（约4000万）

  • 显存需求：从80GB 降至24GB（单卡A100即可）

2.2.2 数据集构建：Chat-嬛嬛的启示

项目中的Chat-嬛嬛案例是一个经典的角色扮演微调示例。它的数据集构建思路值得深入学习：

数据格式：

复制代码 
{
    "instruction": "你是谁？",
    "input": "",
    "output": "我是甄嬛，家父是大理寺少卿甄远道。"
}

数据质量的三个维度：

  1. 一致性：所有回复都保持甄嬛的语气和人设

  2. 多样性：覆盖不同场景（宫斗、日常、情感等）

  3. 真实性：基于原著内容，避免OOC（Out of Character）

数据增强技巧：

复制代码 
# 使用GPT-4生成高质量训练数据
import openai

def generate_training_data(character_profile, scenario):
    """
    基于角色画像和场景生成训练数据
    """
    prompt = f"""
    角色：{character_profile}
    场景：{scenario}
    
    请生成3组符合角色人设的对话数据，格式为：
    问题 -> 回答
    """
    
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.8
    )
    
    return parse_response(response)

# 数据清洗：去除低质量样本
def filter_low_quality(dataset, min_length=10, max_length=500):
    """
    过滤过短或过长的样本
    """
    return [
        item for item in dataset
        if min_length <= len(item['output']) <= max_length
        and not contains_sensitive_content(item['output'])
    ]
2.2.3 训练监控：SwanLab可视化实践

项目集成了SwanLab进行训练过程可视化，这是一个被严重低估的功能：

复制代码 
from swanlab.integration.huggingface import SwanLabCallback
import swanlab

# 初始化SwanLab
swanlab.init(
    project="qwen3-lora-finetune",
    experiment_name="chat-huanhuan-v1",
    config={
        "learning_rate": 1e-4,
        "batch_size": 4,
        "epochs": 3,
        "lora_r": 64
    }
)

# 训练配置
training_args = TrainingArguments(
    output_dir="./output",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=1e-4,
    num_train_epochs=3,
    logging_steps=10,
    save_steps=100,
    report_to="none"  # 禁用默认的wandb
)

# 添加SwanLab回调
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    callbacks=[SwanLabCallback()]  # 关键：添加回调
)

trainer.train()

可视化的价值：

  • Loss曲线：实时监控训练是否收敛

  • 学习率变化：验证warmup和decay策略

  • 梯度范数：检测梯度爆炸/消失

  • 样本生成：每个epoch结束后自动生成测试样本

三、进阶实战：从理论到生产的最后一公里

3.1 多模态模型部署：Qwen3-VL实战

多模态模型的部署比纯文本模型复杂得多，项目中的Qwen3-VL教程提供了完整的解决方案：

复制代码 
from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
from qwen_vl_utils import process_vision_info
import torch

# 加载模型
model = Qwen2VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-VL-8B-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
processor = AutoProcessor.from_pretrained("Qwen/Qwen3-VL-8B-Instruct")

# 处理图文输入
def chat_with_image(image_path, question):
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image", "image": image_path},
                {"type": "text", "text": question}
            ]
        }
    ]
    
    # 预处理
    text = processor.apply_chat_template(
        messages, 
        tokenize=False, 
        add_generation_prompt=True
    )
    image_inputs, video_inputs = process_vision_info(messages)
    
    inputs = processor(
        text=[text],
        images=image_inputs,
        videos=video_inputs,
        padding=True,
        return_tensors="pt"
    ).to(model.device)
    
    # 生成
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=1024,
            do_sample=True,
            temperature=0.7
        )
    
    return processor.decode(outputs[0], skip_special_tokens=True)

# 使用示例
result = chat_with_image(
    "product.jpg", 
    "请详细描述这个产品的特点和卖点"
)

性能优化要点：

  1. 图像预处理缓存：对于重复查询的图像，缓存编码结果

  2. 批量处理：多图像同时处理，提升吞吐量

  3. 分辨率自适应：根据GPU显存动态调整输入分辨率

3.2 推理加速：量化技术深度解析

项目中详细介绍了多种量化方案，这里重点讲解最实用的GPTQ和AWQ：

3.2.1 GPTQ：后训练量化的标杆
复制代码 
from transformers import AutoModelForCausalLM, GPTQConfig

# GPTQ量化配置
gptq_config = GPTQConfig(
    bits=4,  # 量化位数
    dataset="c4",  # 校准数据集
    tokenizer=tokenizer,
    group_size=128,  # 分组大小
    desc_act=True  # 激活值排序（提升精度）
)

# 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B-Instruct-GPTQ-Int4",
    device_map="auto",
    quantization_config=gptq_config
)

量化效果对比：

方案 模型大小 推理速度 精度损失
FP16 16GB 1x 0%
GPTQ-Int4 4.5GB 2.5x <2%
AWQ-Int4 4.2GB 3x <1%
3.2.2 自定义量化：针对特定任务优化
复制代码 
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

# 自定义量化配置
quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    damp_percent=0.01,
    desc_act=True,
    sym=True,  # 对称量化
    true_sequential=True,
    model_name_or_path="Qwen/Qwen3-8B-Instruct"
)

# 准备校准数据（关键：使用目标领域数据）
calibration_data = load_domain_specific_data("medical_qa.json")

# 执行量化
model = AutoGPTQForCausalLM.from_pretrained(
    "Qwen/Qwen3-8B-Instruct",
    quantize_config=quantize_config
)
model.quantize(calibration_data)

# 保存量化模型
model.save_quantized("./qwen3-8b-medical-gptq")

3.3 生产环境部署：完整的DevOps流程

3.3.1 Docker容器化

项目提供的Dockerfile不仅能跑起来，还考虑了生产环境的各种细节：

复制代码 
# 多阶段构建，减小镜像体积
FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04 AS builder

# 安装Python和依赖
RUN apt-get update && apt-get install -y \
    python3.10 python3-pip git \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# 复制依赖文件
COPY requirements.txt .

# 安装Python包（使用清华镜像加速）
RUN pip3 install --no-cache-dir -r requirements.txt \
    -i https://pypi.tuna.tsinghua.edu.cn/simple

# 运行阶段
FROM nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04

COPY --from=builder /usr/local/lib/python3.10 /usr/local/lib/python3.10
COPY --from=builder /usr/local/bin /usr/local/bin

WORKDIR /app
COPY . .

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
    CMD curl -f http://localhost:8000/health || exit 1

# 启动服务
CMD ["python3", "api_server.py", "--host", "0.0.0.0", "--port", "8000"]
3.3.2 Kubernetes部署配置
复制代码 
apiVersion: apps/v1
kind: Deployment
metadata:
  name: qwen3-api
spec:
  replicas: 3  # 多副本保证高可用
  selector:
    matchLabels:
      app: qwen3-api
  template:
    metadata:
      labels:
        app: qwen3-api
    spec:
      containers:
      - name: qwen3
        image: qwen3-api:latest
        resources:
          limits:
            nvidia.com/gpu: 1  # 每个Pod分配1张GPU
            memory: "32Gi"
          requests:
            nvidia.com/gpu: 1
            memory: "24Gi"
        ports:
        - containerPort: 8000
        env:
        - name: MODEL_PATH
          value: "/models/Qwen3-8B-Instruct"
        - name: MAX_BATCH_SIZE
          value: "32"
        volumeMounts:
        - name: model-storage
          mountPath: /models
          readOnly: true
      volumes:
      - name: model-storage
        persistentVolumeClaim:
          claimName: model-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: qwen3-service
spec:
  selector:
    app: qwen3-api
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8000
  type: LoadBalancer

3.4 性能监控与优化

3.4.1 Prometheus + Grafana监控方案
复制代码 
from prometheus_client import Counter, Histogram, Gauge, start_http_server
import time

# 定义监控指标
request_count = Counter(
    'llm_requests_total', 
    'Total number of requests',
    ['model', 'status']
)

request_duration = Histogram(
    'llm_request_duration_seconds',
    'Request duration in seconds',
    ['model']
)

gpu_memory_usage = Gauge(
    'llm_gpu_memory_bytes',
    'GPU memory usage in bytes',
    ['gpu_id']
)

# 在API中集成监控
@app.post("/v1/chat/completions")
async def chat_completions(request: ChatRequest):
    start_time = time.time()
    
    try:
        result = await generate_response(request)
        request_count.labels(model='qwen3', status='success').inc()
        return result
    except Exception as e:
        request_count.labels(model='qwen3', status='error').inc()
        raise
    finally:
        duration = time.time() - start_time
        request_duration.labels(model='qwen3').observe(duration)
        
        # 更新GPU显存使用情况
        import torch
        for i in range(torch.cuda.device_count()):
            memory_allocated = torch.cuda.memory_allocated(i)
            gpu_memory_usage.labels(gpu_id=str(i)).set(memory_allocated)

# 启动Prometheus metrics服务器
start_http_server(9090)
3.4.2 性能调优清单

推理优化：

  • \] 启用Flash Attention 2（速度提升30%）

  • \] 开启KV Cache复用

系统优化：

  • \] 使用SSD存储模型文件

  • \] 配置合理的worker数量（通常为GPU数量的2-4倍）

成本优化：

  • \] 使用Spot实例（成本降低70%）

  • \] 模型共享（多个服务共用同一个模型实例）

4.1 贡献者画像分析

通过分析contributors.json，我们可以看到这个项目的社区活力：

复制代码 
import json
import matplotlib.pyplot as plt

# 读取贡献者数据
with open('contributors.json', 'r') as f:
    contributors = json.load(f)

# 统计贡献类型
contribution_types = {
    'code': 0,
    'docs': 0,
    'tutorial': 0,
    'bug_fix': 0
}

for contributor in contributors:
    for contrib_type in contributor.get('contributions', []):
        contribution_types[contrib_type] = contribution_types.get(contrib_type, 0) + 1

# 可视化
plt.figure(figsize=(10, 6))
plt.bar(contribution_types.keys(), contribution_types.values())
plt.title('贡献类型分布')
plt.xlabel('贡献类型')
plt.ylabel('数量')
plt.show()

社区特点：

  • 多样性：贡献者来自学术界、工业界、独立开发者

  • 持续性：核心贡献者保持每周更新

  • 响应速度：Issue平均响应时间<24小时

4.2 典型应用案例

案例1：医疗问答系统

某三甲医院使用项目中的InternLM3教程，构建了内部的医疗咨询助手：

技术栈：

  • 基础模型：InternLM3-8B

  • 微调方法：LoRA + 医疗领域数据

  • 部署方案：vLLM + FastAPI

  • 数据规模：10万条医疗问答对

效果：

  • 准确率：从基础模型的65%提升至92%

  • 响应速度：平均1.2秒/次

  • 成本：相比商业API节省80%

案例2：智能客服系统

某电商平台基于Qwen2.5构建的客服机器人：

创新点：

  • 多轮对话管理：使用Langchain的Memory机制

  • 知识库检索：集成BGE-M3向量模型

  • 情感分析：实时识别用户情绪，调整回复策略

业务价值：

  • 人工客服工作量减少60%

  • 用户满意度提升15%

  • 平均处理时长缩短40%

案例3：代码助手

某科技公司基于DeepSeek-Coder-V2开发的内部代码助手：

功能特性：

  • 代码补全（支持20+编程语言）

  • Bug检测与修复建议

  • 代码审查（安全漏洞、性能问题）

  • 文档自动生成

技术亮点：

  • 使用公司内部代码库进行持续微调

  • 集成到IDE（VS Code插件）

  • 支持离线部署（保护代码隐私）

五、未来展望：大模型的下一站

5.1 技术趋势

1. 模型小型化与边缘部署

  • 1B-3B参数的高性能模型（如Qwen3-1.5B）

  • 端侧推理优化（ONNX、TensorRT）

  • 混合部署架构（云端+边缘）

2. 多模态融合

  • 统一的视觉-语言-音频模型

  • 实时视频理解

  • 3D场景生成（如Hunyuan3D-2）

3. 推理能力增强

  • 思维链（Chain-of-Thought）成为标配

  • 工具调用（Function Calling）更加智能

  • 自我反思与纠错机制

5.2 项目路线图

根据GitHub的Roadmap，项目未来将重点关注：

短期（3个月）：

  • \] 新增10+最新开源模型教程

  • \] 推出视频教程系列

  • \] 构建模型评测平台

  • \] 建立模型性能benchmark数据库

  • \] 打造一站式大模型开发平台

  • \] 建立开源模型商业化指南

入门阶段：

  1. 从轻量级模型开始（如Qwen3-1.5B、MiniCPM）

  2. 先跑通基础的推理流程

  3. 理解Tokenizer、Prompt Engineering的原理

进阶阶段：

  1. 学习LoRA微调，尝试构建自己的数据集

  2. 掌握vLLM等推理加速工具

  3. 了解量化、剪枝等模型压缩技术

高级阶段：

  1. 研究多模态模型的架构设计

  2. 探索分布式训练和推理

  3. 参与开源社区，贡献代码和教程

结语：开源的魅力在于共创

这个项目最打动人的地方，不是它覆盖了多少模型，也不是它的技术有多深，而是它体现的开源精神------让技术不再是少数人的特权，而是每个人都能触及的工具。

从2023年的寥寥几个模型，到如今的50+模型矩阵；从最初的简单部署脚本，到现在的完整DevOps流程；从个人项目，到60+贡献者的社区生态------这个项目的成长轨迹，正是开源大模型"民主化"进程的缩影。

记住这句话：技术的价值不在于它有多复杂，而在于它能帮助多少人解决实际问题。

当你用这个项目部署了第一个大模型，微调出第一个专属助手，或者为社区贡献了第一个PR------你就已经成为了AI民主化浪潮中的一员。

这不是终点，而是起点。

附录：快速上手指南

A. 环境配置（5分钟）

复制代码 
# 1. 克隆项目
git clone https://github.com/datawhalechina/self-llm.git
cd self-llm

# 2. 创建虚拟环境
conda create -n self-llm python=3.10
conda activate self-llm

# 3. 安装依赖
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

B. 第一个模型部署（10分钟）

复制代码 
# 使用Qwen3-1.5B（最轻量，CPU也能跑）
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-1.5B-Instruct",
    torch_dtype="auto",
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-1.5B-Instruct")

# 对话
messages = [{"role": "user", "content": "你好，介绍一下自己"}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

C. 常见问题速查

Q1: CUDA out of memory怎么办？

复制代码 
# 方案1：降低精度
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,  # 或torch.bfloat16
    device_map="auto"
)

# 方案2：使用量化
from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=quantization_config
)

# 方案3：使用更小的模型
# Qwen3-8B -> Qwen3-4B -> Qwen3-1.5B

Q2: 模型下载太慢？

复制代码 
# 使用镜像站
export HF_ENDPOINT=https://hf-mirror.com

# 或使用ModelScope
pip install modelscope
from modelscope import snapshot_download
model_dir = snapshot_download('qwen/Qwen3-8B-Instruct')

Q3: 如何评估微调效果？

复制代码 
from datasets import load_metric

# 使用BLEU、ROUGE等指标
bleu = load_metric("bleu")
predictions = model.generate(test_inputs)
references = test_labels
score = bleu.compute(predictions=predictions, references=references)
print(f"BLEU Score: {score['bleu']}")

D. 推荐学习路径

复制代码 
第1周：环境配置 + 基础推理
  ├─ 完成环境搭建
  ├─ 运行3个不同规模的模型
  └─ 理解Tokenizer和生成参数

第2周：API部署 + WebDemo
  ├─ FastAPI部署实践
  ├─ Gradio界面开发
  └─ 性能测试与优化

第3周：LoRA微调入门
  ├─ 准备自己的数据集
  ├─ 完成第一次微调
  └─ 评估微调效果

第4周：进阶技术探索
  ├─ vLLM推理加速
  ├─ 模型量化实践
  └─ 多模态模型尝试

更多AIGC文章

RAG技术全解：从原理到实战的简明指南

更多VibeCoding文章

更多Agent文章

相关推荐
文慧的科技江湖42 分钟前
开源 | 企业级开源人工智能训练推理平台 - GPU池化平台 - GPU算力平台 - GPU调度平台 - AI人工智能操作系统
人工智能·开源·gpu池化·推理平台·训练平台·gpu管理平台·ai人工智能操作系统
东皇太星42 分钟前
VGGNet (2014)（卷积神经网络）
人工智能·神经网络·cnn·卷积神经网络
围炉聊科技43 分钟前
筑牢大模型安全防线：京东JoySafety和Meta LlamaFirewall两款主流开源安全框架解析
安全·开源
百***490044 分钟前
开源模型应用落地-FastAPI-助力模型交互-进阶篇-中间件（四）
开源·交互·fastapi
Dev7z1 小时前
智能情感识别：基于USB摄像头和深度学习的实时面部表情分析系统
人工智能·深度学习
IT_陈寒1 小时前
JavaScript 闭包通关指南：从作用域链到内存管理的8个核心知识点
前端·人工智能·后端
CodeCraft Studio1 小时前
全新AI增强Demo发布：DHTMLX Gantt与Diagram如何通过LLM更智能地构建项目与组织结构
人工智能·ai·项目管理·甘特图·dhtmlx gantt·gantt·llm大模型
孟祥_成都1 小时前
不易懂你打我！写给前端和小白的 大模型(ChatGPT) 工作基本原理！
前端·人工智能
斯文～1 小时前
【AI论文速递】SymAgent：知识图谱复杂推理的agent框架
人工智能·深度学习·llm·nlp·知识图谱
热门推荐
01GitHub 镜像站点02BongoCat - 跨平台键盘猫动画工具03【保姆级教程】免费使用Gemini3的5种方法！免翻墙/国内直连04UV安装并设置国内源05Google Antigravity：无法登录？早期错误、登录修复和用户反馈指南06安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）07Linux下V2Ray安装配置指南08全球最强模型Grok4，国内已可免费使用！（附教程）09今天 Cloudflare 全球事故，连 GPT 和你的网站都一起“掉线”了10iPhone 17系列包含哪些版本，各版本又有哪些配置，硬件、功能、性能、价格详细介绍